Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * |
| 3 | * Device driver for GPIO attached remote control interfaces |
| 4 | * on Conexant 2388x based TV/DVB cards. |
| 5 | * |
| 6 | * Copyright (c) 2003 Pavel Machek |
| 7 | * Copyright (c) 2004 Gerd Knorr |
Chris Pascoe | fc40b26 | 2006-01-09 15:25:35 -0200 | [diff] [blame] | 8 | * Copyright (c) 2004, 2005 Chris Pascoe |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | * |
| 10 | * This program is free software; you can redistribute it and/or modify |
| 11 | * it under the terms of the GNU General Public License as published by |
| 12 | * the Free Software Foundation; either version 2 of the License, or |
| 13 | * (at your option) any later version. |
| 14 | * |
| 15 | * This program is distributed in the hope that it will be useful, |
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | * GNU General Public License for more details. |
| 19 | * |
| 20 | * You should have received a copy of the GNU General Public License |
| 21 | * along with this program; if not, write to the Free Software |
| 22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 23 | */ |
| 24 | |
| 25 | #include <linux/init.h> |
| 26 | #include <linux/delay.h> |
| 27 | #include <linux/input.h> |
| 28 | #include <linux/pci.h> |
| 29 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include "cx88.h" |
Mauro Carvalho Chehab | d21838d | 2006-01-09 15:25:21 -0200 | [diff] [blame] | 32 | #include <media/ir-common.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
| 34 | /* ---------------------------------------------------------------------- */ |
| 35 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | struct cx88_IR { |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 37 | struct cx88_core *core; |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 38 | struct input_dev *input; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 39 | struct ir_input_state ir; |
| 40 | char name[32]; |
| 41 | char phys[32]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | |
| 43 | /* sample from gpio pin 16 */ |
Chris Pascoe | fc40b26 | 2006-01-09 15:25:35 -0200 | [diff] [blame] | 44 | u32 sampling; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 45 | u32 samples[16]; |
| 46 | int scount; |
| 47 | unsigned long release; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | |
| 49 | /* poll external decoder */ |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 50 | int polling; |
| 51 | struct work_struct work; |
| 52 | struct timer_list timer; |
| 53 | u32 gpio_addr; |
| 54 | u32 last_gpio; |
| 55 | u32 mask_keycode; |
| 56 | u32 mask_keydown; |
| 57 | u32 mask_keyup; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | }; |
| 59 | |
Douglas Schilling Landgraf | ff699e6 | 2008-04-22 14:41:48 -0300 | [diff] [blame] | 60 | static int ir_debug; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 61 | module_param(ir_debug, int, 0644); /* debug level [IR] */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]"); |
| 63 | |
| 64 | #define ir_dprintk(fmt, arg...) if (ir_debug) \ |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 65 | printk(KERN_DEBUG "%s IR: " fmt , ir->core->name , ##arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | |
| 67 | /* ---------------------------------------------------------------------- */ |
| 68 | |
| 69 | static void cx88_ir_handle_key(struct cx88_IR *ir) |
| 70 | { |
| 71 | struct cx88_core *core = ir->core; |
Ricardo Cerqueira | 680543c | 2006-05-22 07:44:02 -0300 | [diff] [blame] | 72 | u32 gpio, data, auxgpio; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | /* read gpio value */ |
| 75 | gpio = cx_read(ir->gpio_addr); |
Trent Piepho | 6a59d64 | 2007-08-15 14:41:57 -0300 | [diff] [blame] | 76 | switch (core->boardnr) { |
Michael Krufky | 829ea96 | 2007-06-25 14:54:09 -0300 | [diff] [blame] | 77 | case CX88_BOARD_NPGTECH_REALTV_TOP10FM: |
Ricardo Cerqueira | 680543c | 2006-05-22 07:44:02 -0300 | [diff] [blame] | 78 | /* This board apparently uses a combination of 2 GPIO |
| 79 | to represent the keys. Additionally, the second GPIO |
| 80 | can be used for parity. |
| 81 | |
| 82 | Example: |
| 83 | |
| 84 | for key "5" |
| 85 | gpio = 0x758, auxgpio = 0xe5 or 0xf5 |
| 86 | for key "Power" |
| 87 | gpio = 0x758, auxgpio = 0xed or 0xfd |
| 88 | */ |
| 89 | |
| 90 | auxgpio = cx_read(MO_GP1_IO); |
| 91 | /* Take out the parity part */ |
Ricardo Cerqueira | a62c61d | 2006-07-17 16:34:27 -0300 | [diff] [blame] | 92 | gpio=(gpio & 0x7fd) + (auxgpio & 0xef); |
Michael Krufky | 829ea96 | 2007-06-25 14:54:09 -0300 | [diff] [blame] | 93 | break; |
| 94 | case CX88_BOARD_WINFAST_DTV1000: |
Edgar Pisani | e7d11ec | 2007-06-25 14:46:05 -0300 | [diff] [blame] | 95 | gpio = (gpio & 0x6ff) | ((cx_read(MO_GP1_IO) << 8) & 0x900); |
| 96 | auxgpio = gpio; |
Michael Krufky | 829ea96 | 2007-06-25 14:54:09 -0300 | [diff] [blame] | 97 | break; |
| 98 | default: |
Ricardo Cerqueira | 680543c | 2006-05-22 07:44:02 -0300 | [diff] [blame] | 99 | auxgpio = gpio; |
Michael Krufky | 829ea96 | 2007-06-25 14:54:09 -0300 | [diff] [blame] | 100 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | if (ir->polling) { |
Ricardo Cerqueira | 680543c | 2006-05-22 07:44:02 -0300 | [diff] [blame] | 102 | if (ir->last_gpio == auxgpio) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | return; |
Ricardo Cerqueira | 680543c | 2006-05-22 07:44:02 -0300 | [diff] [blame] | 104 | ir->last_gpio = auxgpio; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | /* extract data */ |
| 108 | data = ir_extract_bits(gpio, ir->mask_keycode); |
| 109 | ir_dprintk("irq gpio=0x%x code=%d | %s%s%s\n", |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 110 | gpio, data, |
| 111 | ir->polling ? "poll" : "irq", |
| 112 | (gpio & ir->mask_keydown) ? " down" : "", |
| 113 | (gpio & ir->mask_keyup) ? " up" : ""); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | |
Trent Piepho | 6a59d64 | 2007-08-15 14:41:57 -0300 | [diff] [blame] | 115 | if (ir->core->boardnr == CX88_BOARD_NORWOOD_MICRO) { |
Peter Naulls | d1009bd | 2006-08-08 09:10:05 -0300 | [diff] [blame] | 116 | u32 gpio_key = cx_read(MO_GP0_IO); |
| 117 | |
| 118 | data = (data << 4) | ((gpio_key & 0xf0) >> 4); |
| 119 | |
| 120 | ir_input_keydown(ir->input, &ir->ir, data, data); |
| 121 | ir_input_nokey(ir->input, &ir->ir); |
| 122 | |
| 123 | } else if (ir->mask_keydown) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | /* bit set on keydown */ |
| 125 | if (gpio & ir->mask_keydown) { |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 126 | ir_input_keydown(ir->input, &ir->ir, data, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | } else { |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 128 | ir_input_nokey(ir->input, &ir->ir); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | } else if (ir->mask_keyup) { |
| 132 | /* bit cleared on keydown */ |
| 133 | if (0 == (gpio & ir->mask_keyup)) { |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 134 | ir_input_keydown(ir->input, &ir->ir, data, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | } else { |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 136 | ir_input_nokey(ir->input, &ir->ir); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | } else { |
| 140 | /* can't distinguish keydown/up :-/ */ |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 141 | ir_input_keydown(ir->input, &ir->ir, data, data); |
| 142 | ir_input_nokey(ir->input, &ir->ir); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | } |
| 144 | } |
| 145 | |
| 146 | static void ir_timer(unsigned long data) |
| 147 | { |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 148 | struct cx88_IR *ir = (struct cx88_IR *)data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | |
| 150 | schedule_work(&ir->work); |
| 151 | } |
| 152 | |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 153 | static void cx88_ir_work(struct work_struct *work) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | { |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 155 | struct cx88_IR *ir = container_of(work, struct cx88_IR, work); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | |
| 157 | cx88_ir_handle_key(ir); |
Dmitry Torokhov | 749823a | 2007-05-21 11:48:11 -0300 | [diff] [blame] | 158 | mod_timer(&ir->timer, jiffies + msecs_to_jiffies(ir->polling)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | } |
| 160 | |
Mauro Carvalho Chehab | 13595a5 | 2007-10-01 08:51:39 -0300 | [diff] [blame] | 161 | void cx88_ir_start(struct cx88_core *core, struct cx88_IR *ir) |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 162 | { |
| 163 | if (ir->polling) { |
Dmitry Torokhov | 749823a | 2007-05-21 11:48:11 -0300 | [diff] [blame] | 164 | setup_timer(&ir->timer, ir_timer, (unsigned long)ir); |
Mauro Carvalho Chehab | 67952e8 | 2006-12-10 00:14:21 -0200 | [diff] [blame] | 165 | INIT_WORK(&ir->work, cx88_ir_work); |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 166 | schedule_work(&ir->work); |
| 167 | } |
| 168 | if (ir->sampling) { |
Trent Piepho | 8ddac9e | 2007-08-18 06:57:55 -0300 | [diff] [blame] | 169 | core->pci_irqmask |= PCI_INT_IR_SMPINT; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 170 | cx_write(MO_DDS_IO, 0xa80a80); /* 4 kHz sample rate */ |
| 171 | cx_write(MO_DDSCFG_IO, 0x5); /* enable */ |
| 172 | } |
| 173 | } |
| 174 | |
Mauro Carvalho Chehab | 13595a5 | 2007-10-01 08:51:39 -0300 | [diff] [blame] | 175 | void cx88_ir_stop(struct cx88_core *core, struct cx88_IR *ir) |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 176 | { |
| 177 | if (ir->sampling) { |
| 178 | cx_write(MO_DDSCFG_IO, 0x0); |
Trent Piepho | 8ddac9e | 2007-08-18 06:57:55 -0300 | [diff] [blame] | 179 | core->pci_irqmask &= ~PCI_INT_IR_SMPINT; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | if (ir->polling) { |
| 183 | del_timer_sync(&ir->timer); |
| 184 | flush_scheduled_work(); |
| 185 | } |
| 186 | } |
| 187 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | /* ---------------------------------------------------------------------- */ |
| 189 | |
| 190 | int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci) |
| 191 | { |
| 192 | struct cx88_IR *ir; |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 193 | struct input_dev *input_dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | IR_KEYTAB_TYPE *ir_codes = NULL; |
| 195 | int ir_type = IR_TYPE_OTHER; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 196 | int err = -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 198 | ir = kzalloc(sizeof(*ir), GFP_KERNEL); |
| 199 | input_dev = input_allocate_device(); |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 200 | if (!ir || !input_dev) |
| 201 | goto err_out_free; |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 202 | |
| 203 | ir->input = input_dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | |
| 205 | /* detect & configure */ |
Trent Piepho | 6a59d64 | 2007-08-15 14:41:57 -0300 | [diff] [blame] | 206 | switch (core->boardnr) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | case CX88_BOARD_DNTV_LIVE_DVB_T: |
Mauro Carvalho Chehab | b45009b | 2005-06-23 22:05:03 -0700 | [diff] [blame] | 208 | case CX88_BOARD_KWORLD_DVB_T: |
Marco Manenti | 28ecc44 | 2006-02-07 06:45:33 -0200 | [diff] [blame] | 209 | case CX88_BOARD_KWORLD_DVB_T_CX22702: |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 210 | ir_codes = ir_codes_dntv_live_dvb_t; |
| 211 | ir->gpio_addr = MO_GP1_IO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | ir->mask_keycode = 0x1f; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 213 | ir->mask_keyup = 0x60; |
| 214 | ir->polling = 50; /* ms */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | break; |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 216 | case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1: |
| 217 | ir_codes = ir_codes_cinergy_1400; |
| 218 | ir_type = IR_TYPE_PD; |
Chris Pascoe | fc40b26 | 2006-01-09 15:25:35 -0200 | [diff] [blame] | 219 | ir->sampling = 0xeb04; /* address */ |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 220 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | case CX88_BOARD_HAUPPAUGE: |
| 222 | case CX88_BOARD_HAUPPAUGE_DVB_T1: |
Steven Toth | fb56cb6 | 2006-01-09 15:25:02 -0200 | [diff] [blame] | 223 | case CX88_BOARD_HAUPPAUGE_NOVASE2_S1: |
| 224 | case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1: |
Steven Toth | 611900c | 2006-01-09 15:25:12 -0200 | [diff] [blame] | 225 | case CX88_BOARD_HAUPPAUGE_HVR1100: |
Steven Toth | 76dc82a | 2006-09-30 00:43:58 -0300 | [diff] [blame] | 226 | case CX88_BOARD_HAUPPAUGE_HVR3000: |
Steven Toth | 5bd1b66 | 2008-09-04 01:17:33 -0300 | [diff] [blame] | 227 | case CX88_BOARD_HAUPPAUGE_HVR4000: |
| 228 | case CX88_BOARD_HAUPPAUGE_HVR4000LITE: |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 229 | ir_codes = ir_codes_hauppauge_new; |
| 230 | ir_type = IR_TYPE_RC5; |
| 231 | ir->sampling = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | break; |
Malcolm Valentine | 2de873e | 2006-05-29 13:56:24 -0300 | [diff] [blame] | 233 | case CX88_BOARD_WINFAST_DTV2000H: |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 234 | ir_codes = ir_codes_winfast; |
| 235 | ir->gpio_addr = MO_GP0_IO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | ir->mask_keycode = 0x8f8; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 237 | ir->mask_keyup = 0x100; |
Malcolm Valentine | 2de873e | 2006-05-29 13:56:24 -0300 | [diff] [blame] | 238 | ir->polling = 50; /* ms */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | break; |
Hermann Pitton | ff97d93 | 2006-11-03 10:45:52 -0300 | [diff] [blame] | 240 | case CX88_BOARD_WINFAST2000XP_EXPERT: |
Edgar Pisani | e7d11ec | 2007-06-25 14:46:05 -0300 | [diff] [blame] | 241 | case CX88_BOARD_WINFAST_DTV1000: |
Hermann Pitton | ff97d93 | 2006-11-03 10:45:52 -0300 | [diff] [blame] | 242 | ir_codes = ir_codes_winfast; |
| 243 | ir->gpio_addr = MO_GP0_IO; |
| 244 | ir->mask_keycode = 0x8f8; |
| 245 | ir->mask_keyup = 0x100; |
| 246 | ir->polling = 1; /* ms */ |
| 247 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | case CX88_BOARD_IODATA_GVBCTV7E: |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 249 | ir_codes = ir_codes_iodata_bctv7e; |
| 250 | ir->gpio_addr = MO_GP0_IO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | ir->mask_keycode = 0xfd; |
| 252 | ir->mask_keydown = 0x02; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 253 | ir->polling = 5; /* ms */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | break; |
Hermann Pitton | ff97d93 | 2006-11-03 10:45:52 -0300 | [diff] [blame] | 255 | case CX88_BOARD_PROLINK_PLAYTVPVR: |
Manuel Capinha | 239df2e | 2005-06-23 22:04:53 -0700 | [diff] [blame] | 256 | case CX88_BOARD_PIXELVIEW_PLAYTV_ULTRA_PRO: |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 257 | ir_codes = ir_codes_pixelview; |
| 258 | ir->gpio_addr = MO_GP1_IO; |
Manuel Capinha | 239df2e | 2005-06-23 22:04:53 -0700 | [diff] [blame] | 259 | ir->mask_keycode = 0x1f; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 260 | ir->mask_keyup = 0x80; |
| 261 | ir->polling = 1; /* ms */ |
Manuel Capinha | 239df2e | 2005-06-23 22:04:53 -0700 | [diff] [blame] | 262 | break; |
Mauro Carvalho Chehab | 7f0dd17 | 2008-04-22 14:46:01 -0300 | [diff] [blame] | 263 | case CX88_BOARD_PROLINK_PV_8000GT: |
Mauro Carvalho Chehab | a31d2bb | 2008-09-29 12:08:29 -0300 | [diff] [blame^] | 264 | case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME: |
Mauro Carvalho Chehab | 7f0dd17 | 2008-04-22 14:46:01 -0300 | [diff] [blame] | 265 | ir_codes = ir_codes_pixelview_new; |
| 266 | ir->gpio_addr = MO_GP1_IO; |
| 267 | ir->mask_keycode = 0x3f; |
| 268 | ir->mask_keyup = 0x80; |
| 269 | ir->polling = 1; /* ms */ |
| 270 | break; |
Nickolay V. Shmyrev | b639f9d | 2006-01-23 09:44:10 -0200 | [diff] [blame] | 271 | case CX88_BOARD_KWORLD_LTV883: |
| 272 | ir_codes = ir_codes_pixelview; |
| 273 | ir->gpio_addr = MO_GP1_IO; |
| 274 | ir->mask_keycode = 0x1f; |
| 275 | ir->mask_keyup = 0x60; |
| 276 | ir->polling = 1; /* ms */ |
| 277 | break; |
Mauro Carvalho Chehab | a82decf | 2005-07-07 17:58:36 -0700 | [diff] [blame] | 278 | case CX88_BOARD_ADSTECH_DVB_T_PCI: |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 279 | ir_codes = ir_codes_adstech_dvb_t_pci; |
| 280 | ir->gpio_addr = MO_GP1_IO; |
Mauro Carvalho Chehab | a82decf | 2005-07-07 17:58:36 -0700 | [diff] [blame] | 281 | ir->mask_keycode = 0xbf; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 282 | ir->mask_keyup = 0x40; |
| 283 | ir->polling = 50; /* ms */ |
Mauro Carvalho Chehab | a82decf | 2005-07-07 17:58:36 -0700 | [diff] [blame] | 284 | break; |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 285 | case CX88_BOARD_MSI_TVANYWHERE_MASTER: |
| 286 | ir_codes = ir_codes_msi_tvanywhere; |
| 287 | ir->gpio_addr = MO_GP1_IO; |
| 288 | ir->mask_keycode = 0x1f; |
| 289 | ir->mask_keyup = 0x40; |
| 290 | ir->polling = 1; /* ms */ |
| 291 | break; |
George Gazurkoff | 899ad11 | 2006-01-09 15:25:19 -0200 | [diff] [blame] | 292 | case CX88_BOARD_AVERTV_303: |
George Gazurkoff | 565f494 | 2006-01-09 15:32:46 -0200 | [diff] [blame] | 293 | case CX88_BOARD_AVERTV_STUDIO_303: |
George Gazurkoff | 899ad11 | 2006-01-09 15:25:19 -0200 | [diff] [blame] | 294 | ir_codes = ir_codes_avertv_303; |
| 295 | ir->gpio_addr = MO_GP2_IO; |
| 296 | ir->mask_keycode = 0xfb; |
| 297 | ir->mask_keydown = 0x02; |
| 298 | ir->polling = 50; /* ms */ |
| 299 | break; |
Chris Pascoe | fc40b26 | 2006-01-09 15:25:35 -0200 | [diff] [blame] | 300 | case CX88_BOARD_DNTV_LIVE_DVB_T_PRO: |
| 301 | ir_codes = ir_codes_dntv_live_dvbt_pro; |
| 302 | ir_type = IR_TYPE_PD; |
| 303 | ir->sampling = 0xff00; /* address */ |
| 304 | break; |
Peter Naulls | d1009bd | 2006-08-08 09:10:05 -0300 | [diff] [blame] | 305 | case CX88_BOARD_NORWOOD_MICRO: |
| 306 | ir_codes = ir_codes_norwood; |
| 307 | ir->gpio_addr = MO_GP1_IO; |
| 308 | ir->mask_keycode = 0x0e; |
| 309 | ir->mask_keyup = 0x80; |
| 310 | ir->polling = 50; /* ms */ |
| 311 | break; |
Ricardo Cerqueira | be4f451 | 2006-06-08 17:36:17 -0300 | [diff] [blame] | 312 | case CX88_BOARD_NPGTECH_REALTV_TOP10FM: |
Ricardo Cerqueira | 680543c | 2006-05-22 07:44:02 -0300 | [diff] [blame] | 313 | ir_codes = ir_codes_npgtech; |
| 314 | ir->gpio_addr = MO_GP0_IO; |
| 315 | ir->mask_keycode = 0xfa; |
| 316 | ir->polling = 50; /* ms */ |
| 317 | break; |
Steven Toth | 9121106 | 2008-01-22 01:00:33 -0300 | [diff] [blame] | 318 | case CX88_BOARD_PINNACLE_PCTV_HD_800i: |
| 319 | ir_codes = ir_codes_pinnacle_pctv_hd; |
| 320 | ir_type = IR_TYPE_RC5; |
| 321 | ir->sampling = 1; |
| 322 | break; |
Dâniel Fraga | ba92803 | 2008-04-08 19:56:44 -0300 | [diff] [blame] | 323 | case CX88_BOARD_POWERCOLOR_REAL_ANGEL: |
| 324 | ir_codes = ir_codes_powercolor_real_angel; |
| 325 | ir->gpio_addr = MO_GP2_IO; |
| 326 | ir->mask_keycode = 0x7e; |
| 327 | ir->polling = 100; /* ms */ |
| 328 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | } |
Mauro Carvalho Chehab | b45009b | 2005-06-23 22:05:03 -0700 | [diff] [blame] | 330 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | if (NULL == ir_codes) { |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 332 | err = -ENODEV; |
| 333 | goto err_out_free; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | /* init input device */ |
Trent Piepho | 6a59d64 | 2007-08-15 14:41:57 -0300 | [diff] [blame] | 337 | snprintf(ir->name, sizeof(ir->name), "cx88 IR (%s)", core->board.name); |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 338 | snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(pci)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 340 | ir_input_init(input_dev, &ir->ir, ir_type, ir_codes); |
| 341 | input_dev->name = ir->name; |
| 342 | input_dev->phys = ir->phys; |
| 343 | input_dev->id.bustype = BUS_PCI; |
| 344 | input_dev->id.version = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | if (pci->subsystem_vendor) { |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 346 | input_dev->id.vendor = pci->subsystem_vendor; |
| 347 | input_dev->id.product = pci->subsystem_device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | } else { |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 349 | input_dev->id.vendor = pci->vendor; |
| 350 | input_dev->id.product = pci->device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | } |
Dmitry Torokhov | 2c8a3a3 | 2007-07-16 09:28:15 -0300 | [diff] [blame] | 352 | input_dev->dev.parent = &pci->dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | /* record handles to ourself */ |
| 354 | ir->core = core; |
| 355 | core->ir = ir; |
| 356 | |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 357 | cx88_ir_start(core, ir); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | |
| 359 | /* all done */ |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 360 | err = input_register_device(ir->input); |
| 361 | if (err) |
| 362 | goto err_out_stop; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | |
| 364 | return 0; |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 365 | |
| 366 | err_out_stop: |
| 367 | cx88_ir_stop(core, ir); |
| 368 | core->ir = NULL; |
| 369 | err_out_free: |
| 370 | input_free_device(input_dev); |
| 371 | kfree(ir); |
| 372 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | } |
| 374 | |
| 375 | int cx88_ir_fini(struct cx88_core *core) |
| 376 | { |
| 377 | struct cx88_IR *ir = core->ir; |
| 378 | |
| 379 | /* skip detach on non attached boards */ |
| 380 | if (NULL == ir) |
| 381 | return 0; |
| 382 | |
Dmitry Torokhov | b07b478 | 2006-11-20 10:23:04 -0300 | [diff] [blame] | 383 | cx88_ir_stop(core, ir); |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 384 | input_unregister_device(ir->input); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | kfree(ir); |
| 386 | |
| 387 | /* done */ |
| 388 | core->ir = NULL; |
| 389 | return 0; |
| 390 | } |
| 391 | |
| 392 | /* ---------------------------------------------------------------------- */ |
| 393 | |
| 394 | void cx88_ir_irq(struct cx88_core *core) |
| 395 | { |
| 396 | struct cx88_IR *ir = core->ir; |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 397 | u32 samples, ircode; |
Darron Broad | 34c0802 | 2008-09-22 00:54:59 -0300 | [diff] [blame] | 398 | int i, start, range, toggle, dev, code; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | |
| 400 | if (NULL == ir) |
| 401 | return; |
| 402 | if (!ir->sampling) |
| 403 | return; |
| 404 | |
| 405 | samples = cx_read(MO_SAMPLE_IO); |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 406 | if (0 != samples && 0xffffffff != samples) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 407 | /* record sample data */ |
| 408 | if (ir->scount < ARRAY_SIZE(ir->samples)) |
| 409 | ir->samples[ir->scount++] = samples; |
| 410 | return; |
| 411 | } |
| 412 | if (!ir->scount) { |
| 413 | /* nothing to sample */ |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 414 | if (ir->ir.keypressed && time_after(jiffies, ir->release)) |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 415 | ir_input_nokey(ir->input, &ir->ir); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | return; |
| 417 | } |
| 418 | |
| 419 | /* have a complete sample */ |
| 420 | if (ir->scount < ARRAY_SIZE(ir->samples)) |
| 421 | ir->samples[ir->scount++] = samples; |
| 422 | for (i = 0; i < ir->scount; i++) |
| 423 | ir->samples[i] = ~ir->samples[i]; |
| 424 | if (ir_debug) |
Mauro Carvalho Chehab | 41ef7c1 | 2005-07-12 13:58:44 -0700 | [diff] [blame] | 425 | ir_dump_samples(ir->samples, ir->scount); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 426 | |
| 427 | /* decode it */ |
Trent Piepho | 6a59d64 | 2007-08-15 14:41:57 -0300 | [diff] [blame] | 428 | switch (core->boardnr) { |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 429 | case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1: |
Chris Pascoe | fc40b26 | 2006-01-09 15:25:35 -0200 | [diff] [blame] | 430 | case CX88_BOARD_DNTV_LIVE_DVB_T_PRO: |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 431 | ircode = ir_decode_pulsedistance(ir->samples, ir->scount, 1, 4); |
| 432 | |
| 433 | if (ircode == 0xffffffff) { /* decoding error */ |
| 434 | ir_dprintk("pulse distance decoding error\n"); |
| 435 | break; |
| 436 | } |
| 437 | |
| 438 | ir_dprintk("pulse distance decoded: %x\n", ircode); |
| 439 | |
| 440 | if (ircode == 0) { /* key still pressed */ |
| 441 | ir_dprintk("pulse distance decoded repeat code\n"); |
| 442 | ir->release = jiffies + msecs_to_jiffies(120); |
| 443 | break; |
| 444 | } |
| 445 | |
Chris Pascoe | fc40b26 | 2006-01-09 15:25:35 -0200 | [diff] [blame] | 446 | if ((ircode & 0xffff) != (ir->sampling & 0xffff)) { /* wrong address */ |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 447 | ir_dprintk("pulse distance decoded wrong address\n"); |
Mauro Carvalho Chehab | 4ac9791 | 2005-11-08 21:37:43 -0800 | [diff] [blame] | 448 | break; |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 449 | } |
| 450 | |
| 451 | if (((~ircode >> 24) & 0xff) != ((ircode >> 16) & 0xff)) { /* wrong checksum */ |
| 452 | ir_dprintk("pulse distance decoded wrong check sum\n"); |
| 453 | break; |
| 454 | } |
| 455 | |
| 456 | ir_dprintk("Key Code: %x\n", (ircode >> 16) & 0x7f); |
| 457 | |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 458 | ir_input_keydown(ir->input, &ir->ir, (ircode >> 16) & 0x7f, (ircode >> 16) & 0xff); |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 459 | ir->release = jiffies + msecs_to_jiffies(120); |
| 460 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | case CX88_BOARD_HAUPPAUGE: |
| 462 | case CX88_BOARD_HAUPPAUGE_DVB_T1: |
Steven Toth | fb56cb6 | 2006-01-09 15:25:02 -0200 | [diff] [blame] | 463 | case CX88_BOARD_HAUPPAUGE_NOVASE2_S1: |
| 464 | case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1: |
Chris Pascoe | 30367bf | 2006-01-11 19:40:01 -0200 | [diff] [blame] | 465 | case CX88_BOARD_HAUPPAUGE_HVR1100: |
Steven Toth | 76dc82a | 2006-09-30 00:43:58 -0300 | [diff] [blame] | 466 | case CX88_BOARD_HAUPPAUGE_HVR3000: |
Steven Toth | 5bd1b66 | 2008-09-04 01:17:33 -0300 | [diff] [blame] | 467 | case CX88_BOARD_HAUPPAUGE_HVR4000: |
| 468 | case CX88_BOARD_HAUPPAUGE_HVR4000LITE: |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 469 | ircode = ir_decode_biphase(ir->samples, ir->scount, 5, 7); |
| 470 | ir_dprintk("biphase decoded: %x\n", ircode); |
Darron Broad | 34c0802 | 2008-09-22 00:54:59 -0300 | [diff] [blame] | 471 | /* |
| 472 | * RC5 has an extension bit which adds a new range |
| 473 | * of available codes, this is detected here. Also |
| 474 | * hauppauge remotes (black/silver) always use |
| 475 | * specific device ids. If we do not filter the |
| 476 | * device ids then messages destined for devices |
| 477 | * such as TVs (id=0) will get through to the |
| 478 | * device causing mis-fired events. |
| 479 | */ |
| 480 | /* split rc5 data block ... */ |
| 481 | start = (ircode & 0x2000) >> 13; |
| 482 | range = (ircode & 0x1000) >> 12; |
| 483 | toggle= (ircode & 0x0800) >> 11; |
| 484 | dev = (ircode & 0x07c0) >> 6; |
| 485 | code = (ircode & 0x003f) | ((range << 6) ^ 0x0040); |
| 486 | if( start != 1) |
| 487 | /* no key pressed */ |
| 488 | break; |
| 489 | if ( dev != 0x1e && dev != 0x1f ) |
| 490 | /* not a hauppauge remote */ |
| 491 | break; |
| 492 | ir_input_keydown(ir->input, &ir->ir, code, ircode); |
| 493 | ir->release = jiffies + msecs_to_jiffies(120); |
| 494 | break; |
| 495 | case CX88_BOARD_PINNACLE_PCTV_HD_800i: |
| 496 | ircode = ir_decode_biphase(ir->samples, ir->scount, 5, 7); |
| 497 | ir_dprintk("biphase decoded: %x\n", ircode); |
Mauro Carvalho Chehab | e52e98a | 2005-09-09 13:03:41 -0700 | [diff] [blame] | 498 | if ((ircode & 0xfffff000) != 0x3000) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | break; |
Dmitry Torokhov | b7df391 | 2005-09-15 02:01:53 -0500 | [diff] [blame] | 500 | ir_input_keydown(ir->input, &ir->ir, ircode & 0x3f, ircode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | ir->release = jiffies + msecs_to_jiffies(120); |
| 502 | break; |
| 503 | } |
| 504 | |
| 505 | ir->scount = 0; |
| 506 | return; |
| 507 | } |
| 508 | |
| 509 | /* ---------------------------------------------------------------------- */ |
| 510 | |
| 511 | MODULE_AUTHOR("Gerd Knorr, Pavel Machek, Chris Pascoe"); |
| 512 | MODULE_DESCRIPTION("input driver for cx88 GPIO-based IR remote controls"); |
| 513 | MODULE_LICENSE("GPL"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | /* |
| 515 | * Local variables: |
| 516 | * c-basic-offset: 8 |
| 517 | * End: |
| 518 | */ |