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