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 initalized\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 }
413