← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap/precise

« back to all changes in this revision

Viewing changes to ubuntu/lirc/lirc_ene0100/lirc_ene0100.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Bader, Amit Kucheria
  • Date: 2010-03-23 18:05:12 UTC
  • Revision ID: james.westby@ubuntu.com-20100323180512-iavj906ocnphdubp
Tags: 2.6.33-500.3
[ Amit Kucheria ]

* [Config] Fix the debug package name to end in -dbgsym
* SAUCE: Add the ubuntu/ drivers to omap
* SAUCE: Re-export the symbols for aufs
* [Config] Enable AUFS and COMPCACHE

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntu/lirc/lirc_ene0100/lirc_ene0100.c
 
1
/*
 
2
 * driver for ENE KB3926 B/C/D CIR (also known as ENE0100)
 
3
 *
 
4
 * Copyright (C) 2009 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
 
 
22
#include <linux/kernel.h>
 
23
#include <linux/module.h>
 
24
#include <linux/pnp.h>
 
25
#include <linux/io.h>
 
26
#include <linux/interrupt.h>
 
27
#include "lirc_ene0100.h"
 
28
 
 
29
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
 
30
#error "Sorry, this driver needs kernel version 2.6.16 or higher"
 
31
#else
 
32
 
 
33
static int sample_period = 75;
 
34
static int enable_idle = 1;
 
35
static int enable_learning;
 
36
 
 
37
static void ene_set_idle(struct ene_device *dev, int idle);
 
38
static void ene_set_inputs(struct ene_device *dev, int enable);
 
39
 
 
40
/* read a hardware register */
 
41
static u8 ene_hw_read_reg(struct ene_device *dev, u16 reg)
 
42
{
 
43
        outb(reg >> 8, dev->hw_io + ENE_ADDR_HI);
 
44
        outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO);
 
45
        return inb(dev->hw_io + ENE_IO);
 
46
}
 
47
 
 
48
/* write a hardware register */
 
49
static void ene_hw_write_reg(struct ene_device *dev, u16 reg, u8 value)
 
50
{
 
51
        outb(reg >> 8, dev->hw_io + ENE_ADDR_HI);
 
52
        outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO);
 
53
        outb(value, dev->hw_io + ENE_IO);
 
54
}
 
55
 
 
56
/* change specific bits in hardware register */
 
57
static void ene_hw_write_reg_mask(struct ene_device *dev,
 
58
                                  u16 reg, u8 value, u8 mask)
 
59
{
 
60
        u8 regvalue;
 
61
 
 
62
        outb(reg >> 8, dev->hw_io + ENE_ADDR_HI);
 
63
        outb(reg & 0xFF, dev->hw_io + ENE_ADDR_LO);
 
64
 
 
65
        regvalue = inb(dev->hw_io + ENE_IO) & ~mask;
 
66
        regvalue |= (value & mask);
 
67
        outb(regvalue, dev->hw_io + ENE_IO);
 
68
}
 
69
 
 
70
/* read irq status and ack it */
 
71
static int ene_hw_irq_status(struct ene_device *dev, int *buffer_pointer)
 
72
{
 
73
        u8 irq_status;
 
74
        u8 fw_flags1, fw_flags2;
 
75
 
 
76
        fw_flags2 = ene_hw_read_reg(dev, ENE_FW2);
 
77
 
 
78
        if (buffer_pointer)
 
79
                *buffer_pointer = 4 * (fw_flags2 & ENE_FW2_BUF_HIGH);
 
80
 
 
81
        if (dev->hw_revision < ENE_HW_C) {
 
82
                irq_status = ene_hw_read_reg(dev, ENEB_IRQ_STATUS);
 
83
 
 
84
                if (!irq_status & ENEB_IRQ_STATUS_IR)
 
85
                        return 0;
 
86
                ene_hw_write_reg(dev, ENEB_IRQ_STATUS,
 
87
                                 irq_status & ~ENEB_IRQ_STATUS_IR);
 
88
 
 
89
                /* rev B support only recieving */
 
90
                return ENE_IRQ_RX;
 
91
        }
 
92
 
 
93
        irq_status = ene_hw_read_reg(dev, ENEC_IRQ);
 
94
 
 
95
        if (!irq_status && ENEC_IRQ_STATUS)
 
96
                return 0;
 
97
 
 
98
        /* original driver does that twice - a workaround ? */
 
99
        ene_hw_write_reg(dev, ENEC_IRQ, irq_status & ~ENEC_IRQ_STATUS);
 
100
        ene_hw_write_reg(dev, ENEC_IRQ, irq_status & ~ENEC_IRQ_STATUS);
 
101
 
 
102
        /* clear unknown flag in F8F9 */
 
103
        if (fw_flags2 & ENE_FW2_IRQ_CLR)
 
104
                ene_hw_write_reg(dev, ENE_FW2, fw_flags2 & ~ENE_FW2_IRQ_CLR);
 
105
 
 
106
        /* check if this is a TX interrupt */
 
107
        fw_flags1 = ene_hw_read_reg(dev, ENE_FW1);
 
108
 
 
109
        if (fw_flags1 & ENE_FW1_TXIRQ) {
 
110
                ene_hw_write_reg(dev, ENE_FW1, fw_flags1 & ~ENE_FW1_TXIRQ);
 
111
                return ENE_IRQ_TX;
 
112
        } else
 
113
                return ENE_IRQ_RX;
 
114
}
 
115
 
 
116
static int ene_hw_detect(struct ene_device *dev)
 
117
{
 
118
        u8 chip_major, chip_minor;
 
119
        u8 hw_revision, old_ver;
 
120
        u8 tmp;
 
121
        u8 fw_capabilities;
 
122
 
 
123
        tmp = ene_hw_read_reg(dev, ENE_HW_UNK);
 
124
        ene_hw_write_reg(dev, ENE_HW_UNK, tmp & ~ENE_HW_UNK_CLR);
 
125
 
 
126
        chip_major = ene_hw_read_reg(dev, ENE_HW_VER_MAJOR);
 
127
        chip_minor = ene_hw_read_reg(dev, ENE_HW_VER_MINOR);
 
128
 
 
129
        ene_hw_write_reg(dev, ENE_HW_UNK, tmp);
 
130
        hw_revision = ene_hw_read_reg(dev, ENE_HW_VERSION);
 
131
        old_ver = ene_hw_read_reg(dev, ENE_HW_VER_OLD);
 
132
 
 
133
        if (hw_revision == 0xFF) {
 
134
 
 
135
                ene_printk(KERN_WARNING, "device seems to be disabled\n");
 
136
                ene_printk(KERN_WARNING,
 
137
                        "send a mail to lirc-list@lists.sourceforge.net\n");
 
138
                ene_printk(KERN_WARNING, "please attach output of acpidump\n");
 
139
 
 
140
                return -ENODEV;
 
141
        }
 
142
 
 
143
        if (chip_major == 0x33) {
 
144
                ene_printk(KERN_WARNING, "chips 0x33xx aren't supported yet\n");
 
145
                return -ENODEV;
 
146
        }
 
147
 
 
148
        if (chip_major == 0x39 && chip_minor == 0x26 && hw_revision == 0xC0) {
 
149
                dev->hw_revision = ENE_HW_C;
 
150
                ene_printk(KERN_WARNING,
 
151
                       "KB3926C detected, driver support is not complete!\n");
 
152
 
 
153
        } else if (old_ver == 0x24 && hw_revision == 0xC0) {
 
154
                dev->hw_revision = ENE_HW_B;
 
155
                ene_printk(KERN_NOTICE, "KB3926B detected\n");
 
156
        } else {
 
157
                dev->hw_revision = ENE_HW_D;
 
158
                ene_printk(KERN_WARNING,
 
159
                        "unknown ENE chip detected, assuming KB3926D\n");
 
160
                ene_printk(KERN_WARNING, "driver support incomplete");
 
161
 
 
162
        }
 
163
 
 
164
        ene_printk(KERN_DEBUG, "chip is 0x%02x%02x - 0x%02x, 0x%02x\n",
 
165
                chip_major, chip_minor, old_ver, hw_revision);
 
166
 
 
167
 
 
168
        /* detect features hardware supports */
 
169
 
 
170
        if (dev->hw_revision < ENE_HW_C)
 
171
                return 0;
 
172
 
 
173
        fw_capabilities = ene_hw_read_reg(dev, ENE_FW2);
 
174
 
 
175
        dev->hw_gpio40_learning = fw_capabilities & ENE_FW2_GP40_AS_LEARN;
 
176
        dev->hw_learning_and_tx_capable = fw_capabilities & ENE_FW2_LEARNING;
 
177
 
 
178
        dev->hw_fan_as_normal_input = dev->hw_learning_and_tx_capable &&
 
179
            fw_capabilities & ENE_FW2_FAN_AS_NRML_IN;
 
180
 
 
181
        ene_printk(KERN_NOTICE, "hardware features:\n");
 
182
        ene_printk(KERN_NOTICE,
 
183
                "learning and tx %s, gpio40_learn %s, fan_in %s\n",
 
184
               dev->hw_learning_and_tx_capable ? "on" : "off",
 
185
               dev->hw_gpio40_learning ? "on" : "off",
 
186
               dev->hw_fan_as_normal_input ? "on" : "off");
 
187
 
 
188
        if (!dev->hw_learning_and_tx_capable && enable_learning)
 
189
                enable_learning = 0;
 
190
 
 
191
        if (dev->hw_learning_and_tx_capable) {
 
192
                ene_printk(KERN_WARNING,
 
193
                "Device supports transmitting, but the driver doesn't\n");
 
194
                ene_printk(KERN_WARNING,
 
195
                "due to lack of hardware to test against.\n");
 
196
                ene_printk(KERN_WARNING,
 
197
                "Send a mail to: lirc-list@lists.sourceforge.net\n");
 
198
        }
 
199
        return 0;
 
200
}
 
201
 
 
202
/* hardware initialization */
 
203
static int ene_hw_init(void *data)
 
204
{
 
205
        u8 reg_value;
 
206
        struct ene_device *dev = (struct ene_device *)data;
 
207
        dev->in_use = 1;
 
208
 
 
209
        if (dev->hw_revision < ENE_HW_C) {
 
210
                ene_hw_write_reg(dev, ENEB_IRQ, dev->irq << 1);
 
211
                ene_hw_write_reg(dev, ENEB_IRQ_UNK1, 0x01);
 
212
        } else {
 
213
                reg_value = ene_hw_read_reg(dev, ENEC_IRQ) & 0xF0;
 
214
                reg_value |= ENEC_IRQ_UNK_EN;
 
215
                reg_value &= ~ENEC_IRQ_STATUS;
 
216
                reg_value |= (dev->irq & ENEC_IRQ_MASK);
 
217
                ene_hw_write_reg(dev, ENEC_IRQ, reg_value);
 
218
                ene_hw_write_reg(dev, ENE_TX_UNK1, 0x63);
 
219
        }
 
220
 
 
221
        ene_hw_write_reg(dev, ENE_CIR_CONF2, 0x00);
 
222
        ene_set_inputs(dev, enable_learning);
 
223
 
 
224
        /* set sampling period */
 
225
        ene_hw_write_reg(dev, ENE_CIR_SAMPLE_PERIOD, sample_period);
 
226
 
 
227
        /* ack any pending irqs - just in case */
 
228
        ene_hw_irq_status(dev, NULL);
 
229
 
 
230
        /* enter idle mode */
 
231
        ene_set_idle(dev, 1);
 
232
 
 
233
        /* enable firmware bits */
 
234
        ene_hw_write_reg_mask(dev, ENE_FW1,
 
235
                              ENE_FW1_ENABLE | ENE_FW1_IRQ,
 
236
                              ENE_FW1_ENABLE | ENE_FW1_IRQ);
 
237
        /* clear stats */
 
238
        dev->sample = 0;
 
239
        return 0;
 
240
}
 
241
 
 
242
/* this enables gpio40 signal, used if connected to wide band input*/
 
243
static void ene_enable_gpio40(struct ene_device *dev, int enable)
 
244
{
 
245
        ene_hw_write_reg_mask(dev, ENE_CIR_CONF1, enable ?
 
246
                              0 : ENE_CIR_CONF2_GPIO40DIS,
 
247
                              ENE_CIR_CONF2_GPIO40DIS);
 
248
}
 
249
 
 
250
/* this enables the classic sampler */
 
251
static void ene_enable_normal_recieve(struct ene_device *dev, int enable)
 
252
{
 
253
        ene_hw_write_reg(dev, ENE_CIR_CONF1, enable ? ENE_CIR_CONF1_ADC_ON : 0);
 
254
}
 
255
 
 
256
/* this enables recieve via fan input */
 
257
static void ene_enable_fan_recieve(struct ene_device *dev, int enable)
 
258
{
 
259
        if (!enable)
 
260
                ene_hw_write_reg(dev, ENE_FAN_AS_IN1, 0);
 
261
        else {
 
262
                ene_hw_write_reg(dev, ENE_FAN_AS_IN1, ENE_FAN_AS_IN1_EN);
 
263
                ene_hw_write_reg(dev, ENE_FAN_AS_IN2, ENE_FAN_AS_IN2_EN);
 
264
        }
 
265
        dev->fan_input_inuse = enable;
 
266
}
 
267
 
 
268
/* determine which input to use*/
 
269
static void ene_set_inputs(struct ene_device *dev, int learning_enable)
 
270
{
 
271
        ene_enable_normal_recieve(dev, 1);
 
272
 
 
273
        /* old hardware doesn't support learning mode for sure */
 
274
        if (dev->hw_revision <= ENE_HW_B)
 
275
                return;
 
276
 
 
277
        /* reciever not learning capable, still set gpio40 correctly */
 
278
        if (!dev->hw_learning_and_tx_capable) {
 
279
                ene_enable_gpio40(dev, !dev->hw_gpio40_learning);
 
280
                return;
 
281
        }
 
282
 
 
283
        /* enable learning mode */
 
284
        if (learning_enable) {
 
285
                ene_enable_gpio40(dev, dev->hw_gpio40_learning);
 
286
 
 
287
                /* fan input is not used for learning */
 
288
                if (dev->hw_fan_as_normal_input)
 
289
                        ene_enable_fan_recieve(dev, 0);
 
290
 
 
291
        /* disable learning mode */
 
292
        } else {
 
293
                if (dev->hw_fan_as_normal_input) {
 
294
                        ene_enable_fan_recieve(dev, 1);
 
295
                        ene_enable_normal_recieve(dev, 0);
 
296
                } else
 
297
                        ene_enable_gpio40(dev, !dev->hw_gpio40_learning);
 
298
        }
 
299
 
 
300
        /* set few additional settings for this mode */
 
301
        ene_hw_write_reg_mask(dev, ENE_CIR_CONF1, learning_enable ?
 
302
                              ENE_CIR_CONF1_LEARN1 : 0, ENE_CIR_CONF1_LEARN1);
 
303
 
 
304
        ene_hw_write_reg_mask(dev, ENE_CIR_CONF2, learning_enable ?
 
305
                              ENE_CIR_CONF2_LEARN2 : 0, ENE_CIR_CONF2_LEARN2);
 
306
}
 
307
 
 
308
/* deinitialization */
 
309
static void ene_hw_deinit(void *data)
 
310
{
 
311
        struct ene_device *dev = (struct ene_device *)data;
 
312
 
 
313
        /* disable samplers */
 
314
        ene_enable_normal_recieve(dev, 0);
 
315
 
 
316
        if (dev->hw_fan_as_normal_input)
 
317
                ene_enable_fan_recieve(dev, 0);
 
318
 
 
319
        /* disable hardware IRQ and firmware flag */
 
320
        ene_hw_write_reg_mask(dev, ENE_FW1, 0, ENE_FW1_ENABLE | ENE_FW1_IRQ);
 
321
 
 
322
        ene_set_idle(dev, 1);
 
323
        dev->in_use = 0;
 
324
}
 
325
 
 
326
/*  sends current sample to userspace */
 
327
static void send_sample(struct ene_device *dev)
 
328
{
 
329
        int value = abs(dev->sample) & PULSE_MASK;
 
330
 
 
331
        if (dev->sample > 0)
 
332
                value |= PULSE_BIT;
 
333
 
 
334
        if (!lirc_buffer_full(dev->lirc_driver->rbuf)) {
 
335
                lirc_buffer_write(dev->lirc_driver->rbuf, (void *)&value);
 
336
                wake_up(&dev->lirc_driver->rbuf->wait_poll);
 
337
        }
 
338
        dev->sample = 0;
 
339
}
 
340
 
 
341
/*  this updates current sample */
 
342
static void update_sample(struct ene_device *dev, int sample)
 
343
{
 
344
        if (!dev->sample)
 
345
                dev->sample = sample;
 
346
        else if (same_sign(dev->sample, sample))
 
347
                dev->sample += sample;
 
348
        else {
 
349
                send_sample(dev);
 
350
                dev->sample = sample;
 
351
        }
 
352
}
 
353
 
 
354
/* enable or disable idle mode */
 
355
static void ene_set_idle(struct ene_device *dev, int idle)
 
356
{
 
357
        struct timeval now;
 
358
        int disable = idle && enable_idle && (dev->hw_revision < ENE_HW_C);
 
359
 
 
360
        ene_hw_write_reg_mask(dev, ENE_CIR_SAMPLE_PERIOD,
 
361
                              disable ? 0 : ENE_CIR_SAMPLE_OVERFLOW,
 
362
                              ENE_CIR_SAMPLE_OVERFLOW);
 
363
        dev->idle = idle;
 
364
 
 
365
        /* remember when we have entered the idle mode */
 
366
        if (idle) {
 
367
                do_gettimeofday(&dev->gap_start);
 
368
                return;
 
369
        }
 
370
 
 
371
        /* send the gap between keypresses now */
 
372
        do_gettimeofday(&now);
 
373
 
 
374
        if (now.tv_sec - dev->gap_start.tv_sec > 16)
 
375
                dev->sample = space(PULSE_MASK);
 
376
        else
 
377
                dev->sample = dev->sample +
 
378
                    space(1000000ull * (now.tv_sec - dev->gap_start.tv_sec))
 
379
                    + space(now.tv_usec - dev->gap_start.tv_usec);
 
380
 
 
381
        if (abs(dev->sample) > PULSE_MASK)
 
382
                dev->sample = space(PULSE_MASK);
 
383
        send_sample(dev);
 
384
}
 
385
 
 
386
/* interrupt handler */
 
387
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19)
 
388
static irqreturn_t ene_hw_irq(int irq, void *data)
 
389
#else
 
390
static irqreturn_t ene_hw_irq(int irq, void *data, struct pt_regs *regs)
 
391
#endif
 
392
{
 
393
        u16 hw_value;
 
394
        int i, hw_sample;
 
395
        int space;
 
396
        int buffer_pointer;
 
397
        int irq_status;
 
398
 
 
399
        struct ene_device *dev = (struct ene_device *)data;
 
400
        irq_status = ene_hw_irq_status(dev, &buffer_pointer);
 
401
 
 
402
        if (!irq_status)
 
403
                return IRQ_NONE;
 
404
 
 
405
        /* TODO: only RX for now */
 
406
        if (irq_status == ENE_IRQ_TX)
 
407
                return IRQ_HANDLED;
 
408
 
 
409
        for (i = 0; i < ENE_SAMPLES_SIZE; i++) {
 
410
 
 
411
                hw_value = ene_hw_read_reg(dev,
 
412
                                ENE_SAMPLE_BUFFER + buffer_pointer + i);
 
413
 
 
414
                if (dev->fan_input_inuse) {
 
415
                        /* read high part of the sample */
 
416
                        hw_value |= ene_hw_read_reg(dev,
 
417
                            ENE_SAMPLE_BUFFER_FAN + buffer_pointer + i) << 8;
 
418
 
 
419
                        /* test for _space_ bit */
 
420
                        space = !(hw_value & ENE_FAN_SMPL_PULS_MSK);
 
421
 
 
422
                        /* clear space bit, and other unused bits */
 
423
                        hw_value &= ENE_FAN_VALUE_MASK;
 
424
                        hw_sample = hw_value * ENE_SAMPLE_PERIOD_FAN;
 
425
 
 
426
                } else {
 
427
                        space = hw_value & ENE_SAMPLE_SPC_MASK;
 
428
                        hw_value &= ENE_SAMPLE_VALUE_MASK;
 
429
                        hw_sample = hw_value * sample_period;
 
430
                }
 
431
 
 
432
                /* no more data */
 
433
                if (!(hw_value))
 
434
                        break;
 
435
 
 
436
                if (space)
 
437
                        hw_sample *= -1;
 
438
 
 
439
                /* overflow sample recieved, handle it */
 
440
 
 
441
                if (!dev->fan_input_inuse && hw_value == ENE_SAMPLE_OVERFLOW) {
 
442
 
 
443
                        if (dev->idle)
 
444
                                continue;
 
445
 
 
446
                        if (dev->sample > 0 || abs(dev->sample) <= ENE_MAXGAP)
 
447
                                update_sample(dev, hw_sample);
 
448
                        else
 
449
                                ene_set_idle(dev, 1);
 
450
 
 
451
                        continue;
 
452
                }
 
453
 
 
454
                /* normal first sample recieved */
 
455
                if (!dev->fan_input_inuse && dev->idle) {
 
456
                        ene_set_idle(dev, 0);
 
457
 
 
458
                        /* discard first recieved value, its random
 
459
                           since its the time signal was off before
 
460
                           first pulse if idle mode is enabled, HW
 
461
                           does that for us */
 
462
 
 
463
                        if (!enable_idle)
 
464
                                continue;
 
465
                }
 
466
                update_sample(dev, hw_sample);
 
467
                send_sample(dev);
 
468
        }
 
469
        return IRQ_HANDLED;
 
470
}
 
471
 
 
472
static int ene_probe(struct pnp_dev *pnp_dev,
 
473
                     const struct pnp_device_id *dev_id)
 
474
{
 
475
        struct ene_device *dev;
 
476
        struct lirc_driver *lirc_driver;
 
477
        int error = -ENOMEM;
 
478
 
 
479
        dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL);
 
480
 
 
481
        if (!dev)
 
482
                goto err1;
 
483
 
 
484
        dev->pnp_dev = pnp_dev;
 
485
        pnp_set_drvdata(pnp_dev, dev);
 
486
 
 
487
 
 
488
        /* prepare lirc interface */
 
489
        error = -ENOMEM;
 
490
        lirc_driver = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);
 
491
 
 
492
        if (!lirc_driver)
 
493
                goto err2;
 
494
 
 
495
        dev->lirc_driver = lirc_driver;
 
496
 
 
497
        strcpy(lirc_driver->name, ENE_DRIVER_NAME);
 
498
        lirc_driver->minor = -1;
 
499
        lirc_driver->code_length = sizeof(int) * 8;
 
500
        lirc_driver->features = LIRC_CAN_REC_MODE2;
 
501
        lirc_driver->data = dev;
 
502
        lirc_driver->set_use_inc = ene_hw_init;
 
503
        lirc_driver->set_use_dec = ene_hw_deinit;
 
504
        lirc_driver->dev = &pnp_dev->dev;
 
505
        lirc_driver->owner = THIS_MODULE;
 
506
 
 
507
        lirc_driver->rbuf = kzalloc(sizeof(struct lirc_buffer), GFP_KERNEL);
 
508
 
 
509
        if (!lirc_driver->rbuf)
 
510
                goto err3;
 
511
 
 
512
        if (lirc_buffer_init(lirc_driver->rbuf, sizeof(int), sizeof(int) * 256))
 
513
                goto err4;
 
514
 
 
515
        error = -ENODEV;
 
516
        if (lirc_register_driver(lirc_driver))
 
517
                goto err5;
 
518
 
 
519
        /* validate resources */
 
520
        if (!pnp_port_valid(pnp_dev, 0) || pnp_port_len(pnp_dev, 0) < ENE_MAX_IO)
 
521
                goto err6;
 
522
 
 
523
        if (!pnp_irq_valid(pnp_dev, 0))
 
524
                goto err6;
 
525
 
 
526
        dev->hw_io = pnp_port_start(pnp_dev, 0);
 
527
        dev->irq = pnp_irq(pnp_dev, 0);
 
528
 
 
529
        /* claim the resources */
 
530
        error = -EBUSY;
 
531
        if (!request_region(dev->hw_io, ENE_MAX_IO, ENE_DRIVER_NAME))
 
532
                goto err6;
 
533
 
 
534
        if (request_irq(dev->irq, ene_hw_irq,
 
535
                        IRQF_SHARED, ENE_DRIVER_NAME, (void *)dev))
 
536
                goto err7;
 
537
 
 
538
        /* detect hardware version and features */
 
539
        error = ene_hw_detect(dev);
 
540
        if (error)
 
541
                goto err8;
 
542
 
 
543
        ene_printk(KERN_NOTICE, "driver has been succesfully loaded\n");
 
544
        return 0;
 
545
 
 
546
err8:
 
547
        free_irq(dev->irq, dev);
 
548
err7:
 
549
        release_region(dev->hw_io, ENE_MAX_IO);
 
550
err6:
 
551
        lirc_unregister_driver(lirc_driver->minor);
 
552
err5:
 
553
        lirc_buffer_free(lirc_driver->rbuf);
 
554
err4:
 
555
        kfree(lirc_driver->rbuf);
 
556
err3:
 
557
        kfree(lirc_driver);
 
558
err2:
 
559
        kfree(dev);
 
560
err1:
 
561
        return error;
 
562
}
 
563
 
 
564
static void ene_remove(struct pnp_dev *pnp_dev)
 
565
{
 
566
        struct ene_device *dev = pnp_get_drvdata(pnp_dev);
 
567
        ene_hw_deinit(dev);
 
568
        free_irq(dev->irq, dev);
 
569
        release_region(dev->hw_io, ENE_MAX_IO);
 
570
        lirc_unregister_driver(dev->lirc_driver->minor);
 
571
        lirc_buffer_free(dev->lirc_driver->rbuf);
 
572
        kfree(dev->lirc_driver);
 
573
        kfree(dev);
 
574
}
 
575
 
 
576
#ifdef CONFIG_PM
 
577
 
 
578
/* TODO: make 'wake on IR' configurable and add .shutdown */
 
579
/* currently impossible due to lack of kernel support */
 
580
 
 
581
static int ene_suspend(struct pnp_dev *pnp_dev, pm_message_t state)
 
582
{
 
583
        struct ene_device *dev = pnp_get_drvdata(pnp_dev);
 
584
        ene_hw_write_reg_mask(dev, ENE_FW1, ENE_FW1_WAKE, ENE_FW1_WAKE);
 
585
        return 0;
 
586
}
 
587
 
 
588
static int ene_resume(struct pnp_dev *pnp_dev)
 
589
{
 
590
        struct ene_device *dev = pnp_get_drvdata(pnp_dev);
 
591
        if (dev->in_use)
 
592
                ene_hw_init(dev);
 
593
 
 
594
        ene_hw_write_reg_mask(dev, ENE_FW1, 0, ENE_FW1_WAKE);
 
595
        return 0;
 
596
}
 
597
 
 
598
#endif
 
599
 
 
600
static const struct pnp_device_id ene_ids[] = {
 
601
        {.id = "ENE0100",},
 
602
        {},
 
603
};
 
604
 
 
605
static struct pnp_driver ene_driver = {
 
606
        .name = ENE_DRIVER_NAME,
 
607
        .id_table = ene_ids,
 
608
        .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
 
609
 
 
610
        .probe = ene_probe,
 
611
        .remove = __devexit_p(ene_remove),
 
612
 
 
613
#ifdef CONFIG_PM
 
614
        .suspend = ene_suspend,
 
615
        .resume = ene_resume,
 
616
#endif
 
617
};
 
618
 
 
619
static int __init ene_init(void)
 
620
{
 
621
        if (sample_period < 5) {
 
622
                ene_printk(KERN_ERR, "sample period must be at\n");
 
623
                ene_printk(KERN_ERR, "least 5 us, (at least 30 recommended)\n");
 
624
                return -EINVAL;
 
625
        }
 
626
        return pnp_register_driver(&ene_driver);
 
627
}
 
628
 
 
629
static void ene_exit(void)
 
630
{
 
631
        pnp_unregister_driver(&ene_driver);
 
632
}
 
633
 
 
634
module_param(sample_period, int, S_IRUGO);
 
635
MODULE_PARM_DESC(sample_period, "Hardware sample period (75 us default)");
 
636
 
 
637
module_param(enable_idle, bool, S_IRUGO | S_IWUSR);
 
638
MODULE_PARM_DESC(enable_idle,
 
639
        "Enables turning off signal sampling after long inactivity time; "
 
640
        "if disabled might help detecting input signal (default: enabled)");
 
641
 
 
642
module_param(enable_learning, bool, S_IRUGO);
 
643
MODULE_PARM_DESC(enable_learning, "Use wide band (learning) reciever");
 
644
 
 
645
MODULE_DEVICE_TABLE(pnp, ene_ids);
 
646
MODULE_DESCRIPTION
 
647
    ("LIRC driver for KB3926B/KB3926C/KB3926D (aka ENE0100) CIR port");
 
648
MODULE_AUTHOR("Maxim Levitsky");
 
649
MODULE_LICENSE("GPL");
 
650
 
 
651
module_init(ene_init);
 
652
module_exit(ene_exit);
 
653
#endif