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 <linux/module.h> 21 #include <linux/init.h> 22 #include <linux/delay.h> 23 #include <linux/interrupt.h> 24 #include <linux/usb.h> 25 #include <linux/slab.h> 26 #include <media/rc-core.h> 27 28 #include "au0828.h" 29 30 struct au0828_rc { 31 struct au0828_dev *dev; 32 struct rc_dev *rc; 33 char name[32]; 34 char phys[32]; 35 36 /* poll decoder */ 37 int polling; 38 struct delayed_work work; 39 40 /* i2c slave address of external device (if used) */ 41 u16 i2c_dev_addr; 42 43 int (*get_key_i2c)(struct au0828_rc *ir); 44 }; 45 46 /* 47 * AU8522 has a builtin IR receiver. Add functions to get IR from it 48 */ 49 50 static int au8522_rc_write(struct au0828_rc *ir, u16 reg, u8 data) 51 { 52 int rc; 53 char buf[] = { (reg >> 8) | 0x80, reg & 0xff, data }; 54 struct i2c_msg msg = { .addr = ir->i2c_dev_addr, .flags = 0, 55 .buf = buf, .len = sizeof(buf) }; 56 57 rc = i2c_transfer(ir->dev->i2c_client.adapter, &msg, 1); 58 59 if (rc < 0) 60 return rc; 61 62 return (rc == 1) ? 0 : -EIO; 63 } 64 65 static int au8522_rc_read(struct au0828_rc *ir, u16 reg, int val, 66 char *buf, int size) 67 { 68 int rc; 69 char obuf[3]; 70 struct i2c_msg msg[2] = { { .addr = ir->i2c_dev_addr, .flags = 0, 71 .buf = obuf, .len = 2 }, 72 { .addr = ir->i2c_dev_addr, .flags = I2C_M_RD, 73 .buf = buf, .len = size } }; 74 75 obuf[0] = 0x40 | reg >> 8; 76 obuf[1] = reg & 0xff; 77 if (val >= 0) { 78 obuf[2] = val; 79 msg[0].len++; 80 } 81 82 rc = i2c_transfer(ir->dev->i2c_client.adapter, msg, 2); 83 84 if (rc < 0) 85 return rc; 86 87 return (rc == 2) ? 0 : -EIO; 88 } 89 90 static int au8522_rc_andor(struct au0828_rc *ir, u16 reg, u8 mask, u8 value) 91 { 92 int rc; 93 char buf; 94 95 rc = au8522_rc_read(ir, reg, -1, &buf, 1); 96 if (rc < 0) 97 return rc; 98 99 buf = (buf & ~mask) | (value & mask); 100 101 return au8522_rc_write(ir, reg, buf); 102 } 103 104 #define au8522_rc_set(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), (bit)) 105 #define au8522_rc_clear(ir, reg, bit) au8522_rc_andor(ir, (reg), (bit), 0) 106 107 /* Remote Controller time units */ 108 109 #define AU8522_UNIT 200000 /* ns */ 110 #define NEC_START_SPACE (4500000 / AU8522_UNIT) 111 #define NEC_START_PULSE (562500 * 16) 112 #define RC5_START_SPACE (4 * AU8522_UNIT) 113 #define RC5_START_PULSE 888888 114 115 static int au0828_get_key_au8522(struct au0828_rc *ir) 116 { 117 unsigned char buf[40]; 118 DEFINE_IR_RAW_EVENT(rawir); 119 int i, j, rc; 120 int prv_bit, bit, width; 121 bool first = true; 122 123 /* Check IR int */ 124 rc = au8522_rc_read(ir, 0xe1, -1, buf, 1); 125 if (rc < 0 || !(buf[0] & (1 << 4))) 126 return 0; 127 128 /* Something arrived. Get the data */ 129 rc = au8522_rc_read(ir, 0xe3, 0x11, buf, sizeof(buf)); 130 131 132 if (rc < 0) 133 return rc; 134 135 /* Disable IR */ 136 au8522_rc_clear(ir, 0xe0, 1 << 4); 137 138 usleep_range(45000, 46000); 139 140 /* Enable IR */ 141 au8522_rc_set(ir, 0xe0, 1 << 4); 142 143 dprintk(16, "RC data received: %*ph\n", 40, buf); 144 145 prv_bit = (buf[0] >> 7) & 0x01; 146 width = 0; 147 for (i = 0; i < sizeof(buf); i++) { 148 for (j = 7; j >= 0; j--) { 149 bit = (buf[i] >> j) & 0x01; 150 if (bit == prv_bit) { 151 width++; 152 continue; 153 } 154 155 /* 156 * Fix an au8522 bug: the first pulse event 157 * is lost. So, we need to fake it, based on the 158 * protocol. That means that not all raw decoders 159 * will work, as we need to add a hack for each 160 * protocol, based on the first space. 161 * So, we only support RC5 and NEC. 162 */ 163 164 if (first) { 165 first = false; 166 167 init_ir_raw_event(&rawir); 168 rawir.pulse = true; 169 if (width > NEC_START_SPACE - 2 && 170 width < NEC_START_SPACE + 2) { 171 /* NEC protocol */ 172 rawir.duration = NEC_START_PULSE; 173 dprintk(16, "Storing NEC start %s with duration %d", 174 rawir.pulse ? "pulse" : "space", 175 rawir.duration); 176 } else { 177 /* RC5 protocol */ 178 rawir.duration = RC5_START_PULSE; 179 dprintk(16, "Storing RC5 start %s with duration %d", 180 rawir.pulse ? "pulse" : "space", 181 rawir.duration); 182 } 183 ir_raw_event_store(ir->rc, &rawir); 184 } 185 186 init_ir_raw_event(&rawir); 187 rawir.pulse = prv_bit ? false : true; 188 rawir.duration = AU8522_UNIT * width; 189 dprintk(16, "Storing %s with duration %d", 190 rawir.pulse ? "pulse" : "space", 191 rawir.duration); 192 ir_raw_event_store(ir->rc, &rawir); 193 194 width = 1; 195 prv_bit = bit; 196 } 197 } 198 199 init_ir_raw_event(&rawir); 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 /* Disable IR */ 247 au8522_rc_clear(ir, 0xe0, 1 << 4); 248 249 cancel_delayed_work_sync(&ir->work); 250 } 251 252 static int au0828_probe_i2c_ir(struct au0828_dev *dev) 253 { 254 int i = 0; 255 const unsigned short addr_list[] = { 256 0x47, I2C_CLIENT_END 257 }; 258 259 while (addr_list[i] != I2C_CLIENT_END) { 260 if (i2c_probe_func_quick_read(dev->i2c_client.adapter, 261 addr_list[i]) == 1) 262 return addr_list[i]; 263 i++; 264 } 265 266 return -ENODEV; 267 } 268 269 int au0828_rc_register(struct au0828_dev *dev) 270 { 271 struct au0828_rc *ir; 272 struct rc_dev *rc; 273 int err = -ENOMEM; 274 u16 i2c_rc_dev_addr = 0; 275 276 if (!dev->board.has_ir_i2c) 277 return 0; 278 279 i2c_rc_dev_addr = au0828_probe_i2c_ir(dev); 280 if (!i2c_rc_dev_addr) 281 return -ENODEV; 282 283 ir = kzalloc(sizeof(*ir), GFP_KERNEL); 284 rc = rc_allocate_device(); 285 if (!ir || !rc) 286 goto error; 287 288 /* record handles to ourself */ 289 ir->dev = dev; 290 dev->ir = ir; 291 ir->rc = rc; 292 293 rc->priv = ir; 294 rc->open = au0828_rc_start; 295 rc->close = au0828_rc_stop; 296 297 if (dev->board.has_ir_i2c) { /* external i2c device */ 298 switch (dev->boardnr) { 299 case AU0828_BOARD_HAUPPAUGE_HVR950Q: 300 rc->map_name = RC_MAP_HAUPPAUGE; 301 ir->get_key_i2c = au0828_get_key_au8522; 302 break; 303 default: 304 err = -ENODEV; 305 goto error; 306 } 307 308 ir->i2c_dev_addr = i2c_rc_dev_addr; 309 } 310 311 /* This is how often we ask the chip for IR information */ 312 ir->polling = 100; /* ms */ 313 314 /* init input device */ 315 snprintf(ir->name, sizeof(ir->name), "au0828 IR (%s)", 316 dev->board.name); 317 318 usb_make_path(dev->usbdev, ir->phys, sizeof(ir->phys)); 319 strlcat(ir->phys, "/input0", sizeof(ir->phys)); 320 321 rc->input_name = ir->name; 322 rc->input_phys = ir->phys; 323 rc->input_id.bustype = BUS_USB; 324 rc->input_id.version = 1; 325 rc->input_id.vendor = le16_to_cpu(dev->usbdev->descriptor.idVendor); 326 rc->input_id.product = le16_to_cpu(dev->usbdev->descriptor.idProduct); 327 rc->dev.parent = &dev->usbdev->dev; 328 rc->driver_name = "au0828-input"; 329 rc->driver_type = RC_DRIVER_IR_RAW; 330 rc->allowed_protocols = RC_BIT_NEC | RC_BIT_RC5; 331 332 /* all done */ 333 err = rc_register_device(rc); 334 if (err) 335 goto error; 336 337 pr_info("Remote controller %s initalized\n", ir->name); 338 339 return 0; 340 341 error: 342 dev->ir = NULL; 343 rc_free_device(rc); 344 kfree(ir); 345 return err; 346 } 347 348 void au0828_rc_unregister(struct au0828_dev *dev) 349 { 350 struct au0828_rc *ir = dev->ir; 351 352 /* skip detach on non attached boards */ 353 if (!ir) 354 return; 355 356 if (ir->rc) 357 rc_unregister_device(ir->rc); 358 359 /* done */ 360 kfree(ir); 361 dev->ir = NULL; 362 } 363 364 int au0828_rc_suspend(struct au0828_dev *dev) 365 { 366 struct au0828_rc *ir = dev->ir; 367 368 if (!ir) 369 return 0; 370 371 cancel_delayed_work_sync(&ir->work); 372 373 return 0; 374 } 375 376 int au0828_rc_resume(struct au0828_dev *dev) 377 { 378 struct au0828_rc *ir = dev->ir; 379 380 if (!ir) 381 return 0; 382 383 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling)); 384 385 return 0; 386 } 387