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

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