serial_ir.c 20.9 KB
Newer Older
1
/*
2
 * serial_ir.c
3
 *
4
 * serial_ir - Device driver that records pulse- and pause-lengths
5 6 7 8 9 10 11
 *	       (space-lengths) between DDCD event on a serial port.
 *
 * Copyright (C) 1996,97 Ralph Metzler <rjkm@thp.uni-koeln.de>
 * Copyright (C) 1998 Trent Piepho <xyzzy@u.washington.edu>
 * Copyright (C) 1998 Ben Pfaff <blp@gnu.org>
 * Copyright (C) 1999 Christoph Bartelmus <lirc@bartelmus.de>
 * Copyright (C) 2007 Andrei Tanas <andrei@tanas.ca> (suspend/resume support)
S
Sean Young 已提交
12
 * Copyright (C) 2016 Sean Young <sean@mess.org> (port to rc-core)
13 14 15 16 17 18 19 20 21 22 23
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 */

24 25
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

26 27 28 29 30 31 32 33 34
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/serial_reg.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>
S
Sean Young 已提交
35
#include <media/rc-core.h>
36

S
Sean Young 已提交
37
struct serial_ir_hw {
38 39 40 41
	int signal_pin;
	int signal_pin_change;
	u8 on;
	u8 off;
S
Sean Young 已提交
42 43
	unsigned set_send_carrier:1;
	unsigned set_duty_cycle:1;
44 45
	void (*send_pulse)(unsigned int length, ktime_t edge);
	void (*send_space)(void);
46 47 48
	spinlock_t lock;
};

S
Sean Young 已提交
49 50 51 52 53
#define IR_HOMEBREW	0
#define IR_IRDEO	1
#define IR_IRDEO_REMOTE	2
#define IR_ANIMAX	3
#define IR_IGOR		4
54

S
Sean Young 已提交
55
/* module parameters */
56 57 58
static int type;
static int io;
static int irq;
59
static bool 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 68
static void send_pulse_irdeo(unsigned int length, ktime_t edge);
static void send_space_irdeo(void);
S
Sean Young 已提交
69
#ifdef CONFIG_IR_SERIAL_TRANSMITTER
70 71
static void send_pulse_homebrew(unsigned int length, ktime_t edge);
static void send_space_homebrew(void);
S
Sean Young 已提交
72
#endif
73

S
Sean Young 已提交
74 75 76 77
static struct serial_ir_hw hardware[] = {
	[IR_HOMEBREW] = {
		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_HOMEBREW].lock),
		.signal_pin	   = UART_MSR_DCD,
78 79 80
		.signal_pin_change = UART_MSR_DDCD,
		.on  = (UART_MCR_RTS | UART_MCR_OUT2 | UART_MCR_DTR),
		.off = (UART_MCR_RTS | UART_MCR_OUT2),
S
Sean Young 已提交
81
#ifdef CONFIG_IR_SERIAL_TRANSMITTER
82 83
		.send_pulse = send_pulse_homebrew,
		.send_space = send_space_homebrew,
S
Sean Young 已提交
84 85
		.set_send_carrier = true,
		.set_duty_cycle = true,
86 87 88
#endif
	},

S
Sean Young 已提交
89 90 91
	[IR_IRDEO] = {
		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IRDEO].lock),
		.signal_pin	   = UART_MSR_DSR,
92 93 94
		.signal_pin_change = UART_MSR_DDSR,
		.on  = UART_MCR_OUT2,
		.off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
S
Sean Young 已提交
95 96 97
		.send_pulse = send_pulse_irdeo,
		.send_space = send_space_irdeo,
		.set_duty_cycle = true,
98 99
	},

S
Sean Young 已提交
100 101 102
	[IR_IRDEO_REMOTE] = {
		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IRDEO_REMOTE].lock),
		.signal_pin	   = UART_MSR_DSR,
103 104 105
		.signal_pin_change = UART_MSR_DDSR,
		.on  = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
		.off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
S
Sean Young 已提交
106 107 108
		.send_pulse = send_pulse_irdeo,
		.send_space = send_space_irdeo,
		.set_duty_cycle = true,
109 110
	},

S
Sean Young 已提交
111 112 113
	[IR_ANIMAX] = {
		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_ANIMAX].lock),
		.signal_pin	   = UART_MSR_DCD,
114 115 116 117 118
		.signal_pin_change = UART_MSR_DDCD,
		.on  = 0,
		.off = (UART_MCR_RTS | UART_MCR_DTR | UART_MCR_OUT2),
	},

S
Sean Young 已提交
119 120 121
	[IR_IGOR] = {
		.lock = __SPIN_LOCK_UNLOCKED(hardware[IR_IGOR].lock),
		.signal_pin	   = UART_MSR_DSR,
122 123 124
		.signal_pin_change = UART_MSR_DDSR,
		.on  = (UART_MCR_RTS | UART_MCR_OUT2 | UART_MCR_DTR),
		.off = (UART_MCR_RTS | UART_MCR_OUT2),
S
Sean Young 已提交
125
#ifdef CONFIG_IR_SERIAL_TRANSMITTER
126 127
		.send_pulse = send_pulse_homebrew,
		.send_space = send_space_homebrew,
S
Sean Young 已提交
128 129
		.set_send_carrier = true,
		.set_duty_cycle = true,
130 131 132 133 134 135
#endif
	},
};

#define RS_ISR_PASS_LIMIT 256

S
Sean Young 已提交
136 137 138 139
struct serial_ir {
	ktime_t lastkt;
	struct rc_dev *rcdev;
	struct platform_device *pdev;
S
Sean Young 已提交
140
	struct timer_list timeout_timer;
141

S
Sean Young 已提交
142 143
	unsigned int freq;
	unsigned int duty_cycle;
144

145
	unsigned int pulse_width, space_width;
S
Sean Young 已提交
146
};
147

S
Sean Young 已提交
148
static struct serial_ir serial_ir;
149 150 151 152

/* fetch serial input packet (1 byte) from register offset */
static u8 sinp(int offset)
{
153
	if (iommap)
154 155 156 157 158 159 160 161 162
		/* the register is memory-mapped */
		offset <<= ioshift;

	return inb(io + offset);
}

/* write serial output packet (1 byte) of value to register offset */
static void soutp(int offset, u8 value)
{
163
	if (iommap)
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
		/* the register is memory-mapped */
		offset <<= ioshift;

	outb(value, io + offset);
}

static void on(void)
{
	if (txsense)
		soutp(UART_MCR, hardware[type].off);
	else
		soutp(UART_MCR, hardware[type].on);
}

static void off(void)
{
	if (txsense)
		soutp(UART_MCR, hardware[type].on);
	else
		soutp(UART_MCR, hardware[type].off);
}

186 187
static void init_timing_params(unsigned int new_duty_cycle,
			       unsigned int new_freq)
188
{
S
Sean Young 已提交
189 190
	serial_ir.duty_cycle = new_duty_cycle;
	serial_ir.freq = new_freq;
191

192 193 194 195
	serial_ir.pulse_width = DIV_ROUND_CLOSEST(
		new_duty_cycle * NSEC_PER_SEC, new_freq * 100l);
	serial_ir.space_width = DIV_ROUND_CLOSEST(
		(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 202 203 204 205 206
	int i;
	unsigned char output;
	unsigned char chunk, shifted;

	/* how many bits have to be sent ? */
	rawbits = length * 1152 / 10000;
S
Sean Young 已提交
207
	if (serial_ir.duty_cycle > 50)
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
		chunk = 3;
	else
		chunk = 1;
	for (i = 0, output = 0x7f; rawbits > 0; rawbits -= 3) {
		shifted = chunk << (i * 3);
		shifted >>= 1;
		output &= (~shifted);
		i++;
		if (i == 3) {
			soutp(UART_TX, output);
			while (!(sinp(UART_LSR) & UART_LSR_THRE))
				;
			output = 0x7f;
			i = 0;
		}
	}
	if (i != 0) {
		soutp(UART_TX, output);
		while (!(sinp(UART_LSR) & UART_LSR_TEMT))
			;
	}
}

231
static void send_space_irdeo(void)
S
Sean Young 已提交
232 233 234 235
{
}

#ifdef CONFIG_IR_SERIAL_TRANSMITTER
236
static void send_pulse_homebrew_softcarrier(unsigned int length, ktime_t edge)
237
{
238 239 240 241 242 243
	ktime_t now, target = ktime_add_us(edge, length);
	/*
	 * delta should never exceed 4 seconds and on m68k
	 * ndelay(s64) does not compile; so use s32 rather than s64.
	 */
	s32 delta;
244

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
	for (;;) {
		now = ktime_get();
		if (ktime_compare(now, target) >= 0)
			break;
		on();
		edge = ktime_add_ns(edge, serial_ir.pulse_width);
		delta = ktime_to_ns(ktime_sub(edge, now));
		if (delta > 0)
			ndelay(delta);
		now = ktime_get();
		off();
		if (ktime_compare(now, target) >= 0)
			break;
		edge = ktime_add_ns(edge, serial_ir.space_width);
		delta = ktime_to_ns(ktime_sub(edge, now));
		if (delta > 0)
			ndelay(delta);
262 263 264
	}
}

265
static void send_pulse_homebrew(unsigned int length, ktime_t edge)
266 267
{
	if (softcarrier)
268 269 270
		send_pulse_homebrew_softcarrier(length, edge);
	else
		on();
271 272
}

273
static void send_space_homebrew(void)
274 275 276
{
	off();
}
S
Sean Young 已提交
277
#endif
278

S
Sean Young 已提交
279
static void frbwrite(unsigned int l, bool is_pulse)
280 281
{
	/* simple noise filter */
S
Sean Young 已提交
282 283 284 285 286 287 288 289 290 291 292 293
	static unsigned int ptr, pulse, space;
	DEFINE_IR_RAW_EVENT(ev);

	if (ptr > 0 && is_pulse) {
		pulse += l;
		if (pulse > 250000) {
			ev.duration = space;
			ev.pulse = false;
			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
			ev.duration = pulse;
			ev.pulse = true;
			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
294 295 296 297 298
			ptr = 0;
			pulse = 0;
		}
		return;
	}
S
Sean Young 已提交
299
	if (!is_pulse) {
300
		if (ptr == 0) {
S
Sean Young 已提交
301
			if (l > 20000000) {
302 303 304 305 306
				space = l;
				ptr++;
				return;
			}
		} else {
S
Sean Young 已提交
307
			if (l > 20000000) {
308
				space += pulse;
S
Sean Young 已提交
309 310
				if (space > IR_MAX_DURATION)
					space = IR_MAX_DURATION;
311
				space += l;
S
Sean Young 已提交
312 313
				if (space > IR_MAX_DURATION)
					space = IR_MAX_DURATION;
314 315 316
				pulse = 0;
				return;
			}
S
Sean Young 已提交
317 318 319 320 321 322 323

			ev.duration = space;
			ev.pulse = false;
			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
			ev.duration = pulse;
			ev.pulse = true;
			ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
324 325 326 327
			ptr = 0;
			pulse = 0;
		}
	}
S
Sean Young 已提交
328 329 330 331

	ev.duration = l;
	ev.pulse = is_pulse;
	ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
332 333
}

S
Sean Young 已提交
334
static irqreturn_t serial_ir_irq_handler(int i, void *blah)
335
{
336
	ktime_t kt;
337 338
	int counter, dcd;
	u8 status;
339
	ktime_t delkt;
S
Sean Young 已提交
340
	unsigned int data;
341 342 343 344 345 346 347 348 349 350 351 352
	static int last_dcd = -1;

	if ((sinp(UART_IIR) & UART_IIR_NO_INT)) {
		/* not our interrupt */
		return IRQ_NONE;
	}

	counter = 0;
	do {
		counter++;
		status = sinp(UART_MSR);
		if (counter > RS_ISR_PASS_LIMIT) {
S
Sean Young 已提交
353
			dev_err(&serial_ir.pdev->dev, "Trapped in interrupt");
354 355
			break;
		}
356 357
		if ((status & hardware[type].signal_pin_change) &&
		    sense != -1) {
358
			/* get current time */
359
			kt = ktime_get();
360 361

			/*
S
Sean Young 已提交
362 363 364
			 * The driver needs to know if your receiver is
			 * active high or active low, or the space/pulse
			 * sense could be inverted.
365 366
			 */

S
Sean Young 已提交
367
			/* calc time since last interrupt in nanoseconds */
368 369 370
			dcd = (status & hardware[type].signal_pin) ? 1 : 0;

			if (dcd == last_dcd) {
S
Sean Young 已提交
371 372 373 374
				dev_err(&serial_ir.pdev->dev,
					"ignoring spike: %d %d %lldns %lldns\n",
					dcd, sense, ktime_to_ns(kt),
					ktime_to_ns(serial_ir.lastkt));
375 376 377
				continue;
			}

S
Sean Young 已提交
378
			delkt = ktime_sub(kt, serial_ir.lastkt);
379
			if (ktime_compare(delkt, ktime_set(15, 0)) > 0) {
S
Sean Young 已提交
380
				data = IR_MAX_DURATION; /* really long time */
381
				if (!(dcd ^ sense)) {
382
					/* sanity check */
S
Sean Young 已提交
383 384 385 386
					dev_err(&serial_ir.pdev->dev,
						"dcd unexpected: %d %d %lldns %lldns\n",
						dcd, sense, ktime_to_ns(kt),
						ktime_to_ns(serial_ir.lastkt));
387 388 389 390 391 392
					/*
					 * detecting pulse while this
					 * MUST be a space!
					 */
					sense = sense ? 0 : 1;
				}
393
			} else {
S
Sean Young 已提交
394
				data = ktime_to_ns(delkt);
395
			}
S
Sean Young 已提交
396 397
			frbwrite(data, !(dcd ^ sense));
			serial_ir.lastkt = kt;
398 399 400
			last_dcd = dcd;
		}
	} while (!(sinp(UART_IIR) & UART_IIR_NO_INT)); /* still pending ? */
S
Sean Young 已提交
401 402 403 404 405 406

	mod_timer(&serial_ir.timeout_timer,
		  jiffies + nsecs_to_jiffies(serial_ir.rcdev->timeout));

	ir_raw_event_handle(serial_ir.rcdev);

407 408 409 410 411 412 413 414 415
	return IRQ_HANDLED;
}

static int hardware_init_port(void)
{
	u8 scratch, scratch2, scratch3;

	/*
	 * This is a simple port existence test, borrowed from the autoconfig
416
	 * function in drivers/tty/serial/8250/8250_port.c
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
	 */
	scratch = sinp(UART_IER);
	soutp(UART_IER, 0);
#ifdef __i386__
	outb(0xff, 0x080);
#endif
	scratch2 = sinp(UART_IER) & 0x0f;
	soutp(UART_IER, 0x0f);
#ifdef __i386__
	outb(0x00, 0x080);
#endif
	scratch3 = sinp(UART_IER) & 0x0f;
	soutp(UART_IER, scratch);
	if (scratch2 != 0 || scratch3 != 0x0f) {
		/* we fail, there's nothing here */
432
		pr_err("port existence test failed, cannot continue\n");
433
		return -ENODEV;
434 435 436 437 438 439 440
	}

	/* Set DLAB 0. */
	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));

	/* First of all, disable all interrupts */
	soutp(UART_IER, sinp(UART_IER) &
441
	      (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458

	/* Clear registers. */
	sinp(UART_LSR);
	sinp(UART_RX);
	sinp(UART_IIR);
	sinp(UART_MSR);

	/* Set line for power source */
	off();

	/* Clear registers again to be sure. */
	sinp(UART_LSR);
	sinp(UART_RX);
	sinp(UART_IIR);
	sinp(UART_MSR);

	switch (type) {
S
Sean Young 已提交
459 460
	case IR_IRDEO:
	case IR_IRDEO_REMOTE:
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
		/* setup port to 7N1 @ 115200 Baud */
		/* 7N1+start = 9 bits at 115200 ~ 3 bits at 38kHz */

		/* Set DLAB 1. */
		soutp(UART_LCR, sinp(UART_LCR) | UART_LCR_DLAB);
		/* Set divisor to 1 => 115200 Baud */
		soutp(UART_DLM, 0);
		soutp(UART_DLL, 1);
		/* Set DLAB 0 +  7N1 */
		soutp(UART_LCR, UART_LCR_WLEN7);
		/* THR interrupt already disabled at this point */
		break;
	default:
		break;
	}

	return 0;
}

S
Sean Young 已提交
480 481 482 483 484 485 486 487 488 489
static void serial_ir_timeout(unsigned long arg)
{
	DEFINE_IR_RAW_EVENT(ev);

	ev.timeout = true;
	ev.duration = serial_ir.rcdev->timeout;
	ir_raw_event_store_with_filter(serial_ir.rcdev, &ev);
	ir_raw_event_handle(serial_ir.rcdev);
}

490 491 492 493 494 495 496 497
/* Needed by serial_ir_probe() */
static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
			unsigned int count);
static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle);
static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier);
static int serial_ir_open(struct rc_dev *rcdev);
static void serial_ir_close(struct rc_dev *rcdev);

S
Sean Young 已提交
498
static int serial_ir_probe(struct platform_device *dev)
499
{
500
	struct rc_dev *rcdev;
501 502
	int i, nlow, nhigh, result;

503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
	rcdev = devm_rc_allocate_device(&dev->dev, RC_DRIVER_IR_RAW);
	if (!rcdev)
		return -ENOMEM;

	if (hardware[type].send_pulse && hardware[type].send_space)
		rcdev->tx_ir = serial_ir_tx;
	if (hardware[type].set_send_carrier)
		rcdev->s_tx_carrier = serial_ir_tx_carrier;
	if (hardware[type].set_duty_cycle)
		rcdev->s_tx_duty_cycle = serial_ir_tx_duty_cycle;

	switch (type) {
	case IR_HOMEBREW:
		rcdev->input_name = "Serial IR type home-brew";
		break;
	case IR_IRDEO:
		rcdev->input_name = "Serial IR type IRdeo";
		break;
	case IR_IRDEO_REMOTE:
		rcdev->input_name = "Serial IR type IRdeo remote";
		break;
	case IR_ANIMAX:
		rcdev->input_name = "Serial IR type AnimaX";
		break;
	case IR_IGOR:
		rcdev->input_name = "Serial IR type IgorPlug";
		break;
	}

	rcdev->input_phys = KBUILD_MODNAME "/input0";
	rcdev->input_id.bustype = BUS_HOST;
	rcdev->input_id.vendor = 0x0001;
	rcdev->input_id.product = 0x0001;
	rcdev->input_id.version = 0x0100;
	rcdev->open = serial_ir_open;
	rcdev->close = serial_ir_close;
	rcdev->dev.parent = &serial_ir.pdev->dev;
	rcdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
	rcdev->driver_name = KBUILD_MODNAME;
	rcdev->map_name = RC_MAP_RC6_MCE;
	rcdev->min_timeout = 1;
	rcdev->timeout = IR_DEFAULT_TIMEOUT;
	rcdev->max_timeout = 10 * IR_DEFAULT_TIMEOUT;
	rcdev->rx_resolution = 250000;

	serial_ir.rcdev = rcdev;

	setup_timer(&serial_ir.timeout_timer, serial_ir_timeout,
		    (unsigned long)&serial_ir);

S
Sean Young 已提交
553 554 555
	result = devm_request_irq(&dev->dev, irq, serial_ir_irq_handler,
				  share_irq ? IRQF_SHARED : 0,
				  KBUILD_MODNAME, &hardware);
556 557
	if (result < 0) {
		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 562
		return result;
	}
563 564

	/* Reserve io region. */
565 566 567 568 569
	if ((iommap &&
	     (devm_request_mem_region(&dev->dev, iommap, 8 << ioshift,
				      KBUILD_MODNAME) == NULL)) ||
	     (!iommap && (devm_request_region(&dev->dev, io, 8,
			  KBUILD_MODNAME) == NULL))) {
570 571 572 573 574
		dev_err(&dev->dev, "port %04x already in use\n", io);
		dev_warn(&dev->dev, "use 'setserial /dev/ttySX uart none'\n");
		dev_warn(&dev->dev,
			 "or compile the serial port driver as module and\n");
		dev_warn(&dev->dev, "make sure this module is loaded first\n");
575
		return -EBUSY;
576 577
	}

578 579
	result = hardware_init_port();
	if (result < 0)
580
		return result;
581 582

	/* Initialize pulse/space widths */
S
Sean Young 已提交
583
	init_timing_params(50, 38000);
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602

	/* If pin is high, then this must be an active low receiver. */
	if (sense == -1) {
		/* wait 1/2 sec for the power supply */
		msleep(500);

		/*
		 * probe 9 times every 0.04s, collect "votes" for
		 * active high/low
		 */
		nlow = 0;
		nhigh = 0;
		for (i = 0; i < 9; i++) {
			if (sinp(UART_MSR) & hardware[type].signal_pin)
				nlow++;
			else
				nhigh++;
			msleep(40);
		}
603
		sense = nlow >= nhigh ? 1 : 0;
604 605
		dev_info(&dev->dev, "auto-detected active %s receiver\n",
			 sense ? "low" : "high");
606
	} else
607 608
		dev_info(&dev->dev, "Manually using active %s receiver\n",
			 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
}

S
Sean Young 已提交
615
static int serial_ir_open(struct rc_dev *rcdev)
616 617 618 619
{
	unsigned long flags;

	/* initialize timestamp */
S
Sean Young 已提交
620
	serial_ir.lastkt = ktime_get();
621 622 623 624 625 626

	spin_lock_irqsave(&hardware[type].lock, flags);

	/* Set DLAB 0. */
	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));

627
	soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI);
628 629 630 631 632 633

	spin_unlock_irqrestore(&hardware[type].lock, flags);

	return 0;
}

S
Sean Young 已提交
634 635 636
static void serial_ir_close(struct rc_dev *rcdev)
{
	unsigned long flags;
637 638 639 640 641 642 643 644

	spin_lock_irqsave(&hardware[type].lock, flags);

	/* Set DLAB 0. */
	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));

	/* First of all, disable all interrupts */
	soutp(UART_IER, sinp(UART_IER) &
645
	      (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
646 647 648
	spin_unlock_irqrestore(&hardware[type].lock, flags);
}

S
Sean Young 已提交
649 650
static int serial_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
			unsigned int count)
651 652
{
	unsigned long flags;
653 654
	ktime_t edge;
	s64 delta;
S
Sean Young 已提交
655
	int i;
656 657

	spin_lock_irqsave(&hardware[type].lock, flags);
S
Sean Young 已提交
658
	if (type == IR_IRDEO) {
659 660 661
		/* DTR, RTS down */
		on();
	}
662 663

	edge = ktime_get();
664
	for (i = 0; i < count; i++) {
665
		if (i % 2)
666
			hardware[type].send_space();
667
		else
668 669 670 671 672 673 674 675
			hardware[type].send_pulse(txbuf[i], edge);

		edge = ktime_add_us(edge, txbuf[i]);
		delta = ktime_us_delta(edge, ktime_get());
		if (delta > 25) {
			spin_unlock_irqrestore(&hardware[type].lock, flags);
			usleep_range(delta - 25, delta + 25);
			spin_lock_irqsave(&hardware[type].lock, flags);
676
		} else if (delta > 0) {
677
			udelay(delta);
678
		}
679 680 681
	}
	off();
	spin_unlock_irqrestore(&hardware[type].lock, flags);
S
Sean Young 已提交
682
	return count;
683 684
}

S
Sean Young 已提交
685
static int serial_ir_tx_duty_cycle(struct rc_dev *dev, u32 cycle)
686
{
687 688
	init_timing_params(cycle, serial_ir.freq);
	return 0;
689 690
}

S
Sean Young 已提交
691 692 693 694
static int serial_ir_tx_carrier(struct rc_dev *dev, u32 carrier)
{
	if (carrier > 500000 || carrier < 20000)
		return -EINVAL;
695

696 697
	init_timing_params(serial_ir.duty_cycle, carrier);
	return 0;
S
Sean Young 已提交
698
}
699

S
Sean Young 已提交
700 701
static int serial_ir_suspend(struct platform_device *dev,
			     pm_message_t state)
702 703 704 705 706 707
{
	/* Set DLAB 0. */
	soutp(UART_LCR, sinp(UART_LCR) & (~UART_LCR_DLAB));

	/* Disable all interrupts */
	soutp(UART_IER, sinp(UART_IER) &
708
	      (~(UART_IER_MSI | UART_IER_RLSI | UART_IER_THRI | UART_IER_RDI)));
709 710 711 712 713 714 715 716 717 718

	/* Clear registers. */
	sinp(UART_LSR);
	sinp(UART_RX);
	sinp(UART_IIR);
	sinp(UART_MSR);

	return 0;
}

S
Sean Young 已提交
719
static int serial_ir_resume(struct platform_device *dev)
720 721
{
	unsigned long flags;
722
	int result;
723

724 725 726
	result = hardware_init_port();
	if (result < 0)
		return result;
727 728 729

	spin_lock_irqsave(&hardware[type].lock, flags);
	/* Enable Interrupt */
S
Sean Young 已提交
730
	serial_ir.lastkt = ktime_get();
731
	soutp(UART_IER, sinp(UART_IER) | UART_IER_MSI);
732 733 734 735 736 737 738
	off();

	spin_unlock_irqrestore(&hardware[type].lock, flags);

	return 0;
}

S
Sean Young 已提交
739 740 741 742
static struct platform_driver serial_ir_driver = {
	.probe		= serial_ir_probe,
	.suspend	= serial_ir_suspend,
	.resume		= serial_ir_resume,
743
	.driver		= {
S
Sean Young 已提交
744
		.name	= "serial_ir",
745 746 747
	},
};

S
Sean Young 已提交
748
static int __init serial_ir_init(void)
749 750 751
{
	int result;

S
Sean Young 已提交
752 753
	result = platform_driver_register(&serial_ir_driver);
	if (result)
754
		return result;
755

S
Sean Young 已提交
756 757
	serial_ir.pdev = platform_device_alloc("serial_ir", 0);
	if (!serial_ir.pdev) {
758 759 760 761
		result = -ENOMEM;
		goto exit_driver_unregister;
	}

S
Sean Young 已提交
762
	result = platform_device_add(serial_ir.pdev);
763 764 765 766 767 768
	if (result)
		goto exit_device_put;

	return 0;

exit_device_put:
S
Sean Young 已提交
769
	platform_device_put(serial_ir.pdev);
770
exit_driver_unregister:
S
Sean Young 已提交
771
	platform_driver_unregister(&serial_ir_driver);
772 773 774
	return result;
}

S
Sean Young 已提交
775
static void serial_ir_exit(void)
776
{
S
Sean Young 已提交
777 778
	platform_device_unregister(serial_ir.pdev);
	platform_driver_unregister(&serial_ir_driver);
779 780
}

S
Sean Young 已提交
781
static int __init serial_ir_init_module(void)
782 783 784 785
{
	int result;

	switch (type) {
S
Sean Young 已提交
786 787 788 789 790
	case IR_HOMEBREW:
	case IR_IRDEO:
	case IR_IRDEO_REMOTE:
	case IR_ANIMAX:
	case IR_IGOR:
791 792 793 794 795
		/* if nothing specified, use ttyS0/com1 and irq 4 */
		io = io ? io : 0x3f8;
		irq = irq ? irq : 4;
		break;
	default:
796
		return -EINVAL;
797 798 799
	}
	if (!softcarrier) {
		switch (type) {
S
Sean Young 已提交
800 801 802 803
		case IR_HOMEBREW:
		case IR_IGOR:
			hardware[type].set_send_carrier = false;
			hardware[type].set_duty_cycle = false;
804 805 806 807
			break;
		}
	}

808 809 810 811
	/* make sure sense is either -1, 0, or 1 */
	if (sense != -1)
		sense = !!sense;

S
Sean Young 已提交
812 813 814
	result = serial_ir_init();
	if (!result)
		return 0;
815

S
Sean Young 已提交
816 817
	serial_ir_exit();
	return result;
818 819
}

S
Sean Young 已提交
820
static void __exit serial_ir_exit_module(void)
821
{
S
Sean Young 已提交
822
	del_timer_sync(&serial_ir.timeout_timer);
S
Sean Young 已提交
823
	serial_ir_exit();
824 825
}

S
Sean Young 已提交
826 827
module_init(serial_ir_init_module);
module_exit(serial_ir_exit_module);
828 829

MODULE_DESCRIPTION("Infra-red receiver driver for serial ports.");
S
Sean Young 已提交
830
MODULE_AUTHOR("Ralph Metzler, Trent Piepho, Ben Pfaff, Christoph Bartelmus, Andrei Tanas");
831 832
MODULE_LICENSE("GPL");

S
Sean Young 已提交
833 834
module_param(type, int, 0444);
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 838 839
MODULE_PARM_DESC(io, "I/O address base (0x3f8 or 0x2f8)");

/* some architectures (e.g. intel xscale) have memory mapped registers */
840
module_param_hw(iommap, bool, other, 0444);
S
Sean Young 已提交
841
MODULE_PARM_DESC(iommap, "physical base for memory mapped I/O (0 = no memory mapped io)");
842 843 844 845

/*
 * some architectures (e.g. intel xscale) align the 8bit serial registers
 * 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 850
MODULE_PARM_DESC(ioshift, "shift I/O register offset (0 = no shift)");

851
module_param_hw(irq, int, irq, 0444);
852 853
MODULE_PARM_DESC(irq, "Interrupt (4 or 3)");

854
module_param_hw(share_irq, bool, other, 0444);
855 856
MODULE_PARM_DESC(share_irq, "Share interrupts (0 = off, 1 = on)");

S
Sean Young 已提交
857 858
module_param(sense, int, 0444);
MODULE_PARM_DESC(sense, "Override autodetection of IR receiver circuit (0 = active high, 1 = active low )");
859

S
Sean Young 已提交
860 861 862
#ifdef CONFIG_IR_SERIAL_TRANSMITTER
module_param(txsense, bool, 0444);
MODULE_PARM_DESC(txsense, "Sense of transmitter circuit (0 = active high, 1 = active low )");
863 864
#endif

S
Sean Young 已提交
865
module_param(softcarrier, bool, 0444);
866
MODULE_PARM_DESC(softcarrier, "Software carrier (0 = off, 1 = on, default on)");