xref: /openbmc/linux/drivers/media/rc/serial_ir.c (revision 06b83158)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * serial_ir.c
4  *
5  * serial_ir - Device driver that records pulse- and pause-lengths
6  *	       (space-lengths) between DDCD event on a serial port.
7  *
8  * Copyright (C) 1996,97 Ralph Metzler <rjkm@thp.uni-koeln.de>
9  * Copyright (C) 1998 Trent Piepho <xyzzy@u.washington.edu>
10  * Copyright (C) 1998 Ben Pfaff <blp@gnu.org>
11  * Copyright (C) 1999 Christoph Bartelmus <lirc@bartelmus.de>
12  * Copyright (C) 2007 Andrei Tanas <andrei@tanas.ca> (suspend/resume support)
13  * Copyright (C) 2016 Sean Young <sean@mess.org> (port to rc-core)
14  */
15 
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 
18 #include <linux/module.h>
19 #include <linux/errno.h>
20 #include <linux/interrupt.h>
21 #include <linux/kernel.h>
22 #include <linux/serial_reg.h>
23 #include <linux/types.h>
24 #include <linux/delay.h>
25 #include <linux/platform_device.h>
26 #include <linux/spinlock.h>
27 #include <media/rc-core.h>
28 
29 struct serial_ir_hw {
30 	int signal_pin;
31 	int signal_pin_change;
32 	u8 on;
33 	u8 off;
34 	unsigned set_send_carrier:1;
35 	unsigned set_duty_cycle:1;
36 	void (*send_pulse)(unsigned int length, ktime_t edge);
37 	void (*send_space)(void);
38 	spinlock_t lock;
39 };
40 
41 #define IR_HOMEBREW	0
42 #define IR_IRDEO	1
43 #define IR_IRDEO_REMOTE	2
44 #define IR_ANIMAX	3
45 #define IR_IGOR		4
46 
47 /* module parameters */
48 static int type;
49 static int io;
50 static int irq;
51 static ulong iommap;
52 static int ioshift;
53 static bool softcarrier = true;
54 static bool share_irq;
55 static int sense = -1;	/* -1 = auto, 0 = active high, 1 = active low */
56 static bool txsense;	/* 0 = active high, 1 = active low */
57 
58 /* forward declarations */
59 static void send_pulse_irdeo(unsigned int length, ktime_t edge);
60 static void send_space_irdeo(void);
61 #ifdef CONFIG_IR_SERIAL_TRANSMITTER
62 static void send_pulse_homebrew(unsigned int length, ktime_t edge);
63 static void send_space_homebrew(void);
64 #endif
65 
66 static struct serial_ir_hw hardware[] = {
67 	[IR_HOMEBREW] = {
68 		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_HOMEBREW].lock),
69 		.signal_pin	   = UART_MSR_DCD,
70 		.signal_pin_change = UART_MSR_DDCD,
71 		.on  = (UART_MCR_RTS | UART_MCR_OUT2 | UART_MCR_DTR),
72 		.off = (UART_MCR_RTS | UART_MCR_OUT2),
73 #ifdef CONFIG_IR_SERIAL_TRANSMITTER
74 		.send_pulse = send_pulse_homebrew,
75 		.send_space = send_space_homebrew,
76 		.set_send_carrier = true,
77 		.set_duty_cycle = true,
78 #endif
79 	},
80 
81 	[IR_IRDEO] = {
82 		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IRDEO].lock),
83 		.signal_pin	   = UART_MSR_DSR,
84 		.signal_pin_change = UART_MSR_DDSR,
85 		.on  = UART_MCR_OUT2,
86 		.off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
87 		.send_pulse = send_pulse_irdeo,
88 		.send_space = send_space_irdeo,
89 		.set_duty_cycle = true,
90 	},
91 
92 	[IR_IRDEO_REMOTE] = {
93 		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IRDEO_REMOTE].lock),
94 		.signal_pin	   = UART_MSR_DSR,
95 		.signal_pin_change = UART_MSR_DDSR,
96 		.on  = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
97 		.off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
98 		.send_pulse = send_pulse_irdeo,
99 		.send_space = send_space_irdeo,
100 		.set_duty_cycle = true,
101 	},
102 
103 	[IR_ANIMAX] = {
104 		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_ANIMAX].lock),
105 		.signal_pin	   = UART_MSR_DCD,
106 		.signal_pin_change = UART_MSR_DDCD,
107 		.on  = 0,
108 		.off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
109 	},
110 
111 	[IR_IGOR] = {
112 		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IGOR].lock),
113 		.signal_pin	   = UART_MSR_DSR,
114 		.signal_pin_change = UART_MSR_DDSR,
115 		.on  = (UART_MCR_RTS | UART_MCR_OUT2 | UART_MCR_DTR),
116 		.off = (UART_MCR_RTS | UART_MCR_OUT2),
117 #ifdef CONFIG_IR_SERIAL_TRANSMITTER
118 		.send_pulse = send_pulse_homebrew,
119 		.send_space = send_space_homebrew,
120 		.set_send_carrier = true,
121 		.set_duty_cycle = true,
122 #endif
123 	},
124 };
125 
126 #define RS_ISR_PASS_LIMIT 256
127 
128 struct serial_ir {
129 	ktime_t lastkt;
130 	struct rc_dev *rcdev;
131 	struct platform_device *pdev;
132 	struct timer_list timeout_timer;
133 
134 	unsigned int carrier;
135 	unsigned int duty_cycle;
136 };
137 
138 static struct serial_ir serial_ir;
139 
140 /* fetch serial input packet (1 byte) from register offset */
sinp(int offset)141 static u8 sinp(int offset)
142 {
143 	if (iommap)
144 		/* the register is memory-mapped */
145 		offset <<= ioshift;
146 
147 	return inb(io + offset);
148 }
149 
150 /* write serial output packet (1 byte) of value to register offset */
soutp(int offset,u8 value)151 static void soutp(int offset, u8 value)
152 {
153 	if (iommap)
154 		/* the register is memory-mapped */
155 		offset <<= ioshift;
156 
157 	outb(value, io + offset);
158 }
159 
on(void)160 static void on(void)
161 {
162 	if (txsense)
163 		soutp(UART_MCR, hardware[type].off);
164 	else
165 		soutp(UART_MCR, hardware[type].on);
166 }
167 
off(void)168 static void off(void)
169 {
170 	if (txsense)
171 		soutp(UART_MCR, hardware[type].on);
172 	else
173 		soutp(UART_MCR, hardware[type].off);
174 }
175 
send_pulse_irdeo(unsigned int length,ktime_t target)176 static void send_pulse_irdeo(unsigned int length, ktime_t target)
177 {
178 	long rawbits;
179 	int i;
180 	unsigned char output;
181 	unsigned char chunk, shifted;
182 
183 	/* how many bits have to be sent ? */
184 	rawbits = length * 1152 / 10000;
185 	if (serial_ir.duty_cycle > 50)
186 		chunk = 3;
187 	else
188 		chunk = 1;
189 	for (i = 0, output = 0x7f; rawbits > 0; rawbits -= 3) {
190 		shifted = chunk << (i * 3);
191 		shifted >>= 1;
192 		output &= (~shifted);
193 		i++;
194 		if (i == 3) {
195 			soutp(UART_TX, output);
196 			while (!(sinp(UART_LSR) & UART_LSR_THRE))
197 				;
198 			output = 0x7f;
199 			i = 0;
200 		}
201 	}
202 	if (i != 0) {
203 		soutp(UART_TX, output);
204 		while (!(sinp(UART_LSR) & UART_LSR_TEMT))
205 			;
206 	}
207 }
208 
send_space_irdeo(void)209 static void send_space_irdeo(void)
210 {
211 }
212 
213 #ifdef CONFIG_IR_SERIAL_TRANSMITTER
send_pulse_homebrew_softcarrier(unsigned int length,ktime_t edge)214 static void send_pulse_homebrew_softcarrier(unsigned int length, ktime_t edge)
215 {
216 	ktime_t now, target = ktime_add_us(edge, length);
217 	/*
218 	 * delta should never exceed 4 seconds and on m68k
219 	 * ndelay(s64) does not compile; so use s32 rather than s64.
220 	 */
221 	s32 delta;
222 	unsigned int pulse, space;
223 
224 	/* Ensure the dividend fits into 32 bit */
225 	pulse = DIV_ROUND_CLOSEST(serial_ir.duty_cycle * (NSEC_PER_SEC / 100),
226 				  serial_ir.carrier);
227 	space = DIV_ROUND_CLOSEST((100 - serial_ir.duty_cycle) *
228 				  (NSEC_PER_SEC / 100), serial_ir.carrier);
229 
230 	for (;;) {
231 		now = ktime_get();
232 		if (ktime_compare(now, target) >= 0)
233 			break;
234 		on();
235 		edge = ktime_add_ns(edge, pulse);
236 		delta = ktime_to_ns(ktime_sub(edge, now));
237 		if (delta > 0)
238 			ndelay(delta);
239 		now = ktime_get();
240 		off();
241 		if (ktime_compare(now, target) >= 0)
242 			break;
243 		edge = ktime_add_ns(edge, space);
244 		delta = ktime_to_ns(ktime_sub(edge, now));
245 		if (delta > 0)
246 			ndelay(delta);
247 	}
248 }
249 
send_pulse_homebrew(unsigned int length,ktime_t edge)250 static void send_pulse_homebrew(unsigned int length, ktime_t edge)
251 {
252 	if (softcarrier)
253 		send_pulse_homebrew_softcarrier(length, edge);
254 	else
255 		on();
256 }
257 
send_space_homebrew(void)258 static void send_space_homebrew(void)
259 {
260 	off();
261 }
262 #endif
263 
frbwrite(unsigned int l,bool is_pulse)264 static void frbwrite(unsigned int l, bool is_pulse)
265 {
266 	/* simple noise filter */
267 	static unsigned int ptr, pulse, space;
268 	struct ir_raw_event ev = {};
269 
270 	if (ptr > 0 && is_pulse) {
271 		pulse += l;
272 		if (pulse > 250) {
273 			ev.duration = space;
274 			ev.pulse = false;
275 			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
276 			ev.duration = pulse;
277 			ev.pulse = true;
278 			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
279 			ptr = 0;
280 			pulse = 0;
281 		}
282 		return;
283 	}
284 	if (!is_pulse) {
285 		if (ptr == 0) {
286 			if (l > 20000) {
287 				space = l;
288 				ptr++;
289 				return;
290 			}
291 		} else {
292 			if (l > 20000) {
293 				space += pulse;
294 				if (space > IR_MAX_DURATION)
295 					space = IR_MAX_DURATION;
296 				space += l;
297 				if (space > IR_MAX_DURATION)
298 					space = IR_MAX_DURATION;
299 				pulse = 0;
300 				return;
301 			}
302 
303 			ev.duration = space;
304 			ev.pulse = false;
305 			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
306 			ev.duration = pulse;
307 			ev.pulse = true;
308 			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
309 			ptr = 0;
310 			pulse = 0;
311 		}
312 	}
313 
314 	ev.duration = l;
315 	ev.pulse = is_pulse;
316 	ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
317 }
318 
serial_ir_irq_handler(int i,void * blah)319 static irqreturn_t serial_ir_irq_handler(int i, void *blah)
320 {
321 	ktime_t kt;
322 	int counter, dcd;
323 	u8 status;
324 	ktime_t delkt;
325 	unsigned int data;
326 	static int last_dcd = -1;
327 
328 	if ((sinp(UART_IIR) & UART_IIR_NO_INT)) {
329 		/* not our interrupt */
330 		return IRQ_NONE;
331 	}
332 
333 	counter = 0;
334 	do {
335 		counter++;
336 		status = sinp(UART_MSR);
337 		if (counter > RS_ISR_PASS_LIMIT) {
338 			dev_err(&serial_ir.pdev->dev, "Trapped in interrupt");
339 			break;
340 		}
341 		if ((status & hardware[type].signal_pin_change) &&
342 		    sense != -1) {
343 			/* get current time */
344 			kt = ktime_get();
345 
346 			/*
347 			 * The driver needs to know if your receiver is
348 			 * active high or active low, or the space/pulse
349 			 * sense could be inverted.
350 			 */
351 
352 			/* calc time since last interrupt in nanoseconds */
353 			dcd = (status & hardware[type].signal_pin) ? 1 : 0;
354 
355 			if (dcd == last_dcd) {
356 				dev_dbg(&serial_ir.pdev->dev,
357 					"ignoring spike: %d %d %lldns %lldns\n",
358 					dcd, sense, ktime_to_ns(kt),
359 					ktime_to_ns(serial_ir.lastkt));
360 				continue;
361 			}
362 
363 			delkt = ktime_sub(kt, serial_ir.lastkt);
364 			if (ktime_compare(delkt, ktime_set(15, 0)) > 0) {
365 				data = IR_MAX_DURATION; /* really long time */
366 				if (!(dcd ^ sense)) {
367 					/* sanity check */
368 					dev_err(&serial_ir.pdev->dev,
369 						"dcd unexpected: %d %d %lldns %lldns\n",
370 						dcd, sense, ktime_to_ns(kt),
371 						ktime_to_ns(serial_ir.lastkt));
372 					/*
373 					 * detecting pulse while this
374 					 * MUST be a space!
375 					 */
376 					sense = sense ? 0 : 1;
377 				}
378 			} else {
379 				data = ktime_to_us(delkt);
380 			}
381 			frbwrite(data, !(dcd ^ sense));
382 			serial_ir.lastkt = kt;
383 			last_dcd = dcd;
384 		}
385 	} while (!(sinp(UART_IIR) & UART_IIR_NO_INT)); /* still pending ? */
386 
387 	mod_timer(&serial_ir.timeout_timer,
388 		  jiffies + usecs_to_jiffies(serial_ir.rcdev->timeout));
389 
390 	ir_raw_event_handle(serial_ir.rcdev);
391 
392 	return IRQ_HANDLED;
393 }
394 
hardware_init_port(void)395 static int hardware_init_port(void)
396 {
397 	u8 scratch, scratch2, scratch3;
398 
399 	/*
400 	 * This is a simple port existence test, borrowed from the autoconfig
401 	 * function in drivers/tty/serial/8250/8250_port.c
402 	 */
403 	scratch = sinp(UART_IER);
404 	soutp(UART_IER, 0);
405 #ifdef __i386__
406 	outb(0xff, 0x080);
407 #endif
408 	scratch2 = sinp(UART_IER) & 0x0f;
409 	soutp(UART_IER, 0x0f);
410 #ifdef __i386__
411 	outb(0x00, 0x080);
412 #endif
413 	scratch3 = sinp(UART_IER) & 0x0f;
414 	soutp(UART_IER, scratch);
415 	if (scratch2 != 0 || scratch3 != 0x0f) {
416 		/* we fail, there's nothing here */
417 		pr_err("port existence test failed, cannot continue\n");
418 		return -ENODEV;
419 	}
420 
421 	/* Set DLAB 0. */
422 	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
423 
424 	/* First of all, disable all interrupts */
425 	soutp(UART_IER, sinp(UART_IER) &
426 	      (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
427 
428 	/* Clear registers. */
429 	sinp(UART_LSR);
430 	sinp(UART_RX);
431 	sinp(UART_IIR);
432 	sinp(UART_MSR);
433 
434 	/* Set line for power source */
435 	off();
436 
437 	/* Clear registers again to be sure. */
438 	sinp(UART_LSR);
439 	sinp(UART_RX);
440 	sinp(UART_IIR);
441 	sinp(UART_MSR);
442 
443 	switch (type) {
444 	case IR_IRDEO:
445 	case IR_IRDEO_REMOTE:
446 		/* setup port to 7N1 @ 115200 Baud */
447 		/* 7N1+start = 9 bits at 115200 ~ 3 bits at 38kHz */
448 
449 		/* Set DLAB 1. */
450 		soutp(UART_LCR, sinp(UART_LCR) | UART_LCR_DLAB);
451 		/* Set divisor to 1 => 115200 Baud */
452 		soutp(UART_DLM, 0);
453 		soutp(UART_DLL, 1);
454 		/* Set DLAB 0 +  7N1 */
455 		soutp(UART_LCR, UART_LCR_WLEN7);
456 		/* THR interrupt already disabled at this point */
457 		break;
458 	default:
459 		break;
460 	}
461 
462 	return 0;
463 }
464 
serial_ir_timeout(struct timer_list * unused)465 static void serial_ir_timeout(struct timer_list *unused)
466 {
467 	struct ir_raw_event ev = {
468 		.timeout = true,
469 		.duration = serial_ir.rcdev->timeout
470 	};
471 	ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
472 	ir_raw_event_handle(serial_ir.rcdev);
473 }
474 
475 /* Needed by serial_ir_probe() */
476 static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
477 			unsigned int count);
478 static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle);
479 static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier);
480 static int serial_ir_open(struct rc_dev *rcdev);
481 static void serial_ir_close(struct rc_dev *rcdev);
482 
serial_ir_probe(struct platform_device * dev)483 static int serial_ir_probe(struct platform_device *dev)
484 {
485 	struct rc_dev *rcdev;
486 	int i, nlow, nhigh, result;
487 
488 	rcdev = devm_rc_allocate_device(&dev->dev, RC_DRIVER_IR_RAW);
489 	if (!rcdev)
490 		return -ENOMEM;
491 
492 	if (hardware[type].send_pulse && hardware[type].send_space)
493 		rcdev->tx_ir = serial_ir_tx;
494 	if (hardware[type].set_send_carrier)
495 		rcdev->s_tx_carrier = serial_ir_tx_carrier;
496 	if (hardware[type].set_duty_cycle)
497 		rcdev->s_tx_duty_cycle = serial_ir_tx_duty_cycle;
498 
499 	switch (type) {
500 	case IR_HOMEBREW:
501 		rcdev->device_name = "Serial IR type home-brew";
502 		break;
503 	case IR_IRDEO:
504 		rcdev->device_name = "Serial IR type IRdeo";
505 		break;
506 	case IR_IRDEO_REMOTE:
507 		rcdev->device_name = "Serial IR type IRdeo remote";
508 		break;
509 	case IR_ANIMAX:
510 		rcdev->device_name = "Serial IR type AnimaX";
511 		break;
512 	case IR_IGOR:
513 		rcdev->device_name = "Serial IR type IgorPlug";
514 		break;
515 	}
516 
517 	rcdev->input_phys = KBUILD_MODNAME "/input0";
518 	rcdev->input_id.bustype = BUS_HOST;
519 	rcdev->input_id.vendor = 0x0001;
520 	rcdev->input_id.product = 0x0001;
521 	rcdev->input_id.version = 0x0100;
522 	rcdev->open = serial_ir_open;
523 	rcdev->close = serial_ir_close;
524 	rcdev->dev.parent = &serial_ir.pdev->dev;
525 	rcdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
526 	rcdev->driver_name = KBUILD_MODNAME;
527 	rcdev->map_name = RC_MAP_RC6_MCE;
528 	rcdev->min_timeout = 1;
529 	rcdev->timeout = IR_DEFAULT_TIMEOUT;
530 	rcdev->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
531 	rcdev->rx_resolution = 250;
532 
533 	serial_ir.rcdev = rcdev;
534 
535 	timer_setup(&serial_ir.timeout_timer, serial_ir_timeout, 0);
536 
537 	result = devm_request_irq(&dev->dev, irq, serial_ir_irq_handler,
538 				  share_irq ? IRQF_SHARED : 0,
539 				  KBUILD_MODNAME, &hardware);
540 	if (result < 0) {
541 		if (result == -EBUSY)
542 			dev_err(&dev->dev, "IRQ %d busy\n", irq);
543 		else if (result == -EINVAL)
544 			dev_err(&dev->dev, "Bad irq number or handler\n");
545 		return result;
546 	}
547 
548 	/* Reserve io region. */
549 	if ((iommap &&
550 	     (devm_request_mem_region(&dev->dev, iommap, 8UL << ioshift,
551 				      KBUILD_MODNAME) == NULL)) ||
552 	     (!iommap && (devm_request_region(&dev->dev, io, 8,
553 			  KBUILD_MODNAME) == NULL))) {
554 		dev_err(&dev->dev, "port %04x already in use\n", io);
555 		dev_warn(&dev->dev, "use 'setserial /dev/ttySX uart none'\n");
556 		dev_warn(&dev->dev,
557 			 "or compile the serial port driver as module and\n");
558 		dev_warn(&dev->dev, "make sure this module is loaded first\n");
559 		return -EBUSY;
560 	}
561 
562 	result = hardware_init_port();
563 	if (result < 0)
564 		return result;
565 
566 	/* Initialize pulse/space widths */
567 	serial_ir.duty_cycle = 50;
568 	serial_ir.carrier = 38000;
569 
570 	/* If pin is high, then this must be an active low receiver. */
571 	if (sense == -1) {
572 		/* wait 1/2 sec for the power supply */
573 		msleep(500);
574 
575 		/*
576 		 * probe 9 times every 0.04s, collect "votes" for
577 		 * active high/low
578 		 */
579 		nlow = 0;
580 		nhigh = 0;
581 		for (i = 0; i < 9; i++) {
582 			if (sinp(UART_MSR) & hardware[type].signal_pin)
583 				nlow++;
584 			else
585 				nhigh++;
586 			msleep(40);
587 		}
588 		sense = nlow >= nhigh ? 1 : 0;
589 		dev_info(&dev->dev, "auto-detected active %s receiver\n",
590 			 sense ? "low" : "high");
591 	} else
592 		dev_info(&dev->dev, "Manually using active %s receiver\n",
593 			 sense ? "low" : "high");
594 
595 	dev_dbg(&dev->dev, "Interrupt %d, port %04x obtained\n", irq, io);
596 
597 	return devm_rc_register_device(&dev->dev, rcdev);
598 }
599 
serial_ir_open(struct rc_dev * rcdev)600 static int serial_ir_open(struct rc_dev *rcdev)
601 {
602 	unsigned long flags;
603 
604 	/* initialize timestamp */
605 	serial_ir.lastkt = ktime_get();
606 
607 	spin_lock_irqsave(&hardware[type].lock, flags);
608 
609 	/* Set DLAB 0. */
610 	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
611 
612 	soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI);
613 
614 	spin_unlock_irqrestore(&hardware[type].lock, flags);
615 
616 	return 0;
617 }
618 
serial_ir_close(struct rc_dev * rcdev)619 static void serial_ir_close(struct rc_dev *rcdev)
620 {
621 	unsigned long flags;
622 
623 	spin_lock_irqsave(&hardware[type].lock, flags);
624 
625 	/* Set DLAB 0. */
626 	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
627 
628 	/* First of all, disable all interrupts */
629 	soutp(UART_IER, sinp(UART_IER) &
630 	      (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
631 	spin_unlock_irqrestore(&hardware[type].lock, flags);
632 }
633 
serial_ir_tx(struct rc_dev * dev,unsigned int * txbuf,unsigned int count)634 static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
635 			unsigned int count)
636 {
637 	unsigned long flags;
638 	ktime_t edge;
639 	s64 delta;
640 	int i;
641 
642 	spin_lock_irqsave(&hardware[type].lock, flags);
643 	if (type == IR_IRDEO) {
644 		/* DTR, RTS down */
645 		on();
646 	}
647 
648 	edge = ktime_get();
649 	for (i = 0; i < count; i++) {
650 		if (i % 2)
651 			hardware[type].send_space();
652 		else
653 			hardware[type].send_pulse(txbuf[i], edge);
654 
655 		edge = ktime_add_us(edge, txbuf[i]);
656 		delta = ktime_us_delta(edge, ktime_get());
657 		if (delta > 25) {
658 			spin_unlock_irqrestore(&hardware[type].lock, flags);
659 			usleep_range(delta - 25, delta + 25);
660 			spin_lock_irqsave(&hardware[type].lock, flags);
661 		} else if (delta > 0) {
662 			udelay(delta);
663 		}
664 	}
665 	off();
666 	spin_unlock_irqrestore(&hardware[type].lock, flags);
667 	return count;
668 }
669 
serial_ir_tx_duty_cycle(struct rc_dev * dev,u32 cycle)670 static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle)
671 {
672 	serial_ir.duty_cycle = cycle;
673 	return 0;
674 }
675 
serial_ir_tx_carrier(struct rc_dev * dev,u32 carrier)676 static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier)
677 {
678 	if (carrier > 500000 || carrier < 20000)
679 		return -EINVAL;
680 
681 	serial_ir.carrier = carrier;
682 	return 0;
683 }
684 
serial_ir_suspend(struct platform_device * dev,pm_message_t state)685 static int serial_ir_suspend(struct platform_device *dev,
686 			     pm_message_t state)
687 {
688 	/* Set DLAB 0. */
689 	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));
690 
691 	/* Disable all interrupts */
692 	soutp(UART_IER, sinp(UART_IER) &
693 	      (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
694 
695 	/* Clear registers. */
696 	sinp(UART_LSR);
697 	sinp(UART_RX);
698 	sinp(UART_IIR);
699 	sinp(UART_MSR);
700 
701 	return 0;
702 }
703 
serial_ir_resume(struct platform_device * dev)704 static int serial_ir_resume(struct platform_device *dev)
705 {
706 	unsigned long flags;
707 	int result;
708 
709 	result = hardware_init_port();
710 	if (result < 0)
711 		return result;
712 
713 	spin_lock_irqsave(&hardware[type].lock, flags);
714 	/* Enable Interrupt */
715 	serial_ir.lastkt = ktime_get();
716 	soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI);
717 	off();
718 
719 	spin_unlock_irqrestore(&hardware[type].lock, flags);
720 
721 	return 0;
722 }
723 
724 static struct platform_driver serial_ir_driver = {
725 	.probe		= serial_ir_probe,
726 	.suspend	= serial_ir_suspend,
727 	.resume		= serial_ir_resume,
728 	.driver		= {
729 		.name	= "serial_ir",
730 	},
731 };
732 
serial_ir_init(void)733 static int __init serial_ir_init(void)
734 {
735 	int result;
736 
737 	result = platform_driver_register(&serial_ir_driver);
738 	if (result)
739 		return result;
740 
741 	serial_ir.pdev = platform_device_alloc("serial_ir", 0);
742 	if (!serial_ir.pdev) {
743 		result = -ENOMEM;
744 		goto exit_driver_unregister;
745 	}
746 
747 	result = platform_device_add(serial_ir.pdev);
748 	if (result)
749 		goto exit_device_put;
750 
751 	return 0;
752 
753 exit_device_put:
754 	platform_device_put(serial_ir.pdev);
755 exit_driver_unregister:
756 	platform_driver_unregister(&serial_ir_driver);
757 	return result;
758 }
759 
serial_ir_exit(void)760 static void serial_ir_exit(void)
761 {
762 	platform_device_unregister(serial_ir.pdev);
763 	platform_driver_unregister(&serial_ir_driver);
764 }
765 
serial_ir_init_module(void)766 static int __init serial_ir_init_module(void)
767 {
768 	switch (type) {
769 	case IR_HOMEBREW:
770 	case IR_IRDEO:
771 	case IR_IRDEO_REMOTE:
772 	case IR_ANIMAX:
773 	case IR_IGOR:
774 		/* if nothing specified, use ttyS0/com1 and irq 4 */
775 		io = io ? io : 0x3f8;
776 		irq = irq ? irq : 4;
777 		break;
778 	default:
779 		return -EINVAL;
780 	}
781 	if (!softcarrier) {
782 		switch (type) {
783 		case IR_HOMEBREW:
784 		case IR_IGOR:
785 			hardware[type].set_send_carrier = false;
786 			hardware[type].set_duty_cycle = false;
787 			break;
788 		}
789 	}
790 
791 	/* make sure sense is either -1, 0, or 1 */
792 	if (sense != -1)
793 		sense = !!sense;
794 
795 	return serial_ir_init();
796 }
797 
serial_ir_exit_module(void)798 static void __exit serial_ir_exit_module(void)
799 {
800 	del_timer_sync(&serial_ir.timeout_timer);
801 	serial_ir_exit();
802 }
803 
804 module_init(serial_ir_init_module);
805 module_exit(serial_ir_exit_module);
806 
807 MODULE_DESCRIPTION("Infra-red receiver driver for serial ports.");
808 MODULE_AUTHOR("Ralph Metzler, Trent Piepho, Ben Pfaff, Christoph Bartelmus, Andrei Tanas");
809 MODULE_LICENSE("GPL");
810 
811 module_param(type, int, 0444);
812 MODULE_PARM_DESC(type, "Hardware type (0 = home-brew, 1 = IRdeo, 2 = IRdeo Remote, 3 = AnimaX, 4 = IgorPlug");
813 
814 module_param_hw(io, int, ioport, 0444);
815 MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)");
816 
817 /* some architectures (e.g. intel xscale) have memory mapped registers */
818 module_param_hw(iommap, ulong, other, 0444);
819 MODULE_PARM_DESC(iommap, "physical base for memory mapped I/O (0 = no memory mapped io)");
820 
821 /*
822  * some architectures (e.g. intel xscale) align the 8bit serial registers
823  * on 32bit word boundaries.
824  * See linux-kernel/drivers/tty/serial/8250/8250.c serial_in()/out()
825  */
826 module_param_hw(ioshift, int, other, 0444);
827 MODULE_PARM_DESC(ioshift, "shift I/O register offset (0 = no shift)");
828 
829 module_param_hw(irq, int, irq, 0444);
830 MODULE_PARM_DESC(irq, "Interrupt (4 or 3)");
831 
832 module_param_hw(share_irq, bool, other, 0444);
833 MODULE_PARM_DESC(share_irq, "Share interrupts (0 = off, 1 = on)");
834 
835 module_param(sense, int, 0444);
836 MODULE_PARM_DESC(sense, "Override autodetection of IR receiver circuit (0 = active high, 1 = active low )");
837 
838 #ifdef CONFIG_IR_SERIAL_TRANSMITTER
839 module_param(txsense, bool, 0444);
840 MODULE_PARM_DESC(txsense, "Sense of transmitter circuit (0 = active high, 1 = active low )");
841 #endif
842 
843 module_param(softcarrier, bool, 0444);
844 MODULE_PARM_DESC(softcarrier, "Software carrier (0 = off, 1 = on, default on)");
845