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