?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / media / rc / ene_ir.c
blob6049e5c95394fb1fb923aa59b5fc00fde18ace43
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * driver for ENE KB3926 B/C/D/E/F CIR (pnp id: ENE0XXX)
4 *
5 * Copyright (C) 2010 Maxim Levitsky <maximlevitsky@gmail.com>
6 *
7 * Special thanks to:
8 * Sami R. <maesesami@gmail.com> for lot of help in debugging and therefore
9 * bringing to life support for transmission & learning mode.
10 *
11 * Charlie Andrews <charliethepilot@googlemail.com> for lots of help in
12 * bringing up the support of new firmware buffer that is popular
13 * on latest notebooks
14 *
15 * ENE for partial device documentation
16 */
17
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/pnp.h>
23 #include <linux/io.h>
24 #include <linux/interrupt.h>
25 #include <linux/sched.h>
26 #include <linux/slab.h>
27 #include <media/rc-core.h>
28 #include "ene_ir.h"
29
30 static int sample_period;
31 static bool learning_mode_force;
32 static int debug;
33 static bool txsim;
34
35 static void ene_set_reg_addr(struct ene_device *dev, u16 reg)
36 {
37 outb(reg >> 8, dev->hw_io + ENE_ADDR_HI);
38 outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO);
39 }
40
41 /* read a hardware register */
42 static u8 ene_read_reg(struct ene_device *dev, u16 reg)
43 {
44 u8 retval;
45 ene_set_reg_addr(dev, reg);
46 retval = inb(dev->hw_io + ENE_IO);
47 dbg_regs("reg %04x == %02x", reg, retval);
48 return retval;
49 }
50
51 /* write a hardware register */
52 static void ene_write_reg(struct ene_device *dev, u16 reg, u8 value)
53 {
54 dbg_regs("reg %04x <- %02x", reg, value);
55 ene_set_reg_addr(dev, reg);
56 outb(value, dev->hw_io + ENE_IO);
57 }
58
59 /* Set bits in hardware register */
60 static void ene_set_reg_mask(struct ene_device *dev, u16 reg, u8 mask)
61 {
62 dbg_regs("reg %04x |= %02x", reg, mask);
63 ene_set_reg_addr(dev, reg);
64 outb(inb(dev->hw_io + ENE_IO) | mask, dev->hw_io + ENE_IO);
65 }
66
67 /* Clear bits in hardware register */
68 static void ene_clear_reg_mask(struct ene_device *dev, u16 reg, u8 mask)
69 {
70 dbg_regs("reg %04x &= ~%02x ", reg, mask);
71 ene_set_reg_addr(dev, reg);
72 outb(inb(dev->hw_io + ENE_IO) & ~mask, dev->hw_io + ENE_IO);
73 }
74
75 /* A helper to set/clear a bit in register according to boolean variable */
76 static void ene_set_clear_reg_mask(struct ene_device *dev, u16 reg, u8 mask,
77 bool set)
78 {
79 if (set)
80 ene_set_reg_mask(dev, reg, mask);
81 else
82 ene_clear_reg_mask(dev, reg, mask);
83 }
84
85 /* detect hardware features */
86 static int ene_hw_detect(struct ene_device *dev)
87 {
88 u8 chip_major, chip_minor;
89 u8 hw_revision, old_ver;
90 u8 fw_reg2, fw_reg1;
91
92 ene_clear_reg_mask(dev, ENE_ECSTS, ENE_ECSTS_RSRVD);
93 chip_major = ene_read_reg(dev, ENE_ECVER_MAJOR);
94 chip_minor = ene_read_reg(dev, ENE_ECVER_MINOR);
95 ene_set_reg_mask(dev, ENE_ECSTS, ENE_ECSTS_RSRVD);
96
97 hw_revision = ene_read_reg(dev, ENE_ECHV);
98 old_ver = ene_read_reg(dev, ENE_HW_VER_OLD);
99
100 dev->pll_freq = (ene_read_reg(dev, ENE_PLLFRH) << 4) +
101 (ene_read_reg(dev, ENE_PLLFRL) >> 4);
102
103 if (sample_period != ENE_DEFAULT_SAMPLE_PERIOD)
104 dev->rx_period_adjust =
105 dev->pll_freq == ENE_DEFAULT_PLL_FREQ ? 2 : 4;
106
107 if (hw_revision == 0xFF) {
108 pr_warn("device seems to be disabled\n");
109 pr_warn("send a mail to lirc-list@lists.sourceforge.net\n");
110 pr_warn("please attach output of acpidump and dmidecode\n");
111 return -ENODEV;
112 }
113
114 pr_notice("chip is 0x%02x%02x - kbver = 0x%02x, rev = 0x%02x\n",
115 chip_major, chip_minor, old_ver, hw_revision);
116
117 pr_notice("PLL freq = %d\n", dev->pll_freq);
118
119 if (chip_major == 0x33) {
120 pr_warn("chips 0x33xx aren't supported\n");
121 return -ENODEV;
122 }
123
124 if (chip_major == 0x39 && chip_minor == 0x26 && hw_revision == 0xC0) {
125 dev->hw_revision = ENE_HW_C;
126 pr_notice("KB3926C detected\n");
127 } else if (old_ver == 0x24 && hw_revision == 0xC0) {
128 dev->hw_revision = ENE_HW_B;
129 pr_notice("KB3926B detected\n");
130 } else {
131 dev->hw_revision = ENE_HW_D;
132 pr_notice("KB3926D or higher detected\n");
133 }
134
135 /* detect features hardware supports */
136 if (dev->hw_revision < ENE_HW_C)
137 return 0;
138
139 fw_reg1 = ene_read_reg(dev, ENE_FW1);
140 fw_reg2 = ene_read_reg(dev, ENE_FW2);
141
142 pr_notice("Firmware regs: %02x %02x\n", fw_reg1, fw_reg2);
143
144 dev->hw_use_gpio_0a = !!(fw_reg2 & ENE_FW2_GP0A);
145 dev->hw_learning_and_tx_capable = !!(fw_reg2 & ENE_FW2_LEARNING);
146 dev->hw_extra_buffer = !!(fw_reg1 & ENE_FW1_HAS_EXTRA_BUF);
147
148 if (dev->hw_learning_and_tx_capable)
149 dev->hw_fan_input = !!(fw_reg2 & ENE_FW2_FAN_INPUT);
150
151 pr_notice("Hardware features:\n");
152
153 if (dev->hw_learning_and_tx_capable) {
154 pr_notice("* Supports transmitting & learning mode\n");
155 pr_notice(" This feature is rare and therefore,\n");
156 pr_notice(" you are welcome to test it,\n");
157 pr_notice(" and/or contact the author via:\n");
158 pr_notice(" lirc-list@lists.sourceforge.net\n");
159 pr_notice(" or maximlevitsky@gmail.com\n");
160
161 pr_notice("* Uses GPIO %s for IR raw input\n",
162 dev->hw_use_gpio_0a ? "40" : "0A");
163
164 if (dev->hw_fan_input)
165 pr_notice("* Uses unused fan feedback input as source of demodulated IR data\n");
166 }
167
168 if (!dev->hw_fan_input)
169 pr_notice("* Uses GPIO %s for IR demodulated input\n",
170 dev->hw_use_gpio_0a ? "0A" : "40");
171
172 if (dev->hw_extra_buffer)
173 pr_notice("* Uses new style input buffer\n");
174 return 0;
175 }
176
177 /* Read properties of hw sample buffer */
178 static void ene_rx_setup_hw_buffer(struct ene_device *dev)
179 {
180 u16 tmp;
181
182 ene_rx_read_hw_pointer(dev);
183 dev->r_pointer = dev->w_pointer;
184
185 if (!dev->hw_extra_buffer) {
186 dev->buffer_len = ENE_FW_PACKET_SIZE * 2;
187 return;
188 }
189
190 tmp = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER);
191 tmp |= ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER+1) << 8;
192 dev->extra_buf1_address = tmp;
193
194 dev->extra_buf1_len = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 2);
195
196 tmp = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 3);
197 tmp |= ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 4) << 8;
198 dev->extra_buf2_address = tmp;
199
200 dev->extra_buf2_len = ene_read_reg(dev, ENE_FW_SAMPLE_BUFFER + 5);
201
202 dev->buffer_len = dev->extra_buf1_len + dev->extra_buf2_len + 8;
203
204 pr_notice("Hardware uses 2 extended buffers:\n");
205 pr_notice(" 0x%04x - len : %d\n",
206 dev->extra_buf1_address, dev->extra_buf1_len);
207 pr_notice(" 0x%04x - len : %d\n",
208 dev->extra_buf2_address, dev->extra_buf2_len);
209
210 pr_notice("Total buffer len = %d\n", dev->buffer_len);
211
212 if (dev->buffer_len > 64 || dev->buffer_len < 16)
213 goto error;
214
215 if (dev->extra_buf1_address > 0xFBFC ||
216 dev->extra_buf1_address < 0xEC00)
217 goto error;
218
219 if (dev->extra_buf2_address > 0xFBFC ||
220 dev->extra_buf2_address < 0xEC00)
221 goto error;
222
223 if (dev->r_pointer > dev->buffer_len)
224 goto error;
225
226 ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND);
227 return;
228 error:
229 pr_warn("Error validating extra buffers, device probably won't work\n");
230 dev->hw_extra_buffer = false;
231 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND);
232 }
233
234
235 /* Restore the pointers to extra buffers - to make module reload work*/
236 static void ene_rx_restore_hw_buffer(struct ene_device *dev)
237 {
238 if (!dev->hw_extra_buffer)
239 return;
240
241 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 0,
242 dev->extra_buf1_address & 0xFF);
243 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 1,
244 dev->extra_buf1_address >> 8);
245 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 2, dev->extra_buf1_len);
246
247 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 3,
248 dev->extra_buf2_address & 0xFF);
249 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 4,
250 dev->extra_buf2_address >> 8);
251 ene_write_reg(dev, ENE_FW_SAMPLE_BUFFER + 5,
252 dev->extra_buf2_len);
253 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_EXTRA_BUF_HND);
254 }
255
256 /* Read hardware write pointer */
257 static void ene_rx_read_hw_pointer(struct ene_device *dev)
258 {
259 if (dev->hw_extra_buffer)
260 dev->w_pointer = ene_read_reg(dev, ENE_FW_RX_POINTER);
261 else
262 dev->w_pointer = ene_read_reg(dev, ENE_FW2)
263 & ENE_FW2_BUF_WPTR ? 0 : ENE_FW_PACKET_SIZE;
264
265 dbg_verbose("RB: HW write pointer: %02x, driver read pointer: %02x",
266 dev->w_pointer, dev->r_pointer);
267 }
268
269 /* Gets address of next sample from HW ring buffer */
270 static int ene_rx_get_sample_reg(struct ene_device *dev)
271 {
272 int r_pointer;
273
274 if (dev->r_pointer == dev->w_pointer) {
275 dbg_verbose("RB: hit end, try update w_pointer");
276 ene_rx_read_hw_pointer(dev);
277 }
278
279 if (dev->r_pointer == dev->w_pointer) {
280 dbg_verbose("RB: end of data at %d", dev->r_pointer);
281 return 0;
282 }
283
284 dbg_verbose("RB: reading at offset %d", dev->r_pointer);
285 r_pointer = dev->r_pointer;
286
287 dev->r_pointer++;
288 if (dev->r_pointer == dev->buffer_len)
289 dev->r_pointer = 0;
290
291 dbg_verbose("RB: next read will be from offset %d", dev->r_pointer);
292
293 if (r_pointer < 8) {
294 dbg_verbose("RB: read at main buffer at %d", r_pointer);
295 return ENE_FW_SAMPLE_BUFFER + r_pointer;
296 }
297
298 r_pointer -= 8;
299
300 if (r_pointer < dev->extra_buf1_len) {
301 dbg_verbose("RB: read at 1st extra buffer at %d", r_pointer);
302 return dev->extra_buf1_address + r_pointer;
303 }
304
305 r_pointer -= dev->extra_buf1_len;
306
307 if (r_pointer < dev->extra_buf2_len) {
308 dbg_verbose("RB: read at 2nd extra buffer at %d", r_pointer);
309 return dev->extra_buf2_address + r_pointer;
310 }
311
312 dbg("attempt to read beyond ring buffer end");
313 return 0;
314 }
315
316 /* Sense current received carrier */
317 static void ene_rx_sense_carrier(struct ene_device *dev)
318 {
319 int carrier, duty_cycle;
320 int period = ene_read_reg(dev, ENE_CIRCAR_PRD);
321 int hperiod = ene_read_reg(dev, ENE_CIRCAR_HPRD);
322
323 if (!(period & ENE_CIRCAR_PRD_VALID))
324 return;
325
326 period &= ~ENE_CIRCAR_PRD_VALID;
327
328 if (!period)
329 return;
330
331 dbg("RX: hardware carrier period = %02x", period);
332 dbg("RX: hardware carrier pulse period = %02x", hperiod);
333
334 carrier = 2000000 / period;
335 duty_cycle = (hperiod * 100) / period;
336 dbg("RX: sensed carrier = %d Hz, duty cycle %d%%",
337 carrier, duty_cycle);
338 if (dev->carrier_detect_enabled) {
339 struct ir_raw_event ev = {
340 .carrier_report = true,
341 .carrier = carrier,
342 .duty_cycle = duty_cycle
343 };
344 ir_raw_event_store(dev->rdev, &ev);
345 }
346 }
347
348 /* this enables/disables the CIR RX engine */
349 static void ene_rx_enable_cir_engine(struct ene_device *dev, bool enable)
350 {
351 ene_set_clear_reg_mask(dev, ENE_CIRCFG,
352 ENE_CIRCFG_RX_EN | ENE_CIRCFG_RX_IRQ, enable);
353 }
354
355 /* this selects input for CIR engine. Ether GPIO 0A or GPIO40*/
356 static void ene_rx_select_input(struct ene_device *dev, bool gpio_0a)
357 {
358 ene_set_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_GPIO0A, gpio_0a);
359 }
360
361 /*
362 * this enables alternative input via fan tachometer sensor and bypasses
363 * the hw CIR engine
364 */
365 static void ene_rx_enable_fan_input(struct ene_device *dev, bool enable)
366 {
367 if (!dev->hw_fan_input)
368 return;
369
370 if (!enable)
371 ene_write_reg(dev, ENE_FAN_AS_IN1, 0);
372 else {
373 ene_write_reg(dev, ENE_FAN_AS_IN1, ENE_FAN_AS_IN1_EN);
374 ene_write_reg(dev, ENE_FAN_AS_IN2, ENE_FAN_AS_IN2_EN);
375 }
376 }
377
378 /* setup the receiver for RX*/
379 static void ene_rx_setup(struct ene_device *dev)
380 {
381 bool learning_mode = dev->learning_mode_enabled ||
382 dev->carrier_detect_enabled;
383 int sample_period_adjust = 0;
384
385 dbg("RX: setup receiver, learning mode = %d", learning_mode);
386
387
388 /* This selects RLC input and clears CFG2 settings */
389 ene_write_reg(dev, ENE_CIRCFG2, 0x00);
390
391 /* set sample period*/
392 if (sample_period == ENE_DEFAULT_SAMPLE_PERIOD)
393 sample_period_adjust =
394 dev->pll_freq == ENE_DEFAULT_PLL_FREQ ? 1 : 2;
395
396 ene_write_reg(dev, ENE_CIRRLC_CFG,
397 (sample_period + sample_period_adjust) |
398 ENE_CIRRLC_CFG_OVERFLOW);
399 /* revB doesn't support inputs */
400 if (dev->hw_revision < ENE_HW_C)
401 goto select_timeout;
402
403 if (learning_mode) {
404
405 WARN_ON(!dev->hw_learning_and_tx_capable);
406
407 /* Enable the opposite of the normal input
408 That means that if GPIO40 is normally used, use GPIO0A
409 and vice versa.
410 This input will carry non demodulated
411 signal, and we will tell the hw to demodulate it itself */
412 ene_rx_select_input(dev, !dev->hw_use_gpio_0a);
413 dev->rx_fan_input_inuse = false;
414
415 /* Enable carrier demodulation */
416 ene_set_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_CARR_DEMOD);
417
418 /* Enable carrier detection */
419 ene_write_reg(dev, ENE_CIRCAR_PULS, 0x63);
420 ene_set_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_CARR_DETECT,
421 dev->carrier_detect_enabled || debug);
422 } else {
423 if (dev->hw_fan_input)
424 dev->rx_fan_input_inuse = true;
425 else
426 ene_rx_select_input(dev, dev->hw_use_gpio_0a);
427
428 /* Disable carrier detection & demodulation */
429 ene_clear_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_CARR_DEMOD);
430 ene_clear_reg_mask(dev, ENE_CIRCFG2, ENE_CIRCFG2_CARR_DETECT);
431 }
432
433 select_timeout:
434 if (dev->rx_fan_input_inuse) {
435 dev->rdev->rx_resolution = ENE_FW_SAMPLE_PERIOD_FAN;
436
437 /* Fan input doesn't support timeouts, it just ends the
438 input with a maximum sample */
439 dev->rdev->min_timeout = dev->rdev->max_timeout =
440 ENE_FW_SMPL_BUF_FAN_MSK *
441 ENE_FW_SAMPLE_PERIOD_FAN;
442 } else {
443 dev->rdev->rx_resolution = sample_period;
444
445 /* Theoreticly timeout is unlimited, but we cap it
446 * because it was seen that on one device, it
447 * would stop sending spaces after around 250 msec.
448 * Besides, this is close to 2^32 anyway and timeout is u32.
449 */
450 dev->rdev->min_timeout = 127 * sample_period;
451 dev->rdev->max_timeout = 200000;
452 }
453
454 if (dev->hw_learning_and_tx_capable)
455 dev->rdev->tx_resolution = sample_period;
456
457 if (dev->rdev->timeout > dev->rdev->max_timeout)
458 dev->rdev->timeout = dev->rdev->max_timeout;
459 if (dev->rdev->timeout < dev->rdev->min_timeout)
460 dev->rdev->timeout = dev->rdev->min_timeout;
461 }
462
463 /* Enable the device for receive */
464 static void ene_rx_enable_hw(struct ene_device *dev)
465 {
466 u8 reg_value;
467
468 /* Enable system interrupt */
469 if (dev->hw_revision < ENE_HW_C) {
470 ene_write_reg(dev, ENEB_IRQ, dev->irq << 1);
471 ene_write_reg(dev, ENEB_IRQ_UNK1, 0x01);
472 } else {
473 reg_value = ene_read_reg(dev, ENE_IRQ) & 0xF0;
474 reg_value |= ENE_IRQ_UNK_EN;
475 reg_value &= ~ENE_IRQ_STATUS;
476 reg_value |= (dev->irq & ENE_IRQ_MASK);
477 ene_write_reg(dev, ENE_IRQ, reg_value);
478 }
479
480 /* Enable inputs */
481 ene_rx_enable_fan_input(dev, dev->rx_fan_input_inuse);
482 ene_rx_enable_cir_engine(dev, !dev->rx_fan_input_inuse);
483
484 /* ack any pending irqs - just in case */
485 ene_irq_status(dev);
486
487 /* enable firmware bits */
488 ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ);
489
490 /* enter idle mode */
491 ir_raw_event_set_idle(dev->rdev, true);
492 }
493
494 /* Enable the device for receive - wrapper to track the state*/
495 static void ene_rx_enable(struct ene_device *dev)
496 {
497 ene_rx_enable_hw(dev);
498 dev->rx_enabled = true;
499 }
500
501 /* Disable the device receiver */
502 static void ene_rx_disable_hw(struct ene_device *dev)
503 {
504 /* disable inputs */
505 ene_rx_enable_cir_engine(dev, false);
506 ene_rx_enable_fan_input(dev, false);
507
508 /* disable hardware IRQ and firmware flag */
509 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ);
510 ir_raw_event_set_idle(dev->rdev, true);
511 }
512
513 /* Disable the device receiver - wrapper to track the state */
514 static void ene_rx_disable(struct ene_device *dev)
515 {
516 ene_rx_disable_hw(dev);
517 dev->rx_enabled = false;
518 }
519
520 /* This resets the receiver. Useful to stop stream of spaces at end of
521 * transmission
522 */
523 static void ene_rx_reset(struct ene_device *dev)
524 {
525 ene_clear_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_RX_EN);
526 ene_set_reg_mask(dev, ENE_CIRCFG, ENE_CIRCFG_RX_EN);
527 }
528
529 /* Set up the TX carrier frequency and duty cycle */
530 static void ene_tx_set_carrier(struct ene_device *dev)
531 {
532 u8 tx_puls_width;
533 unsigned long flags;
534
535 spin_lock_irqsave(&dev->hw_lock, flags);
536
537 ene_set_clear_reg_mask(dev, ENE_CIRCFG,
538 ENE_CIRCFG_TX_CARR, dev->tx_period > 0);
539
540 if (!dev->tx_period)
541 goto unlock;
542
543 BUG_ON(dev->tx_duty_cycle >= 100 || dev->tx_duty_cycle <= 0);
544
545 tx_puls_width = dev->tx_period / (100 / dev->tx_duty_cycle);
546
547 if (!tx_puls_width)
548 tx_puls_width = 1;
549
550 dbg("TX: pulse distance = %d * 500 ns", dev->tx_period);
551 dbg("TX: pulse width = %d * 500 ns", tx_puls_width);
552
553 ene_write_reg(dev, ENE_CIRMOD_PRD, dev->tx_period | ENE_CIRMOD_PRD_POL);
554 ene_write_reg(dev, ENE_CIRMOD_HPRD, tx_puls_width);
555 unlock:
556 spin_unlock_irqrestore(&dev->hw_lock, flags);
557 }
558
559 /* Enable/disable transmitters */
560 static void ene_tx_set_transmitters(struct ene_device *dev)
561 {
562 unsigned long flags;
563
564 spin_lock_irqsave(&dev->hw_lock, flags);
565 ene_set_clear_reg_mask(dev, ENE_GPIOFS8, ENE_GPIOFS8_GPIO41,
566 !!(dev->transmitter_mask & 0x01));
567 ene_set_clear_reg_mask(dev, ENE_GPIOFS1, ENE_GPIOFS1_GPIO0D,
568 !!(dev->transmitter_mask & 0x02));
569 spin_unlock_irqrestore(&dev->hw_lock, flags);
570 }
571
572 /* prepare transmission */
573 static void ene_tx_enable(struct ene_device *dev)
574 {
575 u8 conf1 = ene_read_reg(dev, ENE_CIRCFG);
576 u8 fwreg2 = ene_read_reg(dev, ENE_FW2);
577
578 dev->saved_conf1 = conf1;
579
580 /* Show information about currently connected transmitter jacks */
581 if (fwreg2 & ENE_FW2_EMMITER1_CONN)
582 dbg("TX: Transmitter #1 is connected");
583
584 if (fwreg2 & ENE_FW2_EMMITER2_CONN)
585 dbg("TX: Transmitter #2 is connected");
586
587 if (!(fwreg2 & (ENE_FW2_EMMITER1_CONN | ENE_FW2_EMMITER2_CONN)))
588 pr_warn("TX: transmitter cable isn't connected!\n");
589
590 /* disable receive on revc */
591 if (dev->hw_revision == ENE_HW_C)
592 conf1 &= ~ENE_CIRCFG_RX_EN;
593
594 /* Enable TX engine */
595 conf1 |= ENE_CIRCFG_TX_EN | ENE_CIRCFG_TX_IRQ;
596 ene_write_reg(dev, ENE_CIRCFG, conf1);
597 }
598
599 /* end transmission */
600 static void ene_tx_disable(struct ene_device *dev)
601 {
602 ene_write_reg(dev, ENE_CIRCFG, dev->saved_conf1);
603 dev->tx_buffer = NULL;
604 }
605
606
607 /* TX one sample - must be called with dev->hw_lock*/
608 static void ene_tx_sample(struct ene_device *dev)
609 {
610 u8 raw_tx;
611 u32 sample;
612 bool pulse = dev->tx_sample_pulse;
613
614 if (!dev->tx_buffer) {
615 pr_warn("TX: BUG: attempt to transmit NULL buffer\n");
616 return;
617 }
618
619 /* Grab next TX sample */
620 if (!dev->tx_sample) {
621
622 if (dev->tx_pos == dev->tx_len) {
623 if (!dev->tx_done) {
624 dbg("TX: no more data to send");
625 dev->tx_done = true;
626 goto exit;
627 } else {
628 dbg("TX: last sample sent by hardware");
629 ene_tx_disable(dev);
630 complete(&dev->tx_complete);
631 return;
632 }
633 }
634
635 sample = dev->tx_buffer[dev->tx_pos++];
636 dev->tx_sample_pulse = !dev->tx_sample_pulse;
637
638 dev->tx_sample = DIV_ROUND_CLOSEST(sample, sample_period);
639
640 if (!dev->tx_sample)
641 dev->tx_sample = 1;
642 }
643
644 raw_tx = min(dev->tx_sample , (unsigned int)ENE_CIRRLC_OUT_MASK);
645 dev->tx_sample -= raw_tx;
646
647 dbg("TX: sample %8d (%s)", raw_tx * sample_period,
648 pulse ? "pulse" : "space");
649 if (pulse)
650 raw_tx |= ENE_CIRRLC_OUT_PULSE;
651
652 ene_write_reg(dev,
653 dev->tx_reg ? ENE_CIRRLC_OUT1 : ENE_CIRRLC_OUT0, raw_tx);
654
655 dev->tx_reg = !dev->tx_reg;
656 exit:
657 /* simulate TX done interrupt */
658 if (txsim)
659 mod_timer(&dev->tx_sim_timer, jiffies + HZ / 500);
660 }
661
662 /* timer to simulate tx done interrupt */
663 static void ene_tx_irqsim(struct timer_list *t)
664 {
665 struct ene_device *dev = from_timer(dev, t, tx_sim_timer);
666 unsigned long flags;
667
668 spin_lock_irqsave(&dev->hw_lock, flags);
669 ene_tx_sample(dev);
670 spin_unlock_irqrestore(&dev->hw_lock, flags);
671 }
672
673
674 /* read irq status and ack it */
675 static int ene_irq_status(struct ene_device *dev)
676 {
677 u8 irq_status;
678 u8 fw_flags1, fw_flags2;
679 int retval = 0;
680
681 fw_flags2 = ene_read_reg(dev, ENE_FW2);
682
683 if (dev->hw_revision < ENE_HW_C) {
684 irq_status = ene_read_reg(dev, ENEB_IRQ_STATUS);
685
686 if (!(irq_status & ENEB_IRQ_STATUS_IR))
687 return 0;
688
689 ene_clear_reg_mask(dev, ENEB_IRQ_STATUS, ENEB_IRQ_STATUS_IR);
690 return ENE_IRQ_RX;
691 }
692
693 irq_status = ene_read_reg(dev, ENE_IRQ);
694 if (!(irq_status & ENE_IRQ_STATUS))
695 return 0;
696
697 /* original driver does that twice - a workaround ? */
698 ene_write_reg(dev, ENE_IRQ, irq_status & ~ENE_IRQ_STATUS);
699 ene_write_reg(dev, ENE_IRQ, irq_status & ~ENE_IRQ_STATUS);
700
701 /* check RX interrupt */
702 if (fw_flags2 & ENE_FW2_RXIRQ) {
703 retval |= ENE_IRQ_RX;
704 ene_write_reg(dev, ENE_FW2, fw_flags2 & ~ENE_FW2_RXIRQ);
705 }
706
707 /* check TX interrupt */
708 fw_flags1 = ene_read_reg(dev, ENE_FW1);
709 if (fw_flags1 & ENE_FW1_TXIRQ) {
710 ene_write_reg(dev, ENE_FW1, fw_flags1 & ~ENE_FW1_TXIRQ);
711 retval |= ENE_IRQ_TX;
712 }
713
714 return retval;
715 }
716
717 /* interrupt handler */
718 static irqreturn_t ene_isr(int irq, void *data)
719 {
720 u16 hw_value, reg;
721 int hw_sample, irq_status;
722 bool pulse;
723 unsigned long flags;
724 irqreturn_t retval = IRQ_NONE;
725 struct ene_device *dev = (struct ene_device *)data;
726 struct ir_raw_event ev = {};
727
728 spin_lock_irqsave(&dev->hw_lock, flags);
729
730 dbg_verbose("ISR called");
731 ene_rx_read_hw_pointer(dev);
732 irq_status = ene_irq_status(dev);
733
734 if (!irq_status)
735 goto unlock;
736
737 retval = IRQ_HANDLED;
738
739 if (irq_status & ENE_IRQ_TX) {
740 dbg_verbose("TX interrupt");
741 if (!dev->hw_learning_and_tx_capable) {
742 dbg("TX interrupt on unsupported device!");
743 goto unlock;
744 }
745 ene_tx_sample(dev);
746 }
747
748 if (!(irq_status & ENE_IRQ_RX))
749 goto unlock;
750
751 dbg_verbose("RX interrupt");
752
753 if (dev->hw_learning_and_tx_capable)
754 ene_rx_sense_carrier(dev);
755
756 /* On hardware that don't support extra buffer we need to trust
757 the interrupt and not track the read pointer */
758 if (!dev->hw_extra_buffer)
759 dev->r_pointer = dev->w_pointer == 0 ? ENE_FW_PACKET_SIZE : 0;
760
761 while (1) {
762
763 reg = ene_rx_get_sample_reg(dev);
764
765 dbg_verbose("next sample to read at: %04x", reg);
766 if (!reg)
767 break;
768
769 hw_value = ene_read_reg(dev, reg);
770
771 if (dev->rx_fan_input_inuse) {
772
773 int offset = ENE_FW_SMPL_BUF_FAN - ENE_FW_SAMPLE_BUFFER;
774
775 /* read high part of the sample */
776 hw_value |= ene_read_reg(dev, reg + offset) << 8;
777 pulse = hw_value & ENE_FW_SMPL_BUF_FAN_PLS;
778
779 /* clear space bit, and other unused bits */
780 hw_value &= ENE_FW_SMPL_BUF_FAN_MSK;
781 hw_sample = hw_value * ENE_FW_SAMPLE_PERIOD_FAN;
782
783 } else {
784 pulse = !(hw_value & ENE_FW_SAMPLE_SPACE);
785 hw_value &= ~ENE_FW_SAMPLE_SPACE;
786 hw_sample = hw_value * sample_period;
787
788 if (dev->rx_period_adjust) {
789 hw_sample *= 100;
790 hw_sample /= (100 + dev->rx_period_adjust);
791 }
792 }
793
794 if (!dev->hw_extra_buffer && !hw_sample) {
795 dev->r_pointer = dev->w_pointer;
796 continue;
797 }
798
799 dbg("RX: %d (%s)", hw_sample, pulse ? "pulse" : "space");
800
801 ev.duration = hw_sample;
802 ev.pulse = pulse;
803 ir_raw_event_store_with_filter(dev->rdev, &ev);
804 }
805
806 ir_raw_event_handle(dev->rdev);
807 unlock:
808 spin_unlock_irqrestore(&dev->hw_lock, flags);
809 return retval;
810 }
811
812 /* Initialize default settings */
813 static void ene_setup_default_settings(struct ene_device *dev)
814 {
815 dev->tx_period = 32;
816 dev->tx_duty_cycle = 50; /*%*/
817 dev->transmitter_mask = 0x03;
818 dev->learning_mode_enabled = learning_mode_force;
819
820 /* Set reasonable default timeout */
821 dev->rdev->timeout = MS_TO_US(150);
822 }
823
824 /* Upload all hardware settings at once. Used at load and resume time */
825 static void ene_setup_hw_settings(struct ene_device *dev)
826 {
827 if (dev->hw_learning_and_tx_capable) {
828 ene_tx_set_carrier(dev);
829 ene_tx_set_transmitters(dev);
830 }
831
832 ene_rx_setup(dev);
833 }
834
835 /* outside interface: called on first open*/
836 static int ene_open(struct rc_dev *rdev)
837 {
838 struct ene_device *dev = rdev->priv;
839 unsigned long flags;
840
841 spin_lock_irqsave(&dev->hw_lock, flags);
842 ene_rx_enable(dev);
843 spin_unlock_irqrestore(&dev->hw_lock, flags);
844 return 0;
845 }
846
847 /* outside interface: called on device close*/
848 static void ene_close(struct rc_dev *rdev)
849 {
850 struct ene_device *dev = rdev->priv;
851 unsigned long flags;
852 spin_lock_irqsave(&dev->hw_lock, flags);
853
854 ene_rx_disable(dev);
855 spin_unlock_irqrestore(&dev->hw_lock, flags);
856 }
857
858 /* outside interface: set transmitter mask */
859 static int ene_set_tx_mask(struct rc_dev *rdev, u32 tx_mask)
860 {
861 struct ene_device *dev = rdev->priv;
862 dbg("TX: attempt to set transmitter mask %02x", tx_mask);
863
864 /* invalid txmask */
865 if (!tx_mask || tx_mask & ~0x03) {
866 dbg("TX: invalid mask");
867 /* return count of transmitters */
868 return 2;
869 }
870
871 dev->transmitter_mask = tx_mask;
872 ene_tx_set_transmitters(dev);
873 return 0;
874 }
875
876 /* outside interface : set tx carrier */
877 static int ene_set_tx_carrier(struct rc_dev *rdev, u32 carrier)
878 {
879 struct ene_device *dev = rdev->priv;
880 u32 period;
881
882 dbg("TX: attempt to set tx carrier to %d kHz", carrier);
883 if (carrier == 0)
884 return -EINVAL;
885
886 period = 2000000 / carrier;
887 if (period && (period > ENE_CIRMOD_PRD_MAX ||
888 period < ENE_CIRMOD_PRD_MIN)) {
889
890 dbg("TX: out of range %d-%d kHz carrier",
891 2000 / ENE_CIRMOD_PRD_MIN, 2000 / ENE_CIRMOD_PRD_MAX);
892 return -EINVAL;
893 }
894
895 dev->tx_period = period;
896 ene_tx_set_carrier(dev);
897 return 0;
898 }
899
900 /*outside interface : set tx duty cycle */
901 static int ene_set_tx_duty_cycle(struct rc_dev *rdev, u32 duty_cycle)
902 {
903 struct ene_device *dev = rdev->priv;
904 dbg("TX: setting duty cycle to %d%%", duty_cycle);
905 dev->tx_duty_cycle = duty_cycle;
906 ene_tx_set_carrier(dev);
907 return 0;
908 }
909
910 /* outside interface: enable learning mode */
911 static int ene_set_learning_mode(struct rc_dev *rdev, int enable)
912 {
913 struct ene_device *dev = rdev->priv;
914 unsigned long flags;
915 if (enable == dev->learning_mode_enabled)
916 return 0;
917
918 spin_lock_irqsave(&dev->hw_lock, flags);
919 dev->learning_mode_enabled = enable;
920 ene_rx_disable(dev);
921 ene_rx_setup(dev);
922 ene_rx_enable(dev);
923 spin_unlock_irqrestore(&dev->hw_lock, flags);
924 return 0;
925 }
926
927 static int ene_set_carrier_report(struct rc_dev *rdev, int enable)
928 {
929 struct ene_device *dev = rdev->priv;
930 unsigned long flags;
931
932 if (enable == dev->carrier_detect_enabled)
933 return 0;
934
935 spin_lock_irqsave(&dev->hw_lock, flags);
936 dev->carrier_detect_enabled = enable;
937 ene_rx_disable(dev);
938 ene_rx_setup(dev);
939 ene_rx_enable(dev);
940 spin_unlock_irqrestore(&dev->hw_lock, flags);
941 return 0;
942 }
943
944 /* outside interface: enable or disable idle mode */
945 static void ene_set_idle(struct rc_dev *rdev, bool idle)
946 {
947 struct ene_device *dev = rdev->priv;
948
949 if (idle) {
950 ene_rx_reset(dev);
951 dbg("RX: end of data");
952 }
953 }
954
955 /* outside interface: transmit */
956 static int ene_transmit(struct rc_dev *rdev, unsigned *buf, unsigned n)
957 {
958 struct ene_device *dev = rdev->priv;
959 unsigned long flags;
960
961 dev->tx_buffer = buf;
962 dev->tx_len = n;
963 dev->tx_pos = 0;
964 dev->tx_reg = 0;
965 dev->tx_done = 0;
966 dev->tx_sample = 0;
967 dev->tx_sample_pulse = false;
968
969 dbg("TX: %d samples", dev->tx_len);
970
971 spin_lock_irqsave(&dev->hw_lock, flags);
972
973 ene_tx_enable(dev);
974
975 /* Transmit first two samples */
976 ene_tx_sample(dev);
977 ene_tx_sample(dev);
978
979 spin_unlock_irqrestore(&dev->hw_lock, flags);
980
981 if (wait_for_completion_timeout(&dev->tx_complete, 2 * HZ) == 0) {
982 dbg("TX: timeout");
983 spin_lock_irqsave(&dev->hw_lock, flags);
984 ene_tx_disable(dev);
985 spin_unlock_irqrestore(&dev->hw_lock, flags);
986 } else
987 dbg("TX: done");
988 return n;
989 }
990
991 /* probe entry */
992 static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
993 {
994 int error = -ENOMEM;
995 struct rc_dev *rdev;
996 struct ene_device *dev;
997
998 /* allocate memory */
999 dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL);
1000 rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
1001 if (!dev || !rdev)
1002 goto exit_free_dev_rdev;
1003
1004 /* validate resources */
1005 error = -ENODEV;
1006
1007 /* init these to -1, as 0 is valid for both */
1008 dev->hw_io = -1;
1009 dev->irq = -1;
1010
1011 if (!pnp_port_valid(pnp_dev, 0) ||
1012 pnp_port_len(pnp_dev, 0) < ENE_IO_SIZE)
1013 goto exit_free_dev_rdev;
1014
1015 if (!pnp_irq_valid(pnp_dev, 0))
1016 goto exit_free_dev_rdev;
1017
1018 spin_lock_init(&dev->hw_lock);
1019
1020 dev->hw_io = pnp_port_start(pnp_dev, 0);
1021 dev->irq = pnp_irq(pnp_dev, 0);
1022
1023
1024 pnp_set_drvdata(pnp_dev, dev);
1025 dev->pnp_dev = pnp_dev;
1026
1027 /* don't allow too short/long sample periods */
1028 if (sample_period < 5 || sample_period > 0x7F)
1029 sample_period = ENE_DEFAULT_SAMPLE_PERIOD;
1030
1031 /* detect hardware version and features */
1032 error = ene_hw_detect(dev);
1033 if (error)
1034 goto exit_free_dev_rdev;
1035
1036 if (!dev->hw_learning_and_tx_capable && txsim) {
1037 dev->hw_learning_and_tx_capable = true;
1038 timer_setup(&dev->tx_sim_timer, ene_tx_irqsim, 0);
1039 pr_warn("Simulation of TX activated\n");
1040 }
1041
1042 if (!dev->hw_learning_and_tx_capable)
1043 learning_mode_force = false;
1044
1045 rdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER;
1046 rdev->priv = dev;
1047 rdev->open = ene_open;
1048 rdev->close = ene_close;
1049 rdev->s_idle = ene_set_idle;
1050 rdev->driver_name = ENE_DRIVER_NAME;
1051 rdev->map_name = RC_MAP_RC6_MCE;
1052 rdev->device_name = "ENE eHome Infrared Remote Receiver";
1053
1054 if (dev->hw_learning_and_tx_capable) {
1055 rdev->s_learning_mode = ene_set_learning_mode;
1056 init_completion(&dev->tx_complete);
1057 rdev->tx_ir = ene_transmit;
1058 rdev->s_tx_mask = ene_set_tx_mask;
1059 rdev->s_tx_carrier = ene_set_tx_carrier;
1060 rdev->s_tx_duty_cycle = ene_set_tx_duty_cycle;
1061 rdev->s_carrier_report = ene_set_carrier_report;
1062 rdev->device_name = "ENE eHome Infrared Remote Transceiver";
1063 }
1064
1065 dev->rdev = rdev;
1066
1067 ene_rx_setup_hw_buffer(dev);
1068 ene_setup_default_settings(dev);
1069 ene_setup_hw_settings(dev);
1070
1071 device_set_wakeup_capable(&pnp_dev->dev, true);
1072 device_set_wakeup_enable(&pnp_dev->dev, true);
1073
1074 error = rc_register_device(rdev);
1075 if (error < 0)
1076 goto exit_free_dev_rdev;
1077
1078 /* claim the resources */
1079 error = -EBUSY;
1080 if (!request_region(dev->hw_io, ENE_IO_SIZE, ENE_DRIVER_NAME)) {
1081 goto exit_unregister_device;
1082 }
1083
1084 if (request_irq(dev->irq, ene_isr,
1085 IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev)) {
1086 goto exit_release_hw_io;
1087 }
1088
1089 pr_notice("driver has been successfully loaded\n");
1090 return 0;
1091
1092 exit_release_hw_io:
1093 release_region(dev->hw_io, ENE_IO_SIZE);
1094 exit_unregister_device:
1095 rc_unregister_device(rdev);
1096 rdev = NULL;
1097 exit_free_dev_rdev:
1098 rc_free_device(rdev);
1099 kfree(dev);
1100 return error;
1101 }
1102
1103 /* main unload function */
1104 static void ene_remove(struct pnp_dev *pnp_dev)
1105 {
1106 struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1107 unsigned long flags;
1108
1109 spin_lock_irqsave(&dev->hw_lock, flags);
1110 ene_rx_disable(dev);
1111 ene_rx_restore_hw_buffer(dev);
1112 spin_unlock_irqrestore(&dev->hw_lock, flags);
1113
1114 free_irq(dev->irq, dev);
1115 release_region(dev->hw_io, ENE_IO_SIZE);
1116 rc_unregister_device(dev->rdev);
1117 kfree(dev);
1118 }
1119
1120 /* enable wake on IR (wakes on specific button on original remote) */
1121 static void ene_enable_wake(struct ene_device *dev, bool enable)
1122 {
1123 dbg("wake on IR %s", enable ? "enabled" : "disabled");
1124 ene_set_clear_reg_mask(dev, ENE_FW1, ENE_FW1_WAKE, enable);
1125 }
1126
1127 #ifdef CONFIG_PM
1128 static int ene_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
1129 {
1130 struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1131 bool wake = device_may_wakeup(&dev->pnp_dev->dev);
1132
1133 if (!wake && dev->rx_enabled)
1134 ene_rx_disable_hw(dev);
1135
1136 ene_enable_wake(dev, wake);
1137 return 0;
1138 }
1139
1140 static int ene_resume(struct pnp_dev *pnp_dev)
1141 {
1142 struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1143 ene_setup_hw_settings(dev);
1144
1145 if (dev->rx_enabled)
1146 ene_rx_enable(dev);
1147
1148 ene_enable_wake(dev, false);
1149 return 0;
1150 }
1151 #endif
1152
1153 static void ene_shutdown(struct pnp_dev *pnp_dev)
1154 {
1155 struct ene_device *dev = pnp_get_drvdata(pnp_dev);
1156 ene_enable_wake(dev, true);
1157 }
1158
1159 static const struct pnp_device_id ene_ids[] = {
1160 {.id = "ENE0100",},
1161 {.id = "ENE0200",},
1162 {.id = "ENE0201",},
1163 {.id = "ENE0202",},
1164 {},
1165 };
1166
1167 static struct pnp_driver ene_driver = {
1168 .name = ENE_DRIVER_NAME,
1169 .id_table = ene_ids,
1170 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1171
1172 .probe = ene_probe,
1173 .remove = ene_remove,
1174 #ifdef CONFIG_PM
1175 .suspend = ene_suspend,
1176 .resume = ene_resume,
1177 #endif
1178 .shutdown = ene_shutdown,
1179 };
1180
1181 module_param(sample_period, int, S_IRUGO);
1182 MODULE_PARM_DESC(sample_period, "Hardware sample period (50 us default)");
1183
1184 module_param(learning_mode_force, bool, S_IRUGO);
1185 MODULE_PARM_DESC(learning_mode_force, "Enable learning mode by default");
1186
1187 module_param(debug, int, S_IRUGO | S_IWUSR);
1188 MODULE_PARM_DESC(debug, "Debug level");
1189
1190 module_param(txsim, bool, S_IRUGO);
1191 MODULE_PARM_DESC(txsim,
1192 "Simulate TX features on unsupported hardware (dangerous)");
1193
1194 MODULE_DEVICE_TABLE(pnp, ene_ids);
1195 MODULE_DESCRIPTION
1196 ("Infrared input driver for KB3926B/C/D/E/F (aka ENE0100/ENE0200/ENE0201/ENE0202) CIR port");
1197
1198 MODULE_AUTHOR("Maxim Levitsky");
1199 MODULE_LICENSE("GPL");
1200
1201 module_pnp_driver(ene_driver);
Linux with added FPC-III support