drivers/media/usb/au0828/au0828-input.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
au8522_rc_write
au8522_rc_read
au8522_rc_andor
au0828_get_key_au8522
au0828_rc_work
au0828_rc_start
au0828_rc_stop
au0828_probe_i2c_ir
au0828_rc_register
au0828_rc_unregister
au0828_rc_suspend
au0828_rc_resume
   1 // SPDX-License-Identifier: GPL-2.0+
   2 // handle au0828 IR remotes via linux kernel input layer.
   3 //
   4 // Copyright (c) 2014 Mauro Carvalho Chehab <mchehab@samsung.com>
   5 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6 //
   7 // Based on em28xx-input.c.
   8 
   9 #include "au0828.h"
  10 
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/delay.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/usb.h>
  16 #include <linux/slab.h>
  17 #include <media/rc-core.h>
  18 
  19 static int disable_ir;
  20 module_param(disable_ir,        int, 0444);
  21 MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
  22 
  23 struct au0828_rc {
  24         struct au0828_dev *dev;
  25         struct rc_dev *rc;
  26         char name[32];
  27         char phys[32];
  28 
  29         /* poll decoder */
  30         int polling;
  31         struct delayed_work work;
  32 
  33         /* i2c slave address of external device (if used) */
  34         u16 i2c_dev_addr;
  35 
  36         int  (*get_key_i2c)(struct au0828_rc *ir);
  37 };
  38 
  39 /*
  40  * AU8522 has a builtin IR receiver. Add functions to get IR from it
  41  */
  42 
  43 static int au8522_rc_write(struct au0828_rc *ir, u16 reg, u8 data)
  44 {
  45         int rc;
  46         char buf[] = { (reg >> 8) | 0x80, reg & 0xff, data };
  47         struct i2c_msg msg = { .addr = ir->i2c_dev_addr, .flags = 0,
  48                                .buf = buf, .len = sizeof(buf) };
  49 
  50         rc = i2c_transfer(ir->dev->i2c_client.adapter, &msg, 1);
  51 
  52         if (rc < 0)
  53                 return rc;
  54 
  55         return (rc == 1) ? 0 : -EIO;
  56 }
  57 
  58 static int au8522_rc_read(struct au0828_rc *ir, u16 reg, int val,
  59                                  char *buf, int size)
  60 {
  61         int rc;
  62         char obuf[3];
  63         struct i2c_msg msg[2] = { { .addr = ir->i2c_dev_addr, .flags = 0,
  64                                     .buf = obuf, .len = 2 },
  65                                   { .addr = ir->i2c_dev_addr, .flags = I2C_M_RD,
  66                                     .buf = buf, .len = size } };
  67 
  68         obuf[0] = 0x40 | reg >> 8;
  69         obuf[1] = reg & 0xff;
  70         if (val >= 0) {
  71                 obuf[2] = val;
  72                 msg[0].len++;
  73         }
  74 
  75         rc = i2c_transfer(ir->dev->i2c_client.adapter, msg, 2);
  76 
  77         if (rc < 0)
  78                 return rc;
  79 
  80         return (rc == 2) ? 0 : -EIO;
  81 }
  82 
  83 static int au8522_rc_andor(struct au0828_rc *ir, u16 reg, u8 mask, u8 value)
  84 {
  85         int rc;
  86         char buf, oldbuf;
  87 
  88         rc = au8522_rc_read(ir, reg, -1, &buf, 1);
  89         if (rc < 0)
  90                 return rc;
  91 
  92         oldbuf = buf;
  93         buf = (buf & ~mask) | (value & mask);
  94 
  95         /* Nothing to do, just return */
  96         if (buf == oldbuf)
  97                 return 0;
  98 
  99         return au8522_rc_write(ir, reg, buf);
 100 }
 101 
 102 #define au8522_rc_set(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), (bit))
 103 #define au8522_rc_clear(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), 0)
 104 
 105 /* Remote Controller time units */
 106 
 107 #define AU8522_UNIT             200000 /* ns */
 108 #define NEC_START_SPACE         (4500000 / AU8522_UNIT)
 109 #define NEC_START_PULSE         (562500 * 16)
 110 #define RC5_START_SPACE         (4 * AU8522_UNIT)
 111 #define RC5_START_PULSE         888888
 112 
 113 static int au0828_get_key_au8522(struct au0828_rc *ir)
 114 {
 115         unsigned char buf[40];
 116         struct ir_raw_event rawir = {};
 117         int i, j, rc;
 118         int prv_bit, bit, width;
 119         bool first = true;
 120 
 121         /* do nothing if device is disconnected */
 122         if (test_bit(DEV_DISCONNECTED, &ir->dev->dev_state))
 123                 return 0;
 124 
 125         /* Check IR int */
 126         rc = au8522_rc_read(ir, 0xe1, -1, buf, 1);
 127         if (rc < 0 || !(buf[0] & (1 << 4))) {
 128                 /* Be sure that IR is enabled */
 129                 au8522_rc_set(ir, 0xe0, 1 << 4);
 130                 return 0;
 131         }
 132 
 133         /* Something arrived. Get the data */
 134         rc = au8522_rc_read(ir, 0xe3, 0x11, buf, sizeof(buf));
 135 
 136 
 137         if (rc < 0)
 138                 return rc;
 139 
 140         /* Disable IR */
 141         au8522_rc_clear(ir, 0xe0, 1 << 4);
 142 
 143         /* Enable IR */
 144         au8522_rc_set(ir, 0xe0, 1 << 4);
 145 
 146         dprintk(16, "RC data received: %*ph\n", 40, buf);
 147 
 148         prv_bit = (buf[0] >> 7) & 0x01;
 149         width = 0;
 150         for (i = 0; i < sizeof(buf); i++) {
 151                 for (j = 7; j >= 0; j--) {
 152                         bit = (buf[i] >> j) & 0x01;
 153                         if (bit == prv_bit) {
 154                                 width++;
 155                                 continue;
 156                         }
 157 
 158                         /*
 159                          * Fix an au8522 bug: the first pulse event
 160                          * is lost. So, we need to fake it, based on the
 161                          * protocol. That means that not all raw decoders
 162                          * will work, as we need to add a hack for each
 163                          * protocol, based on the first space.
 164                          * So, we only support RC5 and NEC.
 165                          */
 166 
 167                         if (first) {
 168                                 first = false;
 169 
 170                                 rawir.pulse = true;
 171                                 if (width > NEC_START_SPACE - 2 &&
 172                                     width < NEC_START_SPACE + 2) {
 173                                         /* NEC protocol */
 174                                         rawir.duration = NEC_START_PULSE;
 175                                         dprintk(16, "Storing NEC start %s with duration %d",
 176                                                 rawir.pulse ? "pulse" : "space",
 177                                                 rawir.duration);
 178                                 } else {
 179                                         /* RC5 protocol */
 180                                         rawir.duration = RC5_START_PULSE;
 181                                         dprintk(16, "Storing RC5 start %s with duration %d",
 182                                                 rawir.pulse ? "pulse" : "space",
 183                                                 rawir.duration);
 184                                 }
 185                                 ir_raw_event_store(ir->rc, &rawir);
 186                         }
 187 
 188                         rawir.pulse = prv_bit ? false : true;
 189                         rawir.duration = AU8522_UNIT * width;
 190                         dprintk(16, "Storing %s with duration %d",
 191                                 rawir.pulse ? "pulse" : "space",
 192                                 rawir.duration);
 193                         ir_raw_event_store(ir->rc, &rawir);
 194 
 195                         width = 1;
 196                         prv_bit = bit;
 197                 }
 198         }
 199 
 200         rawir.pulse = prv_bit ? false : true;
 201         rawir.duration = AU8522_UNIT * width;
 202         dprintk(16, "Storing end %s with duration %d",
 203                 rawir.pulse ? "pulse" : "space",
 204                 rawir.duration);
 205         ir_raw_event_store(ir->rc, &rawir);
 206 
 207         ir_raw_event_handle(ir->rc);
 208 
 209         return 1;
 210 }
 211 
 212 /*
 213  * Generic IR code
 214  */
 215 
 216 static void au0828_rc_work(struct work_struct *work)
 217 {
 218         struct au0828_rc *ir = container_of(work, struct au0828_rc, work.work);
 219         int rc;
 220 
 221         rc = ir->get_key_i2c(ir);
 222         if (rc < 0)
 223                 pr_info("Error while getting RC scancode\n");
 224 
 225         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 226 }
 227 
 228 static int au0828_rc_start(struct rc_dev *rc)
 229 {
 230         struct au0828_rc *ir = rc->priv;
 231 
 232         INIT_DELAYED_WORK(&ir->work, au0828_rc_work);
 233 
 234         /* Enable IR */
 235         au8522_rc_set(ir, 0xe0, 1 << 4);
 236 
 237         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 238 
 239         return 0;
 240 }
 241 
 242 static void au0828_rc_stop(struct rc_dev *rc)
 243 {
 244         struct au0828_rc *ir = rc->priv;
 245 
 246         cancel_delayed_work_sync(&ir->work);
 247 
 248         /* do nothing if device is disconnected */
 249         if (!test_bit(DEV_DISCONNECTED, &ir->dev->dev_state)) {
 250                 /* Disable IR */
 251                 au8522_rc_clear(ir, 0xe0, 1 << 4);
 252         }
 253 }
 254 
 255 static int au0828_probe_i2c_ir(struct au0828_dev *dev)
 256 {
 257         int i = 0;
 258         static const unsigned short addr_list[] = {
 259                  0x47, I2C_CLIENT_END
 260         };
 261 
 262         while (addr_list[i] != I2C_CLIENT_END) {
 263                 if (i2c_probe_func_quick_read(dev->i2c_client.adapter,
 264                                               addr_list[i]) == 1)
 265                         return addr_list[i];
 266                 i++;
 267         }
 268 
 269         return -ENODEV;
 270 }
 271 
 272 int au0828_rc_register(struct au0828_dev *dev)
 273 {
 274         struct au0828_rc *ir;
 275         struct rc_dev *rc;
 276         int err = -ENOMEM;
 277         u16 i2c_rc_dev_addr = 0;
 278 
 279         if (!dev->board.has_ir_i2c || disable_ir)
 280                 return 0;
 281 
 282         i2c_rc_dev_addr = au0828_probe_i2c_ir(dev);
 283         if (!i2c_rc_dev_addr)
 284                 return -ENODEV;
 285 
 286         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
 287         rc = rc_allocate_device(RC_DRIVER_IR_RAW);
 288         if (!ir || !rc)
 289                 goto error;
 290 
 291         /* record handles to ourself */
 292         ir->dev = dev;
 293         dev->ir = ir;
 294         ir->rc = rc;
 295 
 296         rc->priv = ir;
 297         rc->open = au0828_rc_start;
 298         rc->close = au0828_rc_stop;
 299 
 300         if (dev->board.has_ir_i2c) {    /* external i2c device */
 301                 switch (dev->boardnr) {
 302                 case AU0828_BOARD_HAUPPAUGE_HVR950Q:
 303                         rc->map_name = RC_MAP_HAUPPAUGE;
 304                         ir->get_key_i2c = au0828_get_key_au8522;
 305                         break;
 306                 default:
 307                         err = -ENODEV;
 308                         goto error;
 309                 }
 310 
 311                 ir->i2c_dev_addr = i2c_rc_dev_addr;
 312         }
 313 
 314         /* This is how often we ask the chip for IR information */
 315         ir->polling = 100; /* ms */
 316 
 317         /* init input device */
 318         snprintf(ir->name, sizeof(ir->name), "au0828 IR (%s)",
 319                  dev->board.name);
 320 
 321         usb_make_path(dev->usbdev, ir->phys, sizeof(ir->phys));
 322         strlcat(ir->phys, "/input0", sizeof(ir->phys));
 323 
 324         rc->device_name = ir->name;
 325         rc->input_phys = ir->phys;
 326         rc->input_id.bustype = BUS_USB;
 327         rc->input_id.version = 1;
 328         rc->input_id.vendor = le16_to_cpu(dev->usbdev->descriptor.idVendor);
 329         rc->input_id.product = le16_to_cpu(dev->usbdev->descriptor.idProduct);
 330         rc->dev.parent = &dev->usbdev->dev;
 331         rc->driver_name = "au0828-input";
 332         rc->allowed_protocols = RC_PROTO_BIT_NEC | RC_PROTO_BIT_NECX |
 333                                 RC_PROTO_BIT_NEC32 | RC_PROTO_BIT_RC5;
 334 
 335         /* all done */
 336         err = rc_register_device(rc);
 337         if (err)
 338                 goto error;
 339 
 340         pr_info("Remote controller %s initialized\n", ir->name);
 341 
 342         return 0;
 343 
 344 error:
 345         dev->ir = NULL;
 346         rc_free_device(rc);
 347         kfree(ir);
 348         return err;
 349 }
 350 
 351 void au0828_rc_unregister(struct au0828_dev *dev)
 352 {
 353         struct au0828_rc *ir = dev->ir;
 354 
 355         /* skip detach on non attached boards */
 356         if (!ir)
 357                 return;
 358 
 359         rc_unregister_device(ir->rc);
 360 
 361         /* done */
 362         kfree(ir);
 363         dev->ir = NULL;
 364 }
 365 
 366 int au0828_rc_suspend(struct au0828_dev *dev)
 367 {
 368         struct au0828_rc *ir = dev->ir;
 369 
 370         if (!ir)
 371                 return 0;
 372 
 373         pr_info("Stopping RC\n");
 374 
 375         cancel_delayed_work_sync(&ir->work);
 376 
 377         /* Disable IR */
 378         au8522_rc_clear(ir, 0xe0, 1 << 4);
 379 
 380         return 0;
 381 }
 382 
 383 int au0828_rc_resume(struct au0828_dev *dev)
 384 {
 385         struct au0828_rc *ir = dev->ir;
 386 
 387         if (!ir)
 388                 return 0;
 389 
 390         pr_info("Restarting RC\n");
 391 
 392         /* Enable IR */
 393         au8522_rc_set(ir, 0xe0, 1 << 4);
 394 
 395         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 396 
 397         return 0;
 398 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/media/usb/au0828/au0828-input.c

DEFINITIONS
