pci/cx88/cx88-input.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  * Device driver for GPIO attached remote control interfaces
0005  * on Conexant 2388x based TV/DVB cards.
0006  *
0007  * Copyright (c) 2003 Pavel Machek
0008  * Copyright (c) 2004 Gerd Knorr
0009  * Copyright (c) 2004, 2005 Chris Pascoe
0010  */
0011
0012 #include "cx88.h"
0013
0014 #include <linux/init.h>
0015 #include <linux/hrtimer.h>
0016 #include <linux/pci.h>
0017 #include <linux/slab.h>
0018 #include <linux/module.h>
0019
0020 #include <media/rc-core.h>
0021
0022 #define MODULE_NAME "cx88xx"
0023
0024 /* ---------------------------------------------------------------------- */
0025
0026 struct cx88_IR {
0027     struct cx88_core *core;
0028     struct rc_dev *dev;
0029
0030     int users;
0031
0032     char name[32];
0033     char phys[32];
0034
0035     /* sample from gpio pin 16 */
0036     u32 sampling;
0037
0038     /* poll external decoder */
0039     int polling;
0040     struct hrtimer timer;
0041     u32 gpio_addr;
0042     u32 last_gpio;
0043     u32 mask_keycode;
0044     u32 mask_keydown;
0045     u32 mask_keyup;
0046 };
0047
0048 static unsigned int ir_samplerate = 4;
0049 module_param(ir_samplerate, uint, 0444);
0050 MODULE_PARM_DESC(ir_samplerate, "IR samplerate in kHz, 1 - 20, default 4");
0051
0052 static int ir_debug;
0053 module_param(ir_debug, int, 0644);  /* debug level [IR] */
0054 MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
0055
0056 #define ir_dprintk(fmt, arg...) do {                    \
0057     if (ir_debug)                           \
0058         printk(KERN_DEBUG "%s IR: " fmt, ir->core->name, ##arg);\
0059 } while (0)
0060
0061 #define dprintk(fmt, arg...) do {                   \
0062     if (ir_debug)                           \
0063         printk(KERN_DEBUG "cx88 IR: " fmt, ##arg);      \
0064 } while (0)
0065
0066 /* ---------------------------------------------------------------------- */
0067
0068 static void cx88_ir_handle_key(struct cx88_IR *ir)
0069 {
0070     struct cx88_core *core = ir->core;
0071     u32 gpio, data, auxgpio;
0072
0073     /* read gpio value */
0074     gpio = cx_read(ir->gpio_addr);
0075     switch (core->boardnr) {
0076     case CX88_BOARD_NPGTECH_REALTV_TOP10FM:
0077         /*
0078          * This board apparently uses a combination of 2 GPIO
0079          * to represent the keys. Additionally, the second GPIO
0080          * can be used for parity.
0081          *
0082          * Example:
0083          *
0084          * for key "5"
0085          *  gpio = 0x758, auxgpio = 0xe5 or 0xf5
0086          * for key "Power"
0087          *  gpio = 0x758, auxgpio = 0xed or 0xfd
0088          */
0089
0090         auxgpio = cx_read(MO_GP1_IO);
0091         /* Take out the parity part */
0092         gpio = (gpio & 0x7fd) + (auxgpio & 0xef);
0093         break;
0094     case CX88_BOARD_WINFAST_DTV1000:
0095     case CX88_BOARD_WINFAST_DTV1800H:
0096     case CX88_BOARD_WINFAST_DTV1800H_XC4000:
0097     case CX88_BOARD_WINFAST_DTV2000H_PLUS:
0098     case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
0099     case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36:
0100     case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43:
0101         gpio = (gpio & 0x6ff) | ((cx_read(MO_GP1_IO) << 8) & 0x900);
0102         auxgpio = gpio;
0103         break;
0104     default:
0105         auxgpio = gpio;
0106     }
0107     if (ir->polling) {
0108         if (ir->last_gpio == auxgpio)
0109             return;
0110         ir->last_gpio = auxgpio;
0111     }
0112
0113     /* extract data */
0114     data = ir_extract_bits(gpio, ir->mask_keycode);
0115     ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n",
0116            gpio, data,
0117            ir->polling ? "poll" : "irq",
0118            (gpio & ir->mask_keydown) ? " down" : "",
0119            (gpio & ir->mask_keyup) ? " up" : "");
0120
0121     if (ir->core->boardnr == CX88_BOARD_NORWOOD_MICRO) {
0122         u32 gpio_key = cx_read(MO_GP0_IO);
0123
0124         data = (data << 4) | ((gpio_key & 0xf0) >> 4);
0125
0126         rc_keydown(ir->dev, RC_PROTO_UNKNOWN, data, 0);
0127
0128     } else if (ir->core->boardnr == CX88_BOARD_PROLINK_PLAYTVPVR ||
0129            ir->core->boardnr == CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO) {
0130         /* bit cleared on keydown, NEC scancode, 0xAAAACC, A = 0x866b */
0131         u16 addr;
0132         u8 cmd;
0133         u32 scancode;
0134
0135         addr = (data >> 8) & 0xffff;
0136         cmd  = (data >> 0) & 0x00ff;
0137         scancode = RC_SCANCODE_NECX(addr, cmd);
0138
0139         if (0 == (gpio & ir->mask_keyup))
0140             rc_keydown_notimeout(ir->dev, RC_PROTO_NECX, scancode,
0141                          0);
0142         else
0143             rc_keyup(ir->dev);
0144
0145     } else if (ir->mask_keydown) {
0146         /* bit set on keydown */
0147         if (gpio & ir->mask_keydown)
0148             rc_keydown_notimeout(ir->dev, RC_PROTO_UNKNOWN, data,
0149                          0);
0150         else
0151             rc_keyup(ir->dev);
0152
0153     } else if (ir->mask_keyup) {
0154         /* bit cleared on keydown */
0155         if (0 == (gpio & ir->mask_keyup))
0156             rc_keydown_notimeout(ir->dev, RC_PROTO_UNKNOWN, data,
0157                          0);
0158         else
0159             rc_keyup(ir->dev);
0160
0161     } else {
0162         /* can't distinguish keydown/up :-/ */
0163         rc_keydown_notimeout(ir->dev, RC_PROTO_UNKNOWN, data, 0);
0164         rc_keyup(ir->dev);
0165     }
0166 }
0167
0168 static enum hrtimer_restart cx88_ir_work(struct hrtimer *timer)
0169 {
0170     u64 missed;
0171     struct cx88_IR *ir = container_of(timer, struct cx88_IR, timer);
0172
0173     cx88_ir_handle_key(ir);
0174     missed = hrtimer_forward_now(&ir->timer,
0175                      ktime_set(0, ir->polling * 1000000));
0176     if (missed > 1)
0177         ir_dprintk("Missed ticks %llu\n", missed - 1);
0178
0179     return HRTIMER_RESTART;
0180 }
0181
0182 static int __cx88_ir_start(void *priv)
0183 {
0184     struct cx88_core *core = priv;
0185     struct cx88_IR *ir;
0186
0187     if (!core || !core->ir)
0188         return -EINVAL;
0189
0190     ir = core->ir;
0191
0192     if (ir->polling) {
0193         hrtimer_init(&ir->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
0194         ir->timer.function = cx88_ir_work;
0195         hrtimer_start(&ir->timer,
0196                   ktime_set(0, ir->polling * 1000000),
0197                   HRTIMER_MODE_REL);
0198     }
0199     if (ir->sampling) {
0200         core->pci_irqmask |= PCI_INT_IR_SMPINT;
0201         cx_write(MO_DDS_IO, 0x33F286 * ir_samplerate); /* samplerate */
0202         cx_write(MO_DDSCFG_IO, 0x5); /* enable */
0203     }
0204     return 0;
0205 }
0206
0207 static void __cx88_ir_stop(void *priv)
0208 {
0209     struct cx88_core *core = priv;
0210     struct cx88_IR *ir;
0211
0212     if (!core || !core->ir)
0213         return;
0214
0215     ir = core->ir;
0216     if (ir->sampling) {
0217         cx_write(MO_DDSCFG_IO, 0x0);
0218         core->pci_irqmask &= ~PCI_INT_IR_SMPINT;
0219     }
0220
0221     if (ir->polling)
0222         hrtimer_cancel(&ir->timer);
0223 }
0224
0225 int cx88_ir_start(struct cx88_core *core)
0226 {
0227     if (core->ir->users)
0228         return __cx88_ir_start(core);
0229
0230     return 0;
0231 }
0232 EXPORT_SYMBOL(cx88_ir_start);
0233
0234 void cx88_ir_stop(struct cx88_core *core)
0235 {
0236     if (core->ir->users)
0237         __cx88_ir_stop(core);
0238 }
0239 EXPORT_SYMBOL(cx88_ir_stop);
0240
0241 static int cx88_ir_open(struct rc_dev *rc)
0242 {
0243     struct cx88_core *core = rc->priv;
0244
0245     core->ir->users++;
0246     return __cx88_ir_start(core);
0247 }
0248
0249 static void cx88_ir_close(struct rc_dev *rc)
0250 {
0251     struct cx88_core *core = rc->priv;
0252
0253     core->ir->users--;
0254     if (!core->ir->users)
0255         __cx88_ir_stop(core);
0256 }
0257
0258 /* ---------------------------------------------------------------------- */
0259
0260 int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
0261 {
0262     struct cx88_IR *ir;
0263     struct rc_dev *dev;
0264     char *ir_codes = NULL;
0265     u64 rc_proto = RC_PROTO_BIT_OTHER;
0266     int err = -ENOMEM;
0267     u32 hardware_mask = 0;  /* For devices with a hardware mask, when
0268                  * used with a full-code IR table
0269                  */
0270
0271     ir = kzalloc(sizeof(*ir), GFP_KERNEL);
0272     dev = rc_allocate_device(RC_DRIVER_IR_RAW);
0273     if (!ir || !dev)
0274         goto err_out_free;
0275
0276     ir->dev = dev;
0277
0278     /* detect & configure */
0279     switch (core->boardnr) {
0280     case CX88_BOARD_DNTV_LIVE_DVB_T:
0281     case CX88_BOARD_KWORLD_DVB_T:
0282     case CX88_BOARD_KWORLD_DVB_T_CX22702:
0283         ir_codes = RC_MAP_DNTV_LIVE_DVB_T;
0284         ir->gpio_addr = MO_GP1_IO;
0285         ir->mask_keycode = 0x1f;
0286         ir->mask_keyup = 0x60;
0287         ir->polling = 50; /* ms */
0288         break;
0289     case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1:
0290         ir_codes = RC_MAP_CINERGY_1400;
0291         ir->sampling = 0xeb04; /* address */
0292         break;
0293     case CX88_BOARD_HAUPPAUGE:
0294     case CX88_BOARD_HAUPPAUGE_DVB_T1:
0295     case CX88_BOARD_HAUPPAUGE_NOVASE2_S1:
0296     case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1:
0297     case CX88_BOARD_HAUPPAUGE_HVR1100:
0298     case CX88_BOARD_HAUPPAUGE_HVR3000:
0299     case CX88_BOARD_HAUPPAUGE_HVR4000:
0300     case CX88_BOARD_HAUPPAUGE_HVR4000LITE:
0301     case CX88_BOARD_PCHDTV_HD3000:
0302     case CX88_BOARD_PCHDTV_HD5500:
0303     case CX88_BOARD_HAUPPAUGE_IRONLY:
0304         ir_codes = RC_MAP_HAUPPAUGE;
0305         ir->sampling = 1;
0306         break;
0307     case CX88_BOARD_WINFAST_DTV2000H:
0308     case CX88_BOARD_WINFAST_DTV2000H_J:
0309     case CX88_BOARD_WINFAST_DTV1800H:
0310     case CX88_BOARD_WINFAST_DTV1800H_XC4000:
0311     case CX88_BOARD_WINFAST_DTV2000H_PLUS:
0312         ir_codes = RC_MAP_WINFAST;
0313         ir->gpio_addr = MO_GP0_IO;
0314         ir->mask_keycode = 0x8f8;
0315         ir->mask_keyup = 0x100;
0316         ir->polling = 50; /* ms */
0317         break;
0318     case CX88_BOARD_WINFAST2000XP_EXPERT:
0319     case CX88_BOARD_WINFAST_DTV1000:
0320     case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
0321     case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36:
0322     case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43:
0323         ir_codes = RC_MAP_WINFAST;
0324         ir->gpio_addr = MO_GP0_IO;
0325         ir->mask_keycode = 0x8f8;
0326         ir->mask_keyup = 0x100;
0327         ir->polling = 1; /* ms */
0328         break;
0329     case CX88_BOARD_IODATA_GVBCTV7E:
0330         ir_codes = RC_MAP_IODATA_BCTV7E;
0331         ir->gpio_addr = MO_GP0_IO;
0332         ir->mask_keycode = 0xfd;
0333         ir->mask_keydown = 0x02;
0334         ir->polling = 5; /* ms */
0335         break;
0336     case CX88_BOARD_PROLINK_PLAYTVPVR:
0337     case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO:
0338         /*
0339          * It seems that this hardware is paired with NEC extended
0340          * address 0x866b. So, unfortunately, its usage with other
0341          * IR's with different address won't work. Still, there are
0342          * other IR's from the same manufacturer that works, like the
0343          * 002-T mini RC, provided with newer PV hardware
0344          */
0345         ir_codes = RC_MAP_PIXELVIEW_MK12;
0346         rc_proto = RC_PROTO_BIT_NECX;
0347         ir->gpio_addr = MO_GP1_IO;
0348         ir->mask_keyup = 0x80;
0349         ir->polling = 10; /* ms */
0350         hardware_mask = 0x3f;   /* Hardware returns only 6 bits from command part */
0351         break;
0352     case CX88_BOARD_PROLINK_PV_8000GT:
0353     case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME:
0354         ir_codes = RC_MAP_PIXELVIEW_NEW;
0355         ir->gpio_addr = MO_GP1_IO;
0356         ir->mask_keycode = 0x3f;
0357         ir->mask_keyup = 0x80;
0358         ir->polling = 1; /* ms */
0359         break;
0360     case CX88_BOARD_KWORLD_LTV883:
0361         ir_codes = RC_MAP_PIXELVIEW;
0362         ir->gpio_addr = MO_GP1_IO;
0363         ir->mask_keycode = 0x1f;
0364         ir->mask_keyup = 0x60;
0365         ir->polling = 1; /* ms */
0366         break;
0367     case CX88_BOARD_ADSTECH_DVB_T_PCI:
0368         ir_codes = RC_MAP_ADSTECH_DVB_T_PCI;
0369         ir->gpio_addr = MO_GP1_IO;
0370         ir->mask_keycode = 0xbf;
0371         ir->mask_keyup = 0x40;
0372         ir->polling = 50; /* ms */
0373         break;
0374     case CX88_BOARD_MSI_TVANYWHERE_MASTER:
0375         ir_codes = RC_MAP_MSI_TVANYWHERE;
0376         ir->gpio_addr = MO_GP1_IO;
0377         ir->mask_keycode = 0x1f;
0378         ir->mask_keyup = 0x40;
0379         ir->polling = 1; /* ms */
0380         break;
0381     case CX88_BOARD_AVERTV_303:
0382     case CX88_BOARD_AVERTV_STUDIO_303:
0383         ir_codes         = RC_MAP_AVERTV_303;
0384         ir->gpio_addr    = MO_GP2_IO;
0385         ir->mask_keycode = 0xfb;
0386         ir->mask_keydown = 0x02;
0387         ir->polling      = 50; /* ms */
0388         break;
0389     case CX88_BOARD_OMICOM_SS4_PCI:
0390     case CX88_BOARD_SATTRADE_ST4200:
0391     case CX88_BOARD_TBS_8920:
0392     case CX88_BOARD_TBS_8910:
0393     case CX88_BOARD_PROF_7300:
0394     case CX88_BOARD_PROF_7301:
0395     case CX88_BOARD_PROF_6200:
0396         ir_codes = RC_MAP_TBS_NEC;
0397         ir->sampling = 0xff00; /* address */
0398         break;
0399     case CX88_BOARD_TEVII_S464:
0400     case CX88_BOARD_TEVII_S460:
0401     case CX88_BOARD_TEVII_S420:
0402         ir_codes = RC_MAP_TEVII_NEC;
0403         ir->sampling = 0xff00; /* address */
0404         break;
0405     case CX88_BOARD_DNTV_LIVE_DVB_T_PRO:
0406         ir_codes         = RC_MAP_DNTV_LIVE_DVBT_PRO;
0407         ir->sampling     = 0xff00; /* address */
0408         break;
0409     case CX88_BOARD_NORWOOD_MICRO:
0410         ir_codes         = RC_MAP_NORWOOD;
0411         ir->gpio_addr    = MO_GP1_IO;
0412         ir->mask_keycode = 0x0e;
0413         ir->mask_keyup   = 0x80;
0414         ir->polling      = 50; /* ms */
0415         break;
0416     case CX88_BOARD_NPGTECH_REALTV_TOP10FM:
0417         ir_codes         = RC_MAP_NPGTECH;
0418         ir->gpio_addr    = MO_GP0_IO;
0419         ir->mask_keycode = 0xfa;
0420         ir->polling      = 50; /* ms */
0421         break;
0422     case CX88_BOARD_PINNACLE_PCTV_HD_800i:
0423         ir_codes         = RC_MAP_PINNACLE_PCTV_HD;
0424         ir->sampling     = 1;
0425         break;
0426     case CX88_BOARD_POWERCOLOR_REAL_ANGEL:
0427         ir_codes         = RC_MAP_POWERCOLOR_REAL_ANGEL;
0428         ir->gpio_addr    = MO_GP2_IO;
0429         ir->mask_keycode = 0x7e;
0430         ir->polling      = 100; /* ms */
0431         break;
0432     case CX88_BOARD_TWINHAN_VP1027_DVBS:
0433         ir_codes         = RC_MAP_TWINHAN_VP1027_DVBS;
0434         ir->sampling     = 0xff00; /* address */
0435         break;
0436     }
0437
0438     if (!ir_codes) {
0439         err = -ENODEV;
0440         goto err_out_free;
0441     }
0442
0443     /*
0444      * The usage of mask_keycode were very convenient, due to several
0445      * reasons. Among others, the scancode tables were using the scancode
0446      * as the index elements. So, the less bits it was used, the smaller
0447      * the table were stored. After the input changes, the better is to use
0448      * the full scancodes, since it allows replacing the IR remote by
0449      * another one. Unfortunately, there are still some hardware, like
0450      * Pixelview Ultra Pro, where only part of the scancode is sent via
0451      * GPIO. So, there's no way to get the full scancode. Due to that,
0452      * hardware_mask were introduced here: it represents those hardware
0453      * that has such limits.
0454      */
0455     if (hardware_mask && !ir->mask_keycode)
0456         ir->mask_keycode = hardware_mask;
0457
0458     /* init input device */
0459     snprintf(ir->name, sizeof(ir->name), "cx88 IR (%s)", core->board.name);
0460     snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(pci));
0461
0462     dev->device_name = ir->name;
0463     dev->input_phys = ir->phys;
0464     dev->input_id.bustype = BUS_PCI;
0465     dev->input_id.version = 1;
0466     if (pci->subsystem_vendor) {
0467         dev->input_id.vendor = pci->subsystem_vendor;
0468         dev->input_id.product = pci->subsystem_device;
0469     } else {
0470         dev->input_id.vendor = pci->vendor;
0471         dev->input_id.product = pci->device;
0472     }
0473     dev->dev.parent = &pci->dev;
0474     dev->map_name = ir_codes;
0475     dev->driver_name = MODULE_NAME;
0476     dev->priv = core;
0477     dev->open = cx88_ir_open;
0478     dev->close = cx88_ir_close;
0479     dev->scancode_mask = hardware_mask;
0480
0481     if (ir->sampling) {
0482         dev->timeout = MS_TO_US(10); /* 10 ms */
0483     } else {
0484         dev->driver_type = RC_DRIVER_SCANCODE;
0485         dev->allowed_protocols = rc_proto;
0486     }
0487
0488     ir->core = core;
0489     core->ir = ir;
0490
0491     /* all done */
0492     err = rc_register_device(dev);
0493     if (err)
0494         goto err_out_free;
0495
0496     return 0;
0497
0498 err_out_free:
0499     rc_free_device(dev);
0500     core->ir = NULL;
0501     kfree(ir);
0502     return err;
0503 }
0504
0505 int cx88_ir_fini(struct cx88_core *core)
0506 {
0507     struct cx88_IR *ir = core->ir;
0508
0509     /* skip detach on non attached boards */
0510     if (!ir)
0511         return 0;
0512
0513     cx88_ir_stop(core);
0514     rc_unregister_device(ir->dev);
0515     kfree(ir);
0516
0517     /* done */
0518     core->ir = NULL;
0519     return 0;
0520 }
0521
0522 /* ---------------------------------------------------------------------- */
0523
0524 void cx88_ir_irq(struct cx88_core *core)
0525 {
0526     struct cx88_IR *ir = core->ir;
0527     u32 samples;
0528     unsigned int todo, bits;
0529     struct ir_raw_event ev = {};
0530
0531     if (!ir || !ir->sampling)
0532         return;
0533
0534     /*
0535      * Samples are stored in a 32 bit register, oldest sample in
0536      * the msb. A set bit represents space and an unset bit
0537      * represents a pulse.
0538      */
0539     samples = cx_read(MO_SAMPLE_IO);
0540
0541     if (samples == 0xff && ir->dev->idle)
0542         return;
0543
0544     for (todo = 32; todo > 0; todo -= bits) {
0545         ev.pulse = samples & 0x80000000 ? false : true;
0546         bits = min(todo, 32U - fls(ev.pulse ? samples : ~samples));
0547         ev.duration = (bits * (USEC_PER_SEC / 1000)) / ir_samplerate;
0548         ir_raw_event_store_with_filter(ir->dev, &ev);
0549         samples <<= bits;
0550     }
0551     ir_raw_event_handle(ir->dev);
0552 }
0553
0554 static int get_key_pvr2000(struct IR_i2c *ir, enum rc_proto *protocol,
0555                u32 *scancode, u8 *toggle)
0556 {
0557     int flags, code;
0558
0559     /* poll IR chip */
0560     flags = i2c_smbus_read_byte_data(ir->c, 0x10);
0561     if (flags < 0) {
0562         dprintk("read error\n");
0563         return 0;
0564     }
0565     /* key pressed ? */
0566     if (0 == (flags & 0x80))
0567         return 0;
0568
0569     /* read actual key code */
0570     code = i2c_smbus_read_byte_data(ir->c, 0x00);
0571     if (code < 0) {
0572         dprintk("read error\n");
0573         return 0;
0574     }
0575
0576     dprintk("IR Key/Flags: (0x%02x/0x%02x)\n",
0577         code & 0xff, flags & 0xff);
0578
0579     *protocol = RC_PROTO_UNKNOWN;
0580     *scancode = code & 0xff;
0581     *toggle = 0;
0582     return 1;
0583 }
0584
0585 void cx88_i2c_init_ir(struct cx88_core *core)
0586 {
0587     struct i2c_board_info info;
0588     static const unsigned short default_addr_list[] = {
0589         0x18, 0x6b, 0x71,
0590         I2C_CLIENT_END
0591     };
0592     static const unsigned short pvr2000_addr_list[] = {
0593         0x18, 0x1a,
0594         I2C_CLIENT_END
0595     };
0596     const unsigned short *addr_list = default_addr_list;
0597     const unsigned short *addrp;
0598     /* Instantiate the IR receiver device, if present */
0599     if (core->i2c_rc != 0)
0600         return;
0601
0602     memset(&info, 0, sizeof(struct i2c_board_info));
0603     strscpy(info.type, "ir_video", I2C_NAME_SIZE);
0604
0605     switch (core->boardnr) {
0606     case CX88_BOARD_LEADTEK_PVR2000:
0607         addr_list = pvr2000_addr_list;
0608         core->init_data.name = "cx88 Leadtek PVR 2000 remote";
0609         core->init_data.type = RC_PROTO_BIT_UNKNOWN;
0610         core->init_data.get_key = get_key_pvr2000;
0611         core->init_data.ir_codes = RC_MAP_EMPTY;
0612         break;
0613     }
0614
0615     /*
0616      * We can't call i2c_new_scanned_device() because it uses
0617      * quick writes for probing and at least some RC receiver
0618      * devices only reply to reads.
0619      * Also, Hauppauge XVR needs to be specified, as address 0x71
0620      * conflicts with another remote type used with saa7134
0621      */
0622     for (addrp = addr_list; *addrp != I2C_CLIENT_END; addrp++) {
0623         info.platform_data = NULL;
0624         memset(&core->init_data, 0, sizeof(core->init_data));
0625
0626         if (*addrp == 0x71) {
0627             /* Hauppauge Z8F0811 */
0628             strscpy(info.type, "ir_z8f0811_haup", I2C_NAME_SIZE);
0629             core->init_data.name = core->board.name;
0630             core->init_data.ir_codes = RC_MAP_HAUPPAUGE;
0631             core->init_data.type = RC_PROTO_BIT_RC5 |
0632                 RC_PROTO_BIT_RC6_MCE | RC_PROTO_BIT_RC6_6A_32;
0633             core->init_data.internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
0634
0635             info.platform_data = &core->init_data;
0636         }
0637         if (i2c_smbus_xfer(&core->i2c_adap, *addrp, 0,
0638                    I2C_SMBUS_READ, 0,
0639                    I2C_SMBUS_QUICK, NULL) >= 0) {
0640             info.addr = *addrp;
0641             i2c_new_client_device(&core->i2c_adap, &info);
0642             break;
0643         }
0644     }
0645 }
0646
0647 /* ---------------------------------------------------------------------- */
0648
0649 MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe");
0650 MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls");
0651 MODULE_LICENSE("GPL");