diff options
Diffstat (limited to 'drivers')
76 files changed, 3196 insertions, 2792 deletions
diff --git a/drivers/char/.gitignore b/drivers/char/.gitignore index 73dfdcebfbba..83683a2d8e6a 100644 --- a/drivers/char/.gitignore +++ b/drivers/char/.gitignore | |||
@@ -1,3 +1,2 @@ | |||
1 | consolemap_deftbl.c | 1 | consolemap_deftbl.c |
2 | defkeymap.c | 2 | defkeymap.c |
3 | qtronixmap.c | ||
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig index bde1c665d9f4..0e6f35fcc2eb 100644 --- a/drivers/char/Kconfig +++ b/drivers/char/Kconfig | |||
@@ -371,36 +371,6 @@ config AU1000_SERIAL_CONSOLE | |||
371 | If you have an Alchemy AU1000 processor (MIPS based) and you want | 371 | If you have an Alchemy AU1000 processor (MIPS based) and you want |
372 | to use a console on a serial port, say Y. Otherwise, say N. | 372 | to use a console on a serial port, say Y. Otherwise, say N. |
373 | 373 | ||
374 | config QTRONIX_KEYBOARD | ||
375 | bool "Enable Qtronix 990P Keyboard Support" | ||
376 | depends on IT8712 | ||
377 | help | ||
378 | Images of Qtronix keyboards are at | ||
379 | <http://www.qtronix.com/keyboard.html>. | ||
380 | |||
381 | config IT8172_CIR | ||
382 | bool | ||
383 | depends on QTRONIX_KEYBOARD | ||
384 | default y | ||
385 | |||
386 | config IT8172_SCR0 | ||
387 | bool "Enable Smart Card Reader 0 Support " | ||
388 | depends on IT8712 | ||
389 | help | ||
390 | Say Y here to support smart-card reader 0 (SCR0) on the Integrated | ||
391 | Technology Express, Inc. ITE8172 SBC. Vendor page at | ||
392 | <http://www.ite.com.tw/ia/brief_it8172bsp.htm>; picture of the | ||
393 | board at <http://www.mvista.com/partners/semiconductor/ite.html>. | ||
394 | |||
395 | config IT8172_SCR1 | ||
396 | bool "Enable Smart Card Reader 1 Support " | ||
397 | depends on IT8712 | ||
398 | help | ||
399 | Say Y here to support smart-card reader 1 (SCR1) on the Integrated | ||
400 | Technology Express, Inc. ITE8172 SBC. Vendor page at | ||
401 | <http://www.ite.com.tw/ia/brief_it8172bsp.htm>; picture of the | ||
402 | board at <http://www.mvista.com/partners/semiconductor/ite.html>. | ||
403 | |||
404 | config A2232 | 374 | config A2232 |
405 | tristate "Commodore A2232 serial support (EXPERIMENTAL)" | 375 | tristate "Commodore A2232 serial support (EXPERIMENTAL)" |
406 | depends on EXPERIMENTAL && ZORRO && BROKEN_ON_SMP | 376 | depends on EXPERIMENTAL && ZORRO && BROKEN_ON_SMP |
diff --git a/drivers/char/Makefile b/drivers/char/Makefile index 19114df59bbd..777cad045094 100644 --- a/drivers/char/Makefile +++ b/drivers/char/Makefile | |||
@@ -102,7 +102,7 @@ obj-$(CONFIG_HANGCHECK_TIMER) += hangcheck-timer.o | |||
102 | obj-$(CONFIG_TCG_TPM) += tpm/ | 102 | obj-$(CONFIG_TCG_TPM) += tpm/ |
103 | 103 | ||
104 | # Files generated that shall be removed upon make clean | 104 | # Files generated that shall be removed upon make clean |
105 | clean-files := consolemap_deftbl.c defkeymap.c qtronixmap.c | 105 | clean-files := consolemap_deftbl.c defkeymap.c |
106 | 106 | ||
107 | quiet_cmd_conmk = CONMK $@ | 107 | quiet_cmd_conmk = CONMK $@ |
108 | cmd_conmk = scripts/conmakehash $< > $@ | 108 | cmd_conmk = scripts/conmakehash $< > $@ |
@@ -112,8 +112,6 @@ $(obj)/consolemap_deftbl.c: $(src)/$(FONTMAPFILE) | |||
112 | 112 | ||
113 | $(obj)/defkeymap.o: $(obj)/defkeymap.c | 113 | $(obj)/defkeymap.o: $(obj)/defkeymap.c |
114 | 114 | ||
115 | $(obj)/qtronixmap.o: $(obj)/qtronixmap.c | ||
116 | |||
117 | # Uncomment if you're changing the keymap and have an appropriate | 115 | # Uncomment if you're changing the keymap and have an appropriate |
118 | # loadkeys version for the map. By default, we'll use the shipped | 116 | # loadkeys version for the map. By default, we'll use the shipped |
119 | # versions. | 117 | # versions. |
@@ -121,7 +119,7 @@ $(obj)/qtronixmap.o: $(obj)/qtronixmap.c | |||
121 | 119 | ||
122 | ifdef GENERATE_KEYMAP | 120 | ifdef GENERATE_KEYMAP |
123 | 121 | ||
124 | $(obj)/defkeymap.c $(obj)/qtronixmap.c: $(obj)/%.c: $(src)/%.map | 122 | $(obj)/defkeymap.c $(obj)/%.c: $(src)/%.map |
125 | loadkeys --mktable $< > $@.tmp | 123 | loadkeys --mktable $< > $@.tmp |
126 | sed -e 's/^static *//' $@.tmp > $@ | 124 | sed -e 's/^static *//' $@.tmp > $@ |
127 | rm $@.tmp | 125 | rm $@.tmp |
diff --git a/drivers/char/ite_gpio.c b/drivers/char/ite_gpio.c deleted file mode 100644 index ef14b6d1bc74..000000000000 --- a/drivers/char/ite_gpio.c +++ /dev/null | |||
@@ -1,419 +0,0 @@ | |||
1 | /* | ||
2 | * FILE NAME ite_gpio.c | ||
3 | * | ||
4 | * BRIEF MODULE DESCRIPTION | ||
5 | * API for ITE GPIO device. | ||
6 | * Driver for ITE GPIO device. | ||
7 | * | ||
8 | * Author: MontaVista Software, Inc. <source@mvista.com> | ||
9 | * Hai-Pao Fan <haipao@mvista.com> | ||
10 | * | ||
11 | * Copyright 2001 MontaVista Software Inc. | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or modify it | ||
14 | * under the terms of the GNU General Public License as published by the | ||
15 | * Free Software Foundation; either version 2 of the License, or (at your | ||
16 | * option) any later version. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | ||
19 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | ||
20 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN | ||
21 | * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | ||
22 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
23 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | ||
24 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | ||
25 | * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
26 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | ||
27 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
28 | * | ||
29 | * You should have received a copy of the GNU General Public License along | ||
30 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
31 | * 675 Mass Ave, Cambridge, MA 02139, USA. | ||
32 | */ | ||
33 | #include <linux/module.h> | ||
34 | #include <linux/types.h> | ||
35 | #include <linux/kernel.h> | ||
36 | #include <linux/miscdevice.h> | ||
37 | #include <linux/init.h> | ||
38 | #include <linux/ioport.h> | ||
39 | #include <asm/uaccess.h> | ||
40 | #include <asm/addrspace.h> | ||
41 | #include <asm/it8172/it8172_int.h> | ||
42 | #include <linux/sched.h> | ||
43 | #include <linux/ite_gpio.h> | ||
44 | |||
45 | #define ite_gpio_base 0x14013800 | ||
46 | |||
47 | #define ITE_GPADR (*(volatile __u8 *)(0x14013800 + KSEG1)) | ||
48 | #define ITE_GPBDR (*(volatile __u8 *)(0x14013808 + KSEG1)) | ||
49 | #define ITE_GPCDR (*(volatile __u8 *)(0x14013810 + KSEG1)) | ||
50 | #define ITE_GPACR (*(volatile __u16 *)(0x14013802 + KSEG1)) | ||
51 | #define ITE_GPBCR (*(volatile __u16 *)(0x1401380a + KSEG1)) | ||
52 | #define ITE_GPCCR (*(volatile __u16 *)(0x14013812 + KSEG1)) | ||
53 | #define ITE_GPAICR (*(volatile __u16 *)(0x14013804 + KSEG1)) | ||
54 | #define ITE_GPBICR (*(volatile __u16 *)(0x1401380c + KSEG1)) | ||
55 | #define ITE_GPCICR (*(volatile __u16 *)(0x14013814 + KSEG1)) | ||
56 | #define ITE_GPAISR (*(volatile __u8 *)(0x14013806 + KSEG1)) | ||
57 | #define ITE_GPBISR (*(volatile __u8 *)(0x1401380e + KSEG1)) | ||
58 | #define ITE_GPCISR (*(volatile __u8 *)(0x14013816 + KSEG1)) | ||
59 | #define ITE_GCR (*(volatile __u8 *)(0x14013818 + KSEG1)) | ||
60 | |||
61 | #define MAX_GPIO_LINE 21 | ||
62 | static int ite_gpio_irq=IT8172_GPIO_IRQ; | ||
63 | |||
64 | static long ite_irq_counter[MAX_GPIO_LINE]; | ||
65 | wait_queue_head_t ite_gpio_wait[MAX_GPIO_LINE]; | ||
66 | static int ite_gpio_irq_pending[MAX_GPIO_LINE]; | ||
67 | |||
68 | static int ite_gpio_debug=0; | ||
69 | #define DEB(x) if (ite_gpio_debug>=1) x | ||
70 | |||
71 | int ite_gpio_in(__u32 device, __u32 mask, volatile __u32 *data) | ||
72 | { | ||
73 | DEB(printk("ite_gpio_in mask=0x%x\n",mask)); | ||
74 | |||
75 | switch (device) { | ||
76 | case ITE_GPIO_PORTA: | ||
77 | ITE_GPACR = (__u16)mask; /* 0xffff */ | ||
78 | *data = ITE_GPADR; | ||
79 | break; | ||
80 | case ITE_GPIO_PORTB: | ||
81 | ITE_GPBCR = (__u16)mask; /* 0xffff */ | ||
82 | *data = ITE_GPBDR; | ||
83 | break; | ||
84 | case ITE_GPIO_PORTC: | ||
85 | ITE_GPCCR = (__u16)mask; /* 0x03ff */ | ||
86 | *data = ITE_GPCDR; | ||
87 | break; | ||
88 | default: | ||
89 | return -EFAULT; | ||
90 | } | ||
91 | |||
92 | return 0; | ||
93 | } | ||
94 | |||
95 | |||
96 | int ite_gpio_out(__u32 device, __u32 mask, __u32 data) | ||
97 | { | ||
98 | switch (device) { | ||
99 | case ITE_GPIO_PORTA: | ||
100 | ITE_GPACR = (__u16)mask; /* 0x5555 */ | ||
101 | ITE_GPADR = (__u8)data; | ||
102 | break; | ||
103 | case ITE_GPIO_PORTB: | ||
104 | ITE_GPBCR = (__u16)mask; /* 0x5555 */ | ||
105 | ITE_GPBDR = (__u8)data; | ||
106 | break; | ||
107 | case ITE_GPIO_PORTC: | ||
108 | ITE_GPCCR = (__u16)mask; /* 0x0155 */ | ||
109 | ITE_GPCDR = (__u8)data; | ||
110 | break; | ||
111 | default: | ||
112 | return -EFAULT; | ||
113 | } | ||
114 | |||
115 | return 0; | ||
116 | } | ||
117 | |||
118 | int ite_gpio_int_ctrl(__u32 device, __u32 mask, __u32 data) | ||
119 | { | ||
120 | switch (device) { | ||
121 | case ITE_GPIO_PORTA: | ||
122 | ITE_GPAICR = (ITE_GPAICR & ~mask) | (data & mask); | ||
123 | break; | ||
124 | case ITE_GPIO_PORTB: | ||
125 | ITE_GPBICR = (ITE_GPBICR & ~mask) | (data & mask); | ||
126 | break; | ||
127 | case ITE_GPIO_PORTC: | ||
128 | ITE_GPCICR = (ITE_GPCICR & ~mask) | (data & mask); | ||
129 | break; | ||
130 | default: | ||
131 | return -EFAULT; | ||
132 | } | ||
133 | |||
134 | return 0; | ||
135 | } | ||
136 | |||
137 | int ite_gpio_in_status(__u32 device, __u32 mask, volatile __u32 *data) | ||
138 | { | ||
139 | int ret=-1; | ||
140 | |||
141 | if ((MAX_GPIO_LINE > *data) && (*data >= 0)) | ||
142 | ret=ite_gpio_irq_pending[*data]; | ||
143 | |||
144 | DEB(printk("ite_gpio_in_status %d ret=%d\n",*data, ret)); | ||
145 | |||
146 | switch (device) { | ||
147 | case ITE_GPIO_PORTA: | ||
148 | *data = ITE_GPAISR & mask; | ||
149 | break; | ||
150 | case ITE_GPIO_PORTB: | ||
151 | *data = ITE_GPBISR & mask; | ||
152 | break; | ||
153 | case ITE_GPIO_PORTC: | ||
154 | *data = ITE_GPCISR & mask; | ||
155 | break; | ||
156 | default: | ||
157 | return -EFAULT; | ||
158 | } | ||
159 | |||
160 | return ret; | ||
161 | } | ||
162 | |||
163 | int ite_gpio_out_status(__u32 device, __u32 mask, __u32 data) | ||
164 | { | ||
165 | switch (device) { | ||
166 | case ITE_GPIO_PORTA: | ||
167 | ITE_GPAISR = (ITE_GPAISR & ~mask) | (data & mask); | ||
168 | break; | ||
169 | case ITE_GPIO_PORTB: | ||
170 | ITE_GPBISR = (ITE_GPBISR & ~mask) | (data & mask); | ||
171 | break; | ||
172 | case ITE_GPIO_PORTC: | ||
173 | ITE_GPCISR = (ITE_GPCISR & ~mask) | (data & mask); | ||
174 | break; | ||
175 | default: | ||
176 | return -EFAULT; | ||
177 | } | ||
178 | |||
179 | return 0; | ||
180 | } | ||
181 | |||
182 | int ite_gpio_gen_ctrl(__u32 device, __u32 mask, __u32 data) | ||
183 | { | ||
184 | ITE_GCR = (ITE_GCR & ~mask) | (data & mask); | ||
185 | |||
186 | return 0; | ||
187 | } | ||
188 | |||
189 | int ite_gpio_int_wait (__u32 device, __u32 mask, __u32 data) | ||
190 | { | ||
191 | int i,line=0, ret=0; | ||
192 | unsigned long flags; | ||
193 | |||
194 | switch (device) { | ||
195 | case ITE_GPIO_PORTA: | ||
196 | line = data & mask; | ||
197 | break; | ||
198 | case ITE_GPIO_PORTB: | ||
199 | line = (data & mask) <<8; | ||
200 | break; | ||
201 | case ITE_GPIO_PORTC: | ||
202 | line = (data & mask) <<16; | ||
203 | break; | ||
204 | } | ||
205 | for (i=MAX_GPIO_LINE-1; i >= 0; i--) { | ||
206 | if ( (line) & (1 << i)) | ||
207 | break; | ||
208 | } | ||
209 | |||
210 | DEB(printk("wait device=0x%d mask=0x%x data=0x%x index %d\n", | ||
211 | device, mask, data, i)); | ||
212 | |||
213 | if (line & ~(1<<i)) | ||
214 | return -EFAULT; | ||
215 | |||
216 | if (ite_gpio_irq_pending[i]==1) | ||
217 | return -EFAULT; | ||
218 | |||
219 | save_flags (flags); | ||
220 | cli(); | ||
221 | ite_gpio_irq_pending[i] = 1; | ||
222 | ret = interruptible_sleep_on_timeout(&ite_gpio_wait[i], 3*HZ); | ||
223 | restore_flags (flags); | ||
224 | ite_gpio_irq_pending[i] = 0; | ||
225 | |||
226 | return ret; | ||
227 | } | ||
228 | |||
229 | EXPORT_SYMBOL(ite_gpio_in); | ||
230 | EXPORT_SYMBOL(ite_gpio_out); | ||
231 | EXPORT_SYMBOL(ite_gpio_int_ctrl); | ||
232 | EXPORT_SYMBOL(ite_gpio_in_status); | ||
233 | EXPORT_SYMBOL(ite_gpio_out_status); | ||
234 | EXPORT_SYMBOL(ite_gpio_gen_ctrl); | ||
235 | EXPORT_SYMBOL(ite_gpio_int_wait); | ||
236 | |||
237 | static int ite_gpio_open(struct inode *inode, struct file *file) | ||
238 | { | ||
239 | return 0; | ||
240 | } | ||
241 | |||
242 | |||
243 | static int ite_gpio_release(struct inode *inode, struct file *file) | ||
244 | { | ||
245 | return 0; | ||
246 | } | ||
247 | |||
248 | |||
249 | static int ite_gpio_ioctl(struct inode *inode, struct file *file, | ||
250 | unsigned int cmd, unsigned long arg) | ||
251 | { | ||
252 | static struct ite_gpio_ioctl_data ioctl_data; | ||
253 | |||
254 | if (copy_from_user(&ioctl_data, (struct ite_gpio_ioctl_data *)arg, | ||
255 | sizeof(ioctl_data))) | ||
256 | return -EFAULT; | ||
257 | if ((ioctl_data.device < ITE_GPIO_PORTA) || | ||
258 | (ioctl_data.device > ITE_GPIO_PORTC) ) | ||
259 | return -EFAULT; | ||
260 | |||
261 | switch(cmd) { | ||
262 | case ITE_GPIO_IN: | ||
263 | if (ite_gpio_in(ioctl_data.device, ioctl_data.mask, | ||
264 | &ioctl_data.data)) | ||
265 | return -EFAULT; | ||
266 | |||
267 | if (copy_to_user((struct ite_gpio_ioctl_data *)arg, | ||
268 | &ioctl_data, sizeof(ioctl_data))) | ||
269 | return -EFAULT; | ||
270 | break; | ||
271 | |||
272 | case ITE_GPIO_OUT: | ||
273 | return ite_gpio_out(ioctl_data.device, | ||
274 | ioctl_data.mask, ioctl_data.data); | ||
275 | break; | ||
276 | |||
277 | case ITE_GPIO_INT_CTRL: | ||
278 | return ite_gpio_int_ctrl(ioctl_data.device, | ||
279 | ioctl_data.mask, ioctl_data.data); | ||
280 | break; | ||
281 | |||
282 | case ITE_GPIO_IN_STATUS: | ||
283 | if (ite_gpio_in_status(ioctl_data.device, ioctl_data.mask, | ||
284 | &ioctl_data.data)) | ||
285 | return -EFAULT; | ||
286 | if (copy_to_user((struct ite_gpio_ioctl_data *)arg, | ||
287 | &ioctl_data, sizeof(ioctl_data))) | ||
288 | return -EFAULT; | ||
289 | break; | ||
290 | |||
291 | case ITE_GPIO_OUT_STATUS: | ||
292 | return ite_gpio_out_status(ioctl_data.device, | ||
293 | ioctl_data.mask, ioctl_data.data); | ||
294 | break; | ||
295 | |||
296 | case ITE_GPIO_GEN_CTRL: | ||
297 | return ite_gpio_gen_ctrl(ioctl_data.device, | ||
298 | ioctl_data.mask, ioctl_data.data); | ||
299 | break; | ||
300 | |||
301 | case ITE_GPIO_INT_WAIT: | ||
302 | return ite_gpio_int_wait(ioctl_data.device, | ||
303 | ioctl_data.mask, ioctl_data.data); | ||
304 | break; | ||
305 | |||
306 | default: | ||
307 | return -ENOIOCTLCMD; | ||
308 | |||
309 | } | ||
310 | |||
311 | return 0; | ||
312 | } | ||
313 | |||
314 | static void ite_gpio_irq_handler(int this_irq, void *dev_id, | ||
315 | struct pt_regs *regs) | ||
316 | { | ||
317 | int i,line; | ||
318 | |||
319 | line = ITE_GPCISR & 0x1f; | ||
320 | for (i=4; i >=0; i--) { | ||
321 | if ( line & (1 << i)) { | ||
322 | ++ite_irq_counter[i+16]; | ||
323 | ite_gpio_irq_pending[i+16] = 2; | ||
324 | wake_up_interruptible(&ite_gpio_wait[i+16]); | ||
325 | |||
326 | DEB(printk("interrupt 0x%x %d\n", &ite_gpio_wait[i+16], i+16)); | ||
327 | |||
328 | ITE_GPCISR = ITE_GPCISR & (1<<i); | ||
329 | return; | ||
330 | } | ||
331 | } | ||
332 | line = ITE_GPBISR; | ||
333 | for (i=7; i >= 0; i--) { | ||
334 | if ( line & (1 << i)) { | ||
335 | ++ite_irq_counter[i+8]; | ||
336 | ite_gpio_irq_pending[i+8] = 2; | ||
337 | wake_up_interruptible(&ite_gpio_wait[i+8]); | ||
338 | |||
339 | DEB(printk("interrupt 0x%x %d\n",ITE_GPBISR, i+8)); | ||
340 | |||
341 | ITE_GPBISR = ITE_GPBISR & (1<<i); | ||
342 | return; | ||
343 | } | ||
344 | } | ||
345 | line = ITE_GPAISR; | ||
346 | for (i=7; i >= 0; i--) { | ||
347 | if ( line & (1 << i)) { | ||
348 | ++ite_irq_counter[i]; | ||
349 | ite_gpio_irq_pending[i] = 2; | ||
350 | wake_up_interruptible(&ite_gpio_wait[i]); | ||
351 | |||
352 | DEB(printk("interrupt 0x%x %d\n",ITE_GPAISR, i)); | ||
353 | |||
354 | ITE_GPAISR = ITE_GPAISR & (1<<i); | ||
355 | return; | ||
356 | } | ||
357 | } | ||
358 | } | ||
359 | |||
360 | static const struct file_operations ite_gpio_fops = { | ||
361 | .owner = THIS_MODULE, | ||
362 | .ioctl = ite_gpio_ioctl, | ||
363 | .open = ite_gpio_open, | ||
364 | .release = ite_gpio_release, | ||
365 | }; | ||
366 | |||
367 | static struct miscdevice ite_gpio_miscdev = { | ||
368 | MISC_DYNAMIC_MINOR, | ||
369 | "ite_gpio", | ||
370 | &ite_gpio_fops | ||
371 | }; | ||
372 | |||
373 | int __init ite_gpio_init(void) | ||
374 | { | ||
375 | int i; | ||
376 | |||
377 | if (misc_register(&ite_gpio_miscdev)) | ||
378 | return -ENODEV; | ||
379 | |||
380 | if (!request_region(ite_gpio_base, 0x1c, "ITE GPIO")) | ||
381 | { | ||
382 | misc_deregister(&ite_gpio_miscdev); | ||
383 | return -EIO; | ||
384 | } | ||
385 | |||
386 | /* initialize registers */ | ||
387 | ITE_GPACR = 0xffff; | ||
388 | ITE_GPBCR = 0xffff; | ||
389 | ITE_GPCCR = 0xffff; | ||
390 | ITE_GPAICR = 0x00ff; | ||
391 | ITE_GPBICR = 0x00ff; | ||
392 | ITE_GPCICR = 0x00ff; | ||
393 | ITE_GCR = 0; | ||
394 | |||
395 | for (i = 0; i < MAX_GPIO_LINE; i++) { | ||
396 | ite_gpio_irq_pending[i]=0; | ||
397 | init_waitqueue_head(&ite_gpio_wait[i]); | ||
398 | } | ||
399 | |||
400 | if (request_irq(ite_gpio_irq, ite_gpio_irq_handler, IRQF_SHARED, "gpio", 0) < 0) { | ||
401 | misc_deregister(&ite_gpio_miscdev); | ||
402 | release_region(ite_gpio_base, 0x1c); | ||
403 | return 0; | ||
404 | } | ||
405 | |||
406 | printk("GPIO at 0x%x (irq = %d)\n", ite_gpio_base, ite_gpio_irq); | ||
407 | |||
408 | return 0; | ||
409 | } | ||
410 | |||
411 | static void __exit ite_gpio_exit(void) | ||
412 | { | ||
413 | misc_deregister(&ite_gpio_miscdev); | ||
414 | } | ||
415 | |||
416 | module_init(ite_gpio_init); | ||
417 | module_exit(ite_gpio_exit); | ||
418 | |||
419 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/char/qtronixmap.c_shipped b/drivers/char/qtronixmap.c_shipped deleted file mode 100644 index 1e2b92b7d57a..000000000000 --- a/drivers/char/qtronixmap.c_shipped +++ /dev/null | |||
@@ -1,265 +0,0 @@ | |||
1 | |||
2 | /* Do not edit this file! It was automatically generated by */ | ||
3 | /* loadkeys --mktable defkeymap.map > defkeymap.c */ | ||
4 | |||
5 | #include <linux/types.h> | ||
6 | #include <linux/keyboard.h> | ||
7 | #include <linux/kd.h> | ||
8 | |||
9 | u_short plain_map[NR_KEYS] = { | ||
10 | 0xf200, 0xf060, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, | ||
11 | 0xf037, 0xf038, 0xf039, 0xf030, 0xf02d, 0xf03d, 0xf200, 0xf07f, | ||
12 | 0xf009, 0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75, | ||
13 | 0xfb69, 0xfb6f, 0xfb70, 0xf05b, 0xf05d, 0xf05c, 0xf207, 0xfb61, | ||
14 | 0xfb73, 0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, | ||
15 | 0xf03b, 0xf027, 0xf060, 0xf201, 0xf700, 0xf200, 0xfb7a, 0xfb78, | ||
16 | 0xfb63, 0xfb76, 0xfb62, 0xfb6e, 0xfb6d, 0xf02c, 0xf02e, 0xf02f, | ||
17 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf020, 0xf703, 0xf200, | ||
18 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
19 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601, | ||
20 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200, | ||
21 | 0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
22 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
23 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf01b, 0xf200, | ||
24 | 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, 0xf107, | ||
25 | 0xf108, 0xf109, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
26 | }; | ||
27 | |||
28 | u_short shift_map[NR_KEYS] = { | ||
29 | 0xf200, 0xf07e, 0xf021, 0xf040, 0xf023, 0xf024, 0xf025, 0xf05e, | ||
30 | 0xf026, 0xf02a, 0xf028, 0xf029, 0xf05f, 0xf02b, 0xf200, 0xf07f, | ||
31 | 0xf009, 0xfb51, 0xfb57, 0xfb45, 0xfb52, 0xfb54, 0xfb59, 0xfb55, | ||
32 | 0xfb49, 0xfb4f, 0xfb50, 0xf07b, 0xf07d, 0xf07c, 0xf207, 0xfb41, | ||
33 | 0xfb53, 0xfb44, 0xfb46, 0xfb47, 0xfb48, 0xfb4a, 0xfb4b, 0xfb4c, | ||
34 | 0xf03a, 0xf022, 0xf07e, 0xf201, 0xf700, 0xf200, 0xfb5a, 0xfb58, | ||
35 | 0xfb43, 0xfb56, 0xfb42, 0xfb4e, 0xfb4d, 0xf03c, 0xf03e, 0xf03f, | ||
36 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf020, 0xf703, 0xf200, | ||
37 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
38 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601, | ||
39 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf20b, 0xf20a, 0xf200, | ||
40 | 0xf200, 0xf602, 0xf213, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
41 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
42 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf01b, 0xf200, | ||
43 | 0xf10a, 0xf10b, 0xf10c, 0xf10d, 0xf10e, 0xf10f, 0xf110, 0xf111, | ||
44 | 0xf112, 0xf113, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
45 | }; | ||
46 | |||
47 | u_short altgr_map[NR_KEYS] = { | ||
48 | 0xf200, 0xf200, 0xf200, 0xf040, 0xf200, 0xf024, 0xf200, 0xf200, | ||
49 | 0xf07b, 0xf05b, 0xf05d, 0xf07d, 0xf05c, 0xf200, 0xf200, 0xf200, | ||
50 | 0xf200, 0xfb71, 0xfb77, 0xfb65, 0xfb72, 0xfb74, 0xfb79, 0xfb75, | ||
51 | 0xfb69, 0xfb6f, 0xfb70, 0xf200, 0xf200, 0xf200, 0xf207, 0xfb61, | ||
52 | 0xfb73, 0xfb64, 0xfb66, 0xfb67, 0xfb68, 0xfb6a, 0xfb6b, 0xfb6c, | ||
53 | 0xf200, 0xf200, 0xf200, 0xf201, 0xf700, 0xf200, 0xfb7a, 0xfb78, | ||
54 | 0xfb63, 0xfb76, 0xfb62, 0xfb6e, 0xfb6d, 0xf200, 0xf200, 0xf200, | ||
55 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf200, 0xf703, 0xf200, | ||
56 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
57 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601, | ||
58 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200, | ||
59 | 0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
60 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
61 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200, | ||
62 | 0xf50c, 0xf50d, 0xf50e, 0xf50f, 0xf510, 0xf511, 0xf512, 0xf513, | ||
63 | 0xf514, 0xf515, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
64 | }; | ||
65 | |||
66 | u_short ctrl_map[NR_KEYS] = { | ||
67 | 0xf200, 0xf200, 0xf200, 0xf000, 0xf01b, 0xf01c, 0xf01d, 0xf01e, | ||
68 | 0xf01f, 0xf07f, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf200, 0xf008, | ||
69 | 0xf200, 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015, | ||
70 | 0xf009, 0xf00f, 0xf010, 0xf01b, 0xf01d, 0xf01c, 0xf207, 0xf001, | ||
71 | 0xf013, 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, | ||
72 | 0xf007, 0xf000, 0xf200, 0xf201, 0xf700, 0xf200, 0xf01a, 0xf018, | ||
73 | 0xf003, 0xf016, 0xf002, 0xf00e, 0xf20e, 0xf07f, 0xf200, 0xf200, | ||
74 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf000, 0xf703, 0xf200, | ||
75 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
76 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601, | ||
77 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200, | ||
78 | 0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
79 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
80 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200, | ||
81 | 0xf100, 0xf101, 0xf102, 0xf103, 0xf104, 0xf105, 0xf106, 0xf107, | ||
82 | 0xf108, 0xf109, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
83 | }; | ||
84 | |||
85 | u_short shift_ctrl_map[NR_KEYS] = { | ||
86 | 0xf200, 0xf200, 0xf200, 0xf000, 0xf200, 0xf200, 0xf200, 0xf200, | ||
87 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf01f, 0xf200, 0xf200, 0xf200, | ||
88 | 0xf200, 0xf011, 0xf017, 0xf005, 0xf012, 0xf014, 0xf019, 0xf015, | ||
89 | 0xf009, 0xf00f, 0xf010, 0xf200, 0xf200, 0xf200, 0xf207, 0xf001, | ||
90 | 0xf013, 0xf004, 0xf006, 0xf007, 0xf008, 0xf00a, 0xf00b, 0xf00c, | ||
91 | 0xf200, 0xf200, 0xf200, 0xf201, 0xf700, 0xf200, 0xf01a, 0xf018, | ||
92 | 0xf003, 0xf016, 0xf002, 0xf00e, 0xf00d, 0xf200, 0xf200, 0xf200, | ||
93 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf200, 0xf703, 0xf200, | ||
94 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
95 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601, | ||
96 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200, | ||
97 | 0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
98 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
99 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200, | ||
100 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
101 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
102 | }; | ||
103 | |||
104 | u_short alt_map[NR_KEYS] = { | ||
105 | 0xf200, 0xf81b, 0xf831, 0xf832, 0xf833, 0xf834, 0xf835, 0xf836, | ||
106 | 0xf837, 0xf838, 0xf839, 0xf830, 0xf82d, 0xf83d, 0xf200, 0xf87f, | ||
107 | 0xf809, 0xf871, 0xf877, 0xf865, 0xf872, 0xf874, 0xf879, 0xf875, | ||
108 | 0xf869, 0xf86f, 0xf870, 0xf85b, 0xf85d, 0xf85c, 0xf207, 0xf861, | ||
109 | 0xf873, 0xf864, 0xf866, 0xf867, 0xf868, 0xf86a, 0xf86b, 0xf83b, | ||
110 | 0xf827, 0xf860, 0xf200, 0xf80d, 0xf700, 0xf200, 0xf87a, 0xf878, | ||
111 | 0xf863, 0xf876, 0xf862, 0xf82c, 0xf82e, 0xf82f, 0xf200, 0xf200, | ||
112 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf820, 0xf703, 0xf200, | ||
113 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
114 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf210, | ||
115 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200, | ||
116 | 0xf200, 0xf211, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
117 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
118 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200, | ||
119 | 0xf500, 0xf501, 0xf502, 0xf503, 0xf504, 0xf505, 0xf506, 0xf507, | ||
120 | 0xf508, 0xf509, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
121 | }; | ||
122 | |||
123 | u_short ctrl_alt_map[NR_KEYS] = { | ||
124 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
125 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
126 | 0xf200, 0xf811, 0xf817, 0xf805, 0xf812, 0xf814, 0xf819, 0xf815, | ||
127 | 0xf809, 0xf80f, 0xf810, 0xf200, 0xf200, 0xf200, 0xf207, 0xf801, | ||
128 | 0xf813, 0xf804, 0xf806, 0xf807, 0xf808, 0xf80a, 0xf80b, 0xf80c, | ||
129 | 0xf200, 0xf200, 0xf200, 0xf201, 0xf700, 0xf200, 0xf81a, 0xf818, | ||
130 | 0xf803, 0xf816, 0xf802, 0xf80e, 0xf80d, 0xf200, 0xf200, 0xf200, | ||
131 | 0xf200, 0xf700, 0xf702, 0xf200, 0xf703, 0xf200, 0xf703, 0xf200, | ||
132 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
133 | 0xf200, 0xf200, 0xf200, 0xf115, 0xf07f, 0xf200, 0xf200, 0xf601, | ||
134 | 0xf200, 0xf200, 0xf200, 0xf603, 0xf600, 0xf118, 0xf119, 0xf200, | ||
135 | 0xf200, 0xf602, 0xf208, 0xf02d, 0xf02b, 0xf30c, 0xf02e, 0xf30d, | ||
136 | 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, 0xf200, | ||
137 | 0xf200, 0xf200, 0xf200, 0xf117, 0xf600, 0xf200, 0xf200, 0xf200, | ||
138 | 0xf500, 0xf501, 0xf502, 0xf503, 0xf504, 0xf505, 0xf506, 0xf507, | ||
139 | 0xf508, 0xf509, 0xf200, 0xf200, 0xf200, 0xf200, 0xf11d, 0xf200, | ||
140 | }; | ||
141 | |||
142 | ushort *key_maps[MAX_NR_KEYMAPS] = { | ||
143 | plain_map, shift_map, altgr_map, 0, | ||
144 | ctrl_map, shift_ctrl_map, 0, 0, | ||
145 | alt_map, 0, 0, 0, | ||
146 | ctrl_alt_map, 0 | ||
147 | }; | ||
148 | |||
149 | unsigned int keymap_count = 7; | ||
150 | |||
151 | |||
152 | /* | ||
153 | * Philosophy: most people do not define more strings, but they who do | ||
154 | * often want quite a lot of string space. So, we statically allocate | ||
155 | * the default and allocate dynamically in chunks of 512 bytes. | ||
156 | */ | ||
157 | |||
158 | char func_buf[] = { | ||
159 | '\033', '[', '[', 'A', 0, | ||
160 | '\033', '[', '[', 'B', 0, | ||
161 | '\033', '[', '[', 'C', 0, | ||
162 | '\033', '[', '[', 'D', 0, | ||
163 | '\033', '[', '[', 'E', 0, | ||
164 | '\033', '[', '1', '7', '~', 0, | ||
165 | '\033', '[', '1', '8', '~', 0, | ||
166 | '\033', '[', '1', '9', '~', 0, | ||
167 | '\033', '[', '2', '0', '~', 0, | ||
168 | '\033', '[', '2', '1', '~', 0, | ||
169 | '\033', '[', '2', '3', '~', 0, | ||
170 | '\033', '[', '2', '4', '~', 0, | ||
171 | '\033', '[', '2', '5', '~', 0, | ||
172 | '\033', '[', '2', '6', '~', 0, | ||
173 | '\033', '[', '2', '8', '~', 0, | ||
174 | '\033', '[', '2', '9', '~', 0, | ||
175 | '\033', '[', '3', '1', '~', 0, | ||
176 | '\033', '[', '3', '2', '~', 0, | ||
177 | '\033', '[', '3', '3', '~', 0, | ||
178 | '\033', '[', '3', '4', '~', 0, | ||
179 | '\033', '[', '1', '~', 0, | ||
180 | '\033', '[', '2', '~', 0, | ||
181 | '\033', '[', '3', '~', 0, | ||
182 | '\033', '[', '4', '~', 0, | ||
183 | '\033', '[', '5', '~', 0, | ||
184 | '\033', '[', '6', '~', 0, | ||
185 | '\033', '[', 'M', 0, | ||
186 | '\033', '[', 'P', 0, | ||
187 | }; | ||
188 | |||
189 | |||
190 | char *funcbufptr = func_buf; | ||
191 | int funcbufsize = sizeof(func_buf); | ||
192 | int funcbufleft = 0; /* space left */ | ||
193 | |||
194 | char *func_table[MAX_NR_FUNC] = { | ||
195 | func_buf + 0, | ||
196 | func_buf + 5, | ||
197 | func_buf + 10, | ||
198 | func_buf + 15, | ||
199 | func_buf + 20, | ||
200 | func_buf + 25, | ||
201 | func_buf + 31, | ||
202 | func_buf + 37, | ||
203 | func_buf + 43, | ||
204 | func_buf + 49, | ||
205 | func_buf + 55, | ||
206 | func_buf + 61, | ||
207 | func_buf + 67, | ||
208 | func_buf + 73, | ||
209 | func_buf + 79, | ||
210 | func_buf + 85, | ||
211 | func_buf + 91, | ||
212 | func_buf + 97, | ||
213 | func_buf + 103, | ||
214 | func_buf + 109, | ||
215 | func_buf + 115, | ||
216 | func_buf + 120, | ||
217 | func_buf + 125, | ||
218 | func_buf + 130, | ||
219 | func_buf + 135, | ||
220 | func_buf + 140, | ||
221 | func_buf + 145, | ||
222 | 0, | ||
223 | 0, | ||
224 | func_buf + 149, | ||
225 | 0, | ||
226 | }; | ||
227 | |||
228 | struct kbdiacr accent_table[MAX_DIACR] = { | ||
229 | {'`', 'A', 'À'}, {'`', 'a', 'à'}, | ||
230 | {'\'', 'A', 'Á'}, {'\'', 'a', 'á'}, | ||
231 | {'^', 'A', 'Â'}, {'^', 'a', 'â'}, | ||
232 | {'~', 'A', 'Ã'}, {'~', 'a', 'ã'}, | ||
233 | {'"', 'A', 'Ä'}, {'"', 'a', 'ä'}, | ||
234 | {'O', 'A', 'Å'}, {'o', 'a', 'å'}, | ||
235 | {'0', 'A', 'Å'}, {'0', 'a', 'å'}, | ||
236 | {'A', 'A', 'Å'}, {'a', 'a', 'å'}, | ||
237 | {'A', 'E', 'Æ'}, {'a', 'e', 'æ'}, | ||
238 | {',', 'C', 'Ç'}, {',', 'c', 'ç'}, | ||
239 | {'`', 'E', 'È'}, {'`', 'e', 'è'}, | ||
240 | {'\'', 'E', 'É'}, {'\'', 'e', 'é'}, | ||
241 | {'^', 'E', 'Ê'}, {'^', 'e', 'ê'}, | ||
242 | {'"', 'E', 'Ë'}, {'"', 'e', 'ë'}, | ||
243 | {'`', 'I', 'Ì'}, {'`', 'i', 'ì'}, | ||
244 | {'\'', 'I', 'Í'}, {'\'', 'i', 'í'}, | ||
245 | {'^', 'I', 'Î'}, {'^', 'i', 'î'}, | ||
246 | {'"', 'I', 'Ï'}, {'"', 'i', 'ï'}, | ||
247 | {'-', 'D', 'Ð'}, {'-', 'd', 'ð'}, | ||
248 | {'~', 'N', 'Ñ'}, {'~', 'n', 'ñ'}, | ||
249 | {'`', 'O', 'Ò'}, {'`', 'o', 'ò'}, | ||
250 | {'\'', 'O', 'Ó'}, {'\'', 'o', 'ó'}, | ||
251 | {'^', 'O', 'Ô'}, {'^', 'o', 'ô'}, | ||
252 | {'~', 'O', 'Õ'}, {'~', 'o', 'õ'}, | ||
253 | {'"', 'O', 'Ö'}, {'"', 'o', 'ö'}, | ||
254 | {'/', 'O', 'Ø'}, {'/', 'o', 'ø'}, | ||
255 | {'`', 'U', 'Ù'}, {'`', 'u', 'ù'}, | ||
256 | {'\'', 'U', 'Ú'}, {'\'', 'u', 'ú'}, | ||
257 | {'^', 'U', 'Û'}, {'^', 'u', 'û'}, | ||
258 | {'"', 'U', 'Ü'}, {'"', 'u', 'ü'}, | ||
259 | {'\'', 'Y', 'Ý'}, {'\'', 'y', 'ý'}, | ||
260 | {'T', 'H', 'Þ'}, {'t', 'h', 'þ'}, | ||
261 | {'s', 's', 'ß'}, {'"', 'y', 'ÿ'}, | ||
262 | {'s', 'z', 'ß'}, {'i', 'j', 'ÿ'}, | ||
263 | }; | ||
264 | |||
265 | unsigned int accent_table_size = 68; | ||
diff --git a/drivers/char/qtronixmap.map b/drivers/char/qtronixmap.map deleted file mode 100644 index 8d1ff5c1e281..000000000000 --- a/drivers/char/qtronixmap.map +++ /dev/null | |||
@@ -1,287 +0,0 @@ | |||
1 | # Default kernel keymap. This uses 7 modifier combinations. | ||
2 | keymaps 0-2,4-5,8,12 | ||
3 | # Change the above line into | ||
4 | # keymaps 0-2,4-6,8,12 | ||
5 | # in case you want the entries | ||
6 | # altgr control keycode 83 = Boot | ||
7 | # altgr control keycode 111 = Boot | ||
8 | # below. | ||
9 | # | ||
10 | # In fact AltGr is used very little, and one more keymap can | ||
11 | # be saved by mapping AltGr to Alt (and adapting a few entries): | ||
12 | # keycode 100 = Alt | ||
13 | # | ||
14 | keycode 1 = grave asciitilde | ||
15 | alt keycode 1 = Meta_Escape | ||
16 | keycode 2 = one exclam | ||
17 | alt keycode 2 = Meta_one | ||
18 | keycode 3 = two at at | ||
19 | control keycode 3 = nul | ||
20 | shift control keycode 3 = nul | ||
21 | alt keycode 3 = Meta_two | ||
22 | keycode 4 = three numbersign | ||
23 | control keycode 4 = Escape | ||
24 | alt keycode 4 = Meta_three | ||
25 | keycode 5 = four dollar dollar | ||
26 | control keycode 5 = Control_backslash | ||
27 | alt keycode 5 = Meta_four | ||
28 | keycode 6 = five percent | ||
29 | control keycode 6 = Control_bracketright | ||
30 | alt keycode 6 = Meta_five | ||
31 | keycode 7 = six asciicircum | ||
32 | control keycode 7 = Control_asciicircum | ||
33 | alt keycode 7 = Meta_six | ||
34 | keycode 8 = seven ampersand braceleft | ||
35 | control keycode 8 = Control_underscore | ||
36 | alt keycode 8 = Meta_seven | ||
37 | keycode 9 = eight asterisk bracketleft | ||
38 | control keycode 9 = Delete | ||
39 | alt keycode 9 = Meta_eight | ||
40 | keycode 10 = nine parenleft bracketright | ||
41 | alt keycode 10 = Meta_nine | ||
42 | keycode 11 = zero parenright braceright | ||
43 | alt keycode 11 = Meta_zero | ||
44 | keycode 12 = minus underscore backslash | ||
45 | control keycode 12 = Control_underscore | ||
46 | shift control keycode 12 = Control_underscore | ||
47 | alt keycode 12 = Meta_minus | ||
48 | keycode 13 = equal plus | ||
49 | alt keycode 13 = Meta_equal | ||
50 | keycode 15 = Delete Delete | ||
51 | control keycode 15 = BackSpace | ||
52 | alt keycode 15 = Meta_Delete | ||
53 | keycode 16 = Tab Tab | ||
54 | alt keycode 16 = Meta_Tab | ||
55 | keycode 17 = q | ||
56 | keycode 18 = w | ||
57 | keycode 19 = e | ||
58 | keycode 20 = r | ||
59 | keycode 21 = t | ||
60 | keycode 22 = y | ||
61 | keycode 23 = u | ||
62 | keycode 24 = i | ||
63 | keycode 25 = o | ||
64 | keycode 26 = p | ||
65 | keycode 27 = bracketleft braceleft | ||
66 | control keycode 27 = Escape | ||
67 | alt keycode 27 = Meta_bracketleft | ||
68 | keycode 28 = bracketright braceright | ||
69 | control keycode 28 = Control_bracketright | ||
70 | alt keycode 28 = Meta_bracketright | ||
71 | keycode 29 = backslash bar | ||
72 | control keycode 29 = Control_backslash | ||
73 | alt keycode 29 = Meta_backslash | ||
74 | keycode 30 = Caps_Lock | ||
75 | keycode 31 = a | ||
76 | keycode 32 = s | ||
77 | keycode 33 = d | ||
78 | keycode 34 = f | ||
79 | keycode 35 = g | ||
80 | keycode 36 = h | ||
81 | keycode 37 = j | ||
82 | keycode 38 = k | ||
83 | keycode 39 = l | ||
84 | keycode 40 = semicolon colon | ||
85 | alt keycode 39 = Meta_semicolon | ||
86 | keycode 41 = apostrophe quotedbl | ||
87 | control keycode 40 = Control_g | ||
88 | alt keycode 40 = Meta_apostrophe | ||
89 | keycode 42 = grave asciitilde | ||
90 | control keycode 41 = nul | ||
91 | alt keycode 41 = Meta_grave | ||
92 | keycode 43 = Return | ||
93 | alt keycode 43 = Meta_Control_m | ||
94 | keycode 44 = Shift | ||
95 | keycode 46 = z | ||
96 | keycode 47 = x | ||
97 | keycode 48 = c | ||
98 | keycode 49 = v | ||
99 | keycode 50 = b | ||
100 | keycode 51 = n | ||
101 | keycode 52 = m | ||
102 | keycode 53 = comma less | ||
103 | alt keycode 51 = Meta_comma | ||
104 | keycode 54 = period greater | ||
105 | control keycode 52 = Compose | ||
106 | alt keycode 52 = Meta_period | ||
107 | keycode 55 = slash question | ||
108 | control keycode 53 = Delete | ||
109 | alt keycode 53 = Meta_slash | ||
110 | keycode 57 = Shift | ||
111 | keycode 58 = Control | ||
112 | keycode 60 = Alt | ||
113 | keycode 61 = space space | ||
114 | control keycode 61 = nul | ||
115 | alt keycode 61 = Meta_space | ||
116 | keycode 62 = Alt | ||
117 | |||
118 | keycode 75 = Insert | ||
119 | keycode 76 = Delete | ||
120 | |||
121 | keycode 83 = Up | ||
122 | keycode 84 = Down | ||
123 | |||
124 | keycode 85 = Prior | ||
125 | shift keycode 85 = Scroll_Backward | ||
126 | keycode 86 = Next | ||
127 | shift keycode 86 = Scroll_Forward | ||
128 | keycode 89 = Right | ||
129 | alt keycode 89 = Incr_Console | ||
130 | keycode 79 = Left | ||
131 | alt keycode 79 = Decr_Console | ||
132 | |||
133 | keycode 90 = Num_Lock | ||
134 | shift keycode 90 = Bare_Num_Lock | ||
135 | |||
136 | keycode 91 = minus | ||
137 | keycode 92 = plus | ||
138 | keycode 93 = KP_Multiply | ||
139 | keycode 94 = period | ||
140 | keycode 95 = KP_Divide | ||
141 | |||
142 | keycode 107 = Select | ||
143 | keycode 108 = Down | ||
144 | |||
145 | keycode 110 = Escape Escape | ||
146 | alt keycode 1 = Meta_Escape | ||
147 | |||
148 | keycode 112 = F1 F11 Console_13 | ||
149 | control keycode 112 = F1 | ||
150 | alt keycode 112 = Console_1 | ||
151 | control alt keycode 112 = Console_1 | ||
152 | keycode 113 = F2 F12 Console_14 | ||
153 | control keycode 113 = F2 | ||
154 | alt keycode 113 = Console_2 | ||
155 | control alt keycode 113 = Console_2 | ||
156 | keycode 114 = F3 F13 Console_15 | ||
157 | control keycode 114 = F3 | ||
158 | alt keycode 114 = Console_3 | ||
159 | control alt keycode 114 = Console_3 | ||
160 | keycode 115 = F4 F14 Console_16 | ||
161 | control keycode 115 = F4 | ||
162 | alt keycode 115 = Console_4 | ||
163 | control alt keycode 115 = Console_4 | ||
164 | keycode 116 = F5 F15 Console_17 | ||
165 | control keycode 116 = F5 | ||
166 | alt keycode 116 = Console_5 | ||
167 | control alt keycode 116 = Console_5 | ||
168 | keycode 117 = F6 F16 Console_18 | ||
169 | control keycode 117 = F6 | ||
170 | alt keycode 117 = Console_6 | ||
171 | control alt keycode 117 = Console_6 | ||
172 | keycode 118 = F7 F17 Console_19 | ||
173 | control keycode 118 = F7 | ||
174 | alt keycode 118 = Console_7 | ||
175 | control alt keycode 118 = Console_7 | ||
176 | keycode 119 = F8 F18 Console_20 | ||
177 | control keycode 119 = F8 | ||
178 | alt keycode 119 = Console_8 | ||
179 | control alt keycode 119 = Console_8 | ||
180 | keycode 120 = F9 F19 Console_21 | ||
181 | control keycode 120 = F9 | ||
182 | alt keycode 120 = Console_9 | ||
183 | control alt keycode 120 = Console_9 | ||
184 | keycode 121 = F10 F20 Console_22 | ||
185 | control keycode 121 = F10 | ||
186 | alt keycode 121 = Console_10 | ||
187 | control alt keycode 121 = Console_10 | ||
188 | |||
189 | keycode 126 = Pause | ||
190 | |||
191 | |||
192 | string F1 = "\033[[A" | ||
193 | string F2 = "\033[[B" | ||
194 | string F3 = "\033[[C" | ||
195 | string F4 = "\033[[D" | ||
196 | string F5 = "\033[[E" | ||
197 | string F6 = "\033[17~" | ||
198 | string F7 = "\033[18~" | ||
199 | string F8 = "\033[19~" | ||
200 | string F9 = "\033[20~" | ||
201 | string F10 = "\033[21~" | ||
202 | string F11 = "\033[23~" | ||
203 | string F12 = "\033[24~" | ||
204 | string F13 = "\033[25~" | ||
205 | string F14 = "\033[26~" | ||
206 | string F15 = "\033[28~" | ||
207 | string F16 = "\033[29~" | ||
208 | string F17 = "\033[31~" | ||
209 | string F18 = "\033[32~" | ||
210 | string F19 = "\033[33~" | ||
211 | string F20 = "\033[34~" | ||
212 | string Find = "\033[1~" | ||
213 | string Insert = "\033[2~" | ||
214 | string Remove = "\033[3~" | ||
215 | string Select = "\033[4~" | ||
216 | string Prior = "\033[5~" | ||
217 | string Next = "\033[6~" | ||
218 | string Macro = "\033[M" | ||
219 | string Pause = "\033[P" | ||
220 | compose '`' 'A' to 'À' | ||
221 | compose '`' 'a' to 'à' | ||
222 | compose '\'' 'A' to 'Á' | ||
223 | compose '\'' 'a' to 'á' | ||
224 | compose '^' 'A' to 'Â' | ||
225 | compose '^' 'a' to 'â' | ||
226 | compose '~' 'A' to 'Ã' | ||
227 | compose '~' 'a' to 'ã' | ||
228 | compose '"' 'A' to 'Ä' | ||
229 | compose '"' 'a' to 'ä' | ||
230 | compose 'O' 'A' to 'Å' | ||
231 | compose 'o' 'a' to 'å' | ||
232 | compose '0' 'A' to 'Å' | ||
233 | compose '0' 'a' to 'å' | ||
234 | compose 'A' 'A' to 'Å' | ||
235 | compose 'a' 'a' to 'å' | ||
236 | compose 'A' 'E' to 'Æ' | ||
237 | compose 'a' 'e' to 'æ' | ||
238 | compose ',' 'C' to 'Ç' | ||
239 | compose ',' 'c' to 'ç' | ||
240 | compose '`' 'E' to 'È' | ||
241 | compose '`' 'e' to 'è' | ||
242 | compose '\'' 'E' to 'É' | ||
243 | compose '\'' 'e' to 'é' | ||
244 | compose '^' 'E' to 'Ê' | ||
245 | compose '^' 'e' to 'ê' | ||
246 | compose '"' 'E' to 'Ë' | ||
247 | compose '"' 'e' to 'ë' | ||
248 | compose '`' 'I' to 'Ì' | ||
249 | compose '`' 'i' to 'ì' | ||
250 | compose '\'' 'I' to 'Í' | ||
251 | compose '\'' 'i' to 'í' | ||
252 | compose '^' 'I' to 'Î' | ||
253 | compose '^' 'i' to 'î' | ||
254 | compose '"' 'I' to 'Ï' | ||
255 | compose '"' 'i' to 'ï' | ||
256 | compose '-' 'D' to 'Ð' | ||
257 | compose '-' 'd' to 'ð' | ||
258 | compose '~' 'N' to 'Ñ' | ||
259 | compose '~' 'n' to 'ñ' | ||
260 | compose '`' 'O' to 'Ò' | ||
261 | compose '`' 'o' to 'ò' | ||
262 | compose '\'' 'O' to 'Ó' | ||
263 | compose '\'' 'o' to 'ó' | ||
264 | compose '^' 'O' to 'Ô' | ||
265 | compose '^' 'o' to 'ô' | ||
266 | compose '~' 'O' to 'Õ' | ||
267 | compose '~' 'o' to 'õ' | ||
268 | compose '"' 'O' to 'Ö' | ||
269 | compose '"' 'o' to 'ö' | ||
270 | compose '/' 'O' to 'Ø' | ||
271 | compose '/' 'o' to 'ø' | ||
272 | compose '`' 'U' to 'Ù' | ||
273 | compose '`' 'u' to 'ù' | ||
274 | compose '\'' 'U' to 'Ú' | ||
275 | compose '\'' 'u' to 'ú' | ||
276 | compose '^' 'U' to 'Û' | ||
277 | compose '^' 'u' to 'û' | ||
278 | compose '"' 'U' to 'Ü' | ||
279 | compose '"' 'u' to 'ü' | ||
280 | compose '\'' 'Y' to 'Ý' | ||
281 | compose '\'' 'y' to 'ý' | ||
282 | compose 'T' 'H' to 'Þ' | ||
283 | compose 't' 'h' to 'þ' | ||
284 | compose 's' 's' to 'ß' | ||
285 | compose '"' 'y' to 'ÿ' | ||
286 | compose 's' 'z' to 'ß' | ||
287 | compose 'i' 'j' to 'ÿ' | ||
diff --git a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig index 06f3fa2fe877..89e46d6dfc4e 100644 --- a/drivers/char/watchdog/Kconfig +++ b/drivers/char/watchdog/Kconfig | |||
@@ -316,6 +316,27 @@ config I8XX_TCO | |||
316 | To compile this driver as a module, choose M here: the | 316 | To compile this driver as a module, choose M here: the |
317 | module will be called i8xx_tco. | 317 | module will be called i8xx_tco. |
318 | 318 | ||
319 | config ITCO_WDT | ||
320 | tristate "Intel TCO Timer/Watchdog (EXPERIMENTAL)" | ||
321 | depends on WATCHDOG && (X86 || IA64) && PCI && EXPERIMENTAL | ||
322 | ---help--- | ||
323 | Hardware driver for the intel TCO timer based watchdog devices. | ||
324 | These drivers are included in the Intel 82801 I/O Controller | ||
325 | Hub family 'from ICH0 up to ICH7) and in the Intel 6300ESB | ||
326 | controller hub. | ||
327 | |||
328 | The TCO (Total Cost of Ownership) timer is a watchdog timer | ||
329 | that will reboot the machine after its second expiration. The | ||
330 | expiration time can be configured with the "heartbeat" parameter. | ||
331 | |||
332 | On some motherboards the driver may fail to reset the chipset's | ||
333 | NO_REBOOT flag which prevents the watchdog from rebooting the | ||
334 | machine. If this is the case you will get a kernel message like | ||
335 | "failed to reset NO_REBOOT flag, reboot disabled by hardware". | ||
336 | |||
337 | To compile this driver as a module, choose M here: the | ||
338 | module will be called iTCO_wdt. | ||
339 | |||
319 | config SC1200_WDT | 340 | config SC1200_WDT |
320 | tristate "National Semiconductor PC87307/PC97307 (ala SC1200) Watchdog" | 341 | tristate "National Semiconductor PC87307/PC97307 (ala SC1200) Watchdog" |
321 | depends on WATCHDOG && X86 | 342 | depends on WATCHDOG && X86 |
diff --git a/drivers/char/watchdog/Makefile b/drivers/char/watchdog/Makefile index 6ffca7cb56ab..7f70abad465a 100644 --- a/drivers/char/watchdog/Makefile +++ b/drivers/char/watchdog/Makefile | |||
@@ -47,6 +47,7 @@ obj-$(CONFIG_IBMASR) += ibmasr.o | |||
47 | obj-$(CONFIG_WAFER_WDT) += wafer5823wdt.o | 47 | obj-$(CONFIG_WAFER_WDT) += wafer5823wdt.o |
48 | obj-$(CONFIG_I6300ESB_WDT) += i6300esb.o | 48 | obj-$(CONFIG_I6300ESB_WDT) += i6300esb.o |
49 | obj-$(CONFIG_I8XX_TCO) += i8xx_tco.o | 49 | obj-$(CONFIG_I8XX_TCO) += i8xx_tco.o |
50 | obj-$(CONFIG_ITCO_WDT) += iTCO_wdt.o | ||
50 | obj-$(CONFIG_SC1200_WDT) += sc1200wdt.o | 51 | obj-$(CONFIG_SC1200_WDT) += sc1200wdt.o |
51 | obj-$(CONFIG_SCx200_WDT) += scx200_wdt.o | 52 | obj-$(CONFIG_SCx200_WDT) += scx200_wdt.o |
52 | obj-$(CONFIG_60XX_WDT) += sbc60xxwdt.o | 53 | obj-$(CONFIG_60XX_WDT) += sbc60xxwdt.o |
diff --git a/drivers/char/watchdog/iTCO_wdt.c b/drivers/char/watchdog/iTCO_wdt.c new file mode 100644 index 000000000000..8f89948832fc --- /dev/null +++ b/drivers/char/watchdog/iTCO_wdt.c | |||
@@ -0,0 +1,735 @@ | |||
1 | /* | ||
2 | * intel TCO Watchdog Driver (Used in i82801 and i6300ESB chipsets) | ||
3 | * | ||
4 | * (c) Copyright 2006 Wim Van Sebroeck <wim@iguana.be>. | ||
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 | ||
8 | * as published by the Free Software Foundation; either version | ||
9 | * 2 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * Neither Wim Van Sebroeck nor Iguana vzw. admit liability nor | ||
12 | * provide warranty for any of this software. This material is | ||
13 | * provided "AS-IS" and at no charge. | ||
14 | * | ||
15 | * The TCO watchdog is implemented in the following I/O controller hubs: | ||
16 | * (See the intel documentation on http://developer.intel.com.) | ||
17 | * 82801AA (ICH) : document number 290655-003, 290677-014, | ||
18 | * 82801AB (ICHO) : document number 290655-003, 290677-014, | ||
19 | * 82801BA (ICH2) : document number 290687-002, 298242-027, | ||
20 | * 82801BAM (ICH2-M) : document number 290687-002, 298242-027, | ||
21 | * 82801CA (ICH3-S) : document number 290733-003, 290739-013, | ||
22 | * 82801CAM (ICH3-M) : document number 290716-001, 290718-007, | ||
23 | * 82801DB (ICH4) : document number 290744-001, 290745-020, | ||
24 | * 82801DBM (ICH4-M) : document number 252337-001, 252663-005, | ||
25 | * 82801E (C-ICH) : document number 273599-001, 273645-002, | ||
26 | * 82801EB (ICH5) : document number 252516-001, 252517-003, | ||
27 | * 82801ER (ICH5R) : document number 252516-001, 252517-003, | ||
28 | * 82801FB (ICH6) : document number 301473-002, 301474-007, | ||
29 | * 82801FR (ICH6R) : document number 301473-002, 301474-007, | ||
30 | * 82801FBM (ICH6-M) : document number 301473-002, 301474-007, | ||
31 | * 82801FW (ICH6W) : document number 301473-001, 301474-007, | ||
32 | * 82801FRW (ICH6RW) : document number 301473-001, 301474-007, | ||
33 | * 82801GB (ICH7) : document number 307013-002, 307014-009, | ||
34 | * 82801GR (ICH7R) : document number 307013-002, 307014-009, | ||
35 | * 82801GDH (ICH7DH) : document number 307013-002, 307014-009, | ||
36 | * 82801GBM (ICH7-M) : document number 307013-002, 307014-009, | ||
37 | * 82801GHM (ICH7-M DH) : document number 307013-002, 307014-009, | ||
38 | * 6300ESB (6300ESB) : document number 300641-003 | ||
39 | */ | ||
40 | |||
41 | /* | ||
42 | * Includes, defines, variables, module parameters, ... | ||
43 | */ | ||
44 | |||
45 | /* Module and version information */ | ||
46 | #define DRV_NAME "iTCO_wdt" | ||
47 | #define DRV_VERSION "1.00" | ||
48 | #define DRV_RELDATE "30-Jul-2006" | ||
49 | #define PFX DRV_NAME ": " | ||
50 | |||
51 | /* Includes */ | ||
52 | #include <linux/config.h> /* For CONFIG_WATCHDOG_NOWAYOUT/... */ | ||
53 | #include <linux/module.h> /* For module specific items */ | ||
54 | #include <linux/moduleparam.h> /* For new moduleparam's */ | ||
55 | #include <linux/types.h> /* For standard types (like size_t) */ | ||
56 | #include <linux/errno.h> /* For the -ENODEV/... values */ | ||
57 | #include <linux/kernel.h> /* For printk/panic/... */ | ||
58 | #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */ | ||
59 | #include <linux/watchdog.h> /* For the watchdog specific items */ | ||
60 | #include <linux/init.h> /* For __init/__exit/... */ | ||
61 | #include <linux/fs.h> /* For file operations */ | ||
62 | #include <linux/platform_device.h> /* For platform_driver framework */ | ||
63 | #include <linux/pci.h> /* For pci functions */ | ||
64 | #include <linux/ioport.h> /* For io-port access */ | ||
65 | #include <linux/spinlock.h> /* For spin_lock/spin_unlock/... */ | ||
66 | |||
67 | #include <asm/uaccess.h> /* For copy_to_user/put_user/... */ | ||
68 | #include <asm/io.h> /* For inb/outb/... */ | ||
69 | |||
70 | /* TCO related info */ | ||
71 | enum iTCO_chipsets { | ||
72 | TCO_ICH = 0, /* ICH */ | ||
73 | TCO_ICH0, /* ICH0 */ | ||
74 | TCO_ICH2, /* ICH2 */ | ||
75 | TCO_ICH2M, /* ICH2-M */ | ||
76 | TCO_ICH3, /* ICH3-S */ | ||
77 | TCO_ICH3M, /* ICH3-M */ | ||
78 | TCO_ICH4, /* ICH4 */ | ||
79 | TCO_ICH4M, /* ICH4-M */ | ||
80 | TCO_CICH, /* C-ICH */ | ||
81 | TCO_ICH5, /* ICH5 & ICH5R */ | ||
82 | TCO_6300ESB, /* 6300ESB */ | ||
83 | TCO_ICH6, /* ICH6 & ICH6R */ | ||
84 | TCO_ICH6M, /* ICH6-M */ | ||
85 | TCO_ICH6W, /* ICH6W & ICH6RW */ | ||
86 | TCO_ICH7, /* ICH7 & ICH7R */ | ||
87 | TCO_ICH7M, /* ICH7-M */ | ||
88 | TCO_ICH7MDH, /* ICH7-M DH */ | ||
89 | }; | ||
90 | |||
91 | static struct { | ||
92 | char *name; | ||
93 | unsigned int iTCO_version; | ||
94 | } iTCO_chipset_info[] __devinitdata = { | ||
95 | {"ICH", 1}, | ||
96 | {"ICH0", 1}, | ||
97 | {"ICH2", 1}, | ||
98 | {"ICH2-M", 1}, | ||
99 | {"ICH3-S", 1}, | ||
100 | {"ICH3-M", 1}, | ||
101 | {"ICH4", 1}, | ||
102 | {"ICH4-M", 1}, | ||
103 | {"C-ICH", 1}, | ||
104 | {"ICH5 or ICH5R", 1}, | ||
105 | {"6300ESB", 1}, | ||
106 | {"ICH6 or ICH6R", 2}, | ||
107 | {"ICH6-M", 2}, | ||
108 | {"ICH6W or ICH6RW", 2}, | ||
109 | {"ICH7 or ICH7R", 2}, | ||
110 | {"ICH7-M", 2}, | ||
111 | {"ICH7-M DH", 2}, | ||
112 | {NULL,0} | ||
113 | }; | ||
114 | |||
115 | /* | ||
116 | * This data only exists for exporting the supported PCI ids | ||
117 | * via MODULE_DEVICE_TABLE. We do not actually register a | ||
118 | * pci_driver, because the I/O Controller Hub has also other | ||
119 | * functions that probably will be registered by other drivers. | ||
120 | */ | ||
121 | static struct pci_device_id iTCO_wdt_pci_tbl[] = { | ||
122 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH }, | ||
123 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH0 }, | ||
124 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH2 }, | ||
125 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH2M }, | ||
126 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH3 }, | ||
127 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH3M }, | ||
128 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH4 }, | ||
129 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_12, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH4M }, | ||
130 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_CICH }, | ||
131 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801EB_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH5 }, | ||
132 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_6300ESB }, | ||
133 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH6 }, | ||
134 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH6M }, | ||
135 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH6W }, | ||
136 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7 }, | ||
137 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7M }, | ||
138 | { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_31, PCI_ANY_ID, PCI_ANY_ID, 0, 0, TCO_ICH7MDH }, | ||
139 | { 0, }, /* End of list */ | ||
140 | }; | ||
141 | MODULE_DEVICE_TABLE (pci, iTCO_wdt_pci_tbl); | ||
142 | |||
143 | /* Address definitions for the TCO */ | ||
144 | #define TCOBASE iTCO_wdt_private.ACPIBASE + 0x60 /* TCO base address */ | ||
145 | #define SMI_EN iTCO_wdt_private.ACPIBASE + 0x30 /* SMI Control and Enable Register */ | ||
146 | |||
147 | #define TCO_RLD TCOBASE + 0x00 /* TCO Timer Reload and Current Value */ | ||
148 | #define TCOv1_TMR TCOBASE + 0x01 /* TCOv1 Timer Initial Value */ | ||
149 | #define TCO_DAT_IN TCOBASE + 0x02 /* TCO Data In Register */ | ||
150 | #define TCO_DAT_OUT TCOBASE + 0x03 /* TCO Data Out Register */ | ||
151 | #define TCO1_STS TCOBASE + 0x04 /* TCO1 Status Register */ | ||
152 | #define TCO2_STS TCOBASE + 0x06 /* TCO2 Status Register */ | ||
153 | #define TCO1_CNT TCOBASE + 0x08 /* TCO1 Control Register */ | ||
154 | #define TCO2_CNT TCOBASE + 0x0a /* TCO2 Control Register */ | ||
155 | #define TCOv2_TMR TCOBASE + 0x12 /* TCOv2 Timer Initial Value */ | ||
156 | |||
157 | /* internal variables */ | ||
158 | static unsigned long is_active; | ||
159 | static char expect_release; | ||
160 | static struct { /* this is private data for the iTCO_wdt device */ | ||
161 | unsigned int iTCO_version; /* TCO version/generation */ | ||
162 | unsigned long ACPIBASE; /* The cards ACPIBASE address (TCOBASE = ACPIBASE+0x60) */ | ||
163 | unsigned long __iomem *gcs; /* NO_REBOOT flag is Memory-Mapped GCS register bit 5 (TCO version 2) */ | ||
164 | spinlock_t io_lock; /* the lock for io operations */ | ||
165 | struct pci_dev *pdev; /* the PCI-device */ | ||
166 | } iTCO_wdt_private; | ||
167 | |||
168 | static struct platform_device *iTCO_wdt_platform_device; /* the watchdog platform device */ | ||
169 | |||
170 | /* module parameters */ | ||
171 | #define WATCHDOG_HEARTBEAT 30 /* 30 sec default heartbeat */ | ||
172 | static int heartbeat = WATCHDOG_HEARTBEAT; /* in seconds */ | ||
173 | module_param(heartbeat, int, 0); | ||
174 | MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (2<heartbeat<39 (TCO v1) or 613 (TCO v2), default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")"); | ||
175 | |||
176 | static int nowayout = WATCHDOG_NOWAYOUT; | ||
177 | module_param(nowayout, int, 0); | ||
178 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)"); | ||
179 | |||
180 | /* | ||
181 | * Some TCO specific functions | ||
182 | */ | ||
183 | |||
184 | static inline unsigned int seconds_to_ticks(int seconds) | ||
185 | { | ||
186 | /* the internal timer is stored as ticks which decrement | ||
187 | * every 0.6 seconds */ | ||
188 | return (seconds * 10) / 6; | ||
189 | } | ||
190 | |||
191 | static void iTCO_wdt_set_NO_REBOOT_bit(void) | ||
192 | { | ||
193 | u32 val32; | ||
194 | |||
195 | /* Set the NO_REBOOT bit: this disables reboots */ | ||
196 | if (iTCO_wdt_private.iTCO_version == 2) { | ||
197 | val32 = readl(iTCO_wdt_private.gcs); | ||
198 | val32 |= 0x00000020; | ||
199 | writel(val32, iTCO_wdt_private.gcs); | ||
200 | } else if (iTCO_wdt_private.iTCO_version == 1) { | ||
201 | pci_read_config_dword(iTCO_wdt_private.pdev, 0xd4, &val32); | ||
202 | val32 |= 0x00000002; | ||
203 | pci_write_config_dword(iTCO_wdt_private.pdev, 0xd4, val32); | ||
204 | } | ||
205 | } | ||
206 | |||
207 | static int iTCO_wdt_unset_NO_REBOOT_bit(void) | ||
208 | { | ||
209 | int ret = 0; | ||
210 | u32 val32; | ||
211 | |||
212 | /* Unset the NO_REBOOT bit: this enables reboots */ | ||
213 | if (iTCO_wdt_private.iTCO_version == 2) { | ||
214 | val32 = readl(iTCO_wdt_private.gcs); | ||
215 | val32 &= 0xffffffdf; | ||
216 | writel(val32, iTCO_wdt_private.gcs); | ||
217 | |||
218 | val32 = readl(iTCO_wdt_private.gcs); | ||
219 | if (val32 & 0x00000020) | ||
220 | ret = -EIO; | ||
221 | } else if (iTCO_wdt_private.iTCO_version == 1) { | ||
222 | pci_read_config_dword(iTCO_wdt_private.pdev, 0xd4, &val32); | ||
223 | val32 &= 0xfffffffd; | ||
224 | pci_write_config_dword(iTCO_wdt_private.pdev, 0xd4, val32); | ||
225 | |||
226 | pci_read_config_dword(iTCO_wdt_private.pdev, 0xd4, &val32); | ||
227 | if (val32 & 0x00000002) | ||
228 | ret = -EIO; | ||
229 | } | ||
230 | |||
231 | return ret; /* returns: 0 = OK, -EIO = Error */ | ||
232 | } | ||
233 | |||
234 | static int iTCO_wdt_start(void) | ||
235 | { | ||
236 | unsigned int val; | ||
237 | |||
238 | spin_lock(&iTCO_wdt_private.io_lock); | ||
239 | |||
240 | /* disable chipset's NO_REBOOT bit */ | ||
241 | if (iTCO_wdt_unset_NO_REBOOT_bit()) { | ||
242 | printk(KERN_ERR PFX "failed to reset NO_REBOOT flag, reboot disabled by hardware\n"); | ||
243 | return -EIO; | ||
244 | } | ||
245 | |||
246 | /* Bit 11: TCO Timer Halt -> 0 = The TCO timer is enabled to count */ | ||
247 | val = inw(TCO1_CNT); | ||
248 | val &= 0xf7ff; | ||
249 | outw(val, TCO1_CNT); | ||
250 | val = inw(TCO1_CNT); | ||
251 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
252 | |||
253 | if (val & 0x0800) | ||
254 | return -1; | ||
255 | return 0; | ||
256 | } | ||
257 | |||
258 | static int iTCO_wdt_stop(void) | ||
259 | { | ||
260 | unsigned int val; | ||
261 | |||
262 | spin_lock(&iTCO_wdt_private.io_lock); | ||
263 | |||
264 | /* Bit 11: TCO Timer Halt -> 1 = The TCO timer is disabled */ | ||
265 | val = inw(TCO1_CNT); | ||
266 | val |= 0x0800; | ||
267 | outw(val, TCO1_CNT); | ||
268 | val = inw(TCO1_CNT); | ||
269 | |||
270 | /* Set the NO_REBOOT bit to prevent later reboots, just for sure */ | ||
271 | iTCO_wdt_set_NO_REBOOT_bit(); | ||
272 | |||
273 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
274 | |||
275 | if ((val & 0x0800) == 0) | ||
276 | return -1; | ||
277 | return 0; | ||
278 | } | ||
279 | |||
280 | static int iTCO_wdt_keepalive(void) | ||
281 | { | ||
282 | spin_lock(&iTCO_wdt_private.io_lock); | ||
283 | |||
284 | /* Reload the timer by writing to the TCO Timer Counter register */ | ||
285 | if (iTCO_wdt_private.iTCO_version == 2) { | ||
286 | outw(0x01, TCO_RLD); | ||
287 | } else if (iTCO_wdt_private.iTCO_version == 1) { | ||
288 | outb(0x01, TCO_RLD); | ||
289 | } | ||
290 | |||
291 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
292 | return 0; | ||
293 | } | ||
294 | |||
295 | static int iTCO_wdt_set_heartbeat(int t) | ||
296 | { | ||
297 | unsigned int val16; | ||
298 | unsigned char val8; | ||
299 | unsigned int tmrval; | ||
300 | |||
301 | tmrval = seconds_to_ticks(t); | ||
302 | /* from the specs: */ | ||
303 | /* "Values of 0h-3h are ignored and should not be attempted" */ | ||
304 | if (tmrval < 0x04) | ||
305 | return -EINVAL; | ||
306 | if (((iTCO_wdt_private.iTCO_version == 2) && (tmrval > 0x3ff)) || | ||
307 | ((iTCO_wdt_private.iTCO_version == 1) && (tmrval > 0x03f))) | ||
308 | return -EINVAL; | ||
309 | |||
310 | /* Write new heartbeat to watchdog */ | ||
311 | if (iTCO_wdt_private.iTCO_version == 2) { | ||
312 | spin_lock(&iTCO_wdt_private.io_lock); | ||
313 | val16 = inw(TCOv2_TMR); | ||
314 | val16 &= 0xfc00; | ||
315 | val16 |= tmrval; | ||
316 | outw(val16, TCOv2_TMR); | ||
317 | val16 = inw(TCOv2_TMR); | ||
318 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
319 | |||
320 | if ((val16 & 0x3ff) != tmrval) | ||
321 | return -EINVAL; | ||
322 | } else if (iTCO_wdt_private.iTCO_version == 1) { | ||
323 | spin_lock(&iTCO_wdt_private.io_lock); | ||
324 | val8 = inb(TCOv1_TMR); | ||
325 | val8 &= 0xc0; | ||
326 | val8 |= (tmrval & 0xff); | ||
327 | outb(val8, TCOv1_TMR); | ||
328 | val8 = inb(TCOv1_TMR); | ||
329 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
330 | |||
331 | if ((val8 & 0x3f) != tmrval) | ||
332 | return -EINVAL; | ||
333 | } | ||
334 | |||
335 | heartbeat = t; | ||
336 | return 0; | ||
337 | } | ||
338 | |||
339 | static int iTCO_wdt_get_timeleft (int *time_left) | ||
340 | { | ||
341 | unsigned int val16; | ||
342 | unsigned char val8; | ||
343 | |||
344 | /* read the TCO Timer */ | ||
345 | if (iTCO_wdt_private.iTCO_version == 2) { | ||
346 | spin_lock(&iTCO_wdt_private.io_lock); | ||
347 | val16 = inw(TCO_RLD); | ||
348 | val16 &= 0x3ff; | ||
349 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
350 | |||
351 | *time_left = (val16 * 6) / 10; | ||
352 | } else if (iTCO_wdt_private.iTCO_version == 1) { | ||
353 | spin_lock(&iTCO_wdt_private.io_lock); | ||
354 | val8 = inb(TCO_RLD); | ||
355 | val8 &= 0x3f; | ||
356 | spin_unlock(&iTCO_wdt_private.io_lock); | ||
357 | |||
358 | *time_left = (val8 * 6) / 10; | ||
359 | } | ||
360 | return 0; | ||
361 | } | ||
362 | |||
363 | /* | ||
364 | * /dev/watchdog handling | ||
365 | */ | ||
366 | |||
367 | static int iTCO_wdt_open (struct inode *inode, struct file *file) | ||
368 | { | ||
369 | /* /dev/watchdog can only be opened once */ | ||
370 | if (test_and_set_bit(0, &is_active)) | ||
371 | return -EBUSY; | ||
372 | |||
373 | /* | ||
374 | * Reload and activate timer | ||
375 | */ | ||
376 | iTCO_wdt_keepalive(); | ||
377 | iTCO_wdt_start(); | ||
378 | return nonseekable_open(inode, file); | ||
379 | } | ||
380 | |||
381 | static int iTCO_wdt_release (struct inode *inode, struct file *file) | ||
382 | { | ||
383 | /* | ||
384 | * Shut off the timer. | ||
385 | */ | ||
386 | if (expect_release == 42) { | ||
387 | iTCO_wdt_stop(); | ||
388 | } else { | ||
389 | printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n"); | ||
390 | iTCO_wdt_keepalive(); | ||
391 | } | ||
392 | clear_bit(0, &is_active); | ||
393 | expect_release = 0; | ||
394 | return 0; | ||
395 | } | ||
396 | |||
397 | static ssize_t iTCO_wdt_write (struct file *file, const char __user *data, | ||
398 | size_t len, loff_t * ppos) | ||
399 | { | ||
400 | /* See if we got the magic character 'V' and reload the timer */ | ||
401 | if (len) { | ||
402 | if (!nowayout) { | ||
403 | size_t i; | ||
404 | |||
405 | /* note: just in case someone wrote the magic character | ||
406 | * five months ago... */ | ||
407 | expect_release = 0; | ||
408 | |||
409 | /* scan to see whether or not we got the magic character */ | ||
410 | for (i = 0; i != len; i++) { | ||
411 | char c; | ||
412 | if (get_user(c, data+i)) | ||
413 | return -EFAULT; | ||
414 | if (c == 'V') | ||
415 | expect_release = 42; | ||
416 | } | ||
417 | } | ||
418 | |||
419 | /* someone wrote to us, we should reload the timer */ | ||
420 | iTCO_wdt_keepalive(); | ||
421 | } | ||
422 | return len; | ||
423 | } | ||
424 | |||
425 | static int iTCO_wdt_ioctl (struct inode *inode, struct file *file, | ||
426 | unsigned int cmd, unsigned long arg) | ||
427 | { | ||
428 | int new_options, retval = -EINVAL; | ||
429 | int new_heartbeat; | ||
430 | int time_left; | ||
431 | void __user *argp = (void __user *)arg; | ||
432 | int __user *p = argp; | ||
433 | static struct watchdog_info ident = { | ||
434 | .options = WDIOF_SETTIMEOUT | | ||
435 | WDIOF_KEEPALIVEPING | | ||
436 | WDIOF_MAGICCLOSE, | ||
437 | .firmware_version = 0, | ||
438 | .identity = DRV_NAME, | ||
439 | }; | ||
440 | |||
441 | switch (cmd) { | ||
442 | case WDIOC_GETSUPPORT: | ||
443 | return copy_to_user(argp, &ident, | ||
444 | sizeof (ident)) ? -EFAULT : 0; | ||
445 | |||
446 | case WDIOC_GETSTATUS: | ||
447 | case WDIOC_GETBOOTSTATUS: | ||
448 | return put_user(0, p); | ||
449 | |||
450 | case WDIOC_KEEPALIVE: | ||
451 | iTCO_wdt_keepalive(); | ||
452 | return 0; | ||
453 | |||
454 | case WDIOC_SETOPTIONS: | ||
455 | { | ||
456 | if (get_user(new_options, p)) | ||
457 | return -EFAULT; | ||
458 | |||
459 | if (new_options & WDIOS_DISABLECARD) { | ||
460 | iTCO_wdt_stop(); | ||
461 | retval = 0; | ||
462 | } | ||
463 | |||
464 | if (new_options & WDIOS_ENABLECARD) { | ||
465 | iTCO_wdt_keepalive(); | ||
466 | iTCO_wdt_start(); | ||
467 | retval = 0; | ||
468 | } | ||
469 | |||
470 | return retval; | ||
471 | } | ||
472 | |||
473 | case WDIOC_SETTIMEOUT: | ||
474 | { | ||
475 | if (get_user(new_heartbeat, p)) | ||
476 | return -EFAULT; | ||
477 | |||
478 | if (iTCO_wdt_set_heartbeat(new_heartbeat)) | ||
479 | return -EINVAL; | ||
480 | |||
481 | iTCO_wdt_keepalive(); | ||
482 | /* Fall */ | ||
483 | } | ||
484 | |||
485 | case WDIOC_GETTIMEOUT: | ||
486 | return put_user(heartbeat, p); | ||
487 | |||
488 | case WDIOC_GETTIMELEFT: | ||
489 | { | ||
490 | if (iTCO_wdt_get_timeleft(&time_left)) | ||
491 | return -EINVAL; | ||
492 | |||
493 | return put_user(time_left, p); | ||
494 | } | ||
495 | |||
496 | default: | ||
497 | return -ENOTTY; | ||
498 | } | ||
499 | } | ||
500 | |||
501 | /* | ||
502 | * Kernel Interfaces | ||
503 | */ | ||
504 | |||
505 | static struct file_operations iTCO_wdt_fops = { | ||
506 | .owner = THIS_MODULE, | ||
507 | .llseek = no_llseek, | ||
508 | .write = iTCO_wdt_write, | ||
509 | .ioctl = iTCO_wdt_ioctl, | ||
510 | .open = iTCO_wdt_open, | ||
511 | .release = iTCO_wdt_release, | ||
512 | }; | ||
513 | |||
514 | static struct miscdevice iTCO_wdt_miscdev = { | ||
515 | .minor = WATCHDOG_MINOR, | ||
516 | .name = "watchdog", | ||
517 | .fops = &iTCO_wdt_fops, | ||
518 | }; | ||
519 | |||
520 | /* | ||
521 | * Init & exit routines | ||
522 | */ | ||
523 | |||
524 | static int iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device_id *ent, struct platform_device *dev) | ||
525 | { | ||
526 | int ret; | ||
527 | u32 base_address; | ||
528 | unsigned long RCBA; | ||
529 | unsigned long val32; | ||
530 | |||
531 | /* | ||
532 | * Find the ACPI/PM base I/O address which is the base | ||
533 | * for the TCO registers (TCOBASE=ACPIBASE + 0x60) | ||
534 | * ACPIBASE is bits [15:7] from 0x40-0x43 | ||
535 | */ | ||
536 | pci_read_config_dword(pdev, 0x40, &base_address); | ||
537 | base_address &= 0x00007f80; | ||
538 | if (base_address == 0x00000000) { | ||
539 | /* Something's wrong here, ACPIBASE has to be set */ | ||
540 | printk(KERN_ERR PFX "failed to get TCOBASE address\n"); | ||
541 | pci_dev_put(pdev); | ||
542 | return -ENODEV; | ||
543 | } | ||
544 | iTCO_wdt_private.iTCO_version = iTCO_chipset_info[ent->driver_data].iTCO_version; | ||
545 | iTCO_wdt_private.ACPIBASE = base_address; | ||
546 | iTCO_wdt_private.pdev = pdev; | ||
547 | |||
548 | /* Get the Memory-Mapped GCS register, we need it for the NO_REBOOT flag (TCO v2) */ | ||
549 | /* To get access to it you have to read RCBA from PCI Config space 0xf0 | ||
550 | and use it as base. GCS = RCBA + ICH6_GCS(0x3410). */ | ||
551 | if (iTCO_wdt_private.iTCO_version == 2) { | ||
552 | pci_read_config_dword(pdev, 0xf0, &base_address); | ||
553 | RCBA = base_address & 0xffffc000; | ||
554 | iTCO_wdt_private.gcs = ioremap((RCBA + 0x3410),4); | ||
555 | } | ||
556 | |||
557 | /* Check chipset's NO_REBOOT bit */ | ||
558 | if (iTCO_wdt_unset_NO_REBOOT_bit()) { | ||
559 | printk(KERN_ERR PFX "failed to reset NO_REBOOT flag, reboot disabled by hardware\n"); | ||
560 | ret = -ENODEV; /* Cannot reset NO_REBOOT bit */ | ||
561 | goto out; | ||
562 | } | ||
563 | |||
564 | /* Set the NO_REBOOT bit to prevent later reboots, just for sure */ | ||
565 | iTCO_wdt_set_NO_REBOOT_bit(); | ||
566 | |||
567 | /* Set the TCO_EN bit in SMI_EN register */ | ||
568 | if (!request_region(SMI_EN, 4, "iTCO_wdt")) { | ||
569 | printk(KERN_ERR PFX "I/O address 0x%04lx already in use\n", | ||
570 | SMI_EN ); | ||
571 | ret = -EIO; | ||
572 | goto out; | ||
573 | } | ||
574 | val32 = inl(SMI_EN); | ||
575 | val32 &= 0xffffdfff; /* Turn off SMI clearing watchdog */ | ||
576 | outl(val32, SMI_EN); | ||
577 | release_region(SMI_EN, 4); | ||
578 | |||
579 | /* The TCO I/O registers reside in a 32-byte range pointed to by the TCOBASE value */ | ||
580 | if (!request_region (TCOBASE, 0x20, "iTCO_wdt")) { | ||
581 | printk (KERN_ERR PFX "I/O address 0x%04lx already in use\n", | ||
582 | TCOBASE); | ||
583 | ret = -EIO; | ||
584 | goto out; | ||
585 | } | ||
586 | |||
587 | printk(KERN_INFO PFX "Found a %s TCO device (Version=%d, TCOBASE=0x%04lx)\n", | ||
588 | iTCO_chipset_info[ent->driver_data].name, | ||
589 | iTCO_chipset_info[ent->driver_data].iTCO_version, | ||
590 | TCOBASE); | ||
591 | |||
592 | /* Clear out the (probably old) status */ | ||
593 | outb(0, TCO1_STS); | ||
594 | outb(3, TCO2_STS); | ||
595 | |||
596 | /* Make sure the watchdog is not running */ | ||
597 | iTCO_wdt_stop(); | ||
598 | |||
599 | /* Check that the heartbeat value is within it's range ; if not reset to the default */ | ||
600 | if (iTCO_wdt_set_heartbeat(heartbeat)) { | ||
601 | iTCO_wdt_set_heartbeat(WATCHDOG_HEARTBEAT); | ||
602 | printk(KERN_INFO PFX "heartbeat value must be 2<heartbeat<39 (TCO v1) or 613 (TCO v2), using %d\n", | ||
603 | heartbeat); | ||
604 | } | ||
605 | |||
606 | ret = misc_register(&iTCO_wdt_miscdev); | ||
607 | if (ret != 0) { | ||
608 | printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", | ||
609 | WATCHDOG_MINOR, ret); | ||
610 | goto unreg_region; | ||
611 | } | ||
612 | |||
613 | printk (KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n", | ||
614 | heartbeat, nowayout); | ||
615 | |||
616 | return 0; | ||
617 | |||
618 | unreg_region: | ||
619 | release_region (TCOBASE, 0x20); | ||
620 | out: | ||
621 | if (iTCO_wdt_private.iTCO_version == 2) | ||
622 | iounmap(iTCO_wdt_private.gcs); | ||
623 | pci_dev_put(iTCO_wdt_private.pdev); | ||
624 | iTCO_wdt_private.ACPIBASE = 0; | ||
625 | return ret; | ||
626 | } | ||
627 | |||
628 | static void iTCO_wdt_cleanup(void) | ||
629 | { | ||
630 | /* Stop the timer before we leave */ | ||
631 | if (!nowayout) | ||
632 | iTCO_wdt_stop(); | ||
633 | |||
634 | /* Deregister */ | ||
635 | misc_deregister(&iTCO_wdt_miscdev); | ||
636 | release_region(TCOBASE, 0x20); | ||
637 | if (iTCO_wdt_private.iTCO_version == 2) | ||
638 | iounmap(iTCO_wdt_private.gcs); | ||
639 | pci_dev_put(iTCO_wdt_private.pdev); | ||
640 | iTCO_wdt_private.ACPIBASE = 0; | ||
641 | } | ||
642 | |||
643 | static int iTCO_wdt_probe(struct platform_device *dev) | ||
644 | { | ||
645 | int found = 0; | ||
646 | struct pci_dev *pdev = NULL; | ||
647 | const struct pci_device_id *ent; | ||
648 | |||
649 | spin_lock_init(&iTCO_wdt_private.io_lock); | ||
650 | |||
651 | for_each_pci_dev(pdev) { | ||
652 | ent = pci_match_id(iTCO_wdt_pci_tbl, pdev); | ||
653 | if (ent) { | ||
654 | if (!(iTCO_wdt_init(pdev, ent, dev))) { | ||
655 | found++; | ||
656 | break; | ||
657 | } | ||
658 | } | ||
659 | } | ||
660 | |||
661 | if (!found) { | ||
662 | printk(KERN_INFO PFX "No card detected\n"); | ||
663 | return -ENODEV; | ||
664 | } | ||
665 | |||
666 | return 0; | ||
667 | } | ||
668 | |||
669 | static int iTCO_wdt_remove(struct platform_device *dev) | ||
670 | { | ||
671 | if (iTCO_wdt_private.ACPIBASE) | ||
672 | iTCO_wdt_cleanup(); | ||
673 | |||
674 | return 0; | ||
675 | } | ||
676 | |||
677 | static void iTCO_wdt_shutdown(struct platform_device *dev) | ||
678 | { | ||
679 | iTCO_wdt_stop(); | ||
680 | } | ||
681 | |||
682 | #define iTCO_wdt_suspend NULL | ||
683 | #define iTCO_wdt_resume NULL | ||
684 | |||
685 | static struct platform_driver iTCO_wdt_driver = { | ||
686 | .probe = iTCO_wdt_probe, | ||
687 | .remove = iTCO_wdt_remove, | ||
688 | .shutdown = iTCO_wdt_shutdown, | ||
689 | .suspend = iTCO_wdt_suspend, | ||
690 | .resume = iTCO_wdt_resume, | ||
691 | .driver = { | ||
692 | .owner = THIS_MODULE, | ||
693 | .name = DRV_NAME, | ||
694 | }, | ||
695 | }; | ||
696 | |||
697 | static int __init iTCO_wdt_init_module(void) | ||
698 | { | ||
699 | int err; | ||
700 | |||
701 | printk(KERN_INFO PFX "Intel TCO WatchDog Timer Driver v%s (%s)\n", | ||
702 | DRV_VERSION, DRV_RELDATE); | ||
703 | |||
704 | err = platform_driver_register(&iTCO_wdt_driver); | ||
705 | if (err) | ||
706 | return err; | ||
707 | |||
708 | iTCO_wdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0); | ||
709 | if (IS_ERR(iTCO_wdt_platform_device)) { | ||
710 | err = PTR_ERR(iTCO_wdt_platform_device); | ||
711 | goto unreg_platform_driver; | ||
712 | } | ||
713 | |||
714 | return 0; | ||
715 | |||
716 | unreg_platform_driver: | ||
717 | platform_driver_unregister(&iTCO_wdt_driver); | ||
718 | return err; | ||
719 | } | ||
720 | |||
721 | static void __exit iTCO_wdt_cleanup_module(void) | ||
722 | { | ||
723 | platform_device_unregister(iTCO_wdt_platform_device); | ||
724 | platform_driver_unregister(&iTCO_wdt_driver); | ||
725 | printk(KERN_INFO PFX "Watchdog Module Unloaded.\n"); | ||
726 | } | ||
727 | |||
728 | module_init(iTCO_wdt_init_module); | ||
729 | module_exit(iTCO_wdt_cleanup_module); | ||
730 | |||
731 | MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>"); | ||
732 | MODULE_DESCRIPTION("Intel TCO WatchDog Timer Driver"); | ||
733 | MODULE_VERSION(DRV_VERSION); | ||
734 | MODULE_LICENSE("GPL"); | ||
735 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); | ||
diff --git a/drivers/char/watchdog/pnx4008_wdt.c b/drivers/char/watchdog/pnx4008_wdt.c index e7f0450a939d..db2731ba88e3 100644 --- a/drivers/char/watchdog/pnx4008_wdt.c +++ b/drivers/char/watchdog/pnx4008_wdt.c | |||
@@ -184,7 +184,7 @@ static int | |||
184 | pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, | 184 | pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, |
185 | unsigned long arg) | 185 | unsigned long arg) |
186 | { | 186 | { |
187 | int ret = -ENOIOCTLCMD; | 187 | int ret = -ENOTTY; |
188 | int time; | 188 | int time; |
189 | 189 | ||
190 | switch (cmd) { | 190 | switch (cmd) { |
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig index abcabb295592..0c68d0f0d8e5 100644 --- a/drivers/ide/Kconfig +++ b/drivers/ide/Kconfig | |||
@@ -614,15 +614,6 @@ config BLK_DEV_PIIX | |||
614 | the kernel to change PIO, DMA and UDMA speeds and to configure | 614 | the kernel to change PIO, DMA and UDMA speeds and to configure |
615 | the chip to optimum performance. | 615 | the chip to optimum performance. |
616 | 616 | ||
617 | config BLK_DEV_IT8172 | ||
618 | bool "IT8172 IDE support" | ||
619 | depends on (MIPS_ITE8172 || MIPS_IVR) | ||
620 | help | ||
621 | Say Y here to support the on-board IDE controller on the Integrated | ||
622 | Technology Express, Inc. ITE8172 SBC. Vendor page at | ||
623 | <http://www.ite.com.tw/ia/brief_it8172bsp.htm>; picture of the | ||
624 | board at <http://www.mvista.com/partners/semiconductor/ite.html>. | ||
625 | |||
626 | config BLK_DEV_IT821X | 617 | config BLK_DEV_IT821X |
627 | tristate "IT821X IDE support" | 618 | tristate "IT821X IDE support" |
628 | help | 619 | help |
diff --git a/drivers/ide/pci/Makefile b/drivers/ide/pci/Makefile index 640a54b09b5a..fef08960aa4c 100644 --- a/drivers/ide/pci/Makefile +++ b/drivers/ide/pci/Makefile | |||
@@ -12,7 +12,6 @@ obj-$(CONFIG_BLK_DEV_CY82C693) += cy82c693.o | |||
12 | obj-$(CONFIG_BLK_DEV_HPT34X) += hpt34x.o | 12 | obj-$(CONFIG_BLK_DEV_HPT34X) += hpt34x.o |
13 | obj-$(CONFIG_BLK_DEV_HPT366) += hpt366.o | 13 | obj-$(CONFIG_BLK_DEV_HPT366) += hpt366.o |
14 | #obj-$(CONFIG_BLK_DEV_HPT37X) += hpt37x.o | 14 | #obj-$(CONFIG_BLK_DEV_HPT37X) += hpt37x.o |
15 | obj-$(CONFIG_BLK_DEV_IT8172) += it8172.o | ||
16 | obj-$(CONFIG_BLK_DEV_IT821X) += it821x.o | 15 | obj-$(CONFIG_BLK_DEV_IT821X) += it821x.o |
17 | obj-$(CONFIG_BLK_DEV_JMICRON) += jmicron.o | 16 | obj-$(CONFIG_BLK_DEV_JMICRON) += jmicron.o |
18 | obj-$(CONFIG_BLK_DEV_NS87415) += ns87415.o | 17 | obj-$(CONFIG_BLK_DEV_NS87415) += ns87415.o |
diff --git a/drivers/ide/pci/it8172.c b/drivers/ide/pci/it8172.c deleted file mode 100644 index 0fc89fafad65..000000000000 --- a/drivers/ide/pci/it8172.c +++ /dev/null | |||
@@ -1,307 +0,0 @@ | |||
1 | /* | ||
2 | * | ||
3 | * BRIEF MODULE DESCRIPTION | ||
4 | * IT8172 IDE controller support | ||
5 | * | ||
6 | * Copyright 2000 MontaVista Software Inc. | ||
7 | * Author: MontaVista Software, Inc. | ||
8 | * stevel@mvista.com or source@mvista.com | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify it | ||
11 | * under the terms of the GNU General Public License as published by the | ||
12 | * Free Software Foundation; either version 2 of the License, or (at your | ||
13 | * option) any later version. | ||
14 | * | ||
15 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | ||
16 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | ||
17 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN | ||
18 | * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | ||
19 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
20 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | ||
21 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | ||
22 | * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
23 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | ||
24 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
25 | * | ||
26 | * You should have received a copy of the GNU General Public License along | ||
27 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
28 | * 675 Mass Ave, Cambridge, MA 02139, USA. | ||
29 | */ | ||
30 | |||
31 | #include <linux/module.h> | ||
32 | #include <linux/types.h> | ||
33 | #include <linux/kernel.h> | ||
34 | #include <linux/ioport.h> | ||
35 | #include <linux/pci.h> | ||
36 | #include <linux/hdreg.h> | ||
37 | #include <linux/ide.h> | ||
38 | #include <linux/delay.h> | ||
39 | #include <linux/init.h> | ||
40 | |||
41 | #include <asm/io.h> | ||
42 | #include <asm/it8172/it8172_int.h> | ||
43 | |||
44 | /* | ||
45 | * Prototypes | ||
46 | */ | ||
47 | static u8 it8172_ratemask (ide_drive_t *drive) | ||
48 | { | ||
49 | return 1; | ||
50 | } | ||
51 | |||
52 | static void it8172_tune_drive (ide_drive_t *drive, u8 pio) | ||
53 | { | ||
54 | ide_hwif_t *hwif = HWIF(drive); | ||
55 | struct pci_dev *dev = hwif->pci_dev; | ||
56 | int is_slave = (&hwif->drives[1] == drive); | ||
57 | unsigned long flags; | ||
58 | u16 drive_enables; | ||
59 | u32 drive_timing; | ||
60 | |||
61 | pio = ide_get_best_pio_mode(drive, pio, 4, NULL); | ||
62 | spin_lock_irqsave(&ide_lock, flags); | ||
63 | pci_read_config_word(dev, 0x40, &drive_enables); | ||
64 | pci_read_config_dword(dev, 0x44, &drive_timing); | ||
65 | |||
66 | /* | ||
67 | * FIX! The DIOR/DIOW pulse width and recovery times in port 0x44 | ||
68 | * are being left at the default values of 8 PCI clocks (242 nsec | ||
69 | * for a 33 MHz clock). These can be safely shortened at higher | ||
70 | * PIO modes. The DIOR/DIOW pulse width and recovery times only | ||
71 | * apply to PIO modes, not to the DMA modes. | ||
72 | */ | ||
73 | |||
74 | /* | ||
75 | * Enable port 0x44. The IT8172G spec is confused; it calls | ||
76 | * this register the "Slave IDE Timing Register", but in fact, | ||
77 | * it controls timing for both master and slave drives. | ||
78 | */ | ||
79 | drive_enables |= 0x4000; | ||
80 | |||
81 | if (is_slave) { | ||
82 | drive_enables &= 0xc006; | ||
83 | if (pio > 1) | ||
84 | /* enable prefetch and IORDY sample-point */ | ||
85 | drive_enables |= 0x0060; | ||
86 | } else { | ||
87 | drive_enables &= 0xc060; | ||
88 | if (pio > 1) | ||
89 | /* enable prefetch and IORDY sample-point */ | ||
90 | drive_enables |= 0x0006; | ||
91 | } | ||
92 | |||
93 | pci_write_config_word(dev, 0x40, drive_enables); | ||
94 | spin_unlock_irqrestore(&ide_lock, flags); | ||
95 | } | ||
96 | |||
97 | static u8 it8172_dma_2_pio (u8 xfer_rate) | ||
98 | { | ||
99 | switch(xfer_rate) { | ||
100 | case XFER_UDMA_5: | ||
101 | case XFER_UDMA_4: | ||
102 | case XFER_UDMA_3: | ||
103 | case XFER_UDMA_2: | ||
104 | case XFER_UDMA_1: | ||
105 | case XFER_UDMA_0: | ||
106 | case XFER_MW_DMA_2: | ||
107 | case XFER_PIO_4: | ||
108 | return 4; | ||
109 | case XFER_MW_DMA_1: | ||
110 | case XFER_PIO_3: | ||
111 | return 3; | ||
112 | case XFER_SW_DMA_2: | ||
113 | case XFER_PIO_2: | ||
114 | return 2; | ||
115 | case XFER_MW_DMA_0: | ||
116 | case XFER_SW_DMA_1: | ||
117 | case XFER_SW_DMA_0: | ||
118 | case XFER_PIO_1: | ||
119 | case XFER_PIO_0: | ||
120 | case XFER_PIO_SLOW: | ||
121 | default: | ||
122 | return 0; | ||
123 | } | ||
124 | } | ||
125 | |||
126 | static int it8172_tune_chipset (ide_drive_t *drive, u8 xferspeed) | ||
127 | { | ||
128 | ide_hwif_t *hwif = HWIF(drive); | ||
129 | struct pci_dev *dev = hwif->pci_dev; | ||
130 | u8 speed = ide_rate_filter(it8172_ratemask(drive), xferspeed); | ||
131 | int a_speed = 3 << (drive->dn * 4); | ||
132 | int u_flag = 1 << drive->dn; | ||
133 | int u_speed = 0; | ||
134 | u8 reg48, reg4a; | ||
135 | |||
136 | pci_read_config_byte(dev, 0x48, ®48); | ||
137 | pci_read_config_byte(dev, 0x4a, ®4a); | ||
138 | |||
139 | /* | ||
140 | * Setting the DMA cycle time to 2 or 3 PCI clocks (60 and 91 nsec | ||
141 | * at 33 MHz PCI clock) seems to cause BadCRC errors during DMA | ||
142 | * transfers on some drives, even though both numbers meet the minimum | ||
143 | * ATAPI-4 spec of 73 and 54 nsec for UDMA 1 and 2 respectively. | ||
144 | * So the faster times are just commented out here. The good news is | ||
145 | * that the slower cycle time has very little affect on transfer | ||
146 | * performance. | ||
147 | */ | ||
148 | |||
149 | switch(speed) { | ||
150 | case XFER_UDMA_4: | ||
151 | case XFER_UDMA_2: //u_speed = 2 << (drive->dn * 4); break; | ||
152 | case XFER_UDMA_5: | ||
153 | case XFER_UDMA_3: | ||
154 | case XFER_UDMA_1: //u_speed = 1 << (drive->dn * 4); break; | ||
155 | case XFER_UDMA_0: u_speed = 0 << (drive->dn * 4); break; | ||
156 | case XFER_MW_DMA_2: | ||
157 | case XFER_MW_DMA_1: | ||
158 | case XFER_MW_DMA_0: | ||
159 | case XFER_SW_DMA_2: break; | ||
160 | case XFER_PIO_4: | ||
161 | case XFER_PIO_3: | ||
162 | case XFER_PIO_2: | ||
163 | case XFER_PIO_0: break; | ||
164 | default: return -1; | ||
165 | } | ||
166 | |||
167 | if (speed >= XFER_UDMA_0) { | ||
168 | pci_write_config_byte(dev, 0x48, reg48 | u_flag); | ||
169 | reg4a &= ~a_speed; | ||
170 | pci_write_config_byte(dev, 0x4a, reg4a | u_speed); | ||
171 | } else { | ||
172 | pci_write_config_byte(dev, 0x48, reg48 & ~u_flag); | ||
173 | pci_write_config_byte(dev, 0x4a, reg4a & ~a_speed); | ||
174 | } | ||
175 | |||
176 | it8172_tune_drive(drive, it8172_dma_2_pio(speed)); | ||
177 | return (ide_config_drive_speed(drive, speed)); | ||
178 | } | ||
179 | |||
180 | static int it8172_config_chipset_for_dma (ide_drive_t *drive) | ||
181 | { | ||
182 | u8 speed = ide_dma_speed(drive, it8172_ratemask(drive)); | ||
183 | |||
184 | if (!(speed)) { | ||
185 | u8 tspeed = ide_get_best_pio_mode(drive, 255, 4, NULL); | ||
186 | speed = it8172_dma_2_pio(XFER_PIO_0 + tspeed); | ||
187 | } | ||
188 | |||
189 | (void) it8172_tune_chipset(drive, speed); | ||
190 | return ide_dma_enable(drive); | ||
191 | } | ||
192 | |||
193 | static int it8172_config_drive_xfer_rate (ide_drive_t *drive) | ||
194 | { | ||
195 | ide_hwif_t *hwif = HWIF(drive); | ||
196 | struct hd_driveid *id = drive->id; | ||
197 | |||
198 | drive->init_speed = 0; | ||
199 | |||
200 | if (id && (id->capability & 1) && drive->autodma) { | ||
201 | |||
202 | if (ide_use_dma(drive)) { | ||
203 | if (it8172_config_chipset_for_dma(drive)) | ||
204 | return hwif->ide_dma_on(drive); | ||
205 | } | ||
206 | |||
207 | goto fast_ata_pio; | ||
208 | |||
209 | } else if ((id->capability & 8) || (id->field_valid & 2)) { | ||
210 | fast_ata_pio: | ||
211 | it8172_tune_drive(drive, 5); | ||
212 | return hwif->ide_dma_off_quietly(drive); | ||
213 | } | ||
214 | /* IORDY not supported */ | ||
215 | return 0; | ||
216 | } | ||
217 | |||
218 | static unsigned int __devinit init_chipset_it8172 (struct pci_dev *dev, const char *name) | ||
219 | { | ||
220 | unsigned char progif; | ||
221 | |||
222 | /* | ||
223 | * Place both IDE interfaces into PCI "native" mode | ||
224 | */ | ||
225 | pci_read_config_byte(dev, PCI_CLASS_PROG, &progif); | ||
226 | pci_write_config_byte(dev, PCI_CLASS_PROG, progif | 0x05); | ||
227 | |||
228 | return IT8172_IDE_IRQ; | ||
229 | } | ||
230 | |||
231 | |||
232 | static void __devinit init_hwif_it8172 (ide_hwif_t *hwif) | ||
233 | { | ||
234 | struct pci_dev* dev = hwif->pci_dev; | ||
235 | unsigned long cmdBase, ctrlBase; | ||
236 | |||
237 | hwif->autodma = 0; | ||
238 | hwif->tuneproc = &it8172_tune_drive; | ||
239 | hwif->speedproc = &it8172_tune_chipset; | ||
240 | |||
241 | cmdBase = dev->resource[0].start; | ||
242 | ctrlBase = dev->resource[1].start; | ||
243 | |||
244 | ide_init_hwif_ports(&hwif->hw, cmdBase, ctrlBase | 2, NULL); | ||
245 | memcpy(hwif->io_ports, hwif->hw.io_ports, sizeof(hwif->io_ports)); | ||
246 | hwif->noprobe = 0; | ||
247 | |||
248 | if (!hwif->dma_base) { | ||
249 | hwif->drives[0].autotune = 1; | ||
250 | hwif->drives[1].autotune = 1; | ||
251 | return; | ||
252 | } | ||
253 | |||
254 | hwif->atapi_dma = 1; | ||
255 | hwif->ultra_mask = 0x07; | ||
256 | hwif->mwdma_mask = 0x06; | ||
257 | hwif->swdma_mask = 0x04; | ||
258 | |||
259 | hwif->ide_dma_check = &it8172_config_drive_xfer_rate; | ||
260 | if (!noautodma) | ||
261 | hwif->autodma = 1; | ||
262 | hwif->drives[0].autodma = hwif->autodma; | ||
263 | hwif->drives[1].autodma = hwif->autodma; | ||
264 | } | ||
265 | |||
266 | static ide_pci_device_t it8172_chipsets[] __devinitdata = { | ||
267 | { /* 0 */ | ||
268 | .name = "IT8172G", | ||
269 | .init_chipset = init_chipset_it8172, | ||
270 | .init_hwif = init_hwif_it8172, | ||
271 | .channels = 2, | ||
272 | .autodma = AUTODMA, | ||
273 | .enablebits = {{0x00,0x00,0x00}, {0x40,0x00,0x01}}, | ||
274 | .bootable = ON_BOARD, | ||
275 | } | ||
276 | }; | ||
277 | |||
278 | static int __devinit it8172_init_one(struct pci_dev *dev, const struct pci_device_id *id) | ||
279 | { | ||
280 | if ((!(PCI_FUNC(dev->devfn) & 1) || | ||
281 | (!((dev->class >> 8) == PCI_CLASS_STORAGE_IDE)))) | ||
282 | return -ENODEV; /* IT8172 is more than an IDE controller */ | ||
283 | return ide_setup_pci_device(dev, &it8172_chipsets[id->driver_data]); | ||
284 | } | ||
285 | |||
286 | static struct pci_device_id it8172_pci_tbl[] = { | ||
287 | { PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_IT8172G, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, | ||
288 | { 0, }, | ||
289 | }; | ||
290 | MODULE_DEVICE_TABLE(pci, it8172_pci_tbl); | ||
291 | |||
292 | static struct pci_driver driver = { | ||
293 | .name = "IT8172_IDE", | ||
294 | .id_table = it8172_pci_tbl, | ||
295 | .probe = it8172_init_one, | ||
296 | }; | ||
297 | |||
298 | static int it8172_ide_init(void) | ||
299 | { | ||
300 | return ide_pci_register_driver(&driver); | ||
301 | } | ||
302 | |||
303 | module_init(it8172_ide_init); | ||
304 | |||
305 | MODULE_AUTHOR("SteveL@mvista.com"); | ||
306 | MODULE_DESCRIPTION("PCI driver module for ITE 8172 IDE"); | ||
307 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.c b/drivers/media/dvb/dvb-core/dvb_frontend.c index 3dd5dbafb330..53304e6991ac 100644 --- a/drivers/media/dvb/dvb-core/dvb_frontend.c +++ b/drivers/media/dvb/dvb-core/dvb_frontend.c | |||
@@ -1014,6 +1014,13 @@ static int dvb_frontend_open(struct inode *inode, struct file *file) | |||
1014 | if ((ret = dvb_generic_open (inode, file)) < 0) | 1014 | if ((ret = dvb_generic_open (inode, file)) < 0) |
1015 | return ret; | 1015 | return ret; |
1016 | 1016 | ||
1017 | if (fe->ops.ts_bus_ctrl) { | ||
1018 | if ((ret = fe->ops.ts_bus_ctrl (fe, 1)) < 0) { | ||
1019 | dvb_generic_release (inode, file); | ||
1020 | return ret; | ||
1021 | } | ||
1022 | } | ||
1023 | |||
1017 | if ((file->f_flags & O_ACCMODE) != O_RDONLY) { | 1024 | if ((file->f_flags & O_ACCMODE) != O_RDONLY) { |
1018 | 1025 | ||
1019 | /* normal tune mode when opened R/W */ | 1026 | /* normal tune mode when opened R/W */ |
@@ -1043,6 +1050,9 @@ static int dvb_frontend_release(struct inode *inode, struct file *file) | |||
1043 | if ((file->f_flags & O_ACCMODE) != O_RDONLY) | 1050 | if ((file->f_flags & O_ACCMODE) != O_RDONLY) |
1044 | fepriv->release_jiffies = jiffies; | 1051 | fepriv->release_jiffies = jiffies; |
1045 | 1052 | ||
1053 | if (fe->ops.ts_bus_ctrl) | ||
1054 | fe->ops.ts_bus_ctrl (fe, 0); | ||
1055 | |||
1046 | return dvb_generic_release (inode, file); | 1056 | return dvb_generic_release (inode, file); |
1047 | } | 1057 | } |
1048 | 1058 | ||
diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.h b/drivers/media/dvb/dvb-core/dvb_frontend.h index e5d5028b3694..f233d78bc364 100644 --- a/drivers/media/dvb/dvb-core/dvb_frontend.h +++ b/drivers/media/dvb/dvb-core/dvb_frontend.h | |||
@@ -129,6 +129,7 @@ struct dvb_frontend_ops { | |||
129 | int (*enable_high_lnb_voltage)(struct dvb_frontend* fe, long arg); | 129 | int (*enable_high_lnb_voltage)(struct dvb_frontend* fe, long arg); |
130 | int (*dishnetwork_send_legacy_command)(struct dvb_frontend* fe, unsigned long cmd); | 130 | int (*dishnetwork_send_legacy_command)(struct dvb_frontend* fe, unsigned long cmd); |
131 | int (*i2c_gate_ctrl)(struct dvb_frontend* fe, int enable); | 131 | int (*i2c_gate_ctrl)(struct dvb_frontend* fe, int enable); |
132 | int (*ts_bus_ctrl)(struct dvb_frontend* fe, int acquire); | ||
132 | 133 | ||
133 | struct dvb_tuner_ops tuner_ops; | 134 | struct dvb_tuner_ops tuner_ops; |
134 | }; | 135 | }; |
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig index 0a3c35399bea..67cefdd2334a 100644 --- a/drivers/media/dvb/dvb-usb/Kconfig +++ b/drivers/media/dvb/dvb-usb/Kconfig | |||
@@ -39,20 +39,8 @@ config DVB_USB_DIBUSB_MB | |||
39 | Support for USB 1.1 and 2.0 DVB-T receivers based on reference designs made by | 39 | Support for USB 1.1 and 2.0 DVB-T receivers based on reference designs made by |
40 | DiBcom (<http://www.dibcom.fr>) equipped with a DiB3000M-B demodulator. | 40 | DiBcom (<http://www.dibcom.fr>) equipped with a DiB3000M-B demodulator. |
41 | 41 | ||
42 | Devices supported by this driver: | 42 | For an up-to-date list of devices supported by this driver, have a look |
43 | Artec T1 USB1.1 boxes | 43 | on the Linux-DVB Wiki at www.linuxtv.org. |
44 | Avermedia AverTV DVBT USB1.1 | ||
45 | Compro Videomate DVB-U2000 - DVB-T USB | ||
46 | DiBcom USB1.1 reference devices (non-public) | ||
47 | Grandtec DVB-T USB | ||
48 | Hama DVB-T USB1.1-Box | ||
49 | KWorld/JetWay/ADSTech V-Stream XPERT DTV - DVB-T USB1.1 and USB2.0 | ||
50 | TwinhanDTV Magic Box (VP7041e) | ||
51 | TwinhanDTV USB-Ter (VP7041) | ||
52 | Ultima Electronic/Artec T1 USB TVBOX | ||
53 | |||
54 | The VP7041 seems to be identical to "CTS Portable" (Chinese | ||
55 | Television System). | ||
56 | 44 | ||
57 | Say Y if you own such a device and want to use it. You should build it as | 45 | Say Y if you own such a device and want to use it. You should build it as |
58 | a module. | 46 | a module. |
@@ -69,12 +57,29 @@ config DVB_USB_DIBUSB_MC | |||
69 | select DVB_DIB3000MC | 57 | select DVB_DIB3000MC |
70 | select DVB_TUNER_MT2060 | 58 | select DVB_TUNER_MT2060 |
71 | help | 59 | help |
72 | Support for 2.0 DVB-T receivers based on reference designs made by | 60 | Support for USB2.0 DVB-T receivers based on reference designs made by |
73 | DiBcom (<http://www.dibcom.fr>) equipped with a DiB3000M-C/P demodulator. | 61 | DiBcom (<http://www.dibcom.fr>) equipped with a DiB3000M-C/P demodulator. |
74 | 62 | ||
75 | Devices supported by this driver: | 63 | For an up-to-date list of devices supported by this driver, have a look |
76 | Artec T1 USB2.0 boxes | 64 | on the Linux-DVB Wiki at www.linuxtv.org. |
77 | DiBcom USB2.0 reference devices (non-public) | 65 | |
66 | Say Y if you own such a device and want to use it. You should build it as | ||
67 | a module. | ||
68 | |||
69 | config DVB_USB_DIB0700 | ||
70 | tristate "DiBcom DiB0700 USB DVB devices (see help for supported devices)" | ||
71 | depends on DVB_USB | ||
72 | select DVB_DIB7000M | ||
73 | select DVB_DIB3000MC | ||
74 | select DVB_TUNER_MT2060 | ||
75 | help | ||
76 | Support for USB2.0/1.1 DVB receivers based on the DiB0700 USB bridge. The | ||
77 | USB bridge is also present in devices having the DiB7700 DVB-T-USB | ||
78 | silicon. This chip can be found in devices offered by Hauppauge, | ||
79 | Avermedia and other big and small companies. | ||
80 | |||
81 | For an up-to-date list of devices supported by this driver, have a look | ||
82 | on the Linux-DVB Wiki at www.linuxtv.org. | ||
78 | 83 | ||
79 | Say Y if you own such a device and want to use it. You should build it as | 84 | Say Y if you own such a device and want to use it. You should build it as |
80 | a module. | 85 | a module. |
diff --git a/drivers/media/dvb/dvb-usb/Makefile b/drivers/media/dvb/dvb-usb/Makefile index 9643f56c7fe9..e239107998e5 100644 --- a/drivers/media/dvb/dvb-usb/Makefile +++ b/drivers/media/dvb/dvb-usb/Makefile | |||
@@ -1,4 +1,4 @@ | |||
1 | dvb-usb-objs = dvb-usb-firmware.o dvb-usb-init.o dvb-usb-urb.o dvb-usb-i2c.o dvb-usb-dvb.o dvb-usb-remote.o | 1 | dvb-usb-objs = dvb-usb-firmware.o dvb-usb-init.o dvb-usb-urb.o dvb-usb-i2c.o dvb-usb-dvb.o dvb-usb-remote.o usb-urb.o |
2 | obj-$(CONFIG_DVB_USB) += dvb-usb.o | 2 | obj-$(CONFIG_DVB_USB) += dvb-usb.o |
3 | 3 | ||
4 | dvb-usb-vp7045-objs = vp7045.o vp7045-fe.o | 4 | dvb-usb-vp7045-objs = vp7045.o vp7045-fe.o |
@@ -36,4 +36,7 @@ obj-$(CONFIG_DVB_USB_DIGITV) += dvb-usb-digitv.o | |||
36 | dvb-usb-cxusb-objs = cxusb.o | 36 | dvb-usb-cxusb-objs = cxusb.o |
37 | obj-$(CONFIG_DVB_USB_CXUSB) += dvb-usb-cxusb.o | 37 | obj-$(CONFIG_DVB_USB_CXUSB) += dvb-usb-cxusb.o |
38 | 38 | ||
39 | dvb-usb-dib0700-objs = dib0700_core.o dib0700_devices.o | ||
40 | obj-$(CONFIG_DVB_USB_DIB0700) += dvb-usb-dib0700.o | ||
41 | |||
39 | EXTRA_CFLAGS = -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/ | 42 | EXTRA_CFLAGS = -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/ |
diff --git a/drivers/media/dvb/dvb-usb/a800.c b/drivers/media/dvb/dvb-usb/a800.c index df0c384bd4ca..2ed3eb62d787 100644 --- a/drivers/media/dvb/dvb-usb/a800.c +++ b/drivers/media/dvb/dvb-usb/a800.c | |||
@@ -27,7 +27,8 @@ static int a800_power_ctrl(struct dvb_usb_device *d, int onoff) | |||
27 | } | 27 | } |
28 | 28 | ||
29 | /* assure to put cold to 0 for iManufacturer == 1 */ | 29 | /* assure to put cold to 0 for iManufacturer == 1 */ |
30 | static int a800_identify_state(struct usb_device *udev, struct dvb_usb_properties *props,struct dvb_usb_device_description **desc, int *cold) | 30 | static int a800_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props, |
31 | struct dvb_usb_device_description **desc, int *cold) | ||
31 | { | 32 | { |
32 | *cold = udev->descriptor.iManufacturer != 1; | 33 | *cold = udev->descriptor.iManufacturer != 1; |
33 | return 0; | 34 | return 0; |
@@ -88,7 +89,7 @@ static int a800_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |||
88 | } | 89 | } |
89 | 90 | ||
90 | /* USB Driver stuff */ | 91 | /* USB Driver stuff */ |
91 | static struct dvb_usb_properties a800_properties; | 92 | static struct dvb_usb_device_properties a800_properties; |
92 | 93 | ||
93 | static int a800_probe(struct usb_interface *intf, | 94 | static int a800_probe(struct usb_interface *intf, |
94 | const struct usb_device_id *id) | 95 | const struct usb_device_id *id) |
@@ -104,35 +105,27 @@ static struct usb_device_id a800_table [] = { | |||
104 | }; | 105 | }; |
105 | MODULE_DEVICE_TABLE (usb, a800_table); | 106 | MODULE_DEVICE_TABLE (usb, a800_table); |
106 | 107 | ||
107 | static struct dvb_usb_properties a800_properties = { | 108 | static struct dvb_usb_device_properties a800_properties = { |
108 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 109 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
109 | .pid_filter_count = 32, | ||
110 | 110 | ||
111 | .usb_ctrl = CYPRESS_FX2, | 111 | .usb_ctrl = CYPRESS_FX2, |
112 | |||
113 | .firmware = "dvb-usb-avertv-a800-02.fw", | 112 | .firmware = "dvb-usb-avertv-a800-02.fw", |
114 | 113 | ||
115 | .size_of_priv = sizeof(struct dibusb_state), | 114 | .num_adapters = 1, |
116 | 115 | .adapter = { | |
116 | { | ||
117 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | ||
118 | .pid_filter_count = 32, | ||
117 | .streaming_ctrl = dibusb2_0_streaming_ctrl, | 119 | .streaming_ctrl = dibusb2_0_streaming_ctrl, |
118 | .pid_filter = dibusb_pid_filter, | 120 | .pid_filter = dibusb_pid_filter, |
119 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 121 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
120 | .power_ctrl = a800_power_ctrl, | 122 | |
121 | .frontend_attach = dibusb_dib3000mc_frontend_attach, | 123 | .frontend_attach = dibusb_dib3000mc_frontend_attach, |
122 | .tuner_attach = dibusb_dib3000mc_tuner_attach, | 124 | .tuner_attach = dibusb_dib3000mc_tuner_attach, |
123 | .identify_state = a800_identify_state, | ||
124 | |||
125 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
126 | .rc_key_map = a800_rc_keys, | ||
127 | .rc_key_map_size = ARRAY_SIZE(a800_rc_keys), | ||
128 | .rc_query = a800_rc_query, | ||
129 | 125 | ||
130 | .i2c_algo = &dibusb_i2c_algo, | ||
131 | |||
132 | .generic_bulk_ctrl_endpoint = 0x01, | ||
133 | /* parameter for the MPEG2-data transfer */ | 126 | /* parameter for the MPEG2-data transfer */ |
134 | .urb = { | 127 | .stream = { |
135 | .type = DVB_USB_BULK, | 128 | .type = USB_BULK, |
136 | .count = 7, | 129 | .count = 7, |
137 | .endpoint = 0x06, | 130 | .endpoint = 0x06, |
138 | .u = { | 131 | .u = { |
@@ -142,6 +135,21 @@ static struct dvb_usb_properties a800_properties = { | |||
142 | } | 135 | } |
143 | }, | 136 | }, |
144 | 137 | ||
138 | .size_of_priv = sizeof(struct dibusb_state), | ||
139 | }, | ||
140 | }, | ||
141 | |||
142 | .power_ctrl = a800_power_ctrl, | ||
143 | .identify_state = a800_identify_state, | ||
144 | |||
145 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
146 | .rc_key_map = a800_rc_keys, | ||
147 | .rc_key_map_size = ARRAY_SIZE(a800_rc_keys), | ||
148 | .rc_query = a800_rc_query, | ||
149 | |||
150 | .i2c_algo = &dibusb_i2c_algo, | ||
151 | |||
152 | .generic_bulk_ctrl_endpoint = 0x01, | ||
145 | .num_device_descs = 1, | 153 | .num_device_descs = 1, |
146 | .devices = { | 154 | .devices = { |
147 | { "AVerMedia AverTV DVB-T USB 2.0 (A800)", | 155 | { "AVerMedia AverTV DVB-T USB 2.0 (A800)", |
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c index c710c0176e07..43f39069ef34 100644 --- a/drivers/media/dvb/dvb-usb/cxusb.c +++ b/drivers/media/dvb/dvb-usb/cxusb.c | |||
@@ -161,13 +161,13 @@ static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff) | |||
161 | return 0; | 161 | return 0; |
162 | } | 162 | } |
163 | 163 | ||
164 | static int cxusb_streaming_ctrl(struct dvb_usb_device *d, int onoff) | 164 | static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) |
165 | { | 165 | { |
166 | u8 buf[2] = { 0x03, 0x00 }; | 166 | u8 buf[2] = { 0x03, 0x00 }; |
167 | if (onoff) | 167 | if (onoff) |
168 | cxusb_ctrl_msg(d,CMD_STREAMING_ON, buf, 2, NULL, 0); | 168 | cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0); |
169 | else | 169 | else |
170 | cxusb_ctrl_msg(d,CMD_STREAMING_OFF, NULL, 0, NULL, 0); | 170 | cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0); |
171 | 171 | ||
172 | return 0; | 172 | return 0; |
173 | } | 173 | } |
@@ -327,8 +327,8 @@ static int cxusb_mt352_demod_init(struct dvb_frontend* fe) | |||
327 | static int cxusb_lgh064f_tuner_set_params(struct dvb_frontend *fe, | 327 | static int cxusb_lgh064f_tuner_set_params(struct dvb_frontend *fe, |
328 | struct dvb_frontend_parameters *fep) | 328 | struct dvb_frontend_parameters *fep) |
329 | { | 329 | { |
330 | struct dvb_usb_device *d = fe->dvb->priv; | 330 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
331 | return lg_h06xf_pll_set(fe, &d->i2c_adap, fep); | 331 | return lg_h06xf_pll_set(fe, &adap->dev->i2c_adap, fep); |
332 | } | 332 | } |
333 | 333 | ||
334 | static struct cx22702_config cxusb_cx22702_config = { | 334 | static struct cx22702_config cxusb_cx22702_config = { |
@@ -359,98 +359,99 @@ static struct mt352_config cxusb_mt352_config = { | |||
359 | }; | 359 | }; |
360 | 360 | ||
361 | /* Callbacks for DVB USB */ | 361 | /* Callbacks for DVB USB */ |
362 | static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_device *d) | 362 | static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap) |
363 | { | 363 | { |
364 | u8 bpll[4] = { 0x0b, 0xdc, 0x9c, 0xa0 }; | 364 | u8 bpll[4] = { 0x0b, 0xdc, 0x9c, 0xa0 }; |
365 | d->pll_addr = 0x61; | 365 | adap->pll_addr = 0x61; |
366 | memcpy(d->pll_init, bpll, 4); | 366 | memcpy(adap->pll_init, bpll, 4); |
367 | d->pll_desc = &dvb_pll_fmd1216me; | 367 | adap->pll_desc = &dvb_pll_fmd1216me; |
368 | 368 | ||
369 | d->fe->ops.tuner_ops.init = dvb_usb_tuner_init_i2c; | 369 | adap->fe->ops.tuner_ops.init = dvb_usb_tuner_init_i2c; |
370 | d->fe->ops.tuner_ops.set_params = dvb_usb_tuner_set_params_i2c; | 370 | adap->fe->ops.tuner_ops.set_params = dvb_usb_tuner_set_params_i2c; |
371 | 371 | ||
372 | return 0; | 372 | return 0; |
373 | } | 373 | } |
374 | 374 | ||
375 | static int cxusb_dee1601_tuner_attach(struct dvb_usb_device *d) | 375 | static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap) |
376 | { | 376 | { |
377 | d->pll_addr = 0x61; | 377 | adap->pll_addr = 0x61; |
378 | d->pll_desc = &dvb_pll_thomson_dtt7579; | 378 | adap->pll_desc = &dvb_pll_thomson_dtt7579; |
379 | d->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; | 379 | adap->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; |
380 | return 0; | 380 | return 0; |
381 | } | 381 | } |
382 | 382 | ||
383 | static int cxusb_lgz201_tuner_attach(struct dvb_usb_device *d) | 383 | static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap) |
384 | { | 384 | { |
385 | d->pll_addr = 0x61; | 385 | adap->pll_addr = 0x61; |
386 | d->pll_desc = &dvb_pll_lg_z201; | 386 | adap->pll_desc = &dvb_pll_lg_z201; |
387 | d->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; | 387 | adap->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; |
388 | return 0; | 388 | return 0; |
389 | } | 389 | } |
390 | 390 | ||
391 | static int cxusb_dtt7579_tuner_attach(struct dvb_usb_device *d) | 391 | static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap) |
392 | { | 392 | { |
393 | d->pll_addr = 0x60; | 393 | adap->pll_addr = 0x60; |
394 | d->pll_desc = &dvb_pll_thomson_dtt7579; | 394 | adap->pll_desc = &dvb_pll_thomson_dtt7579; |
395 | d->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; | 395 | adap->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; |
396 | return 0; | 396 | return 0; |
397 | } | 397 | } |
398 | 398 | ||
399 | static int cxusb_lgdt3303_tuner_attach(struct dvb_usb_device *d) | 399 | static int cxusb_lgdt3303_tuner_attach(struct dvb_usb_adapter *adap) |
400 | { | 400 | { |
401 | d->fe->ops.tuner_ops.set_params = cxusb_lgh064f_tuner_set_params; | 401 | adap->fe->ops.tuner_ops.set_params = cxusb_lgh064f_tuner_set_params; |
402 | return 0; | 402 | return 0; |
403 | } | 403 | } |
404 | 404 | ||
405 | static int cxusb_cx22702_frontend_attach(struct dvb_usb_device *d) | 405 | static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap) |
406 | { | 406 | { |
407 | u8 b; | 407 | u8 b; |
408 | if (usb_set_interface(d->udev,0,6) < 0) | 408 | if (usb_set_interface(adap->dev->udev, 0, 6) < 0) |
409 | err("set interface failed"); | 409 | err("set interface failed"); |
410 | 410 | ||
411 | cxusb_ctrl_msg(d,CMD_DIGITAL, NULL, 0, &b, 1); | 411 | cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1); |
412 | 412 | ||
413 | if ((d->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config, &d->i2c_adap)) != NULL) | 413 | if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config, &adap->dev->i2c_adap)) != NULL) |
414 | return 0; | 414 | return 0; |
415 | 415 | ||
416 | return -EIO; | 416 | return -EIO; |
417 | } | 417 | } |
418 | 418 | ||
419 | static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_device *d) | 419 | static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap) |
420 | { | 420 | { |
421 | if (usb_set_interface(d->udev,0,7) < 0) | 421 | if (usb_set_interface(adap->dev->udev, 0, 7) < 0) |
422 | err("set interface failed"); | 422 | err("set interface failed"); |
423 | 423 | ||
424 | cxusb_ctrl_msg(d,CMD_DIGITAL, NULL, 0, NULL, 0); | 424 | cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); |
425 | 425 | ||
426 | if ((d->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config, &d->i2c_adap)) != NULL) | 426 | if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config, &adap->dev->i2c_adap)) != NULL) |
427 | return 0; | 427 | return 0; |
428 | 428 | ||
429 | return -EIO; | 429 | return -EIO; |
430 | } | 430 | } |
431 | 431 | ||
432 | static int cxusb_mt352_frontend_attach(struct dvb_usb_device *d) | 432 | static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap) |
433 | { /* used in both lgz201 and th7579 */ | 433 | { |
434 | if (usb_set_interface(d->udev,0,0) < 0) | 434 | /* used in both lgz201 and th7579 */ |
435 | if (usb_set_interface(adap->dev->udev, 0, 0) < 0) | ||
435 | err("set interface failed"); | 436 | err("set interface failed"); |
436 | 437 | ||
437 | cxusb_ctrl_msg(d,CMD_DIGITAL, NULL, 0, NULL, 0); | 438 | cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); |
438 | 439 | ||
439 | if ((d->fe = dvb_attach(mt352_attach, &cxusb_mt352_config, &d->i2c_adap)) != NULL) | 440 | if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config, &adap->dev->i2c_adap)) != NULL) |
440 | return 0; | 441 | return 0; |
441 | 442 | ||
442 | return -EIO; | 443 | return -EIO; |
443 | } | 444 | } |
444 | 445 | ||
445 | static int cxusb_dee1601_frontend_attach(struct dvb_usb_device *d) | 446 | static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap) |
446 | { | 447 | { |
447 | if (usb_set_interface(d->udev,0,0) < 0) | 448 | if (usb_set_interface(adap->dev->udev, 0, 0) < 0) |
448 | err("set interface failed"); | 449 | err("set interface failed"); |
449 | 450 | ||
450 | cxusb_ctrl_msg(d,CMD_DIGITAL, NULL, 0, NULL, 0); | 451 | cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); |
451 | 452 | ||
452 | if (((d->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config, &d->i2c_adap)) != NULL) || | 453 | if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config, &adap->dev->i2c_adap)) != NULL) || |
453 | ((d->fe = dvb_attach(zl10353_attach, &cxusb_zl10353_dee1601_config, &d->i2c_adap)) != NULL)) | 454 | ((adap->fe = dvb_attach(zl10353_attach, &cxusb_zl10353_dee1601_config, &adap->dev->i2c_adap)) != NULL)) |
454 | return 0; | 455 | return 0; |
455 | 456 | ||
456 | return -EIO; | 457 | return -EIO; |
@@ -480,11 +481,11 @@ static int bluebird_patch_dvico_firmware_download(struct usb_device *udev, const | |||
480 | } | 481 | } |
481 | 482 | ||
482 | /* DVB USB Driver stuff */ | 483 | /* DVB USB Driver stuff */ |
483 | static struct dvb_usb_properties cxusb_medion_properties; | 484 | static struct dvb_usb_device_properties cxusb_medion_properties; |
484 | static struct dvb_usb_properties cxusb_bluebird_lgh064f_properties; | 485 | static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties; |
485 | static struct dvb_usb_properties cxusb_bluebird_dee1601_properties; | 486 | static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties; |
486 | static struct dvb_usb_properties cxusb_bluebird_lgz201_properties; | 487 | static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties; |
487 | static struct dvb_usb_properties cxusb_bluebird_dtt7579_properties; | 488 | static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties; |
488 | 489 | ||
489 | static int cxusb_probe(struct usb_interface *intf, | 490 | static int cxusb_probe(struct usb_interface *intf, |
490 | const struct usb_device_id *id) | 491 | const struct usb_device_id *id) |
@@ -504,36 +505,36 @@ static struct usb_device_id cxusb_table [] = { | |||
504 | { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) }, | 505 | { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) }, |
505 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) }, | 506 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) }, |
506 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) }, | 507 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) }, |
507 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DEE1601_COLD) }, | 508 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) }, |
508 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DEE1601_WARM) }, | 509 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) }, |
509 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) }, | 510 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) }, |
510 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) }, | 511 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) }, |
511 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) }, | 512 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) }, |
512 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) }, | 513 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) }, |
513 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DEE1601_COLD) }, | 514 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) }, |
514 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DEE1601_WARM) }, | 515 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) }, |
516 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) }, | ||
517 | { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) }, | ||
515 | {} /* Terminating entry */ | 518 | {} /* Terminating entry */ |
516 | }; | 519 | }; |
517 | MODULE_DEVICE_TABLE (usb, cxusb_table); | 520 | MODULE_DEVICE_TABLE (usb, cxusb_table); |
518 | 521 | ||
519 | static struct dvb_usb_properties cxusb_medion_properties = { | 522 | static struct dvb_usb_device_properties cxusb_medion_properties = { |
520 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 523 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
521 | 524 | ||
522 | .usb_ctrl = CYPRESS_FX2, | 525 | .usb_ctrl = CYPRESS_FX2, |
523 | 526 | ||
524 | .size_of_priv = sizeof(struct cxusb_state), | 527 | .size_of_priv = sizeof(struct cxusb_state), |
525 | 528 | ||
529 | .num_adapters = 1, | ||
530 | .adapter = { | ||
531 | { | ||
526 | .streaming_ctrl = cxusb_streaming_ctrl, | 532 | .streaming_ctrl = cxusb_streaming_ctrl, |
527 | .power_ctrl = cxusb_power_ctrl, | ||
528 | .frontend_attach = cxusb_cx22702_frontend_attach, | 533 | .frontend_attach = cxusb_cx22702_frontend_attach, |
529 | .tuner_attach = cxusb_fmd1216me_tuner_attach, | 534 | .tuner_attach = cxusb_fmd1216me_tuner_attach, |
530 | |||
531 | .i2c_algo = &cxusb_i2c_algo, | ||
532 | |||
533 | .generic_bulk_ctrl_endpoint = 0x01, | ||
534 | /* parameter for the MPEG2-data transfer */ | 535 | /* parameter for the MPEG2-data transfer */ |
535 | .urb = { | 536 | .stream = { |
536 | .type = DVB_USB_BULK, | 537 | .type = USB_BULK, |
537 | .count = 5, | 538 | .count = 5, |
538 | .endpoint = 0x02, | 539 | .endpoint = 0x02, |
539 | .u = { | 540 | .u = { |
@@ -543,6 +544,14 @@ static struct dvb_usb_properties cxusb_medion_properties = { | |||
543 | } | 544 | } |
544 | }, | 545 | }, |
545 | 546 | ||
547 | }, | ||
548 | }, | ||
549 | .power_ctrl = cxusb_power_ctrl, | ||
550 | |||
551 | .i2c_algo = &cxusb_i2c_algo, | ||
552 | |||
553 | .generic_bulk_ctrl_endpoint = 0x01, | ||
554 | |||
546 | .num_device_descs = 1, | 555 | .num_device_descs = 1, |
547 | .devices = { | 556 | .devices = { |
548 | { "Medion MD95700 (MDUSBTV-HYBRID)", | 557 | { "Medion MD95700 (MDUSBTV-HYBRID)", |
@@ -552,7 +561,7 @@ static struct dvb_usb_properties cxusb_medion_properties = { | |||
552 | } | 561 | } |
553 | }; | 562 | }; |
554 | 563 | ||
555 | static struct dvb_usb_properties cxusb_bluebird_lgh064f_properties = { | 564 | static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = { |
556 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 565 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
557 | 566 | ||
558 | .usb_ctrl = DEVICE_SPECIFIC, | 567 | .usb_ctrl = DEVICE_SPECIFIC, |
@@ -563,22 +572,16 @@ static struct dvb_usb_properties cxusb_bluebird_lgh064f_properties = { | |||
563 | 572 | ||
564 | .size_of_priv = sizeof(struct cxusb_state), | 573 | .size_of_priv = sizeof(struct cxusb_state), |
565 | 574 | ||
575 | .num_adapters = 1, | ||
576 | .adapter = { | ||
577 | { | ||
566 | .streaming_ctrl = cxusb_streaming_ctrl, | 578 | .streaming_ctrl = cxusb_streaming_ctrl, |
567 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
568 | .frontend_attach = cxusb_lgdt3303_frontend_attach, | 579 | .frontend_attach = cxusb_lgdt3303_frontend_attach, |
569 | .tuner_attach = cxusb_lgdt3303_tuner_attach, | 580 | .tuner_attach = cxusb_lgdt3303_tuner_attach, |
570 | 581 | ||
571 | .i2c_algo = &cxusb_i2c_algo, | ||
572 | |||
573 | .rc_interval = 100, | ||
574 | .rc_key_map = dvico_portable_rc_keys, | ||
575 | .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys), | ||
576 | .rc_query = cxusb_rc_query, | ||
577 | |||
578 | .generic_bulk_ctrl_endpoint = 0x01, | ||
579 | /* parameter for the MPEG2-data transfer */ | 582 | /* parameter for the MPEG2-data transfer */ |
580 | .urb = { | 583 | .stream = { |
581 | .type = DVB_USB_BULK, | 584 | .type = USB_BULK, |
582 | .count = 5, | 585 | .count = 5, |
583 | .endpoint = 0x02, | 586 | .endpoint = 0x02, |
584 | .u = { | 587 | .u = { |
@@ -587,6 +590,19 @@ static struct dvb_usb_properties cxusb_bluebird_lgh064f_properties = { | |||
587 | } | 590 | } |
588 | } | 591 | } |
589 | }, | 592 | }, |
593 | }, | ||
594 | }, | ||
595 | |||
596 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
597 | |||
598 | .i2c_algo = &cxusb_i2c_algo, | ||
599 | |||
600 | .rc_interval = 100, | ||
601 | .rc_key_map = dvico_portable_rc_keys, | ||
602 | .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys), | ||
603 | .rc_query = cxusb_rc_query, | ||
604 | |||
605 | .generic_bulk_ctrl_endpoint = 0x01, | ||
590 | 606 | ||
591 | .num_device_descs = 1, | 607 | .num_device_descs = 1, |
592 | .devices = { | 608 | .devices = { |
@@ -597,7 +613,7 @@ static struct dvb_usb_properties cxusb_bluebird_lgh064f_properties = { | |||
597 | } | 613 | } |
598 | }; | 614 | }; |
599 | 615 | ||
600 | static struct dvb_usb_properties cxusb_bluebird_dee1601_properties = { | 616 | static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = { |
601 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 617 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
602 | 618 | ||
603 | .usb_ctrl = DEVICE_SPECIFIC, | 619 | .usb_ctrl = DEVICE_SPECIFIC, |
@@ -608,22 +624,15 @@ static struct dvb_usb_properties cxusb_bluebird_dee1601_properties = { | |||
608 | 624 | ||
609 | .size_of_priv = sizeof(struct cxusb_state), | 625 | .size_of_priv = sizeof(struct cxusb_state), |
610 | 626 | ||
627 | .num_adapters = 1, | ||
628 | .adapter = { | ||
629 | { | ||
611 | .streaming_ctrl = cxusb_streaming_ctrl, | 630 | .streaming_ctrl = cxusb_streaming_ctrl, |
612 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
613 | .frontend_attach = cxusb_dee1601_frontend_attach, | 631 | .frontend_attach = cxusb_dee1601_frontend_attach, |
614 | .tuner_attach = cxusb_dee1601_tuner_attach, | 632 | .tuner_attach = cxusb_dee1601_tuner_attach, |
615 | |||
616 | .i2c_algo = &cxusb_i2c_algo, | ||
617 | |||
618 | .rc_interval = 150, | ||
619 | .rc_key_map = dvico_mce_rc_keys, | ||
620 | .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys), | ||
621 | .rc_query = cxusb_rc_query, | ||
622 | |||
623 | .generic_bulk_ctrl_endpoint = 0x01, | ||
624 | /* parameter for the MPEG2-data transfer */ | 633 | /* parameter for the MPEG2-data transfer */ |
625 | .urb = { | 634 | .stream = { |
626 | .type = DVB_USB_BULK, | 635 | .type = USB_BULK, |
627 | .count = 5, | 636 | .count = 5, |
628 | .endpoint = 0x04, | 637 | .endpoint = 0x04, |
629 | .u = { | 638 | .u = { |
@@ -632,8 +641,21 @@ static struct dvb_usb_properties cxusb_bluebird_dee1601_properties = { | |||
632 | } | 641 | } |
633 | } | 642 | } |
634 | }, | 643 | }, |
644 | }, | ||
645 | }, | ||
646 | |||
647 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
635 | 648 | ||
636 | .num_device_descs = 2, | 649 | .i2c_algo = &cxusb_i2c_algo, |
650 | |||
651 | .rc_interval = 150, | ||
652 | .rc_key_map = dvico_mce_rc_keys, | ||
653 | .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys), | ||
654 | .rc_query = cxusb_rc_query, | ||
655 | |||
656 | .generic_bulk_ctrl_endpoint = 0x01, | ||
657 | |||
658 | .num_device_descs = 3, | ||
637 | .devices = { | 659 | .devices = { |
638 | { "DViCO FusionHDTV DVB-T Dual USB", | 660 | { "DViCO FusionHDTV DVB-T Dual USB", |
639 | { &cxusb_table[3], NULL }, | 661 | { &cxusb_table[3], NULL }, |
@@ -643,10 +665,14 @@ static struct dvb_usb_properties cxusb_bluebird_dee1601_properties = { | |||
643 | { &cxusb_table[9], NULL }, | 665 | { &cxusb_table[9], NULL }, |
644 | { &cxusb_table[10], NULL }, | 666 | { &cxusb_table[10], NULL }, |
645 | }, | 667 | }, |
668 | { "DViCO FusionHDTV DVB-T Dual Digital 2", | ||
669 | { &cxusb_table[11], NULL }, | ||
670 | { &cxusb_table[12], NULL }, | ||
671 | }, | ||
646 | } | 672 | } |
647 | }; | 673 | }; |
648 | 674 | ||
649 | static struct dvb_usb_properties cxusb_bluebird_lgz201_properties = { | 675 | static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = { |
650 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 676 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
651 | 677 | ||
652 | .usb_ctrl = DEVICE_SPECIFIC, | 678 | .usb_ctrl = DEVICE_SPECIFIC, |
@@ -657,22 +683,16 @@ static struct dvb_usb_properties cxusb_bluebird_lgz201_properties = { | |||
657 | 683 | ||
658 | .size_of_priv = sizeof(struct cxusb_state), | 684 | .size_of_priv = sizeof(struct cxusb_state), |
659 | 685 | ||
686 | .num_adapters = 2, | ||
687 | .adapter = { | ||
688 | { | ||
660 | .streaming_ctrl = cxusb_streaming_ctrl, | 689 | .streaming_ctrl = cxusb_streaming_ctrl, |
661 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
662 | .frontend_attach = cxusb_mt352_frontend_attach, | 690 | .frontend_attach = cxusb_mt352_frontend_attach, |
663 | .tuner_attach = cxusb_lgz201_tuner_attach, | 691 | .tuner_attach = cxusb_lgz201_tuner_attach, |
664 | 692 | ||
665 | .i2c_algo = &cxusb_i2c_algo, | ||
666 | |||
667 | .rc_interval = 100, | ||
668 | .rc_key_map = dvico_portable_rc_keys, | ||
669 | .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys), | ||
670 | .rc_query = cxusb_rc_query, | ||
671 | |||
672 | .generic_bulk_ctrl_endpoint = 0x01, | ||
673 | /* parameter for the MPEG2-data transfer */ | 693 | /* parameter for the MPEG2-data transfer */ |
674 | .urb = { | 694 | .stream = { |
675 | .type = DVB_USB_BULK, | 695 | .type = USB_BULK, |
676 | .count = 5, | 696 | .count = 5, |
677 | .endpoint = 0x04, | 697 | .endpoint = 0x04, |
678 | .u = { | 698 | .u = { |
@@ -681,7 +701,18 @@ static struct dvb_usb_properties cxusb_bluebird_lgz201_properties = { | |||
681 | } | 701 | } |
682 | } | 702 | } |
683 | }, | 703 | }, |
704 | }, | ||
705 | }, | ||
706 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
707 | |||
708 | .i2c_algo = &cxusb_i2c_algo, | ||
684 | 709 | ||
710 | .rc_interval = 100, | ||
711 | .rc_key_map = dvico_portable_rc_keys, | ||
712 | .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys), | ||
713 | .rc_query = cxusb_rc_query, | ||
714 | |||
715 | .generic_bulk_ctrl_endpoint = 0x01, | ||
685 | .num_device_descs = 1, | 716 | .num_device_descs = 1, |
686 | .devices = { | 717 | .devices = { |
687 | { "DViCO FusionHDTV DVB-T USB (LGZ201)", | 718 | { "DViCO FusionHDTV DVB-T USB (LGZ201)", |
@@ -691,7 +722,7 @@ static struct dvb_usb_properties cxusb_bluebird_lgz201_properties = { | |||
691 | } | 722 | } |
692 | }; | 723 | }; |
693 | 724 | ||
694 | static struct dvb_usb_properties cxusb_bluebird_dtt7579_properties = { | 725 | static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = { |
695 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 726 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
696 | 727 | ||
697 | .usb_ctrl = DEVICE_SPECIFIC, | 728 | .usb_ctrl = DEVICE_SPECIFIC, |
@@ -702,22 +733,16 @@ static struct dvb_usb_properties cxusb_bluebird_dtt7579_properties = { | |||
702 | 733 | ||
703 | .size_of_priv = sizeof(struct cxusb_state), | 734 | .size_of_priv = sizeof(struct cxusb_state), |
704 | 735 | ||
736 | .num_adapters = 1, | ||
737 | .adapter = { | ||
738 | { | ||
705 | .streaming_ctrl = cxusb_streaming_ctrl, | 739 | .streaming_ctrl = cxusb_streaming_ctrl, |
706 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
707 | .frontend_attach = cxusb_mt352_frontend_attach, | 740 | .frontend_attach = cxusb_mt352_frontend_attach, |
708 | .tuner_attach = cxusb_dtt7579_tuner_attach, | 741 | .tuner_attach = cxusb_dtt7579_tuner_attach, |
709 | 742 | ||
710 | .i2c_algo = &cxusb_i2c_algo, | ||
711 | |||
712 | .rc_interval = 100, | ||
713 | .rc_key_map = dvico_portable_rc_keys, | ||
714 | .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys), | ||
715 | .rc_query = cxusb_rc_query, | ||
716 | |||
717 | .generic_bulk_ctrl_endpoint = 0x01, | ||
718 | /* parameter for the MPEG2-data transfer */ | 743 | /* parameter for the MPEG2-data transfer */ |
719 | .urb = { | 744 | .stream = { |
720 | .type = DVB_USB_BULK, | 745 | .type = USB_BULK, |
721 | .count = 5, | 746 | .count = 5, |
722 | .endpoint = 0x04, | 747 | .endpoint = 0x04, |
723 | .u = { | 748 | .u = { |
@@ -726,6 +751,18 @@ static struct dvb_usb_properties cxusb_bluebird_dtt7579_properties = { | |||
726 | } | 751 | } |
727 | } | 752 | } |
728 | }, | 753 | }, |
754 | }, | ||
755 | }, | ||
756 | .power_ctrl = cxusb_bluebird_power_ctrl, | ||
757 | |||
758 | .i2c_algo = &cxusb_i2c_algo, | ||
759 | |||
760 | .rc_interval = 100, | ||
761 | .rc_key_map = dvico_portable_rc_keys, | ||
762 | .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys), | ||
763 | .rc_query = cxusb_rc_query, | ||
764 | |||
765 | .generic_bulk_ctrl_endpoint = 0x01, | ||
729 | 766 | ||
730 | .num_device_descs = 1, | 767 | .num_device_descs = 1, |
731 | .devices = { | 768 | .devices = { |
diff --git a/drivers/media/dvb/dvb-usb/dib0700.h b/drivers/media/dvb/dvb-usb/dib0700.h new file mode 100644 index 000000000000..ac84347f9d4c --- /dev/null +++ b/drivers/media/dvb/dvb-usb/dib0700.h | |||
@@ -0,0 +1,49 @@ | |||
1 | /* Linux driver for devices based on the DiBcom DiB0700 USB bridge | ||
2 | * | ||
3 | * This program is free software; you can redistribute it and/or modify it | ||
4 | * under the terms of the GNU General Public License as published by the Free | ||
5 | * Software Foundation, version 2. | ||
6 | * | ||
7 | * Copyright (C) 2005-6 DiBcom, SA | ||
8 | */ | ||
9 | #ifndef _DIB0700_H_ | ||
10 | #define _DIB0700_H_ | ||
11 | |||
12 | #define DVB_USB_LOG_PREFIX "dib0700" | ||
13 | #include "dvb-usb.h" | ||
14 | |||
15 | #include "dib07x0.h" | ||
16 | |||
17 | extern int dvb_usb_dib0700_debug; | ||
18 | #define deb_info(args...) dprintk(dvb_usb_dib0700_debug,0x01,args) | ||
19 | #define deb_fw(args...) dprintk(dvb_usb_dib0700_debug,0x02,args) | ||
20 | #define deb_fwdata(args...) dprintk(dvb_usb_dib0700_debug,0x04,args) | ||
21 | #define deb_data(args...) dprintk(dvb_usb_dib0700_debug,0x08,args) | ||
22 | |||
23 | #define REQUEST_I2C_READ 0x2 | ||
24 | #define REQUEST_I2C_WRITE 0x3 | ||
25 | #define REQUEST_POLL_RC 0x4 | ||
26 | #define REQUEST_JUMPRAM 0x8 | ||
27 | #define REQUEST_SET_GPIO 0xC | ||
28 | #define REQUEST_ENABLE_VIDEO 0xF | ||
29 | // 1 Byte: 4MSB(1 = enable streaming, 0 = disable streaming) 4LSB(Video Mode: 0 = MPEG2 188Bytes, 1 = Analog) | ||
30 | // 2 Byte: MPEG2 mode: 4MSB(1 = Master Mode, 0 = Slave Mode) 4LSB(Channel 1 = bit0, Channel 2 = bit1) | ||
31 | // 2 Byte: Analog mode: 4MSB(0 = 625 lines, 1 = 525 lines) 4LSB( " " ) | ||
32 | |||
33 | struct dib0700_state { | ||
34 | u8 channel_state; | ||
35 | u16 mt2060_if1[2]; | ||
36 | }; | ||
37 | |||
38 | extern int dib0700_set_gpio(struct dvb_usb_device *, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val); | ||
39 | extern int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw); | ||
40 | extern int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff); | ||
41 | extern struct i2c_algorithm dib0700_i2c_algo; | ||
42 | extern int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props, | ||
43 | struct dvb_usb_device_description **desc, int *cold); | ||
44 | |||
45 | extern int dib0700_device_count; | ||
46 | extern struct dvb_usb_device_properties dib0700_devices[]; | ||
47 | extern struct usb_device_id dib0700_usb_id_table[]; | ||
48 | |||
49 | #endif | ||
diff --git a/drivers/media/dvb/dvb-usb/dib0700_core.c b/drivers/media/dvb/dvb-usb/dib0700_core.c new file mode 100644 index 000000000000..dca6c6985661 --- /dev/null +++ b/drivers/media/dvb/dvb-usb/dib0700_core.c | |||
@@ -0,0 +1,279 @@ | |||
1 | /* Linux driver for devices based on the DiBcom DiB0700 USB bridge | ||
2 | * | ||
3 | * This program is free software; you can redistribute it and/or modify it | ||
4 | * under the terms of the GNU General Public License as published by the Free | ||
5 | * Software Foundation, version 2. | ||
6 | * | ||
7 | * Copyright (C) 2005-6 DiBcom, SA | ||
8 | */ | ||
9 | #include "dib0700.h" | ||
10 | |||
11 | /* debug */ | ||
12 | int dvb_usb_dib0700_debug; | ||
13 | module_param_named(debug,dvb_usb_dib0700_debug, int, 0644); | ||
14 | MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS); | ||
15 | |||
16 | /* expecting rx buffer: request data[0] data[1] ... data[2] */ | ||
17 | static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen) | ||
18 | { | ||
19 | int status; | ||
20 | |||
21 | deb_data(">>> "); | ||
22 | debug_dump(tx,txlen,deb_data); | ||
23 | |||
24 | status = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev,0), | ||
25 | tx[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, tx, txlen, | ||
26 | USB_CTRL_GET_TIMEOUT); | ||
27 | |||
28 | if (status != txlen) | ||
29 | deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen); | ||
30 | |||
31 | return status < 0 ? status : 0; | ||
32 | } | ||
33 | |||
34 | /* expecting tx buffer: request data[0] ... data[n] (n <= 4) */ | ||
35 | static int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen) | ||
36 | { | ||
37 | u16 index, value; | ||
38 | int status; | ||
39 | |||
40 | if (txlen < 2) { | ||
41 | err("tx buffer length is smaller than 2. Makes no sense."); | ||
42 | return -EINVAL; | ||
43 | } | ||
44 | if (txlen > 4) { | ||
45 | err("tx buffer length is larger than 4. Not supported."); | ||
46 | return -EINVAL; | ||
47 | } | ||
48 | |||
49 | deb_data(">>> "); | ||
50 | debug_dump(tx,txlen,deb_data); | ||
51 | |||
52 | value = ((txlen - 2) << 8) | tx[1]; | ||
53 | index = 0; | ||
54 | if (txlen > 2) | ||
55 | index |= (tx[2] << 8); | ||
56 | if (txlen > 3) | ||
57 | index |= tx[3]; | ||
58 | |||
59 | /* think about swapping here */ | ||
60 | value = le16_to_cpu(value); | ||
61 | index = le16_to_cpu(index); | ||
62 | |||
63 | status = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev,0), tx[0], | ||
64 | USB_TYPE_VENDOR | USB_DIR_IN, value, index, rx, rxlen, | ||
65 | USB_CTRL_GET_TIMEOUT); | ||
66 | |||
67 | if (status < 0) | ||
68 | deb_info("ep 0 read error (status = %d)\n",status); | ||
69 | |||
70 | deb_data("<<< "); | ||
71 | debug_dump(rx,rxlen,deb_data); | ||
72 | |||
73 | return status; /* length in case of success */ | ||
74 | } | ||
75 | |||
76 | int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val) | ||
77 | { | ||
78 | u8 buf[3] = { REQUEST_SET_GPIO, gpio, ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6) }; | ||
79 | return dib0700_ctrl_wr(d,buf,3); | ||
80 | } | ||
81 | |||
82 | /* | ||
83 | * I2C master xfer function | ||
84 | */ | ||
85 | static int dib0700_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg *msg,int num) | ||
86 | { | ||
87 | struct dvb_usb_device *d = i2c_get_adapdata(adap); | ||
88 | int i,len; | ||
89 | u8 buf[255]; | ||
90 | |||
91 | if (mutex_lock_interruptible(&d->i2c_mutex) < 0) | ||
92 | return -EAGAIN; | ||
93 | |||
94 | for (i = 0; i < num; i++) { | ||
95 | /* fill in the address */ | ||
96 | buf[1] = (msg[i].addr << 1); | ||
97 | /* fill the buffer */ | ||
98 | memcpy(&buf[2], msg[i].buf, msg[i].len); | ||
99 | |||
100 | /* write/read request */ | ||
101 | if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) { | ||
102 | buf[0] = REQUEST_I2C_READ; | ||
103 | buf[1] |= 1; | ||
104 | |||
105 | /* special thing in the current firmware: when length is zero the read-failed */ | ||
106 | if ((len = dib0700_ctrl_rd(d, buf, msg[i].len + 2, msg[i+1].buf, msg[i+1].len)) <= 0) { | ||
107 | deb_info("I2C read failed on address %x\n", msg[i].addr); | ||
108 | break; | ||
109 | } | ||
110 | |||
111 | msg[i+1].len = len; | ||
112 | |||
113 | i++; | ||
114 | } else { | ||
115 | buf[0] = REQUEST_I2C_WRITE; | ||
116 | if (dib0700_ctrl_wr(d, buf, msg[i].len + 2) < 0) | ||
117 | break; | ||
118 | } | ||
119 | } | ||
120 | |||
121 | mutex_unlock(&d->i2c_mutex); | ||
122 | return i; | ||
123 | } | ||
124 | |||
125 | static u32 dib0700_i2c_func(struct i2c_adapter *adapter) | ||
126 | { | ||
127 | return I2C_FUNC_I2C; | ||
128 | } | ||
129 | |||
130 | struct i2c_algorithm dib0700_i2c_algo = { | ||
131 | .master_xfer = dib0700_i2c_xfer, | ||
132 | .functionality = dib0700_i2c_func, | ||
133 | }; | ||
134 | |||
135 | int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props, | ||
136 | struct dvb_usb_device_description **desc, int *cold) | ||
137 | { | ||
138 | u8 buf[3] = { REQUEST_SET_GPIO, 4, (GPIO_IN << 7) | (0 << 6) }; // GPIO4 is save - used for I2C | ||
139 | *cold = usb_control_msg(udev, usb_sndctrlpipe(udev,0), | ||
140 | buf[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, buf, 3, USB_CTRL_GET_TIMEOUT) != 3; | ||
141 | |||
142 | deb_info("cold: %d\n", *cold); | ||
143 | return 0; | ||
144 | } | ||
145 | |||
146 | static int dib0700_jumpram(struct usb_device *udev, u32 address) | ||
147 | { | ||
148 | int ret, actlen; | ||
149 | u8 buf[8] = { REQUEST_JUMPRAM, 0, 0, 0, | ||
150 | (address >> 24) & 0xff, | ||
151 | (address >> 16) & 0xff, | ||
152 | (address >> 8) & 0xff, | ||
153 | address & 0xff }; | ||
154 | |||
155 | if ((ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x01),buf,8,&actlen,1000)) < 0) { | ||
156 | deb_fw("jumpram to 0x%x failed\n",address); | ||
157 | return ret; | ||
158 | } | ||
159 | if (actlen != 8) { | ||
160 | deb_fw("jumpram to 0x%x failed\n",address); | ||
161 | return -EIO; | ||
162 | } | ||
163 | return 0; | ||
164 | } | ||
165 | |||
166 | int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw) | ||
167 | { | ||
168 | struct hexline hx; | ||
169 | int pos = 0, ret, act_len; | ||
170 | |||
171 | u8 buf[260]; | ||
172 | |||
173 | while ((ret = dvb_usb_get_hexline(fw, &hx, &pos)) > 0) { | ||
174 | deb_fwdata("writing to address 0x%08x (buffer: 0x%02x %02x)\n",hx.addr, hx.len, hx.chk); | ||
175 | |||
176 | buf[0] = hx.len; | ||
177 | buf[1] = (hx.addr >> 8) & 0xff; | ||
178 | buf[2] = hx.addr & 0xff; | ||
179 | buf[3] = hx.type; | ||
180 | memcpy(&buf[4],hx.data,hx.len); | ||
181 | buf[4+hx.len] = hx.chk; | ||
182 | |||
183 | ret = usb_bulk_msg(udev, | ||
184 | usb_sndbulkpipe(udev, 0x01), | ||
185 | buf, | ||
186 | hx.len + 5, | ||
187 | &act_len, | ||
188 | 1000); | ||
189 | |||
190 | if (ret < 0) { | ||
191 | err("firmware download failed at %d with %d",pos,ret); | ||
192 | return ret; | ||
193 | } | ||
194 | } | ||
195 | |||
196 | if (ret == 0) { | ||
197 | /* start the firmware */ | ||
198 | if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) { | ||
199 | info("firmware started successfully."); | ||
200 | msleep(100); | ||
201 | } | ||
202 | } else | ||
203 | ret = -EIO; | ||
204 | |||
205 | return ret; | ||
206 | } | ||
207 | |||
208 | int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) | ||
209 | { | ||
210 | struct dib0700_state *st = adap->dev->priv; | ||
211 | u8 b[4]; | ||
212 | |||
213 | b[0] = REQUEST_ENABLE_VIDEO; | ||
214 | b[1] = 0x00; | ||
215 | b[2] = (0x01 << 4); /* Master mode */ | ||
216 | b[3] = 0x00; | ||
217 | |||
218 | deb_info("modifying (%d) streaming state for %d\n", onoff, adap->id); | ||
219 | |||
220 | if (onoff) | ||
221 | st->channel_state |= 1 << adap->id; | ||
222 | else | ||
223 | st->channel_state &= ~(1 << adap->id); | ||
224 | |||
225 | b[2] |= st->channel_state; | ||
226 | |||
227 | if (st->channel_state) /* if at least one channel is active */ | ||
228 | b[1] = (0x01 << 4) | 0x00; | ||
229 | |||
230 | deb_info("data for streaming: %x %x\n",b[1],b[2]); | ||
231 | |||
232 | return dib0700_ctrl_wr(adap->dev, b, 4); | ||
233 | } | ||
234 | |||
235 | static int dib0700_probe(struct usb_interface *intf, | ||
236 | const struct usb_device_id *id) | ||
237 | { | ||
238 | int i; | ||
239 | |||
240 | for (i = 0; i < dib0700_device_count; i++) | ||
241 | if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE, NULL) == 0) | ||
242 | return 0; | ||
243 | |||
244 | return -ENODEV; | ||
245 | } | ||
246 | |||
247 | static struct usb_driver dib0700_driver = { | ||
248 | .name = "dvb_usb_dib0700", | ||
249 | .probe = dib0700_probe, | ||
250 | .disconnect = dvb_usb_device_exit, | ||
251 | .id_table = dib0700_usb_id_table, | ||
252 | }; | ||
253 | |||
254 | /* module stuff */ | ||
255 | static int __init dib0700_module_init(void) | ||
256 | { | ||
257 | int result; | ||
258 | info("loaded with support for %d different device-types", dib0700_device_count); | ||
259 | if ((result = usb_register(&dib0700_driver))) { | ||
260 | err("usb_register failed. Error number %d",result); | ||
261 | return result; | ||
262 | } | ||
263 | |||
264 | return 0; | ||
265 | } | ||
266 | |||
267 | static void __exit dib0700_module_exit(void) | ||
268 | { | ||
269 | /* deregister this driver from the USB subsystem */ | ||
270 | usb_deregister(&dib0700_driver); | ||
271 | } | ||
272 | |||
273 | module_init (dib0700_module_init); | ||
274 | module_exit (dib0700_module_exit); | ||
275 | |||
276 | MODULE_AUTHOR("Patrick Boettcher <pboettcher@dibcom.fr>"); | ||
277 | MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge"); | ||
278 | MODULE_VERSION("1.0"); | ||
279 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/media/dvb/dvb-usb/dib0700_devices.c b/drivers/media/dvb/dvb-usb/dib0700_devices.c new file mode 100644 index 000000000000..e473bfed226b --- /dev/null +++ b/drivers/media/dvb/dvb-usb/dib0700_devices.c | |||
@@ -0,0 +1,212 @@ | |||
1 | /* Linux driver for devices based on the DiBcom DiB0700 USB bridge | ||
2 | * | ||
3 | * This program is free software; you can redistribute it and/or modify it | ||
4 | * under the terms of the GNU General Public License as published by the Free | ||
5 | * Software Foundation, version 2. | ||
6 | * | ||
7 | * Copyright (C) 2005-6 DiBcom, SA | ||
8 | */ | ||
9 | #include "dib0700.h" | ||
10 | |||
11 | #include "dib3000mc.h" | ||
12 | #include "mt2060.h" | ||
13 | |||
14 | static int force_lna_activation; | ||
15 | module_param(force_lna_activation, int, 0644); | ||
16 | MODULE_PARM_DESC(force_lna_activation, "force the activation of Low-Noise-Amplifyer(s) (LNA), " | ||
17 | "if applicable for the device (default: 0=automatic/off)."); | ||
18 | |||
19 | /* Hauppauge Nova-T 500 | ||
20 | * has a LNA on GPIO0 which is enabled by setting 1 */ | ||
21 | static struct mt2060_config bristol_mt2060_config[2] = { | ||
22 | { | ||
23 | .i2c_address = 0x60, | ||
24 | .clock_out = 3, | ||
25 | }, { | ||
26 | .i2c_address = 0x61, | ||
27 | } | ||
28 | }; | ||
29 | |||
30 | static struct dibx000_agc_config bristol_dib3000p_mt2060_agc_config = { | ||
31 | .band_caps = BAND_VHF | BAND_UHF, | ||
32 | .setup = (1 << 8) | (5 << 5) | (0 << 4) | (0 << 3) | (0 << 2) | (2 << 0), | ||
33 | |||
34 | .agc1_max = 42598, | ||
35 | .agc1_min = 17694, | ||
36 | .agc2_max = 45875, | ||
37 | .agc2_min = 0, | ||
38 | |||
39 | .agc1_pt1 = 0, | ||
40 | .agc1_pt2 = 59, | ||
41 | |||
42 | .agc1_slope1 = 0, | ||
43 | .agc1_slope2 = 69, | ||
44 | |||
45 | .agc2_pt1 = 0, | ||
46 | .agc2_pt2 = 59, | ||
47 | |||
48 | .agc2_slope1 = 111, | ||
49 | .agc2_slope2 = 28, | ||
50 | }; | ||
51 | |||
52 | static struct dib3000mc_config bristol_dib3000mc_config[2] = { | ||
53 | { .agc = &bristol_dib3000p_mt2060_agc_config, | ||
54 | .max_time = 0x196, | ||
55 | .ln_adc_level = 0x1cc7, | ||
56 | .output_mpeg2_in_188_bytes = 1, | ||
57 | }, | ||
58 | { .agc = &bristol_dib3000p_mt2060_agc_config, | ||
59 | .max_time = 0x196, | ||
60 | .ln_adc_level = 0x1cc7, | ||
61 | .output_mpeg2_in_188_bytes = 1, | ||
62 | } | ||
63 | }; | ||
64 | |||
65 | static int bristol_frontend_attach(struct dvb_usb_adapter *adap) | ||
66 | { | ||
67 | struct dib0700_state *st = adap->dev->priv; | ||
68 | if (adap->id == 0) { | ||
69 | dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10); | ||
70 | dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10); | ||
71 | dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10); | ||
72 | dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10); | ||
73 | |||
74 | if (force_lna_activation) | ||
75 | dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 1); | ||
76 | else | ||
77 | dib0700_set_gpio(adap->dev, GPIO0, GPIO_OUT, 0); | ||
78 | |||
79 | if (dib3000mc_i2c_enumeration(&adap->dev->i2c_adap, 2, DEFAULT_DIB3000P_I2C_ADDRESS, bristol_dib3000mc_config) != 0) { | ||
80 | dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10); | ||
81 | return -ENODEV; | ||
82 | } | ||
83 | } | ||
84 | st->mt2060_if1[adap->id] = 1220; | ||
85 | return (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap, | ||
86 | (10 + adap->id) << 1, &bristol_dib3000mc_config[adap->id])) == NULL ? -ENODEV : 0; | ||
87 | } | ||
88 | |||
89 | static int bristol_tuner_attach(struct dvb_usb_adapter *adap) | ||
90 | { | ||
91 | struct dib0700_state *st = adap->dev->priv; | ||
92 | struct i2c_adapter *tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1); | ||
93 | return dvb_attach(mt2060_attach,adap->fe, tun_i2c, &bristol_mt2060_config[adap->id], | ||
94 | st->mt2060_if1[adap->id]) == NULL ? -ENODEV : 0; | ||
95 | } | ||
96 | |||
97 | /* STK7700P: Hauppauge Nova-T Stick, AVerMedia Volar */ | ||
98 | /* | ||
99 | static struct mt2060_config stk7000p_mt2060_config = { | ||
100 | 0x60 | ||
101 | }; | ||
102 | */ | ||
103 | |||
104 | static int stk7700p_frontend_attach(struct dvb_usb_adapter *adap) | ||
105 | { | ||
106 | /* unless there is no real power management in DVB - we leave the device on GPIO6 */ | ||
107 | dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 0); msleep(10); | ||
108 | dib0700_set_gpio(adap->dev, GPIO6, GPIO_OUT, 1); msleep(10); | ||
109 | dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 1); msleep(10); | ||
110 | dib0700_set_gpio(adap->dev, GPIO10, GPIO_OUT, 0); msleep(10); | ||
111 | |||
112 | // adap->fe = dib7000m_attach(&adap->dev->i2c_adap, &stk7700p_dib7000m_config, 18); | ||
113 | return 0; | ||
114 | } | ||
115 | |||
116 | static int stk7700p_tuner_attach(struct dvb_usb_adapter *adap) | ||
117 | { | ||
118 | // tun_i2c = dib7000m_get_tuner_i2c_master(adap->fe, 1); | ||
119 | // return mt2060_attach(adap->fe, tun_i2c, &stk3000p_mt2060_config, if1); | ||
120 | return 0; | ||
121 | } | ||
122 | |||
123 | struct usb_device_id dib0700_usb_id_table[] = { | ||
124 | { USB_DEVICE(USB_VID_DIBCOM, USB_PID_DIBCOM_STK7700P) }, | ||
125 | { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500) }, | ||
126 | { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_500_2) }, | ||
127 | { USB_DEVICE(USB_VID_HAUPPAUGE, USB_PID_HAUPPAUGE_NOVA_T_STICK) }, | ||
128 | { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR) }, | ||
129 | { } /* Terminating entry */ | ||
130 | }; | ||
131 | MODULE_DEVICE_TABLE(usb, dib0700_usb_id_table); | ||
132 | |||
133 | #define DIB0700_DEFAULT_DEVICE_PROPERTIES \ | ||
134 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, \ | ||
135 | .usb_ctrl = DEVICE_SPECIFIC, \ | ||
136 | .firmware = "dvb-usb-dib0700-01.fw", \ | ||
137 | .download_firmware = dib0700_download_firmware, \ | ||
138 | .no_reconnect = 1, \ | ||
139 | .size_of_priv = sizeof(struct dib0700_state), \ | ||
140 | .i2c_algo = &dib0700_i2c_algo, \ | ||
141 | .identify_state = dib0700_identify_state | ||
142 | |||
143 | #define DIB0700_DEFAULT_STREAMING_CONFIG(ep) \ | ||
144 | .streaming_ctrl = dib0700_streaming_ctrl, \ | ||
145 | .stream = { \ | ||
146 | .type = USB_BULK, \ | ||
147 | .count = 4, \ | ||
148 | .endpoint = ep, \ | ||
149 | .u = { \ | ||
150 | .bulk = { \ | ||
151 | .buffersize = 39480, \ | ||
152 | } \ | ||
153 | } \ | ||
154 | } | ||
155 | |||
156 | struct dvb_usb_device_properties dib0700_devices[] = { | ||
157 | { | ||
158 | DIB0700_DEFAULT_DEVICE_PROPERTIES, | ||
159 | |||
160 | .num_adapters = 1, | ||
161 | .adapter = { | ||
162 | { | ||
163 | .frontend_attach = stk7700p_frontend_attach, | ||
164 | .tuner_attach = stk7700p_tuner_attach, | ||
165 | |||
166 | DIB0700_DEFAULT_STREAMING_CONFIG(0x02), | ||
167 | }, | ||
168 | }, | ||
169 | |||
170 | .num_device_descs = 3, | ||
171 | .devices = { | ||
172 | { "DiBcom STK7700P reference design", | ||
173 | { &dib0700_usb_id_table[0], NULL }, | ||
174 | { NULL }, | ||
175 | }, | ||
176 | { "Hauppauge Nova-T Stick", | ||
177 | { &dib0700_usb_id_table[3], NULL }, | ||
178 | { NULL }, | ||
179 | }, | ||
180 | { "AVerMedia AVerTV DVB-T Volar", | ||
181 | { &dib0700_usb_id_table[4], NULL }, | ||
182 | { NULL }, | ||
183 | }, | ||
184 | } | ||
185 | }, { DIB0700_DEFAULT_DEVICE_PROPERTIES, | ||
186 | |||
187 | .num_adapters = 2, | ||
188 | .adapter = { | ||
189 | { | ||
190 | .frontend_attach = bristol_frontend_attach, | ||
191 | .tuner_attach = bristol_tuner_attach, | ||
192 | |||
193 | DIB0700_DEFAULT_STREAMING_CONFIG(0x02), | ||
194 | }, { | ||
195 | .frontend_attach = bristol_frontend_attach, | ||
196 | .tuner_attach = bristol_tuner_attach, | ||
197 | |||
198 | DIB0700_DEFAULT_STREAMING_CONFIG(0x03), | ||
199 | } | ||
200 | }, | ||
201 | |||
202 | .num_device_descs = 1, | ||
203 | .devices = { | ||
204 | { "Hauppauge Nova-T 500 Dual DVB-T", | ||
205 | { &dib0700_usb_id_table[1], &dib0700_usb_id_table[2], NULL }, | ||
206 | { NULL }, | ||
207 | }, | ||
208 | } | ||
209 | } | ||
210 | }; | ||
211 | |||
212 | int dib0700_device_count = ARRAY_SIZE(dib0700_devices); | ||
diff --git a/drivers/media/dvb/dvb-usb/dib07x0.h b/drivers/media/dvb/dvb-usb/dib07x0.h new file mode 100644 index 000000000000..7e62c1018520 --- /dev/null +++ b/drivers/media/dvb/dvb-usb/dib07x0.h | |||
@@ -0,0 +1,21 @@ | |||
1 | #ifndef _DIB07X0_H_ | ||
2 | #define _DIB07X0_H_ | ||
3 | |||
4 | enum dib07x0_gpios { | ||
5 | GPIO0 = 0, | ||
6 | GPIO1 = 2, | ||
7 | GPIO2 = 3, | ||
8 | GPIO3 = 4, | ||
9 | GPIO4 = 5, | ||
10 | GPIO5 = 6, | ||
11 | GPIO6 = 8, | ||
12 | GPIO7 = 10, | ||
13 | GPIO8 = 11, | ||
14 | GPIO9 = 14, | ||
15 | GPIO10 = 15, | ||
16 | }; | ||
17 | |||
18 | #define GPIO_IN 0 | ||
19 | #define GPIO_OUT 1 | ||
20 | |||
21 | #endif | ||
diff --git a/drivers/media/dvb/dvb-usb/dibusb-common.c b/drivers/media/dvb/dvb-usb/dibusb-common.c index 124e25ac53b3..fd3a9902f98d 100644 --- a/drivers/media/dvb/dvb-usb/dibusb-common.c +++ b/drivers/media/dvb/dvb-usb/dibusb-common.c | |||
@@ -18,12 +18,12 @@ MODULE_LICENSE("GPL"); | |||
18 | #define deb_info(args...) dprintk(debug,0x01,args) | 18 | #define deb_info(args...) dprintk(debug,0x01,args) |
19 | 19 | ||
20 | /* common stuff used by the different dibusb modules */ | 20 | /* common stuff used by the different dibusb modules */ |
21 | int dibusb_streaming_ctrl(struct dvb_usb_device *d, int onoff) | 21 | int dibusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) |
22 | { | 22 | { |
23 | if (d->priv != NULL) { | 23 | if (adap->priv != NULL) { |
24 | struct dibusb_state *st = d->priv; | 24 | struct dibusb_state *st = adap->priv; |
25 | if (st->ops.fifo_ctrl != NULL) | 25 | if (st->ops.fifo_ctrl != NULL) |
26 | if (st->ops.fifo_ctrl(d->fe,onoff)) { | 26 | if (st->ops.fifo_ctrl(adap->fe,onoff)) { |
27 | err("error while controlling the fifo of the demod."); | 27 | err("error while controlling the fifo of the demod."); |
28 | return -ENODEV; | 28 | return -ENODEV; |
29 | } | 29 | } |
@@ -32,23 +32,23 @@ int dibusb_streaming_ctrl(struct dvb_usb_device *d, int onoff) | |||
32 | } | 32 | } |
33 | EXPORT_SYMBOL(dibusb_streaming_ctrl); | 33 | EXPORT_SYMBOL(dibusb_streaming_ctrl); |
34 | 34 | ||
35 | int dibusb_pid_filter(struct dvb_usb_device *d, int index, u16 pid, int onoff) | 35 | int dibusb_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff) |
36 | { | 36 | { |
37 | if (d->priv != NULL) { | 37 | if (adap->priv != NULL) { |
38 | struct dibusb_state *st = d->priv; | 38 | struct dibusb_state *st = adap->priv; |
39 | if (st->ops.pid_ctrl != NULL) | 39 | if (st->ops.pid_ctrl != NULL) |
40 | st->ops.pid_ctrl(d->fe,index,pid,onoff); | 40 | st->ops.pid_ctrl(adap->fe,index,pid,onoff); |
41 | } | 41 | } |
42 | return 0; | 42 | return 0; |
43 | } | 43 | } |
44 | EXPORT_SYMBOL(dibusb_pid_filter); | 44 | EXPORT_SYMBOL(dibusb_pid_filter); |
45 | 45 | ||
46 | int dibusb_pid_filter_ctrl(struct dvb_usb_device *d, int onoff) | 46 | int dibusb_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff) |
47 | { | 47 | { |
48 | if (d->priv != NULL) { | 48 | if (adap->priv != NULL) { |
49 | struct dibusb_state *st = d->priv; | 49 | struct dibusb_state *st = adap->priv; |
50 | if (st->ops.pid_parse != NULL) | 50 | if (st->ops.pid_parse != NULL) |
51 | if (st->ops.pid_parse(d->fe,onoff) < 0) | 51 | if (st->ops.pid_parse(adap->fe,onoff) < 0) |
52 | err("could not handle pid_parser"); | 52 | err("could not handle pid_parser"); |
53 | } | 53 | } |
54 | return 0; | 54 | return 0; |
@@ -68,24 +68,24 @@ int dibusb_power_ctrl(struct dvb_usb_device *d, int onoff) | |||
68 | } | 68 | } |
69 | EXPORT_SYMBOL(dibusb_power_ctrl); | 69 | EXPORT_SYMBOL(dibusb_power_ctrl); |
70 | 70 | ||
71 | int dibusb2_0_streaming_ctrl(struct dvb_usb_device *d, int onoff) | 71 | int dibusb2_0_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) |
72 | { | 72 | { |
73 | u8 b[3] = { 0 }; | 73 | u8 b[3] = { 0 }; |
74 | int ret; | 74 | int ret; |
75 | 75 | ||
76 | if ((ret = dibusb_streaming_ctrl(d,onoff)) < 0) | 76 | if ((ret = dibusb_streaming_ctrl(adap,onoff)) < 0) |
77 | return ret; | 77 | return ret; |
78 | 78 | ||
79 | if (onoff) { | 79 | if (onoff) { |
80 | b[0] = DIBUSB_REQ_SET_STREAMING_MODE; | 80 | b[0] = DIBUSB_REQ_SET_STREAMING_MODE; |
81 | b[1] = 0x00; | 81 | b[1] = 0x00; |
82 | if ((ret = dvb_usb_generic_write(d,b,2)) < 0) | 82 | if ((ret = dvb_usb_generic_write(adap->dev,b,2)) < 0) |
83 | return ret; | 83 | return ret; |
84 | } | 84 | } |
85 | 85 | ||
86 | b[0] = DIBUSB_REQ_SET_IOCTL; | 86 | b[0] = DIBUSB_REQ_SET_IOCTL; |
87 | b[1] = onoff ? DIBUSB_IOCTL_CMD_ENABLE_STREAM : DIBUSB_IOCTL_CMD_DISABLE_STREAM; | 87 | b[1] = onoff ? DIBUSB_IOCTL_CMD_ENABLE_STREAM : DIBUSB_IOCTL_CMD_DISABLE_STREAM; |
88 | return dvb_usb_generic_write(d,b,3); | 88 | return dvb_usb_generic_write(adap->dev,b,3); |
89 | } | 89 | } |
90 | EXPORT_SYMBOL(dibusb2_0_streaming_ctrl); | 90 | EXPORT_SYMBOL(dibusb2_0_streaming_ctrl); |
91 | 91 | ||
@@ -228,12 +228,12 @@ static struct dib3000mc_config mod3000p_dib3000p_config = { | |||
228 | .output_mpeg2_in_188_bytes = 1, | 228 | .output_mpeg2_in_188_bytes = 1, |
229 | }; | 229 | }; |
230 | 230 | ||
231 | int dibusb_dib3000mc_frontend_attach(struct dvb_usb_device *d) | 231 | int dibusb_dib3000mc_frontend_attach(struct dvb_usb_adapter *adap) |
232 | { | 232 | { |
233 | if (dib3000mc_attach(&d->i2c_adap, 1, DEFAULT_DIB3000P_I2C_ADDRESS, 0, &mod3000p_dib3000p_config, &d->fe) == 0 || | 233 | if ((adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap, DEFAULT_DIB3000P_I2C_ADDRESS, &mod3000p_dib3000p_config)) != NULL || |
234 | dib3000mc_attach(&d->i2c_adap, 1, DEFAULT_DIB3000MC_I2C_ADDRESS, 0, &mod3000p_dib3000p_config, &d->fe) == 0) { | 234 | (adap->fe = dvb_attach(dib3000mc_attach, &adap->dev->i2c_adap, DEFAULT_DIB3000MC_I2C_ADDRESS, &mod3000p_dib3000p_config)) != NULL) { |
235 | if (d->priv != NULL) { | 235 | if (adap->priv != NULL) { |
236 | struct dibusb_state *st = d->priv; | 236 | struct dibusb_state *st = adap->priv; |
237 | st->ops.pid_parse = dib3000mc_pid_parse; | 237 | st->ops.pid_parse = dib3000mc_pid_parse; |
238 | st->ops.pid_ctrl = dib3000mc_pid_control; | 238 | st->ops.pid_ctrl = dib3000mc_pid_control; |
239 | } | 239 | } |
@@ -247,20 +247,19 @@ static struct mt2060_config stk3000p_mt2060_config = { | |||
247 | 0x60 | 247 | 0x60 |
248 | }; | 248 | }; |
249 | 249 | ||
250 | int dibusb_dib3000mc_tuner_attach (struct dvb_usb_device *d) | 250 | int dibusb_dib3000mc_tuner_attach(struct dvb_usb_adapter *adap) |
251 | { | 251 | { |
252 | struct dibusb_state *st = d->priv; | 252 | struct dibusb_state *st = adap->priv; |
253 | int ret; | ||
254 | u8 a,b; | 253 | u8 a,b; |
255 | u16 if1 = 1220; | 254 | u16 if1 = 1220; |
256 | struct i2c_adapter *tun_i2c; | 255 | struct i2c_adapter *tun_i2c; |
257 | 256 | ||
258 | // First IF calibration for Liteon Sticks | 257 | // First IF calibration for Liteon Sticks |
259 | if (d->udev->descriptor.idVendor == USB_VID_LITEON && | 258 | if (adap->dev->udev->descriptor.idVendor == USB_VID_LITEON && |
260 | d->udev->descriptor.idProduct == USB_PID_LITEON_DVB_T_WARM) { | 259 | adap->dev->udev->descriptor.idProduct == USB_PID_LITEON_DVB_T_WARM) { |
261 | 260 | ||
262 | dibusb_read_eeprom_byte(d,0x7E,&a); | 261 | dibusb_read_eeprom_byte(adap->dev,0x7E,&a); |
263 | dibusb_read_eeprom_byte(d,0x7F,&b); | 262 | dibusb_read_eeprom_byte(adap->dev,0x7F,&b); |
264 | 263 | ||
265 | if (a == 0x00) | 264 | if (a == 0x00) |
266 | if1 += b; | 265 | if1 += b; |
@@ -269,14 +268,14 @@ int dibusb_dib3000mc_tuner_attach (struct dvb_usb_device *d) | |||
269 | else | 268 | else |
270 | warn("LITE-ON DVB-T: Strange IF1 calibration :%2X %2X\n", a, b); | 269 | warn("LITE-ON DVB-T: Strange IF1 calibration :%2X %2X\n", a, b); |
271 | 270 | ||
272 | } else if (d->udev->descriptor.idVendor == USB_VID_DIBCOM && | 271 | } else if (adap->dev->udev->descriptor.idVendor == USB_VID_DIBCOM && |
273 | d->udev->descriptor.idProduct == USB_PID_DIBCOM_MOD3001_WARM) { | 272 | adap->dev->udev->descriptor.idProduct == USB_PID_DIBCOM_MOD3001_WARM) { |
274 | u8 desc; | 273 | u8 desc; |
275 | dibusb_read_eeprom_byte(d, 7, &desc); | 274 | dibusb_read_eeprom_byte(adap->dev, 7, &desc); |
276 | if (desc == 2) { | 275 | if (desc == 2) { |
277 | a = 127; | 276 | a = 127; |
278 | do { | 277 | do { |
279 | dibusb_read_eeprom_byte(d, a, &desc); | 278 | dibusb_read_eeprom_byte(adap->dev, a, &desc); |
280 | a--; | 279 | a--; |
281 | } while (a > 7 && (desc == 0xff || desc == 0x00)); | 280 | } while (a > 7 && (desc == 0xff || desc == 0x00)); |
282 | if (desc & 0x80) | 281 | if (desc & 0x80) |
@@ -286,15 +285,15 @@ int dibusb_dib3000mc_tuner_attach (struct dvb_usb_device *d) | |||
286 | } | 285 | } |
287 | } | 286 | } |
288 | 287 | ||
289 | tun_i2c = dib3000mc_get_tuner_i2c_master(d->fe, 1); | 288 | tun_i2c = dib3000mc_get_tuner_i2c_master(adap->fe, 1); |
290 | if ((ret = mt2060_attach(d->fe, tun_i2c, &stk3000p_mt2060_config, if1)) != 0) { | 289 | if (dvb_attach(mt2060_attach, adap->fe, tun_i2c, &stk3000p_mt2060_config, if1) == NULL) { |
291 | /* not found - use panasonic pll parameters */ | 290 | /* not found - use panasonic pll parameters */ |
292 | if (dvb_pll_attach(d->fe, 0x60, tun_i2c, &dvb_pll_env57h1xd5) == NULL) | 291 | if (dvb_attach(dvb_pll_attach, adap->fe, 0x60, tun_i2c, &dvb_pll_env57h1xd5) == NULL) |
293 | return -ENOMEM; | 292 | return -ENOMEM; |
294 | } else { | 293 | } else { |
295 | st->mt2060_present = 1; | 294 | st->mt2060_present = 1; |
296 | /* set the correct parameters for the dib3000p */ | 295 | /* set the correct parameters for the dib3000p */ |
297 | dib3000mc_set_config(d->fe, &stk3000p_dib3000p_config); | 296 | dib3000mc_set_config(adap->fe, &stk3000p_dib3000p_config); |
298 | } | 297 | } |
299 | return 0; | 298 | return 0; |
300 | } | 299 | } |
diff --git a/drivers/media/dvb/dvb-usb/dibusb-mb.c b/drivers/media/dvb/dvb-usb/dibusb-mb.c index effd34cc4b02..4fe363e48352 100644 --- a/drivers/media/dvb/dvb-usb/dibusb-mb.c +++ b/drivers/media/dvb/dvb-usb/dibusb-mb.c | |||
@@ -14,35 +14,35 @@ | |||
14 | */ | 14 | */ |
15 | #include "dibusb.h" | 15 | #include "dibusb.h" |
16 | 16 | ||
17 | static int dibusb_dib3000mb_frontend_attach(struct dvb_usb_device *d) | 17 | static int dibusb_dib3000mb_frontend_attach(struct dvb_usb_adapter *adap) |
18 | { | 18 | { |
19 | struct dib3000_config demod_cfg; | 19 | struct dib3000_config demod_cfg; |
20 | struct dibusb_state *st = d->priv; | 20 | struct dibusb_state *st = adap->priv; |
21 | 21 | ||
22 | demod_cfg.demod_address = 0x8; | 22 | demod_cfg.demod_address = 0x8; |
23 | 23 | ||
24 | if ((d->fe = dib3000mb_attach(&demod_cfg,&d->i2c_adap,&st->ops)) == NULL) | 24 | if ((adap->fe = dib3000mb_attach(&demod_cfg,&adap->dev->i2c_adap,&st->ops)) == NULL) |
25 | return -ENODEV; | 25 | return -ENODEV; |
26 | 26 | ||
27 | d->fe->ops.tuner_ops.init = dvb_usb_tuner_init_i2c; | 27 | adap->fe->ops.tuner_ops.init = dvb_usb_tuner_init_i2c; |
28 | d->fe->ops.tuner_ops.set_params = dvb_usb_tuner_set_params_i2c; | 28 | adap->fe->ops.tuner_ops.set_params = dvb_usb_tuner_set_params_i2c; |
29 | 29 | ||
30 | d->tuner_pass_ctrl = st->ops.tuner_pass_ctrl; | 30 | adap->tuner_pass_ctrl = st->ops.tuner_pass_ctrl; |
31 | 31 | ||
32 | return 0; | 32 | return 0; |
33 | } | 33 | } |
34 | 34 | ||
35 | static int dibusb_thomson_tuner_attach(struct dvb_usb_device *d) | 35 | static int dibusb_thomson_tuner_attach(struct dvb_usb_adapter *adap) |
36 | { | 36 | { |
37 | d->pll_addr = 0x61; | 37 | adap->pll_addr = 0x61; |
38 | d->pll_desc = &dvb_pll_tua6010xs; | 38 | adap->pll_desc = &dvb_pll_tua6010xs; |
39 | return 0; | 39 | return 0; |
40 | } | 40 | } |
41 | 41 | ||
42 | /* Some of the Artec 1.1 device aren't equipped with the default tuner | 42 | /* Some of the Artec 1.1 device aren't equipped with the default tuner |
43 | * (Thomson Cable), but with a Panasonic ENV77H11D5. This function figures | 43 | * (Thomson Cable), but with a Panasonic ENV77H11D5. This function figures |
44 | * this out. */ | 44 | * this out. */ |
45 | static int dibusb_tuner_probe_and_attach(struct dvb_usb_device *d) | 45 | static int dibusb_tuner_probe_and_attach(struct dvb_usb_adapter *adap) |
46 | { | 46 | { |
47 | u8 b[2] = { 0,0 }, b2[1]; | 47 | u8 b[2] = { 0,0 }, b2[1]; |
48 | int ret = 0; | 48 | int ret = 0; |
@@ -54,36 +54,36 @@ static int dibusb_tuner_probe_and_attach(struct dvb_usb_device *d) | |||
54 | /* the Panasonic sits on I2C addrass 0x60, the Thomson on 0x61 */ | 54 | /* the Panasonic sits on I2C addrass 0x60, the Thomson on 0x61 */ |
55 | msg[0].addr = msg[1].addr = 0x60; | 55 | msg[0].addr = msg[1].addr = 0x60; |
56 | 56 | ||
57 | if (d->tuner_pass_ctrl) | 57 | if (adap->tuner_pass_ctrl) |
58 | d->tuner_pass_ctrl(d->fe,1,msg[0].addr); | 58 | adap->tuner_pass_ctrl(adap->fe,1,msg[0].addr); |
59 | 59 | ||
60 | if (i2c_transfer (&d->i2c_adap, msg, 2) != 2) { | 60 | if (i2c_transfer(&adap->dev->i2c_adap, msg, 2) != 2) { |
61 | err("tuner i2c write failed."); | 61 | err("tuner i2c write failed."); |
62 | ret = -EREMOTEIO; | 62 | ret = -EREMOTEIO; |
63 | } | 63 | } |
64 | 64 | ||
65 | if (d->tuner_pass_ctrl) | 65 | if (adap->tuner_pass_ctrl) |
66 | d->tuner_pass_ctrl(d->fe,0,msg[0].addr); | 66 | adap->tuner_pass_ctrl(adap->fe,0,msg[0].addr); |
67 | 67 | ||
68 | if (b2[0] == 0xfe) { | 68 | if (b2[0] == 0xfe) { |
69 | info("This device has the Thomson Cable onboard. Which is default."); | 69 | info("This device has the Thomson Cable onboard. Which is default."); |
70 | dibusb_thomson_tuner_attach(d); | 70 | dibusb_thomson_tuner_attach(adap); |
71 | } else { | 71 | } else { |
72 | u8 bpll[4] = { 0x0b, 0xf5, 0x85, 0xab }; | 72 | u8 bpll[4] = { 0x0b, 0xf5, 0x85, 0xab }; |
73 | info("This device has the Panasonic ENV77H11D5 onboard."); | 73 | info("This device has the Panasonic ENV77H11D5 onboard."); |
74 | d->pll_addr = 0x60; | 74 | adap->pll_addr = 0x60; |
75 | memcpy(d->pll_init,bpll,4); | 75 | memcpy(adap->pll_init,bpll,4); |
76 | d->pll_desc = &dvb_pll_tda665x; | 76 | adap->pll_desc = &dvb_pll_tda665x; |
77 | } | 77 | } |
78 | 78 | ||
79 | return ret; | 79 | return ret; |
80 | } | 80 | } |
81 | 81 | ||
82 | /* USB Driver stuff */ | 82 | /* USB Driver stuff */ |
83 | static struct dvb_usb_properties dibusb1_1_properties; | 83 | static struct dvb_usb_device_properties dibusb1_1_properties; |
84 | static struct dvb_usb_properties dibusb1_1_an2235_properties; | 84 | static struct dvb_usb_device_properties dibusb1_1_an2235_properties; |
85 | static struct dvb_usb_properties dibusb2_0b_properties; | 85 | static struct dvb_usb_device_properties dibusb2_0b_properties; |
86 | static struct dvb_usb_properties artec_t1_usb2_properties; | 86 | static struct dvb_usb_device_properties artec_t1_usb2_properties; |
87 | 87 | ||
88 | static int dibusb_probe(struct usb_interface *intf, | 88 | static int dibusb_probe(struct usb_interface *intf, |
89 | const struct usb_device_id *id) | 89 | const struct usb_device_id *id) |
@@ -150,34 +150,28 @@ static struct usb_device_id dibusb_dib3000mb_table [] = { | |||
150 | }; | 150 | }; |
151 | MODULE_DEVICE_TABLE (usb, dibusb_dib3000mb_table); | 151 | MODULE_DEVICE_TABLE (usb, dibusb_dib3000mb_table); |
152 | 152 | ||
153 | static struct dvb_usb_properties dibusb1_1_properties = { | 153 | static struct dvb_usb_device_properties dibusb1_1_properties = { |
154 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 154 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
155 | .pid_filter_count = 16, | ||
156 | 155 | ||
157 | .usb_ctrl = CYPRESS_AN2135, | 156 | .usb_ctrl = CYPRESS_AN2135, |
158 | 157 | ||
159 | .firmware = "dvb-usb-dibusb-5.0.0.11.fw", | 158 | .firmware = "dvb-usb-dibusb-5.0.0.11.fw", |
160 | 159 | ||
161 | .size_of_priv = sizeof(struct dibusb_state), | 160 | .num_adapters = 1, |
161 | .adapter = { | ||
162 | { | ||
163 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | ||
164 | .pid_filter_count = 16, | ||
162 | 165 | ||
163 | .streaming_ctrl = dibusb_streaming_ctrl, | 166 | .streaming_ctrl = dibusb_streaming_ctrl, |
164 | .pid_filter = dibusb_pid_filter, | 167 | .pid_filter = dibusb_pid_filter, |
165 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 168 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
166 | .power_ctrl = dibusb_power_ctrl, | ||
167 | .frontend_attach = dibusb_dib3000mb_frontend_attach, | 169 | .frontend_attach = dibusb_dib3000mb_frontend_attach, |
168 | .tuner_attach = dibusb_tuner_probe_and_attach, | 170 | .tuner_attach = dibusb_tuner_probe_and_attach, |
169 | 171 | ||
170 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
171 | .rc_key_map = dibusb_rc_keys, | ||
172 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
173 | .rc_query = dibusb_rc_query, | ||
174 | |||
175 | .i2c_algo = &dibusb_i2c_algo, | ||
176 | |||
177 | .generic_bulk_ctrl_endpoint = 0x01, | ||
178 | /* parameter for the MPEG2-data transfer */ | 172 | /* parameter for the MPEG2-data transfer */ |
179 | .urb = { | 173 | .stream = { |
180 | .type = DVB_USB_BULK, | 174 | .type = USB_BULK, |
181 | .count = 7, | 175 | .count = 7, |
182 | .endpoint = 0x02, | 176 | .endpoint = 0x02, |
183 | .u = { | 177 | .u = { |
@@ -186,6 +180,20 @@ static struct dvb_usb_properties dibusb1_1_properties = { | |||
186 | } | 180 | } |
187 | } | 181 | } |
188 | }, | 182 | }, |
183 | .size_of_priv = sizeof(struct dibusb_state), | ||
184 | } | ||
185 | }, | ||
186 | |||
187 | .power_ctrl = dibusb_power_ctrl, | ||
188 | |||
189 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
190 | .rc_key_map = dibusb_rc_keys, | ||
191 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
192 | .rc_query = dibusb_rc_query, | ||
193 | |||
194 | .i2c_algo = &dibusb_i2c_algo, | ||
195 | |||
196 | .generic_bulk_ctrl_endpoint = 0x01, | ||
189 | 197 | ||
190 | .num_device_descs = 9, | 198 | .num_device_descs = 9, |
191 | .devices = { | 199 | .devices = { |
@@ -228,34 +236,27 @@ static struct dvb_usb_properties dibusb1_1_properties = { | |||
228 | } | 236 | } |
229 | }; | 237 | }; |
230 | 238 | ||
231 | static struct dvb_usb_properties dibusb1_1_an2235_properties = { | 239 | static struct dvb_usb_device_properties dibusb1_1_an2235_properties = { |
232 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 240 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
233 | .pid_filter_count = 16, | ||
234 | |||
235 | .usb_ctrl = CYPRESS_AN2235, | 241 | .usb_ctrl = CYPRESS_AN2235, |
236 | 242 | ||
237 | .firmware = "dvb-usb-dibusb-an2235-01.fw", | 243 | .firmware = "dvb-usb-dibusb-an2235-01.fw", |
238 | 244 | ||
239 | .size_of_priv = sizeof(struct dibusb_state), | 245 | .num_adapters = 1, |
246 | .adapter = { | ||
247 | { | ||
248 | .caps = DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_ADAP_HAS_PID_FILTER, | ||
249 | .pid_filter_count = 16, | ||
240 | 250 | ||
241 | .streaming_ctrl = dibusb_streaming_ctrl, | 251 | .streaming_ctrl = dibusb_streaming_ctrl, |
242 | .pid_filter = dibusb_pid_filter, | 252 | .pid_filter = dibusb_pid_filter, |
243 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 253 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
244 | .power_ctrl = dibusb_power_ctrl, | ||
245 | .frontend_attach = dibusb_dib3000mb_frontend_attach, | 254 | .frontend_attach = dibusb_dib3000mb_frontend_attach, |
246 | .tuner_attach = dibusb_tuner_probe_and_attach, | 255 | .tuner_attach = dibusb_tuner_probe_and_attach, |
247 | 256 | ||
248 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
249 | .rc_key_map = dibusb_rc_keys, | ||
250 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
251 | .rc_query = dibusb_rc_query, | ||
252 | |||
253 | .i2c_algo = &dibusb_i2c_algo, | ||
254 | |||
255 | .generic_bulk_ctrl_endpoint = 0x01, | ||
256 | /* parameter for the MPEG2-data transfer */ | 257 | /* parameter for the MPEG2-data transfer */ |
257 | .urb = { | 258 | .stream = { |
258 | .type = DVB_USB_BULK, | 259 | .type = USB_BULK, |
259 | .count = 7, | 260 | .count = 7, |
260 | .endpoint = 0x02, | 261 | .endpoint = 0x02, |
261 | .u = { | 262 | .u = { |
@@ -264,6 +265,19 @@ static struct dvb_usb_properties dibusb1_1_an2235_properties = { | |||
264 | } | 265 | } |
265 | } | 266 | } |
266 | }, | 267 | }, |
268 | .size_of_priv = sizeof(struct dibusb_state), | ||
269 | }, | ||
270 | }, | ||
271 | .power_ctrl = dibusb_power_ctrl, | ||
272 | |||
273 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
274 | .rc_key_map = dibusb_rc_keys, | ||
275 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
276 | .rc_query = dibusb_rc_query, | ||
277 | |||
278 | .i2c_algo = &dibusb_i2c_algo, | ||
279 | |||
280 | .generic_bulk_ctrl_endpoint = 0x01, | ||
267 | 281 | ||
268 | #ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY | 282 | #ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY |
269 | .num_device_descs = 2, | 283 | .num_device_descs = 2, |
@@ -285,34 +299,27 @@ static struct dvb_usb_properties dibusb1_1_an2235_properties = { | |||
285 | } | 299 | } |
286 | }; | 300 | }; |
287 | 301 | ||
288 | static struct dvb_usb_properties dibusb2_0b_properties = { | 302 | static struct dvb_usb_device_properties dibusb2_0b_properties = { |
289 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 303 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
290 | .pid_filter_count = 16, | ||
291 | 304 | ||
292 | .usb_ctrl = CYPRESS_FX2, | 305 | .usb_ctrl = CYPRESS_FX2, |
293 | 306 | ||
294 | .firmware = "dvb-usb-adstech-usb2-02.fw", | 307 | .firmware = "dvb-usb-adstech-usb2-02.fw", |
295 | 308 | ||
296 | .size_of_priv = sizeof(struct dibusb_state), | 309 | .num_adapters = 1, |
310 | .adapter = { | ||
311 | { | ||
312 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | ||
313 | .pid_filter_count = 16, | ||
297 | 314 | ||
298 | .streaming_ctrl = dibusb2_0_streaming_ctrl, | 315 | .streaming_ctrl = dibusb2_0_streaming_ctrl, |
299 | .pid_filter = dibusb_pid_filter, | 316 | .pid_filter = dibusb_pid_filter, |
300 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 317 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
301 | .power_ctrl = dibusb2_0_power_ctrl, | ||
302 | .frontend_attach = dibusb_dib3000mb_frontend_attach, | 318 | .frontend_attach = dibusb_dib3000mb_frontend_attach, |
303 | .tuner_attach = dibusb_thomson_tuner_attach, | 319 | .tuner_attach = dibusb_thomson_tuner_attach, |
304 | |||
305 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
306 | .rc_key_map = dibusb_rc_keys, | ||
307 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
308 | .rc_query = dibusb_rc_query, | ||
309 | |||
310 | .i2c_algo = &dibusb_i2c_algo, | ||
311 | |||
312 | .generic_bulk_ctrl_endpoint = 0x01, | ||
313 | /* parameter for the MPEG2-data transfer */ | 320 | /* parameter for the MPEG2-data transfer */ |
314 | .urb = { | 321 | .stream = { |
315 | .type = DVB_USB_BULK, | 322 | .type = USB_BULK, |
316 | .count = 7, | 323 | .count = 7, |
317 | .endpoint = 0x06, | 324 | .endpoint = 0x06, |
318 | .u = { | 325 | .u = { |
@@ -321,6 +328,19 @@ static struct dvb_usb_properties dibusb2_0b_properties = { | |||
321 | } | 328 | } |
322 | } | 329 | } |
323 | }, | 330 | }, |
331 | .size_of_priv = sizeof(struct dibusb_state), | ||
332 | } | ||
333 | }, | ||
334 | .power_ctrl = dibusb2_0_power_ctrl, | ||
335 | |||
336 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
337 | .rc_key_map = dibusb_rc_keys, | ||
338 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
339 | .rc_query = dibusb_rc_query, | ||
340 | |||
341 | .i2c_algo = &dibusb_i2c_algo, | ||
342 | |||
343 | .generic_bulk_ctrl_endpoint = 0x01, | ||
324 | 344 | ||
325 | .num_device_descs = 2, | 345 | .num_device_descs = 2, |
326 | .devices = { | 346 | .devices = { |
@@ -336,34 +356,27 @@ static struct dvb_usb_properties dibusb2_0b_properties = { | |||
336 | } | 356 | } |
337 | }; | 357 | }; |
338 | 358 | ||
339 | static struct dvb_usb_properties artec_t1_usb2_properties = { | 359 | static struct dvb_usb_device_properties artec_t1_usb2_properties = { |
340 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 360 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
341 | .pid_filter_count = 16, | ||
342 | 361 | ||
343 | .usb_ctrl = CYPRESS_FX2, | 362 | .usb_ctrl = CYPRESS_FX2, |
344 | 363 | ||
345 | .firmware = "dvb-usb-dibusb-6.0.0.8.fw", | 364 | .firmware = "dvb-usb-dibusb-6.0.0.8.fw", |
346 | 365 | ||
347 | .size_of_priv = sizeof(struct dibusb_state), | 366 | .num_adapters = 1, |
367 | .adapter = { | ||
368 | { | ||
369 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | ||
370 | .pid_filter_count = 16, | ||
348 | 371 | ||
349 | .streaming_ctrl = dibusb2_0_streaming_ctrl, | 372 | .streaming_ctrl = dibusb2_0_streaming_ctrl, |
350 | .pid_filter = dibusb_pid_filter, | 373 | .pid_filter = dibusb_pid_filter, |
351 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 374 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
352 | .power_ctrl = dibusb2_0_power_ctrl, | ||
353 | .frontend_attach = dibusb_dib3000mb_frontend_attach, | 375 | .frontend_attach = dibusb_dib3000mb_frontend_attach, |
354 | .tuner_attach = dibusb_tuner_probe_and_attach, | 376 | .tuner_attach = dibusb_tuner_probe_and_attach, |
355 | |||
356 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
357 | .rc_key_map = dibusb_rc_keys, | ||
358 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
359 | .rc_query = dibusb_rc_query, | ||
360 | |||
361 | .i2c_algo = &dibusb_i2c_algo, | ||
362 | |||
363 | .generic_bulk_ctrl_endpoint = 0x01, | ||
364 | /* parameter for the MPEG2-data transfer */ | 377 | /* parameter for the MPEG2-data transfer */ |
365 | .urb = { | 378 | .stream = { |
366 | .type = DVB_USB_BULK, | 379 | .type = USB_BULK, |
367 | .count = 7, | 380 | .count = 7, |
368 | .endpoint = 0x06, | 381 | .endpoint = 0x06, |
369 | .u = { | 382 | .u = { |
@@ -372,6 +385,19 @@ static struct dvb_usb_properties artec_t1_usb2_properties = { | |||
372 | } | 385 | } |
373 | } | 386 | } |
374 | }, | 387 | }, |
388 | .size_of_priv = sizeof(struct dibusb_state), | ||
389 | } | ||
390 | }, | ||
391 | .power_ctrl = dibusb2_0_power_ctrl, | ||
392 | |||
393 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
394 | .rc_key_map = dibusb_rc_keys, | ||
395 | .rc_key_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */ | ||
396 | .rc_query = dibusb_rc_query, | ||
397 | |||
398 | .i2c_algo = &dibusb_i2c_algo, | ||
399 | |||
400 | .generic_bulk_ctrl_endpoint = 0x01, | ||
375 | 401 | ||
376 | .num_device_descs = 1, | 402 | .num_device_descs = 1, |
377 | .devices = { | 403 | .devices = { |
diff --git a/drivers/media/dvb/dvb-usb/dibusb-mc.c b/drivers/media/dvb/dvb-usb/dibusb-mc.c index eca4082a61ae..a0fd37efc04b 100644 --- a/drivers/media/dvb/dvb-usb/dibusb-mc.c +++ b/drivers/media/dvb/dvb-usb/dibusb-mc.c | |||
@@ -15,7 +15,7 @@ | |||
15 | #include "dibusb.h" | 15 | #include "dibusb.h" |
16 | 16 | ||
17 | /* USB Driver stuff */ | 17 | /* USB Driver stuff */ |
18 | static struct dvb_usb_properties dibusb_mc_properties; | 18 | static struct dvb_usb_device_properties dibusb_mc_properties; |
19 | 19 | ||
20 | static int dibusb_mc_probe(struct usb_interface *intf, | 20 | static int dibusb_mc_probe(struct usb_interface *intf, |
21 | const struct usb_device_id *id) | 21 | const struct usb_device_id *id) |
@@ -43,33 +43,26 @@ static struct usb_device_id dibusb_dib3000mc_table [] = { | |||
43 | }; | 43 | }; |
44 | MODULE_DEVICE_TABLE (usb, dibusb_dib3000mc_table); | 44 | MODULE_DEVICE_TABLE (usb, dibusb_dib3000mc_table); |
45 | 45 | ||
46 | static struct dvb_usb_properties dibusb_mc_properties = { | 46 | static struct dvb_usb_device_properties dibusb_mc_properties = { |
47 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 47 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
48 | .pid_filter_count = 32, | ||
49 | 48 | ||
50 | .usb_ctrl = CYPRESS_FX2, | 49 | .usb_ctrl = CYPRESS_FX2, |
51 | .firmware = "dvb-usb-dibusb-6.0.0.8.fw", | 50 | .firmware = "dvb-usb-dibusb-6.0.0.8.fw", |
52 | 51 | ||
53 | .size_of_priv = sizeof(struct dibusb_state), | 52 | .num_adapters = 1, |
54 | 53 | .adapter = { | |
54 | { | ||
55 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | ||
56 | .pid_filter_count = 32, | ||
55 | .streaming_ctrl = dibusb2_0_streaming_ctrl, | 57 | .streaming_ctrl = dibusb2_0_streaming_ctrl, |
56 | .pid_filter = dibusb_pid_filter, | 58 | .pid_filter = dibusb_pid_filter, |
57 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 59 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
58 | .power_ctrl = dibusb2_0_power_ctrl, | ||
59 | .frontend_attach = dibusb_dib3000mc_frontend_attach, | 60 | .frontend_attach = dibusb_dib3000mc_frontend_attach, |
60 | .tuner_attach = dibusb_dib3000mc_tuner_attach, | 61 | .tuner_attach = dibusb_dib3000mc_tuner_attach, |
61 | 62 | ||
62 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
63 | .rc_key_map = dibusb_rc_keys, | ||
64 | .rc_key_map_size = 111, /* FIXME */ | ||
65 | .rc_query = dibusb_rc_query, | ||
66 | |||
67 | .i2c_algo = &dibusb_i2c_algo, | ||
68 | |||
69 | .generic_bulk_ctrl_endpoint = 0x01, | ||
70 | /* parameter for the MPEG2-data transfer */ | 63 | /* parameter for the MPEG2-data transfer */ |
71 | .urb = { | 64 | .stream = { |
72 | .type = DVB_USB_BULK, | 65 | .type = USB_BULK, |
73 | .count = 7, | 66 | .count = 7, |
74 | .endpoint = 0x06, | 67 | .endpoint = 0x06, |
75 | .u = { | 68 | .u = { |
@@ -78,6 +71,19 @@ static struct dvb_usb_properties dibusb_mc_properties = { | |||
78 | } | 71 | } |
79 | } | 72 | } |
80 | }, | 73 | }, |
74 | .size_of_priv = sizeof(struct dibusb_state), | ||
75 | } | ||
76 | }, | ||
77 | .power_ctrl = dibusb2_0_power_ctrl, | ||
78 | |||
79 | .rc_interval = DEFAULT_RC_INTERVAL, | ||
80 | .rc_key_map = dibusb_rc_keys, | ||
81 | .rc_key_map_size = 111, /* FIXME */ | ||
82 | .rc_query = dibusb_rc_query, | ||
83 | |||
84 | .i2c_algo = &dibusb_i2c_algo, | ||
85 | |||
86 | .generic_bulk_ctrl_endpoint = 0x01, | ||
81 | 87 | ||
82 | .num_device_descs = 7, | 88 | .num_device_descs = 7, |
83 | .devices = { | 89 | .devices = { |
diff --git a/drivers/media/dvb/dvb-usb/dibusb.h b/drivers/media/dvb/dvb-usb/dibusb.h index a43f87480cf6..5153fb943da1 100644 --- a/drivers/media/dvb/dvb-usb/dibusb.h +++ b/drivers/media/dvb/dvb-usb/dibusb.h | |||
@@ -107,14 +107,15 @@ struct dibusb_state { | |||
107 | 107 | ||
108 | extern struct i2c_algorithm dibusb_i2c_algo; | 108 | extern struct i2c_algorithm dibusb_i2c_algo; |
109 | 109 | ||
110 | extern int dibusb_dib3000mc_frontend_attach(struct dvb_usb_device *); | 110 | extern int dibusb_dib3000mc_frontend_attach(struct dvb_usb_adapter *); |
111 | extern int dibusb_dib3000mc_tuner_attach (struct dvb_usb_device *); | 111 | extern int dibusb_dib3000mc_tuner_attach (struct dvb_usb_adapter *); |
112 | |||
113 | extern int dibusb_streaming_ctrl(struct dvb_usb_adapter *, int); | ||
114 | extern int dibusb_pid_filter(struct dvb_usb_adapter *, int, u16, int); | ||
115 | extern int dibusb_pid_filter_ctrl(struct dvb_usb_adapter *, int); | ||
116 | extern int dibusb2_0_streaming_ctrl(struct dvb_usb_adapter *, int); | ||
112 | 117 | ||
113 | extern int dibusb_streaming_ctrl(struct dvb_usb_device *, int); | ||
114 | extern int dibusb_pid_filter(struct dvb_usb_device *, int, u16, int); | ||
115 | extern int dibusb_pid_filter_ctrl(struct dvb_usb_device *, int); | ||
116 | extern int dibusb_power_ctrl(struct dvb_usb_device *, int); | 118 | extern int dibusb_power_ctrl(struct dvb_usb_device *, int); |
117 | extern int dibusb2_0_streaming_ctrl(struct dvb_usb_device *, int); | ||
118 | extern int dibusb2_0_power_ctrl(struct dvb_usb_device *, int); | 119 | extern int dibusb2_0_power_ctrl(struct dvb_usb_device *, int); |
119 | 120 | ||
120 | #define DEFAULT_RC_INTERVAL 150 | 121 | #define DEFAULT_RC_INTERVAL 150 |
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c index 015854487308..8fb34375c1fb 100644 --- a/drivers/media/dvb/dvb-usb/digitv.c +++ b/drivers/media/dvb/dvb-usb/digitv.c | |||
@@ -83,7 +83,7 @@ static struct i2c_algorithm digitv_i2c_algo = { | |||
83 | 83 | ||
84 | /* Callbacks for DVB USB */ | 84 | /* Callbacks for DVB USB */ |
85 | static int digitv_identify_state (struct usb_device *udev, struct | 85 | static int digitv_identify_state (struct usb_device *udev, struct |
86 | dvb_usb_properties *props, struct dvb_usb_device_description **desc, | 86 | dvb_usb_device_properties *props, struct dvb_usb_device_description **desc, |
87 | int *cold) | 87 | int *cold) |
88 | { | 88 | { |
89 | *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0; | 89 | *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0; |
@@ -116,33 +116,33 @@ static struct mt352_config digitv_mt352_config = { | |||
116 | 116 | ||
117 | static int digitv_nxt6000_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) | 117 | static int digitv_nxt6000_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) |
118 | { | 118 | { |
119 | struct dvb_usb_device *d = fe->dvb->priv; | 119 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
120 | u8 b[5]; | 120 | u8 b[5]; |
121 | dvb_usb_tuner_calc_regs(fe,fep,b, 5); | 121 | dvb_usb_tuner_calc_regs(fe,fep,b, 5); |
122 | return digitv_ctrl_msg(d,USB_WRITE_TUNER,0,&b[1],4,NULL,0); | 122 | return digitv_ctrl_msg(adap->dev, USB_WRITE_TUNER, 0, &b[1], 4, NULL, 0); |
123 | } | 123 | } |
124 | 124 | ||
125 | static struct nxt6000_config digitv_nxt6000_config = { | 125 | static struct nxt6000_config digitv_nxt6000_config = { |
126 | .clock_inversion = 1, | 126 | .clock_inversion = 1, |
127 | }; | 127 | }; |
128 | 128 | ||
129 | static int digitv_frontend_attach(struct dvb_usb_device *d) | 129 | static int digitv_frontend_attach(struct dvb_usb_adapter *adap) |
130 | { | 130 | { |
131 | if ((d->fe = dvb_attach(mt352_attach, &digitv_mt352_config, &d->i2c_adap)) != NULL) { | 131 | if ((adap->fe = dvb_attach(mt352_attach, &digitv_mt352_config, &adap->dev->i2c_adap)) != NULL) { |
132 | d->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; | 132 | adap->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; |
133 | return 0; | 133 | return 0; |
134 | } | 134 | } |
135 | if ((d->fe = dvb_attach(nxt6000_attach, &digitv_nxt6000_config, &d->i2c_adap)) != NULL) { | 135 | if ((adap->fe = dvb_attach(nxt6000_attach, &digitv_nxt6000_config, &adap->dev->i2c_adap)) != NULL) { |
136 | d->fe->ops.tuner_ops.set_params = digitv_nxt6000_tuner_set_params; | 136 | adap->fe->ops.tuner_ops.set_params = digitv_nxt6000_tuner_set_params; |
137 | return 0; | 137 | return 0; |
138 | } | 138 | } |
139 | return -EIO; | 139 | return -EIO; |
140 | } | 140 | } |
141 | 141 | ||
142 | static int digitv_tuner_attach(struct dvb_usb_device *d) | 142 | static int digitv_tuner_attach(struct dvb_usb_adapter *adap) |
143 | { | 143 | { |
144 | d->pll_addr = 0x60; | 144 | adap->pll_addr = 0x60; |
145 | d->pll_desc = &dvb_pll_tded4; | 145 | adap->pll_desc = &dvb_pll_tded4; |
146 | return 0; | 146 | return 0; |
147 | } | 147 | } |
148 | 148 | ||
@@ -238,7 +238,7 @@ static int digitv_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |||
238 | } | 238 | } |
239 | 239 | ||
240 | /* DVB USB Driver stuff */ | 240 | /* DVB USB Driver stuff */ |
241 | static struct dvb_usb_properties digitv_properties; | 241 | static struct dvb_usb_device_properties digitv_properties; |
242 | 242 | ||
243 | static int digitv_probe(struct usb_interface *intf, | 243 | static int digitv_probe(struct usb_interface *intf, |
244 | const struct usb_device_id *id) | 244 | const struct usb_device_id *id) |
@@ -265,30 +265,21 @@ static struct usb_device_id digitv_table [] = { | |||
265 | }; | 265 | }; |
266 | MODULE_DEVICE_TABLE (usb, digitv_table); | 266 | MODULE_DEVICE_TABLE (usb, digitv_table); |
267 | 267 | ||
268 | static struct dvb_usb_properties digitv_properties = { | 268 | static struct dvb_usb_device_properties digitv_properties = { |
269 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 269 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
270 | 270 | ||
271 | .usb_ctrl = CYPRESS_FX2, | 271 | .usb_ctrl = CYPRESS_FX2, |
272 | .firmware = "dvb-usb-digitv-02.fw", | 272 | .firmware = "dvb-usb-digitv-02.fw", |
273 | 273 | ||
274 | .size_of_priv = 0, | 274 | .num_adapters = 1, |
275 | 275 | .adapter = { | |
276 | { | ||
276 | .frontend_attach = digitv_frontend_attach, | 277 | .frontend_attach = digitv_frontend_attach, |
277 | .tuner_attach = digitv_tuner_attach, | 278 | .tuner_attach = digitv_tuner_attach, |
278 | 279 | ||
279 | .rc_interval = 1000, | ||
280 | .rc_key_map = digitv_rc_keys, | ||
281 | .rc_key_map_size = ARRAY_SIZE(digitv_rc_keys), | ||
282 | .rc_query = digitv_rc_query, | ||
283 | |||
284 | .identify_state = digitv_identify_state, | ||
285 | |||
286 | .i2c_algo = &digitv_i2c_algo, | ||
287 | |||
288 | .generic_bulk_ctrl_endpoint = 0x01, | ||
289 | /* parameter for the MPEG2-data transfer */ | 280 | /* parameter for the MPEG2-data transfer */ |
290 | .urb = { | 281 | .stream = { |
291 | .type = DVB_USB_BULK, | 282 | .type = USB_BULK, |
292 | .count = 7, | 283 | .count = 7, |
293 | .endpoint = 0x02, | 284 | .endpoint = 0x02, |
294 | .u = { | 285 | .u = { |
@@ -297,6 +288,18 @@ static struct dvb_usb_properties digitv_properties = { | |||
297 | } | 288 | } |
298 | } | 289 | } |
299 | }, | 290 | }, |
291 | } | ||
292 | }, | ||
293 | .identify_state = digitv_identify_state, | ||
294 | |||
295 | .rc_interval = 1000, | ||
296 | .rc_key_map = digitv_rc_keys, | ||
297 | .rc_key_map_size = ARRAY_SIZE(digitv_rc_keys), | ||
298 | .rc_query = digitv_rc_query, | ||
299 | |||
300 | .i2c_algo = &digitv_i2c_algo, | ||
301 | |||
302 | .generic_bulk_ctrl_endpoint = 0x01, | ||
300 | 303 | ||
301 | .num_device_descs = 1, | 304 | .num_device_descs = 1, |
302 | .devices = { | 305 | .devices = { |
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.c b/drivers/media/dvb/dvb-usb/dtt200u.c index 27af4e436479..fa43a41d753b 100644 --- a/drivers/media/dvb/dvb-usb/dtt200u.c +++ b/drivers/media/dvb/dvb-usb/dtt200u.c | |||
@@ -28,19 +28,19 @@ static int dtt200u_power_ctrl(struct dvb_usb_device *d, int onoff) | |||
28 | return 0; | 28 | return 0; |
29 | } | 29 | } |
30 | 30 | ||
31 | static int dtt200u_streaming_ctrl(struct dvb_usb_device *d, int onoff) | 31 | static int dtt200u_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) |
32 | { | 32 | { |
33 | u8 b_streaming[2] = { SET_STREAMING, onoff }; | 33 | u8 b_streaming[2] = { SET_STREAMING, onoff }; |
34 | u8 b_rst_pid = RESET_PID_FILTER; | 34 | u8 b_rst_pid = RESET_PID_FILTER; |
35 | 35 | ||
36 | dvb_usb_generic_write(d,b_streaming,2); | 36 | dvb_usb_generic_write(adap->dev, b_streaming, 2); |
37 | 37 | ||
38 | if (onoff == 0) | 38 | if (onoff == 0) |
39 | dvb_usb_generic_write(d,&b_rst_pid,1); | 39 | dvb_usb_generic_write(adap->dev, &b_rst_pid, 1); |
40 | return 0; | 40 | return 0; |
41 | } | 41 | } |
42 | 42 | ||
43 | static int dtt200u_pid_filter(struct dvb_usb_device *d, int index, u16 pid, int onoff) | 43 | static int dtt200u_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff) |
44 | { | 44 | { |
45 | u8 b_pid[4]; | 45 | u8 b_pid[4]; |
46 | pid = onoff ? pid : 0; | 46 | pid = onoff ? pid : 0; |
@@ -50,7 +50,7 @@ static int dtt200u_pid_filter(struct dvb_usb_device *d, int index, u16 pid, int | |||
50 | b_pid[2] = pid & 0xff; | 50 | b_pid[2] = pid & 0xff; |
51 | b_pid[3] = (pid >> 8) & 0x1f; | 51 | b_pid[3] = (pid >> 8) & 0x1f; |
52 | 52 | ||
53 | return dvb_usb_generic_write(d,b_pid,4); | 53 | return dvb_usb_generic_write(adap->dev, b_pid, 4); |
54 | } | 54 | } |
55 | 55 | ||
56 | /* remote control */ | 56 | /* remote control */ |
@@ -86,16 +86,16 @@ static int dtt200u_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |||
86 | return 0; | 86 | return 0; |
87 | } | 87 | } |
88 | 88 | ||
89 | static int dtt200u_frontend_attach(struct dvb_usb_device *d) | 89 | static int dtt200u_frontend_attach(struct dvb_usb_adapter *adap) |
90 | { | 90 | { |
91 | d->fe = dtt200u_fe_attach(d); | 91 | adap->fe = dtt200u_fe_attach(adap->dev); |
92 | return 0; | 92 | return 0; |
93 | } | 93 | } |
94 | 94 | ||
95 | static struct dvb_usb_properties dtt200u_properties; | 95 | static struct dvb_usb_device_properties dtt200u_properties; |
96 | static struct dvb_usb_properties wt220u_fc_properties; | 96 | static struct dvb_usb_device_properties wt220u_fc_properties; |
97 | static struct dvb_usb_properties wt220u_properties; | 97 | static struct dvb_usb_device_properties wt220u_properties; |
98 | static struct dvb_usb_properties wt220u_zl0353_properties; | 98 | static struct dvb_usb_device_properties wt220u_zl0353_properties; |
99 | 99 | ||
100 | static int dtt200u_usb_probe(struct usb_interface *intf, | 100 | static int dtt200u_usb_probe(struct usb_interface *intf, |
101 | const struct usb_device_id *id) | 101 | const struct usb_device_id *id) |
@@ -123,28 +123,22 @@ static struct usb_device_id dtt200u_usb_table [] = { | |||
123 | }; | 123 | }; |
124 | MODULE_DEVICE_TABLE(usb, dtt200u_usb_table); | 124 | MODULE_DEVICE_TABLE(usb, dtt200u_usb_table); |
125 | 125 | ||
126 | static struct dvb_usb_properties dtt200u_properties = { | 126 | static struct dvb_usb_device_properties dtt200u_properties = { |
127 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_NEED_PID_FILTERING, | ||
128 | .pid_filter_count = 15, | ||
129 | |||
130 | .usb_ctrl = CYPRESS_FX2, | 127 | .usb_ctrl = CYPRESS_FX2, |
131 | .firmware = "dvb-usb-dtt200u-01.fw", | 128 | .firmware = "dvb-usb-dtt200u-01.fw", |
132 | 129 | ||
133 | .power_ctrl = dtt200u_power_ctrl, | 130 | .num_adapters = 1, |
131 | .adapter = { | ||
132 | { | ||
133 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, | ||
134 | .pid_filter_count = 15, | ||
135 | |||
134 | .streaming_ctrl = dtt200u_streaming_ctrl, | 136 | .streaming_ctrl = dtt200u_streaming_ctrl, |
135 | .pid_filter = dtt200u_pid_filter, | 137 | .pid_filter = dtt200u_pid_filter, |
136 | .frontend_attach = dtt200u_frontend_attach, | 138 | .frontend_attach = dtt200u_frontend_attach, |
137 | |||
138 | .rc_interval = 300, | ||
139 | .rc_key_map = dtt200u_rc_keys, | ||
140 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
141 | .rc_query = dtt200u_rc_query, | ||
142 | |||
143 | .generic_bulk_ctrl_endpoint = 0x01, | ||
144 | |||
145 | /* parameter for the MPEG2-data transfer */ | 139 | /* parameter for the MPEG2-data transfer */ |
146 | .urb = { | 140 | .stream = { |
147 | .type = DVB_USB_BULK, | 141 | .type = USB_BULK, |
148 | .count = 7, | 142 | .count = 7, |
149 | .endpoint = 0x02, | 143 | .endpoint = 0x02, |
150 | .u = { | 144 | .u = { |
@@ -153,6 +147,16 @@ static struct dvb_usb_properties dtt200u_properties = { | |||
153 | } | 147 | } |
154 | } | 148 | } |
155 | }, | 149 | }, |
150 | } | ||
151 | }, | ||
152 | .power_ctrl = dtt200u_power_ctrl, | ||
153 | |||
154 | .rc_interval = 300, | ||
155 | .rc_key_map = dtt200u_rc_keys, | ||
156 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
157 | .rc_query = dtt200u_rc_query, | ||
158 | |||
159 | .generic_bulk_ctrl_endpoint = 0x01, | ||
156 | 160 | ||
157 | .num_device_descs = 1, | 161 | .num_device_descs = 1, |
158 | .devices = { | 162 | .devices = { |
@@ -164,28 +168,22 @@ static struct dvb_usb_properties dtt200u_properties = { | |||
164 | } | 168 | } |
165 | }; | 169 | }; |
166 | 170 | ||
167 | static struct dvb_usb_properties wt220u_properties = { | 171 | static struct dvb_usb_device_properties wt220u_properties = { |
168 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_NEED_PID_FILTERING, | ||
169 | .pid_filter_count = 15, | ||
170 | |||
171 | .usb_ctrl = CYPRESS_FX2, | 172 | .usb_ctrl = CYPRESS_FX2, |
172 | .firmware = "dvb-usb-wt220u-02.fw", | 173 | .firmware = "dvb-usb-wt220u-02.fw", |
173 | 174 | ||
174 | .power_ctrl = dtt200u_power_ctrl, | 175 | .num_adapters = 1, |
176 | .adapter = { | ||
177 | { | ||
178 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, | ||
179 | .pid_filter_count = 15, | ||
180 | |||
175 | .streaming_ctrl = dtt200u_streaming_ctrl, | 181 | .streaming_ctrl = dtt200u_streaming_ctrl, |
176 | .pid_filter = dtt200u_pid_filter, | 182 | .pid_filter = dtt200u_pid_filter, |
177 | .frontend_attach = dtt200u_frontend_attach, | 183 | .frontend_attach = dtt200u_frontend_attach, |
178 | |||
179 | .rc_interval = 300, | ||
180 | .rc_key_map = dtt200u_rc_keys, | ||
181 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
182 | .rc_query = dtt200u_rc_query, | ||
183 | |||
184 | .generic_bulk_ctrl_endpoint = 0x01, | ||
185 | |||
186 | /* parameter for the MPEG2-data transfer */ | 184 | /* parameter for the MPEG2-data transfer */ |
187 | .urb = { | 185 | .stream = { |
188 | .type = DVB_USB_BULK, | 186 | .type = USB_BULK, |
189 | .count = 7, | 187 | .count = 7, |
190 | .endpoint = 0x02, | 188 | .endpoint = 0x02, |
191 | .u = { | 189 | .u = { |
@@ -194,6 +192,16 @@ static struct dvb_usb_properties wt220u_properties = { | |||
194 | } | 192 | } |
195 | } | 193 | } |
196 | }, | 194 | }, |
195 | } | ||
196 | }, | ||
197 | .power_ctrl = dtt200u_power_ctrl, | ||
198 | |||
199 | .rc_interval = 300, | ||
200 | .rc_key_map = dtt200u_rc_keys, | ||
201 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
202 | .rc_query = dtt200u_rc_query, | ||
203 | |||
204 | .generic_bulk_ctrl_endpoint = 0x01, | ||
197 | 205 | ||
198 | .num_device_descs = 1, | 206 | .num_device_descs = 1, |
199 | .devices = { | 207 | .devices = { |
@@ -205,36 +213,40 @@ static struct dvb_usb_properties wt220u_properties = { | |||
205 | } | 213 | } |
206 | }; | 214 | }; |
207 | 215 | ||
208 | static struct dvb_usb_properties wt220u_fc_properties = { | 216 | static struct dvb_usb_device_properties wt220u_fc_properties = { |
209 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_NEED_PID_FILTERING, | ||
210 | .pid_filter_count = 15, | ||
211 | |||
212 | .usb_ctrl = CYPRESS_FX2, | 217 | .usb_ctrl = CYPRESS_FX2, |
213 | .firmware = "dvb-usb-wt220u-fc03.fw", | 218 | .firmware = "dvb-usb-wt220u-fc03.fw", |
214 | 219 | ||
215 | .power_ctrl = dtt200u_power_ctrl, | 220 | .num_adapters = 1, |
221 | .adapter = { | ||
222 | { | ||
223 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, | ||
224 | .pid_filter_count = 15, | ||
225 | |||
216 | .streaming_ctrl = dtt200u_streaming_ctrl, | 226 | .streaming_ctrl = dtt200u_streaming_ctrl, |
217 | .pid_filter = dtt200u_pid_filter, | 227 | .pid_filter = dtt200u_pid_filter, |
218 | .frontend_attach = dtt200u_frontend_attach, | 228 | .frontend_attach = dtt200u_frontend_attach, |
219 | |||
220 | .rc_interval = 300, | ||
221 | .rc_key_map = dtt200u_rc_keys, | ||
222 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
223 | .rc_query = dtt200u_rc_query, | ||
224 | |||
225 | .generic_bulk_ctrl_endpoint = 0x01, | ||
226 | |||
227 | /* parameter for the MPEG2-data transfer */ | 229 | /* parameter for the MPEG2-data transfer */ |
228 | .urb = { | 230 | .stream = { |
229 | .type = DVB_USB_BULK, | 231 | .type = USB_BULK, |
230 | .count = 7, | 232 | .count = 7, |
231 | .endpoint = 0x86, | 233 | .endpoint = 0x06, |
232 | .u = { | 234 | .u = { |
233 | .bulk = { | 235 | .bulk = { |
234 | .buffersize = 4096, | 236 | .buffersize = 4096, |
235 | } | 237 | } |
236 | } | 238 | } |
237 | }, | 239 | }, |
240 | } | ||
241 | }, | ||
242 | .power_ctrl = dtt200u_power_ctrl, | ||
243 | |||
244 | .rc_interval = 300, | ||
245 | .rc_key_map = dtt200u_rc_keys, | ||
246 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
247 | .rc_query = dtt200u_rc_query, | ||
248 | |||
249 | .generic_bulk_ctrl_endpoint = 0x01, | ||
238 | 250 | ||
239 | .num_device_descs = 1, | 251 | .num_device_descs = 1, |
240 | .devices = { | 252 | .devices = { |
@@ -246,28 +258,22 @@ static struct dvb_usb_properties wt220u_fc_properties = { | |||
246 | } | 258 | } |
247 | }; | 259 | }; |
248 | 260 | ||
249 | static struct dvb_usb_properties wt220u_zl0353_properties = { | 261 | static struct dvb_usb_device_properties wt220u_zl0353_properties = { |
250 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_NEED_PID_FILTERING, | ||
251 | .pid_filter_count = 15, | ||
252 | |||
253 | .usb_ctrl = CYPRESS_FX2, | 262 | .usb_ctrl = CYPRESS_FX2, |
254 | .firmware = "dvb-usb-wt220u-zl0353-01.fw", | 263 | .firmware = "dvb-usb-wt220u-zl0353-01.fw", |
255 | 264 | ||
256 | .power_ctrl = dtt200u_power_ctrl, | 265 | .num_adapters = 1, |
266 | .adapter = { | ||
267 | { | ||
268 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_NEED_PID_FILTERING, | ||
269 | .pid_filter_count = 15, | ||
270 | |||
257 | .streaming_ctrl = dtt200u_streaming_ctrl, | 271 | .streaming_ctrl = dtt200u_streaming_ctrl, |
258 | .pid_filter = dtt200u_pid_filter, | 272 | .pid_filter = dtt200u_pid_filter, |
259 | .frontend_attach = dtt200u_frontend_attach, | 273 | .frontend_attach = dtt200u_frontend_attach, |
260 | |||
261 | .rc_interval = 300, | ||
262 | .rc_key_map = dtt200u_rc_keys, | ||
263 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
264 | .rc_query = dtt200u_rc_query, | ||
265 | |||
266 | .generic_bulk_ctrl_endpoint = 0x01, | ||
267 | |||
268 | /* parameter for the MPEG2-data transfer */ | 274 | /* parameter for the MPEG2-data transfer */ |
269 | .urb = { | 275 | .stream = { |
270 | .type = DVB_USB_BULK, | 276 | .type = USB_BULK, |
271 | .count = 7, | 277 | .count = 7, |
272 | .endpoint = 0x02, | 278 | .endpoint = 0x02, |
273 | .u = { | 279 | .u = { |
@@ -276,6 +282,16 @@ static struct dvb_usb_properties wt220u_zl0353_properties = { | |||
276 | } | 282 | } |
277 | } | 283 | } |
278 | }, | 284 | }, |
285 | } | ||
286 | }, | ||
287 | .power_ctrl = dtt200u_power_ctrl, | ||
288 | |||
289 | .rc_interval = 300, | ||
290 | .rc_key_map = dtt200u_rc_keys, | ||
291 | .rc_key_map_size = ARRAY_SIZE(dtt200u_rc_keys), | ||
292 | .rc_query = dtt200u_rc_query, | ||
293 | |||
294 | .generic_bulk_ctrl_endpoint = 0x01, | ||
279 | 295 | ||
280 | .num_device_descs = 1, | 296 | .num_device_descs = 1, |
281 | .devices = { | 297 | .devices = { |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-common.h b/drivers/media/dvb/dvb-usb/dvb-usb-common.h index a3460bf2d9fa..35ab68f6dcf6 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-common.h +++ b/drivers/media/dvb/dvb-usb/dvb-usb-common.h | |||
@@ -14,31 +14,36 @@ | |||
14 | extern int dvb_usb_debug; | 14 | extern int dvb_usb_debug; |
15 | extern int dvb_usb_disable_rc_polling; | 15 | extern int dvb_usb_disable_rc_polling; |
16 | 16 | ||
17 | #define deb_info(args...) dprintk(dvb_usb_debug,0x01,args) | 17 | #define deb_info(args...) dprintk(dvb_usb_debug,0x001,args) |
18 | #define deb_xfer(args...) dprintk(dvb_usb_debug,0x02,args) | 18 | #define deb_xfer(args...) dprintk(dvb_usb_debug,0x002,args) |
19 | #define deb_pll(args...) dprintk(dvb_usb_debug,0x04,args) | 19 | #define deb_pll(args...) dprintk(dvb_usb_debug,0x004,args) |
20 | #define deb_ts(args...) dprintk(dvb_usb_debug,0x08,args) | 20 | #define deb_ts(args...) dprintk(dvb_usb_debug,0x008,args) |
21 | #define deb_err(args...) dprintk(dvb_usb_debug,0x10,args) | 21 | #define deb_err(args...) dprintk(dvb_usb_debug,0x010,args) |
22 | #define deb_rc(args...) dprintk(dvb_usb_debug,0x20,args) | 22 | #define deb_rc(args...) dprintk(dvb_usb_debug,0x020,args) |
23 | #define deb_fw(args...) dprintk(dvb_usb_debug,0x40,args) | 23 | #define deb_fw(args...) dprintk(dvb_usb_debug,0x040,args) |
24 | #define deb_mem(args...) dprintk(dvb_usb_debug,0x80,args) | 24 | #define deb_mem(args...) dprintk(dvb_usb_debug,0x080,args) |
25 | #define deb_uxfer(args...) dprintk(dvb_usb_debug,0x100,args) | ||
25 | 26 | ||
26 | /* commonly used methods */ | 27 | /* commonly used methods */ |
27 | extern int dvb_usb_download_firmware(struct usb_device *, struct dvb_usb_properties *); | 28 | extern int dvb_usb_download_firmware(struct usb_device *, struct dvb_usb_device_properties *); |
28 | 29 | ||
29 | extern int dvb_usb_urb_submit(struct dvb_usb_device *); | 30 | extern int dvb_usb_device_power_ctrl(struct dvb_usb_device *d, int onoff); |
30 | extern int dvb_usb_urb_kill(struct dvb_usb_device *); | 31 | |
31 | extern int dvb_usb_urb_init(struct dvb_usb_device *); | 32 | extern int usb_urb_init(struct usb_data_stream *stream, struct usb_data_stream_properties *props); |
32 | extern int dvb_usb_urb_exit(struct dvb_usb_device *); | 33 | extern int usb_urb_exit(struct usb_data_stream *stream); |
34 | extern int usb_urb_submit(struct usb_data_stream *stream); | ||
35 | extern int usb_urb_kill(struct usb_data_stream *stream); | ||
36 | |||
37 | extern int dvb_usb_adapter_stream_init(struct dvb_usb_adapter *adap); | ||
38 | extern int dvb_usb_adapter_stream_exit(struct dvb_usb_adapter *adap); | ||
33 | 39 | ||
34 | extern int dvb_usb_i2c_init(struct dvb_usb_device *); | 40 | extern int dvb_usb_i2c_init(struct dvb_usb_device *); |
35 | extern int dvb_usb_i2c_exit(struct dvb_usb_device *); | 41 | extern int dvb_usb_i2c_exit(struct dvb_usb_device *); |
36 | 42 | ||
37 | extern int dvb_usb_dvb_init(struct dvb_usb_device *); | 43 | extern int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap); |
38 | extern int dvb_usb_dvb_exit(struct dvb_usb_device *); | 44 | extern int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap); |
39 | 45 | extern int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap); | |
40 | extern int dvb_usb_fe_init(struct dvb_usb_device *); | 46 | extern int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap); |
41 | extern int dvb_usb_fe_exit(struct dvb_usb_device *); | ||
42 | 47 | ||
43 | extern int dvb_usb_remote_init(struct dvb_usb_device *); | 48 | extern int dvb_usb_remote_init(struct dvb_usb_device *); |
44 | extern int dvb_usb_remote_exit(struct dvb_usb_device *); | 49 | extern int dvb_usb_remote_exit(struct dvb_usb_device *); |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c b/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c index fe6208ada903..4561a672da92 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-dvb.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* dvb-usb-dvb.c is part of the DVB USB library. | 1 | /* dvb-usb-dvb.c is part of the DVB USB library. |
2 | * | 2 | * |
3 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
4 | * see dvb-usb-init.c for copyright information. | 4 | * see dvb-usb-init.c for copyright information. |
5 | * | 5 | * |
6 | * This file contains functions for initializing and handling the | 6 | * This file contains functions for initializing and handling the |
@@ -8,55 +8,55 @@ | |||
8 | */ | 8 | */ |
9 | #include "dvb-usb-common.h" | 9 | #include "dvb-usb-common.h" |
10 | 10 | ||
11 | /* does the complete input transfer handling */ | ||
11 | static int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff) | 12 | static int dvb_usb_ctrl_feed(struct dvb_demux_feed *dvbdmxfeed, int onoff) |
12 | { | 13 | { |
13 | struct dvb_usb_device *d = dvbdmxfeed->demux->priv; | 14 | struct dvb_usb_adapter *adap = dvbdmxfeed->demux->priv; |
14 | int newfeedcount,ret; | 15 | int newfeedcount,ret; |
15 | 16 | ||
16 | if (d == NULL) | 17 | if (adap == NULL) |
17 | return -ENODEV; | 18 | return -ENODEV; |
18 | 19 | ||
19 | newfeedcount = d->feedcount + (onoff ? 1 : -1); | 20 | newfeedcount = adap->feedcount + (onoff ? 1 : -1); |
20 | 21 | ||
21 | /* | 22 | /* stop feed before setting a new pid if there will be no pid anymore */ |
22 | * stop feed before setting a new pid if there will be no pid anymore | ||
23 | */ | ||
24 | if (newfeedcount == 0) { | 23 | if (newfeedcount == 0) { |
25 | deb_ts("stop feeding\n"); | 24 | deb_ts("stop feeding\n"); |
26 | dvb_usb_urb_kill(d); | 25 | usb_urb_kill(&adap->stream); |
27 | 26 | ||
28 | if (d->props.streaming_ctrl != NULL) | 27 | if (adap->props.streaming_ctrl != NULL) |
29 | if ((ret = d->props.streaming_ctrl(d,0))) | 28 | if ((ret = adap->props.streaming_ctrl(adap,0))) |
30 | err("error while stopping stream."); | 29 | err("error while stopping stream."); |
31 | |||
32 | } | 30 | } |
33 | 31 | ||
34 | d->feedcount = newfeedcount; | 32 | adap->feedcount = newfeedcount; |
35 | 33 | ||
36 | /* activate the pid on the device specific pid_filter */ | 34 | /* activate the pid on the device specific pid_filter */ |
37 | deb_ts("setting pid: %5d %04x at index %d '%s'\n",dvbdmxfeed->pid,dvbdmxfeed->pid,dvbdmxfeed->index,onoff ? "on" : "off"); | 35 | deb_ts("setting pid (%s): %5d %04x at index %d '%s'\n",adap->pid_filtering ? |
38 | if (d->props.caps & DVB_USB_HAS_PID_FILTER && | 36 | "yes" : "no", dvbdmxfeed->pid,dvbdmxfeed->pid,dvbdmxfeed->index,onoff ? |
39 | d->pid_filtering && | 37 | "on" : "off"); |
40 | d->props.pid_filter != NULL) | 38 | if (adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER && |
41 | d->props.pid_filter(d,dvbdmxfeed->index,dvbdmxfeed->pid,onoff); | 39 | adap->pid_filtering && |
40 | adap->props.pid_filter != NULL) | ||
41 | adap->props.pid_filter(adap, dvbdmxfeed->index, dvbdmxfeed->pid,onoff); | ||
42 | 42 | ||
43 | /* start the feed if this was the first feed and there is still a feed | 43 | /* start the feed if this was the first feed and there is still a feed |
44 | * for reception. | 44 | * for reception. |
45 | */ | 45 | */ |
46 | if (d->feedcount == onoff && d->feedcount > 0) { | 46 | if (adap->feedcount == onoff && adap->feedcount > 0) { |
47 | deb_ts("submitting all URBs\n"); | 47 | deb_ts("submitting all URBs\n"); |
48 | dvb_usb_urb_submit(d); | 48 | usb_urb_submit(&adap->stream); |
49 | 49 | ||
50 | deb_ts("controlling pid parser\n"); | 50 | deb_ts("controlling pid parser\n"); |
51 | if (d->props.caps & DVB_USB_HAS_PID_FILTER && | 51 | if (adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER && |
52 | d->props.caps & DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF && | 52 | adap->props.caps & DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF && |
53 | d->props.pid_filter_ctrl != NULL) | 53 | adap->props.pid_filter_ctrl != NULL) |
54 | if (d->props.pid_filter_ctrl(d,d->pid_filtering) < 0) | 54 | if (adap->props.pid_filter_ctrl(adap,adap->pid_filtering) < 0) |
55 | err("could not handle pid_parser"); | 55 | err("could not handle pid_parser"); |
56 | 56 | ||
57 | deb_ts("start feeding\n"); | 57 | deb_ts("start feeding\n"); |
58 | if (d->props.streaming_ctrl != NULL) | 58 | if (adap->props.streaming_ctrl != NULL) |
59 | if (d->props.streaming_ctrl(d,1)) { | 59 | if (adap->props.streaming_ctrl(adap,1)) { |
60 | err("error while enabling fifo."); | 60 | err("error while enabling fifo."); |
61 | return -ENODEV; | 61 | return -ENODEV; |
62 | } | 62 | } |
@@ -77,134 +77,130 @@ static int dvb_usb_stop_feed(struct dvb_demux_feed *dvbdmxfeed) | |||
77 | return dvb_usb_ctrl_feed(dvbdmxfeed,0); | 77 | return dvb_usb_ctrl_feed(dvbdmxfeed,0); |
78 | } | 78 | } |
79 | 79 | ||
80 | int dvb_usb_dvb_init(struct dvb_usb_device *d) | 80 | int dvb_usb_adapter_dvb_init(struct dvb_usb_adapter *adap) |
81 | { | 81 | { |
82 | int ret; | 82 | int ret; |
83 | 83 | ||
84 | if ((ret = dvb_register_adapter(&d->dvb_adap, d->desc->name, | 84 | if ((ret = dvb_register_adapter(&adap->dvb_adap, adap->dev->desc->name, |
85 | d->owner, &d->udev->dev)) < 0) { | 85 | adap->dev->owner, &adap->dev->udev->dev)) < 0) { |
86 | deb_info("dvb_register_adapter failed: error %d", ret); | 86 | deb_info("dvb_register_adapter failed: error %d", ret); |
87 | goto err; | 87 | goto err; |
88 | } | 88 | } |
89 | d->dvb_adap.priv = d; | 89 | adap->dvb_adap.priv = adap; |
90 | 90 | ||
91 | if (d->props.read_mac_address) { | 91 | if (adap->dev->props.read_mac_address) { |
92 | if (d->props.read_mac_address(d,d->dvb_adap.proposed_mac) == 0) | 92 | if (adap->dev->props.read_mac_address(adap->dev,adap->dvb_adap.proposed_mac) == 0) |
93 | info("MAC address: %02x:%02x:%02x:%02x:%02x:%02x",d->dvb_adap.proposed_mac[0], | 93 | info("MAC address: %02x:%02x:%02x:%02x:%02x:%02x",adap->dvb_adap.proposed_mac[0], |
94 | d->dvb_adap.proposed_mac[1],d->dvb_adap.proposed_mac[2], | 94 | adap->dvb_adap.proposed_mac[1], adap->dvb_adap.proposed_mac[2], |
95 | d->dvb_adap.proposed_mac[3],d->dvb_adap.proposed_mac[4], | 95 | adap->dvb_adap.proposed_mac[3], adap->dvb_adap.proposed_mac[4], |
96 | d->dvb_adap.proposed_mac[5]); | 96 | adap->dvb_adap.proposed_mac[5]); |
97 | else | 97 | else |
98 | err("MAC address reading failed."); | 98 | err("MAC address reading failed."); |
99 | } | 99 | } |
100 | 100 | ||
101 | 101 | ||
102 | d->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; | 102 | adap->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; |
103 | d->demux.priv = d; | 103 | adap->demux.priv = adap; |
104 | 104 | ||
105 | d->demux.feednum = d->demux.filternum = d->max_feed_count; | 105 | adap->demux.feednum = adap->demux.filternum = adap->max_feed_count; |
106 | d->demux.start_feed = dvb_usb_start_feed; | 106 | adap->demux.start_feed = dvb_usb_start_feed; |
107 | d->demux.stop_feed = dvb_usb_stop_feed; | 107 | adap->demux.stop_feed = dvb_usb_stop_feed; |
108 | d->demux.write_to_decoder = NULL; | 108 | adap->demux.write_to_decoder = NULL; |
109 | if ((ret = dvb_dmx_init(&d->demux)) < 0) { | 109 | if ((ret = dvb_dmx_init(&adap->demux)) < 0) { |
110 | err("dvb_dmx_init failed: error %d",ret); | 110 | err("dvb_dmx_init failed: error %d",ret); |
111 | goto err_dmx; | 111 | goto err_dmx; |
112 | } | 112 | } |
113 | 113 | ||
114 | d->dmxdev.filternum = d->demux.filternum; | 114 | adap->dmxdev.filternum = adap->demux.filternum; |
115 | d->dmxdev.demux = &d->demux.dmx; | 115 | adap->dmxdev.demux = &adap->demux.dmx; |
116 | d->dmxdev.capabilities = 0; | 116 | adap->dmxdev.capabilities = 0; |
117 | if ((ret = dvb_dmxdev_init(&d->dmxdev, &d->dvb_adap)) < 0) { | 117 | if ((ret = dvb_dmxdev_init(&adap->dmxdev, &adap->dvb_adap)) < 0) { |
118 | err("dvb_dmxdev_init failed: error %d",ret); | 118 | err("dvb_dmxdev_init failed: error %d",ret); |
119 | goto err_dmx_dev; | 119 | goto err_dmx_dev; |
120 | } | 120 | } |
121 | 121 | ||
122 | dvb_net_init(&d->dvb_adap, &d->dvb_net, &d->demux.dmx); | 122 | dvb_net_init(&adap->dvb_adap, &adap->dvb_net, &adap->demux.dmx); |
123 | 123 | ||
124 | d->state |= DVB_USB_STATE_DVB; | 124 | adap->state |= DVB_USB_ADAP_STATE_DVB; |
125 | return 0; | 125 | return 0; |
126 | 126 | ||
127 | err_dmx_dev: | 127 | err_dmx_dev: |
128 | dvb_dmx_release(&d->demux); | 128 | dvb_dmx_release(&adap->demux); |
129 | err_dmx: | 129 | err_dmx: |
130 | dvb_unregister_adapter(&d->dvb_adap); | 130 | dvb_unregister_adapter(&adap->dvb_adap); |
131 | err: | 131 | err: |
132 | return ret; | 132 | return ret; |
133 | } | 133 | } |
134 | 134 | ||
135 | int dvb_usb_dvb_exit(struct dvb_usb_device *d) | 135 | int dvb_usb_adapter_dvb_exit(struct dvb_usb_adapter *adap) |
136 | { | 136 | { |
137 | if (d->state & DVB_USB_STATE_DVB) { | 137 | if (adap->state & DVB_USB_ADAP_STATE_DVB) { |
138 | deb_info("unregistering DVB part\n"); | 138 | deb_info("unregistering DVB part\n"); |
139 | dvb_net_release(&d->dvb_net); | 139 | dvb_net_release(&adap->dvb_net); |
140 | d->demux.dmx.close(&d->demux.dmx); | 140 | adap->demux.dmx.close(&adap->demux.dmx); |
141 | dvb_dmxdev_release(&d->dmxdev); | 141 | dvb_dmxdev_release(&adap->dmxdev); |
142 | dvb_dmx_release(&d->demux); | 142 | dvb_dmx_release(&adap->demux); |
143 | dvb_unregister_adapter(&d->dvb_adap); | 143 | dvb_unregister_adapter(&adap->dvb_adap); |
144 | d->state &= ~DVB_USB_STATE_DVB; | 144 | adap->state &= ~DVB_USB_ADAP_STATE_DVB; |
145 | } | 145 | } |
146 | return 0; | 146 | return 0; |
147 | } | 147 | } |
148 | 148 | ||
149 | static int dvb_usb_fe_wakeup(struct dvb_frontend *fe) | 149 | static int dvb_usb_fe_wakeup(struct dvb_frontend *fe) |
150 | { | 150 | { |
151 | struct dvb_usb_device *d = fe->dvb->priv; | 151 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
152 | 152 | ||
153 | if (d->props.power_ctrl) | 153 | dvb_usb_device_power_ctrl(adap->dev, 1); |
154 | d->props.power_ctrl(d,1); | ||
155 | 154 | ||
156 | if (d->fe_init) | 155 | if (adap->fe_init) |
157 | d->fe_init(fe); | 156 | adap->fe_init(fe); |
158 | 157 | ||
159 | return 0; | 158 | return 0; |
160 | } | 159 | } |
161 | 160 | ||
162 | static int dvb_usb_fe_sleep(struct dvb_frontend *fe) | 161 | static int dvb_usb_fe_sleep(struct dvb_frontend *fe) |
163 | { | 162 | { |
164 | struct dvb_usb_device *d = fe->dvb->priv; | 163 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
165 | 164 | ||
166 | if (d->fe_sleep) | 165 | if (adap->fe_sleep) |
167 | d->fe_sleep(fe); | 166 | adap->fe_sleep(fe); |
168 | 167 | ||
169 | if (d->props.power_ctrl) | 168 | return dvb_usb_device_power_ctrl(adap->dev, 0); |
170 | d->props.power_ctrl(d,0); | ||
171 | |||
172 | return 0; | ||
173 | } | 169 | } |
174 | 170 | ||
175 | int dvb_usb_fe_init(struct dvb_usb_device* d) | 171 | int dvb_usb_adapter_frontend_init(struct dvb_usb_adapter *adap) |
176 | { | 172 | { |
177 | if (d->props.frontend_attach == NULL) { | 173 | if (adap->props.frontend_attach == NULL) { |
178 | err("strange: '%s' doesn't want to attach a frontend.",d->desc->name); | 174 | err("strange: '%s' #%d doesn't want to attach a frontend.",adap->dev->desc->name, adap->id); |
179 | return 0; | 175 | return 0; |
180 | } | 176 | } |
181 | 177 | ||
182 | /* re-assign sleep and wakeup functions */ | 178 | /* re-assign sleep and wakeup functions */ |
183 | if (d->props.frontend_attach(d) == 0 && d->fe != NULL) { | 179 | if (adap->props.frontend_attach(adap) == 0 && adap->fe != NULL) { |
184 | d->fe_init = d->fe->ops.init; d->fe->ops.init = dvb_usb_fe_wakeup; | 180 | adap->fe_init = adap->fe->ops.init; adap->fe->ops.init = dvb_usb_fe_wakeup; |
185 | d->fe_sleep = d->fe->ops.sleep; d->fe->ops.sleep = dvb_usb_fe_sleep; | 181 | adap->fe_sleep = adap->fe->ops.sleep; adap->fe->ops.sleep = dvb_usb_fe_sleep; |
186 | 182 | ||
187 | if (dvb_register_frontend(&d->dvb_adap, d->fe)) { | 183 | if (dvb_register_frontend(&adap->dvb_adap, adap->fe)) { |
188 | err("Frontend registration failed."); | 184 | err("Frontend registration failed."); |
189 | dvb_frontend_detach(d->fe); | 185 | dvb_frontend_detach(adap->fe); |
190 | d->fe = NULL; | 186 | adap->fe = NULL; |
191 | return -ENODEV; | 187 | return -ENODEV; |
192 | } | 188 | } |
193 | 189 | ||
194 | /* only attach the tuner if the demod is there */ | 190 | /* only attach the tuner if the demod is there */ |
195 | if (d->props.tuner_attach != NULL) | 191 | if (adap->props.tuner_attach != NULL) |
196 | d->props.tuner_attach(d); | 192 | adap->props.tuner_attach(adap); |
197 | } else | 193 | } else |
198 | err("no frontend was attached by '%s'",d->desc->name); | 194 | err("no frontend was attached by '%s'",adap->dev->desc->name); |
199 | 195 | ||
200 | return 0; | 196 | return 0; |
201 | } | 197 | } |
202 | 198 | ||
203 | int dvb_usb_fe_exit(struct dvb_usb_device *d) | 199 | int dvb_usb_adapter_frontend_exit(struct dvb_usb_adapter *adap) |
204 | { | 200 | { |
205 | if (d->fe != NULL) { | 201 | if (adap->fe != NULL) { |
206 | dvb_unregister_frontend(d->fe); | 202 | dvb_unregister_frontend(adap->fe); |
207 | dvb_frontend_detach(d->fe); | 203 | dvb_frontend_detach(adap->fe); |
208 | } | 204 | } |
209 | return 0; | 205 | return 0; |
210 | } | 206 | } |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c index 9222b0a81f74..e1112e39fb63 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* dvb-usb-firmware.c is part of the DVB USB library. | 1 | /* dvb-usb-firmware.c is part of the DVB USB library. |
2 | * | 2 | * |
3 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
4 | * see dvb-usb-init.c for copyright information. | 4 | * see dvb-usb-init.c for copyright information. |
5 | * | 5 | * |
6 | * This file contains functions for downloading the firmware to Cypress FX 1 and 2 based devices. | 6 | * This file contains functions for downloading the firmware to Cypress FX 1 and 2 based devices. |
@@ -24,9 +24,6 @@ static struct usb_cypress_controller cypress[] = { | |||
24 | { .id = CYPRESS_FX2, .name = "Cypress FX2", .cpu_cs_register = 0xe600 }, | 24 | { .id = CYPRESS_FX2, .name = "Cypress FX2", .cpu_cs_register = 0xe600 }, |
25 | }; | 25 | }; |
26 | 26 | ||
27 | static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, | ||
28 | int *pos); | ||
29 | |||
30 | /* | 27 | /* |
31 | * load a firmware packet to the device | 28 | * load a firmware packet to the device |
32 | */ | 29 | */ |
@@ -78,7 +75,7 @@ int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw | |||
78 | } | 75 | } |
79 | EXPORT_SYMBOL(usb_cypress_load_firmware); | 76 | EXPORT_SYMBOL(usb_cypress_load_firmware); |
80 | 77 | ||
81 | int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_properties *props) | 78 | int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_device_properties *props) |
82 | { | 79 | { |
83 | int ret; | 80 | int ret; |
84 | const struct firmware *fw = NULL; | 81 | const struct firmware *fw = NULL; |
@@ -115,7 +112,7 @@ int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_properties | |||
115 | return ret; | 112 | return ret; |
116 | } | 113 | } |
117 | 114 | ||
118 | static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, | 115 | int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, |
119 | int *pos) | 116 | int *pos) |
120 | { | 117 | { |
121 | u8 *b = (u8 *) &fw->data[*pos]; | 118 | u8 *b = (u8 *) &fw->data[*pos]; |
@@ -146,3 +143,4 @@ static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, | |||
146 | 143 | ||
147 | return *pos; | 144 | return *pos; |
148 | } | 145 | } |
146 | EXPORT_SYMBOL(dvb_usb_get_hexline); | ||
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c b/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c index 6b611a725093..55ba020386c9 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-i2c.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* dvb-usb-i2c.c is part of the DVB USB library. | 1 | /* dvb-usb-i2c.c is part of the DVB USB library. |
2 | * | 2 | * |
3 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
4 | * see dvb-usb-init.c for copyright information. | 4 | * see dvb-usb-init.c for copyright information. |
5 | * | 5 | * |
6 | * This file contains functions for (de-)initializing an I2C adapter. | 6 | * This file contains functions for (de-)initializing an I2C adapter. |
@@ -48,48 +48,48 @@ int dvb_usb_i2c_exit(struct dvb_usb_device *d) | |||
48 | 48 | ||
49 | int dvb_usb_tuner_init_i2c(struct dvb_frontend *fe) | 49 | int dvb_usb_tuner_init_i2c(struct dvb_frontend *fe) |
50 | { | 50 | { |
51 | struct dvb_usb_device *d = fe->dvb->priv; | 51 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
52 | struct i2c_msg msg = { .addr = d->pll_addr, .flags = 0, .buf = d->pll_init, .len = 4 }; | 52 | struct i2c_msg msg = { .addr = adap->pll_addr, .flags = 0, .buf = adap->pll_init, .len = 4 }; |
53 | int ret = 0; | 53 | int ret = 0; |
54 | 54 | ||
55 | /* if pll_desc is not used */ | 55 | /* if pll_desc is not used */ |
56 | if (d->pll_desc == NULL) | 56 | if (adap->pll_desc == NULL) |
57 | return 0; | 57 | return 0; |
58 | 58 | ||
59 | if (d->tuner_pass_ctrl) | 59 | if (adap->tuner_pass_ctrl) |
60 | d->tuner_pass_ctrl(fe,1,d->pll_addr); | 60 | adap->tuner_pass_ctrl(fe, 1, adap->pll_addr); |
61 | 61 | ||
62 | deb_pll("pll init: %x\n",d->pll_addr); | 62 | deb_pll("pll init: %x\n",adap->pll_addr); |
63 | deb_pll("pll-buf: %x %x %x %x\n",d->pll_init[0],d->pll_init[1], | 63 | deb_pll("pll-buf: %x %x %x %x\n",adap->pll_init[0], adap->pll_init[1], |
64 | d->pll_init[2],d->pll_init[3]); | 64 | adap->pll_init[2], adap->pll_init[3]); |
65 | 65 | ||
66 | if (fe->ops.i2c_gate_ctrl) | 66 | if (fe->ops.i2c_gate_ctrl) |
67 | fe->ops.i2c_gate_ctrl(fe, 1); | 67 | fe->ops.i2c_gate_ctrl(fe, 1); |
68 | if (i2c_transfer (&d->i2c_adap, &msg, 1) != 1) { | 68 | if (i2c_transfer (&adap->dev->i2c_adap, &msg, 1) != 1) { |
69 | err("tuner i2c write failed for pll_init."); | 69 | err("tuner i2c write failed for pll_init."); |
70 | ret = -EREMOTEIO; | 70 | ret = -EREMOTEIO; |
71 | } | 71 | } |
72 | msleep(1); | 72 | msleep(1); |
73 | 73 | ||
74 | if (d->tuner_pass_ctrl) | 74 | if (adap->tuner_pass_ctrl) |
75 | d->tuner_pass_ctrl(fe,0,d->pll_addr); | 75 | adap->tuner_pass_ctrl(fe,0,adap->pll_addr); |
76 | return ret; | 76 | return ret; |
77 | } | 77 | } |
78 | EXPORT_SYMBOL(dvb_usb_tuner_init_i2c); | 78 | EXPORT_SYMBOL(dvb_usb_tuner_init_i2c); |
79 | 79 | ||
80 | int dvb_usb_tuner_calc_regs(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep, u8 *b, int buf_len) | 80 | int dvb_usb_tuner_calc_regs(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep, u8 *b, int buf_len) |
81 | { | 81 | { |
82 | struct dvb_usb_device *d = fe->dvb->priv; | 82 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
83 | 83 | ||
84 | if (buf_len != 5) | 84 | if (buf_len != 5) |
85 | return -EINVAL; | 85 | return -EINVAL; |
86 | if (d->pll_desc == NULL) | 86 | if (adap->pll_desc == NULL) |
87 | return 0; | 87 | return 0; |
88 | 88 | ||
89 | deb_pll("pll addr: %x, freq: %d %p\n",d->pll_addr,fep->frequency,d->pll_desc); | 89 | deb_pll("pll addr: %x, freq: %d %p\n",adap->pll_addr, fep->frequency, adap->pll_desc); |
90 | 90 | ||
91 | b[0] = d->pll_addr; | 91 | b[0] = adap->pll_addr; |
92 | dvb_pll_configure(d->pll_desc,&b[1],fep->frequency,fep->u.ofdm.bandwidth); | 92 | dvb_pll_configure(adap->pll_desc, &b[1], fep->frequency, fep->u.ofdm.bandwidth); |
93 | 93 | ||
94 | deb_pll("pll-buf: %x %x %x %x %x\n",b[0],b[1],b[2],b[3],b[4]); | 94 | deb_pll("pll-buf: %x %x %x %x %x\n",b[0],b[1],b[2],b[3],b[4]); |
95 | 95 | ||
@@ -99,26 +99,27 @@ EXPORT_SYMBOL(dvb_usb_tuner_calc_regs); | |||
99 | 99 | ||
100 | int dvb_usb_tuner_set_params_i2c(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) | 100 | int dvb_usb_tuner_set_params_i2c(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep) |
101 | { | 101 | { |
102 | struct dvb_usb_device *d = fe->dvb->priv; | 102 | struct dvb_usb_adapter *adap = fe->dvb->priv; |
103 | int ret = 0; | 103 | int ret = 0; |
104 | u8 b[5]; | 104 | u8 b[5]; |
105 | struct i2c_msg msg = { .addr = d->pll_addr, .flags = 0, .buf = &b[1], .len = 4 }; | 105 | struct i2c_msg msg = { .addr = adap->pll_addr, .flags = 0, .buf = &b[1], .len = 4 }; |
106 | 106 | ||
107 | dvb_usb_tuner_calc_regs(fe,fep,b,5); | 107 | dvb_usb_tuner_calc_regs(fe,fep,b,5); |
108 | 108 | ||
109 | if (d->tuner_pass_ctrl) | 109 | if (adap->tuner_pass_ctrl) |
110 | d->tuner_pass_ctrl(fe,1,d->pll_addr); | 110 | adap->tuner_pass_ctrl(fe, 1, adap->pll_addr); |
111 | 111 | ||
112 | if (fe->ops.i2c_gate_ctrl) | 112 | if (fe->ops.i2c_gate_ctrl) |
113 | fe->ops.i2c_gate_ctrl(fe, 1); | 113 | fe->ops.i2c_gate_ctrl(fe, 1); |
114 | if (i2c_transfer (&d->i2c_adap, &msg, 1) != 1) { | 114 | |
115 | if (i2c_transfer(&adap->dev->i2c_adap, &msg, 1) != 1) { | ||
115 | err("tuner i2c write failed for pll_set."); | 116 | err("tuner i2c write failed for pll_set."); |
116 | ret = -EREMOTEIO; | 117 | ret = -EREMOTEIO; |
117 | } | 118 | } |
118 | msleep(1); | 119 | msleep(1); |
119 | 120 | ||
120 | if (d->tuner_pass_ctrl) | 121 | if (adap->tuner_pass_ctrl) |
121 | d->tuner_pass_ctrl(fe,0,d->pll_addr); | 122 | adap->tuner_pass_ctrl(fe, 0, adap->pll_addr); |
122 | 123 | ||
123 | return ret; | 124 | return ret; |
124 | } | 125 | } |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h index 57a10de1d3dd..4d6b069536ce 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h +++ b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h | |||
@@ -52,8 +52,7 @@ | |||
52 | #define USB_PID_DIBCOM_MOD3000_WARM 0x0bb9 | 52 | #define USB_PID_DIBCOM_MOD3000_WARM 0x0bb9 |
53 | #define USB_PID_DIBCOM_MOD3001_COLD 0x0bc6 | 53 | #define USB_PID_DIBCOM_MOD3001_COLD 0x0bc6 |
54 | #define USB_PID_DIBCOM_MOD3001_WARM 0x0bc7 | 54 | #define USB_PID_DIBCOM_MOD3001_WARM 0x0bc7 |
55 | #define USB_PID_DIBCOM_STK7700 0x1e14 | 55 | #define USB_PID_DIBCOM_STK7700P 0x1e14 |
56 | #define USB_PID_DIBCOM_STK7700_REENUM 0x1e15 | ||
57 | #define USB_PID_DIBCOM_ANCHOR_2135_COLD 0x2131 | 56 | #define USB_PID_DIBCOM_ANCHOR_2135_COLD 0x2131 |
58 | #define USB_PID_GRANDTEC_DVBT_USB_COLD 0x0fa0 | 57 | #define USB_PID_GRANDTEC_DVBT_USB_COLD 0x0fa0 |
59 | #define USB_PID_GRANDTEC_DVBT_USB_WARM 0x0fa1 | 58 | #define USB_PID_GRANDTEC_DVBT_USB_WARM 0x0fa1 |
@@ -95,6 +94,10 @@ | |||
95 | #define USB_PID_WT220U_ZL0353_WARM 0x022b | 94 | #define USB_PID_WT220U_ZL0353_WARM 0x022b |
96 | #define USB_PID_WINTV_NOVA_T_USB2_COLD 0x9300 | 95 | #define USB_PID_WINTV_NOVA_T_USB2_COLD 0x9300 |
97 | #define USB_PID_WINTV_NOVA_T_USB2_WARM 0x9301 | 96 | #define USB_PID_WINTV_NOVA_T_USB2_WARM 0x9301 |
97 | #define USB_PID_HAUPPAUGE_NOVA_T_500 0x9941 | ||
98 | #define USB_PID_HAUPPAUGE_NOVA_T_500_2 0x9950 | ||
99 | #define USB_PID_HAUPPAUGE_NOVA_T_STICK 0x7050 | ||
100 | #define USB_PID_AVERMEDIA_VOLAR 0x1234 | ||
98 | #define USB_PID_NEBULA_DIGITV 0x0201 | 101 | #define USB_PID_NEBULA_DIGITV 0x0201 |
99 | #define USB_PID_DVICO_BLUEBIRD_LGDT 0xd820 | 102 | #define USB_PID_DVICO_BLUEBIRD_LGDT 0xd820 |
100 | #define USB_PID_DVICO_BLUEBIRD_LG064F_COLD 0xd500 | 103 | #define USB_PID_DVICO_BLUEBIRD_LG064F_COLD 0xd500 |
@@ -103,10 +106,12 @@ | |||
103 | #define USB_PID_DVICO_BLUEBIRD_LGZ201_WARM 0xdb01 | 106 | #define USB_PID_DVICO_BLUEBIRD_LGZ201_WARM 0xdb01 |
104 | #define USB_PID_DVICO_BLUEBIRD_TH7579_COLD 0xdb10 | 107 | #define USB_PID_DVICO_BLUEBIRD_TH7579_COLD 0xdb10 |
105 | #define USB_PID_DVICO_BLUEBIRD_TH7579_WARM 0xdb11 | 108 | #define USB_PID_DVICO_BLUEBIRD_TH7579_WARM 0xdb11 |
106 | #define USB_PID_DVICO_BLUEBIRD_DEE1601_COLD 0xdb50 | 109 | #define USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD 0xdb50 |
107 | #define USB_PID_DVICO_BLUEBIRD_DEE1601_WARM 0xdb51 | 110 | #define USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM 0xdb51 |
108 | #define USB_PID_DIGITALNOW_BLUEBIRD_DEE1601_COLD 0xdb54 | 111 | #define USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD 0xdb58 |
109 | #define USB_PID_DIGITALNOW_BLUEBIRD_DEE1601_WARM 0xdb55 | 112 | #define USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM 0xdb59 |
113 | #define USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD 0xdb54 | ||
114 | #define USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM 0xdb55 | ||
110 | #define USB_PID_MEDION_MD95700 0x0932 | 115 | #define USB_PID_MEDION_MD95700 0x0932 |
111 | #define USB_PID_KYE_DVB_T_COLD 0x701e | 116 | #define USB_PID_KYE_DVB_T_COLD 0x701e |
112 | #define USB_PID_KYE_DVB_T_WARM 0x701f | 117 | #define USB_PID_KYE_DVB_T_WARM 0x701f |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-init.c b/drivers/media/dvb/dvb-usb/dvb-usb-init.c index a1705ecb9a54..ffdde83d1e77 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-init.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-init.c | |||
@@ -3,7 +3,7 @@ | |||
3 | * | 3 | * |
4 | * dvb-usb-init.c | 4 | * dvb-usb-init.c |
5 | * | 5 | * |
6 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 6 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
7 | * | 7 | * |
8 | * This program is free software; you can redistribute it and/or modify it | 8 | * This program is free software; you can redistribute it and/or modify it |
9 | * under the terms of the GNU General Public License as published by the Free | 9 | * under the terms of the GNU General Public License as published by the Free |
@@ -16,21 +16,105 @@ | |||
16 | /* debug */ | 16 | /* debug */ |
17 | int dvb_usb_debug; | 17 | int dvb_usb_debug; |
18 | module_param_named(debug,dvb_usb_debug, int, 0644); | 18 | module_param_named(debug,dvb_usb_debug, int, 0644); |
19 | MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))." DVB_USB_DEBUG_STATUS); | 19 | MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64,mem=128,uxfer=256 (or-able))." DVB_USB_DEBUG_STATUS); |
20 | 20 | ||
21 | int dvb_usb_disable_rc_polling; | 21 | int dvb_usb_disable_rc_polling; |
22 | module_param_named(disable_rc_polling, dvb_usb_disable_rc_polling, int, 0644); | 22 | module_param_named(disable_rc_polling, dvb_usb_disable_rc_polling, int, 0644); |
23 | MODULE_PARM_DESC(disable_rc_polling, "disable remote control polling (default: 0)."); | 23 | MODULE_PARM_DESC(disable_rc_polling, "disable remote control polling (default: 0)."); |
24 | 24 | ||
25 | static int dvb_usb_force_pid_filter_usage; | ||
26 | module_param_named(force_pid_filter_usage, dvb_usb_force_pid_filter_usage, int, 0444); | ||
27 | MODULE_PARM_DESC(disable_rc_polling, "force all dvb-usb-devices to use a PID filter, if any (default: 0)."); | ||
28 | |||
29 | static int dvb_usb_adapter_init(struct dvb_usb_device *d) | ||
30 | { | ||
31 | struct dvb_usb_adapter *adap; | ||
32 | int ret,n; | ||
33 | |||
34 | for (n = 0; n < d->props.num_adapters; n++) { | ||
35 | adap = &d->adapter[n]; | ||
36 | adap->dev = d; | ||
37 | adap->id = n; | ||
38 | |||
39 | memcpy(&adap->props, &d->props.adapter[n], sizeof(struct dvb_usb_adapter_properties)); | ||
40 | |||
41 | /* speed - when running at FULL speed we need a HW PID filter */ | ||
42 | if (d->udev->speed == USB_SPEED_FULL && !(adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER)) { | ||
43 | err("This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)"); | ||
44 | return -ENODEV; | ||
45 | } | ||
46 | |||
47 | if ((d->udev->speed == USB_SPEED_FULL && adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) || | ||
48 | (adap->props.caps & DVB_USB_ADAP_NEED_PID_FILTERING)) { | ||
49 | info("will use the device's hardware PID filter (table count: %d).",adap->props.pid_filter_count); | ||
50 | adap->pid_filtering = 1; | ||
51 | adap->max_feed_count = adap->props.pid_filter_count; | ||
52 | } else { | ||
53 | info("will pass the complete MPEG2 transport stream to the software demuxer."); | ||
54 | adap->pid_filtering = 0; | ||
55 | adap->max_feed_count = 255; | ||
56 | } | ||
57 | |||
58 | if (!adap->pid_filtering && | ||
59 | dvb_usb_force_pid_filter_usage && | ||
60 | adap->props.caps & DVB_USB_ADAP_HAS_PID_FILTER) { | ||
61 | info("pid filter enabled by module option."); | ||
62 | adap->pid_filtering = 1; | ||
63 | adap->max_feed_count = adap->props.pid_filter_count; | ||
64 | } | ||
65 | |||
66 | if (adap->props.size_of_priv > 0) { | ||
67 | adap->priv = kzalloc(adap->props.size_of_priv,GFP_KERNEL); | ||
68 | if (adap->priv == NULL) { | ||
69 | err("no memory for priv for adapter %d.",n); | ||
70 | return -ENOMEM; | ||
71 | } | ||
72 | } | ||
73 | |||
74 | if ((ret = dvb_usb_adapter_stream_init(adap)) || | ||
75 | (ret = dvb_usb_adapter_dvb_init(adap)) || | ||
76 | (ret = dvb_usb_adapter_frontend_init(adap))) { | ||
77 | return ret; | ||
78 | } | ||
79 | |||
80 | d->num_adapters_initialized++; | ||
81 | d->state |= DVB_USB_STATE_DVB; | ||
82 | } | ||
83 | |||
84 | /* | ||
85 | * when reloading the driver w/o replugging the device | ||
86 | * sometimes a timeout occures, this helps | ||
87 | */ | ||
88 | if (d->props.generic_bulk_ctrl_endpoint != 0) { | ||
89 | usb_clear_halt(d->udev,usb_sndbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint)); | ||
90 | usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint)); | ||
91 | } | ||
92 | |||
93 | return 0; | ||
94 | } | ||
95 | |||
96 | static int dvb_usb_adapter_exit(struct dvb_usb_device *d) | ||
97 | { | ||
98 | int n; | ||
99 | for (n = 0; n < d->num_adapters_initialized; n++) { | ||
100 | dvb_usb_adapter_frontend_exit(&d->adapter[n]); | ||
101 | dvb_usb_adapter_dvb_exit(&d->adapter[n]); | ||
102 | dvb_usb_adapter_stream_exit(&d->adapter[n]); | ||
103 | kfree(d->adapter[n].priv); | ||
104 | } | ||
105 | d->num_adapters_initialized = 0; | ||
106 | d->state &= ~DVB_USB_STATE_DVB; | ||
107 | return 0; | ||
108 | } | ||
109 | |||
110 | |||
25 | /* general initialization functions */ | 111 | /* general initialization functions */ |
26 | static int dvb_usb_exit(struct dvb_usb_device *d) | 112 | static int dvb_usb_exit(struct dvb_usb_device *d) |
27 | { | 113 | { |
28 | deb_info("state before exiting everything: %x\n",d->state); | 114 | deb_info("state before exiting everything: %x\n",d->state); |
29 | dvb_usb_remote_exit(d); | 115 | dvb_usb_remote_exit(d); |
30 | dvb_usb_fe_exit(d); | 116 | dvb_usb_adapter_exit(d); |
31 | dvb_usb_i2c_exit(d); | 117 | dvb_usb_i2c_exit(d); |
32 | dvb_usb_dvb_exit(d); | ||
33 | dvb_usb_urb_exit(d); | ||
34 | deb_info("state should be zero now: %x\n",d->state); | 118 | deb_info("state should be zero now: %x\n",d->state); |
35 | d->state = DVB_USB_STATE_INIT; | 119 | d->state = DVB_USB_STATE_INIT; |
36 | kfree(d->priv); | 120 | kfree(d->priv); |
@@ -47,32 +131,19 @@ static int dvb_usb_init(struct dvb_usb_device *d) | |||
47 | 131 | ||
48 | d->state = DVB_USB_STATE_INIT; | 132 | d->state = DVB_USB_STATE_INIT; |
49 | 133 | ||
50 | /* check the capabilities and set appropriate variables */ | 134 | if (d->props.size_of_priv > 0) { |
51 | 135 | d->priv = kzalloc(d->props.size_of_priv,GFP_KERNEL); | |
52 | /* speed - when running at FULL speed we need a HW PID filter */ | 136 | if (d->priv == NULL) { |
53 | if (d->udev->speed == USB_SPEED_FULL && !(d->props.caps & DVB_USB_HAS_PID_FILTER)) { | 137 | err("no memory for priv in 'struct dvb_usb_device'"); |
54 | err("This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)"); | 138 | return -ENOMEM; |
55 | return -ENODEV; | 139 | } |
56 | } | ||
57 | |||
58 | if ((d->udev->speed == USB_SPEED_FULL && d->props.caps & DVB_USB_HAS_PID_FILTER) || | ||
59 | (d->props.caps & DVB_USB_NEED_PID_FILTERING)) { | ||
60 | info("will use the device's hardware PID filter (table count: %d).",d->props.pid_filter_count); | ||
61 | d->pid_filtering = 1; | ||
62 | d->max_feed_count = d->props.pid_filter_count; | ||
63 | } else { | ||
64 | info("will pass the complete MPEG2 transport stream to the software demuxer."); | ||
65 | d->pid_filtering = 0; | ||
66 | d->max_feed_count = 255; | ||
67 | } | 140 | } |
68 | 141 | ||
69 | if (d->props.power_ctrl) | 142 | /* check the capabilities and set appropriate variables */ |
70 | d->props.power_ctrl(d,1); | 143 | dvb_usb_device_power_ctrl(d, 1); |
71 | 144 | ||
72 | if ((ret = dvb_usb_urb_init(d)) || | 145 | if ((ret = dvb_usb_i2c_init(d)) || |
73 | (ret = dvb_usb_dvb_init(d)) || | 146 | (ret = dvb_usb_adapter_init(d))) { |
74 | (ret = dvb_usb_i2c_init(d)) || | ||
75 | (ret = dvb_usb_fe_init(d))) { | ||
76 | dvb_usb_exit(d); | 147 | dvb_usb_exit(d); |
77 | return ret; | 148 | return ret; |
78 | } | 149 | } |
@@ -80,14 +151,13 @@ static int dvb_usb_init(struct dvb_usb_device *d) | |||
80 | if ((ret = dvb_usb_remote_init(d))) | 151 | if ((ret = dvb_usb_remote_init(d))) |
81 | err("could not initialize remote control."); | 152 | err("could not initialize remote control."); |
82 | 153 | ||
83 | if (d->props.power_ctrl) | 154 | dvb_usb_device_power_ctrl(d, 0); |
84 | d->props.power_ctrl(d,0); | ||
85 | 155 | ||
86 | return 0; | 156 | return 0; |
87 | } | 157 | } |
88 | 158 | ||
89 | /* determine the name and the state of the just found USB device */ | 159 | /* determine the name and the state of the just found USB device */ |
90 | static struct dvb_usb_device_description * dvb_usb_find_device(struct usb_device *udev,struct dvb_usb_properties *props, int *cold) | 160 | static struct dvb_usb_device_description * dvb_usb_find_device(struct usb_device *udev,struct dvb_usb_device_properties *props, int *cold) |
91 | { | 161 | { |
92 | int i,j; | 162 | int i,j; |
93 | struct dvb_usb_device_description *desc = NULL; | 163 | struct dvb_usb_device_description *desc = NULL; |
@@ -125,11 +195,25 @@ static struct dvb_usb_device_description * dvb_usb_find_device(struct usb_device | |||
125 | return desc; | 195 | return desc; |
126 | } | 196 | } |
127 | 197 | ||
198 | int dvb_usb_device_power_ctrl(struct dvb_usb_device *d, int onoff) | ||
199 | { | ||
200 | if (onoff) | ||
201 | d->powered++; | ||
202 | else | ||
203 | d->powered--; | ||
204 | |||
205 | if (d->powered == 0 || (onoff && d->powered == 1)) { // when switching from 1 to 0 or from 0 to 1 | ||
206 | deb_info("power control: %d\n", onoff); | ||
207 | if (d->props.power_ctrl) | ||
208 | return d->props.power_ctrl(d, onoff); | ||
209 | } | ||
210 | return 0; | ||
211 | } | ||
212 | |||
128 | /* | 213 | /* |
129 | * USB | 214 | * USB |
130 | */ | 215 | */ |
131 | 216 | int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_device_properties | |
132 | int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_properties | ||
133 | *props, struct module *owner,struct dvb_usb_device **du) | 217 | *props, struct module *owner,struct dvb_usb_device **du) |
134 | { | 218 | { |
135 | struct usb_device *udev = interface_to_usbdev(intf); | 219 | struct usb_device *udev = interface_to_usbdev(intf); |
@@ -149,7 +233,7 @@ int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_properties | |||
149 | if (cold) { | 233 | if (cold) { |
150 | info("found a '%s' in cold state, will try to load a firmware",desc->name); | 234 | info("found a '%s' in cold state, will try to load a firmware",desc->name); |
151 | ret = dvb_usb_download_firmware(udev,props); | 235 | ret = dvb_usb_download_firmware(udev,props); |
152 | if (!props->no_reconnect) | 236 | if (!props->no_reconnect || ret != 0) |
153 | return ret; | 237 | return ret; |
154 | } | 238 | } |
155 | 239 | ||
@@ -161,19 +245,10 @@ int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_properties | |||
161 | } | 245 | } |
162 | 246 | ||
163 | d->udev = udev; | 247 | d->udev = udev; |
164 | memcpy(&d->props,props,sizeof(struct dvb_usb_properties)); | 248 | memcpy(&d->props,props,sizeof(struct dvb_usb_device_properties)); |
165 | d->desc = desc; | 249 | d->desc = desc; |
166 | d->owner = owner; | 250 | d->owner = owner; |
167 | 251 | ||
168 | if (d->props.size_of_priv > 0) { | ||
169 | d->priv = kzalloc(d->props.size_of_priv,GFP_KERNEL); | ||
170 | if (d->priv == NULL) { | ||
171 | err("no memory for priv in 'struct dvb_usb_device'"); | ||
172 | kfree(d); | ||
173 | return -ENOMEM; | ||
174 | } | ||
175 | } | ||
176 | |||
177 | usb_set_intfdata(intf, d); | 252 | usb_set_intfdata(intf, d); |
178 | 253 | ||
179 | if (du != NULL) | 254 | if (du != NULL) |
@@ -204,7 +279,7 @@ void dvb_usb_device_exit(struct usb_interface *intf) | |||
204 | } | 279 | } |
205 | EXPORT_SYMBOL(dvb_usb_device_exit); | 280 | EXPORT_SYMBOL(dvb_usb_device_exit); |
206 | 281 | ||
207 | MODULE_VERSION("0.3"); | 282 | MODULE_VERSION("1.0"); |
208 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); | 283 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); |
209 | MODULE_DESCRIPTION("A library module containing commonly used USB and DVB function USB DVB devices"); | 284 | MODULE_DESCRIPTION("A library module containing commonly used USB and DVB function USB DVB devices"); |
210 | MODULE_LICENSE("GPL"); | 285 | MODULE_LICENSE("GPL"); |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c index 380b2a45ee4c..0a3a0b6c2350 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-remote.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-remote.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* dvb-usb-remote.c is part of the DVB USB library. | 1 | /* dvb-usb-remote.c is part of the DVB USB library. |
2 | * | 2 | * |
3 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
4 | * see dvb-usb-init.c for copyright information. | 4 | * see dvb-usb-init.c for copyright information. |
5 | * | 5 | * |
6 | * This file contains functions for initializing the the input-device and for handling remote-control-queries. | 6 | * This file contains functions for initializing the the input-device and for handling remote-control-queries. |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-urb.c b/drivers/media/dvb/dvb-usb/dvb-usb-urb.c index 88b283731bb8..5cef12a07f72 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb-urb.c +++ b/drivers/media/dvb/dvb-usb/dvb-usb-urb.c | |||
@@ -1,9 +1,9 @@ | |||
1 | /* dvb-usb-urb.c is part of the DVB USB library. | 1 | /* dvb-usb-urb.c is part of the DVB USB library. |
2 | * | 2 | * |
3 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
4 | * see dvb-usb-init.c for copyright information. | 4 | * see dvb-usb-init.c for copyright information. |
5 | * | 5 | * |
6 | * This file contains functions for initializing and handling the | 6 | * This file keeps functions for initializing and handling the |
7 | * USB and URB stuff. | 7 | * USB and URB stuff. |
8 | */ | 8 | */ |
9 | #include "dvb-usb-common.h" | 9 | #include "dvb-usb-common.h" |
@@ -64,260 +64,32 @@ int dvb_usb_generic_write(struct dvb_usb_device *d, u8 *buf, u16 len) | |||
64 | } | 64 | } |
65 | EXPORT_SYMBOL(dvb_usb_generic_write); | 65 | EXPORT_SYMBOL(dvb_usb_generic_write); |
66 | 66 | ||
67 | 67 | static void dvb_usb_data_complete(struct usb_data_stream *stream, u8 *buffer, size_t length) | |
68 | /* URB stuff for streaming */ | ||
69 | static void dvb_usb_urb_complete(struct urb *urb, struct pt_regs *ptregs) | ||
70 | { | ||
71 | struct dvb_usb_device *d = urb->context; | ||
72 | int ptype = usb_pipetype(urb->pipe); | ||
73 | int i; | ||
74 | u8 *b; | ||
75 | |||
76 | deb_ts("'%s' urb completed. feedcount: %d, status: %d, length: %d/%d, pack_num: %d, errors: %d\n", | ||
77 | ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk", d->feedcount, | ||
78 | urb->status,urb->actual_length,urb->transfer_buffer_length, | ||
79 | urb->number_of_packets,urb->error_count); | ||
80 | |||
81 | switch (urb->status) { | ||
82 | case 0: /* success */ | ||
83 | break; | ||
84 | case -ECONNRESET: /* kill */ | ||
85 | case -ENOENT: | ||
86 | case -ESHUTDOWN: | ||
87 | return; | ||
88 | default: /* error */ | ||
89 | deb_ts("urb completition error %d.", urb->status); | ||
90 | break; | ||
91 | } | ||
92 | |||
93 | if (d->feedcount > 0) { | ||
94 | if (d->state & DVB_USB_STATE_DVB) { | ||
95 | switch (ptype) { | ||
96 | case PIPE_ISOCHRONOUS: | ||
97 | b = (u8 *) urb->transfer_buffer; | ||
98 | for (i = 0; i < urb->number_of_packets; i++) { | ||
99 | if (urb->iso_frame_desc[i].status != 0) | ||
100 | deb_ts("iso frame descriptor has an error: %d\n",urb->iso_frame_desc[i].status); | ||
101 | else if (urb->iso_frame_desc[i].actual_length > 0) { | ||
102 | dvb_dmx_swfilter(&d->demux,b + urb->iso_frame_desc[i].offset, | ||
103 | urb->iso_frame_desc[i].actual_length); | ||
104 | } | ||
105 | urb->iso_frame_desc[i].status = 0; | ||
106 | urb->iso_frame_desc[i].actual_length = 0; | ||
107 | } | ||
108 | debug_dump(b,20,deb_ts); | ||
109 | break; | ||
110 | case PIPE_BULK: | ||
111 | if (urb->actual_length > 0) | ||
112 | dvb_dmx_swfilter(&d->demux, (u8 *) urb->transfer_buffer,urb->actual_length); | ||
113 | break; | ||
114 | default: | ||
115 | err("unkown endpoint type in completition handler."); | ||
116 | return; | ||
117 | } | ||
118 | } | ||
119 | } | ||
120 | |||
121 | usb_submit_urb(urb,GFP_ATOMIC); | ||
122 | } | ||
123 | |||
124 | int dvb_usb_urb_kill(struct dvb_usb_device *d) | ||
125 | { | ||
126 | int i; | ||
127 | for (i = 0; i < d->urbs_submitted; i++) { | ||
128 | deb_ts("killing URB no. %d.\n",i); | ||
129 | |||
130 | /* stop the URB */ | ||
131 | usb_kill_urb(d->urb_list[i]); | ||
132 | } | ||
133 | d->urbs_submitted = 0; | ||
134 | return 0; | ||
135 | } | ||
136 | |||
137 | int dvb_usb_urb_submit(struct dvb_usb_device *d) | ||
138 | { | ||
139 | int i,ret; | ||
140 | for (i = 0; i < d->urbs_initialized; i++) { | ||
141 | deb_ts("submitting URB no. %d\n",i); | ||
142 | if ((ret = usb_submit_urb(d->urb_list[i],GFP_ATOMIC))) { | ||
143 | err("could not submit URB no. %d - get them all back",i); | ||
144 | dvb_usb_urb_kill(d); | ||
145 | return ret; | ||
146 | } | ||
147 | d->urbs_submitted++; | ||
148 | } | ||
149 | return 0; | ||
150 | } | ||
151 | |||
152 | static int dvb_usb_free_stream_buffers(struct dvb_usb_device *d) | ||
153 | { | ||
154 | if (d->state & DVB_USB_STATE_URB_BUF) { | ||
155 | while (d->buf_num) { | ||
156 | d->buf_num--; | ||
157 | deb_mem("freeing buffer %d\n",d->buf_num); | ||
158 | usb_buffer_free(d->udev, d->buf_size, | ||
159 | d->buf_list[d->buf_num], d->dma_addr[d->buf_num]); | ||
160 | } | ||
161 | kfree(d->buf_list); | ||
162 | kfree(d->dma_addr); | ||
163 | } | ||
164 | |||
165 | d->state &= ~DVB_USB_STATE_URB_BUF; | ||
166 | |||
167 | return 0; | ||
168 | } | ||
169 | |||
170 | static int dvb_usb_allocate_stream_buffers(struct dvb_usb_device *d, int num, unsigned long size) | ||
171 | { | ||
172 | d->buf_num = 0; | ||
173 | d->buf_size = size; | ||
174 | |||
175 | deb_mem("all in all I will use %lu bytes for streaming\n",num*size); | ||
176 | |||
177 | if ((d->buf_list = kcalloc(num, sizeof(u8 *), GFP_ATOMIC)) == NULL) | ||
178 | return -ENOMEM; | ||
179 | |||
180 | if ((d->dma_addr = kcalloc(num, sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) { | ||
181 | kfree(d->buf_list); | ||
182 | return -ENOMEM; | ||
183 | } | ||
184 | |||
185 | d->state |= DVB_USB_STATE_URB_BUF; | ||
186 | |||
187 | for (d->buf_num = 0; d->buf_num < num; d->buf_num++) { | ||
188 | deb_mem("allocating buffer %d\n",d->buf_num); | ||
189 | if (( d->buf_list[d->buf_num] = | ||
190 | usb_buffer_alloc(d->udev, size, SLAB_ATOMIC, | ||
191 | &d->dma_addr[d->buf_num]) ) == NULL) { | ||
192 | deb_mem("not enough memory for urb-buffer allocation.\n"); | ||
193 | dvb_usb_free_stream_buffers(d); | ||
194 | return -ENOMEM; | ||
195 | } | ||
196 | deb_mem("buffer %d: %p (dma: %llu)\n", | ||
197 | d->buf_num, d->buf_list[d->buf_num], | ||
198 | (unsigned long long)d->dma_addr[d->buf_num]); | ||
199 | memset(d->buf_list[d->buf_num],0,size); | ||
200 | } | ||
201 | deb_mem("allocation successful\n"); | ||
202 | |||
203 | return 0; | ||
204 | } | ||
205 | |||
206 | static int dvb_usb_bulk_urb_init(struct dvb_usb_device *d) | ||
207 | { | 68 | { |
208 | int i; | 69 | struct dvb_usb_adapter *adap = stream->user_priv; |
209 | 70 | if (adap->feedcount > 0 && adap->state & DVB_USB_ADAP_STATE_DVB) | |
210 | if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count, | 71 | dvb_dmx_swfilter(&adap->demux, buffer, length); |
211 | d->props.urb.u.bulk.buffersize)) < 0) | ||
212 | return i; | ||
213 | |||
214 | /* allocate the URBs */ | ||
215 | for (i = 0; i < d->props.urb.count; i++) { | ||
216 | if ((d->urb_list[i] = usb_alloc_urb(0,GFP_ATOMIC)) == NULL) | ||
217 | return -ENOMEM; | ||
218 | |||
219 | usb_fill_bulk_urb( d->urb_list[i], d->udev, | ||
220 | usb_rcvbulkpipe(d->udev,d->props.urb.endpoint), | ||
221 | d->buf_list[i], | ||
222 | d->props.urb.u.bulk.buffersize, | ||
223 | dvb_usb_urb_complete, d); | ||
224 | |||
225 | d->urb_list[i]->transfer_flags = 0; | ||
226 | d->urbs_initialized++; | ||
227 | } | ||
228 | return 0; | ||
229 | } | 72 | } |
230 | 73 | ||
231 | static int dvb_usb_isoc_urb_init(struct dvb_usb_device *d) | 74 | static void dvb_usb_data_complete_204(struct usb_data_stream *stream, u8 *buffer, size_t length) |
232 | { | 75 | { |
233 | int i,j; | 76 | struct dvb_usb_adapter *adap = stream->user_priv; |
234 | 77 | if (adap->feedcount > 0 && adap->state & DVB_USB_ADAP_STATE_DVB) | |
235 | if ((i = dvb_usb_allocate_stream_buffers(d,d->props.urb.count, | 78 | dvb_dmx_swfilter_204(&adap->demux, buffer, length); |
236 | d->props.urb.u.isoc.framesize*d->props.urb.u.isoc.framesperurb)) < 0) | ||
237 | return i; | ||
238 | |||
239 | /* allocate the URBs */ | ||
240 | for (i = 0; i < d->props.urb.count; i++) { | ||
241 | struct urb *urb; | ||
242 | int frame_offset = 0; | ||
243 | if ((d->urb_list[i] = | ||
244 | usb_alloc_urb(d->props.urb.u.isoc.framesperurb,GFP_ATOMIC)) == NULL) | ||
245 | return -ENOMEM; | ||
246 | |||
247 | urb = d->urb_list[i]; | ||
248 | |||
249 | urb->dev = d->udev; | ||
250 | urb->context = d; | ||
251 | urb->complete = dvb_usb_urb_complete; | ||
252 | urb->pipe = usb_rcvisocpipe(d->udev,d->props.urb.endpoint); | ||
253 | urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; | ||
254 | urb->interval = d->props.urb.u.isoc.interval; | ||
255 | urb->number_of_packets = d->props.urb.u.isoc.framesperurb; | ||
256 | urb->transfer_buffer_length = d->buf_size; | ||
257 | urb->transfer_buffer = d->buf_list[i]; | ||
258 | urb->transfer_dma = d->dma_addr[i]; | ||
259 | |||
260 | for (j = 0; j < d->props.urb.u.isoc.framesperurb; j++) { | ||
261 | urb->iso_frame_desc[j].offset = frame_offset; | ||
262 | urb->iso_frame_desc[j].length = d->props.urb.u.isoc.framesize; | ||
263 | frame_offset += d->props.urb.u.isoc.framesize; | ||
264 | } | ||
265 | |||
266 | d->urbs_initialized++; | ||
267 | } | ||
268 | return 0; | ||
269 | |||
270 | } | 79 | } |
271 | 80 | ||
272 | int dvb_usb_urb_init(struct dvb_usb_device *d) | 81 | int dvb_usb_adapter_stream_init(struct dvb_usb_adapter *adap) |
273 | { | 82 | { |
274 | /* | 83 | adap->stream.udev = adap->dev->udev; |
275 | * when reloading the driver w/o replugging the device | 84 | if (adap->props.caps & DVB_USB_ADAP_RECEIVES_204_BYTE_TS) |
276 | * sometimes a timeout occures, this helps | 85 | adap->stream.complete = dvb_usb_data_complete_204; |
277 | */ | 86 | else |
278 | if (d->props.generic_bulk_ctrl_endpoint != 0) { | 87 | adap->stream.complete = dvb_usb_data_complete; |
279 | usb_clear_halt(d->udev,usb_sndbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint)); | 88 | adap->stream.user_priv = adap; |
280 | usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.generic_bulk_ctrl_endpoint)); | 89 | return usb_urb_init(&adap->stream, &adap->props.stream); |
281 | } | ||
282 | usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.urb.endpoint)); | ||
283 | |||
284 | /* allocate the array for the data transfer URBs */ | ||
285 | d->urb_list = kzalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL); | ||
286 | if (d->urb_list == NULL) | ||
287 | return -ENOMEM; | ||
288 | d->state |= DVB_USB_STATE_URB_LIST; | ||
289 | |||
290 | switch (d->props.urb.type) { | ||
291 | case DVB_USB_BULK: | ||
292 | return dvb_usb_bulk_urb_init(d); | ||
293 | case DVB_USB_ISOC: | ||
294 | return dvb_usb_isoc_urb_init(d); | ||
295 | default: | ||
296 | err("unkown URB-type for data transfer."); | ||
297 | return -EINVAL; | ||
298 | } | ||
299 | } | 90 | } |
300 | 91 | ||
301 | int dvb_usb_urb_exit(struct dvb_usb_device *d) | 92 | int dvb_usb_adapter_stream_exit(struct dvb_usb_adapter *adap) |
302 | { | 93 | { |
303 | int i; | 94 | return usb_urb_exit(&adap->stream); |
304 | |||
305 | dvb_usb_urb_kill(d); | ||
306 | |||
307 | if (d->state & DVB_USB_STATE_URB_LIST) { | ||
308 | for (i = 0; i < d->urbs_initialized; i++) { | ||
309 | if (d->urb_list[i] != NULL) { | ||
310 | deb_mem("freeing URB no. %d.\n",i); | ||
311 | /* free the URBs */ | ||
312 | usb_free_urb(d->urb_list[i]); | ||
313 | } | ||
314 | } | ||
315 | d->urbs_initialized = 0; | ||
316 | /* free the urb array */ | ||
317 | kfree(d->urb_list); | ||
318 | d->state &= ~DVB_USB_STATE_URB_LIST; | ||
319 | } | ||
320 | |||
321 | dvb_usb_free_stream_buffers(d); | ||
322 | return 0; | ||
323 | } | 95 | } |
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h index 97f8ea962438..376c45a8e779 100644 --- a/drivers/media/dvb/dvb-usb/dvb-usb.h +++ b/drivers/media/dvb/dvb-usb/dvb-usb.h | |||
@@ -1,9 +1,11 @@ | |||
1 | /* dvb-usb.h is part of the DVB USB library. | 1 | /* dvb-usb.h is part of the DVB USB library. |
2 | * | 2 | * |
3 | * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@desy.de) | 3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) |
4 | * see dvb-usb-init.c for copyright information. | 4 | * see dvb-usb-init.c for copyright information. |
5 | * | 5 | * |
6 | * the headerfile, all dvb-usb-drivers have to include. | 6 | * the headerfile, all dvb-usb-drivers have to include. |
7 | * | ||
8 | * TODO: clean-up the structures for unused fields and update the comments | ||
7 | */ | 9 | */ |
8 | #ifndef __DVB_USB_H__ | 10 | #ifndef __DVB_USB_H__ |
9 | #define __DVB_USB_H__ | 11 | #define __DVB_USB_H__ |
@@ -84,36 +86,84 @@ struct dvb_usb_rc_key { | |||
84 | }; | 86 | }; |
85 | 87 | ||
86 | struct dvb_usb_device; | 88 | struct dvb_usb_device; |
89 | struct dvb_usb_adapter; | ||
90 | struct usb_data_stream; | ||
91 | |||
92 | /** | ||
93 | * Properties of USB streaming - TODO this structure should be somewhere else | ||
94 | * describes the kind of USB transfer used for data-streaming. | ||
95 | * (BULK or ISOC) | ||
96 | */ | ||
97 | struct usb_data_stream_properties { | ||
98 | #define USB_BULK 1 | ||
99 | #define USB_ISOC 2 | ||
100 | int type; | ||
101 | int count; | ||
102 | int endpoint; | ||
103 | |||
104 | union { | ||
105 | struct { | ||
106 | int buffersize; /* per URB */ | ||
107 | } bulk; | ||
108 | struct { | ||
109 | int framesperurb; | ||
110 | int framesize; | ||
111 | int interval; | ||
112 | } isoc; | ||
113 | } u; | ||
114 | }; | ||
87 | 115 | ||
88 | /** | 116 | /** |
89 | * struct dvb_usb_properties - properties of a dvb-usb-device | 117 | * struct dvb_usb_adapter_properties - properties of a dvb-usb-adapter. |
118 | * A DVB-USB-Adapter is basically a dvb_adapter which is present on a USB-device. | ||
90 | * @caps: capabilities of the DVB USB device. | 119 | * @caps: capabilities of the DVB USB device. |
91 | * @pid_filter_count: number of PID filter position in the optional hardware | 120 | * @pid_filter_count: number of PID filter position in the optional hardware |
92 | * PID-filter. | 121 | * PID-filter. |
93 | * | 122 | * @streaming_crtl: called to start and stop the MPEG2-TS streaming of the |
123 | * device (not URB submitting/killing). | ||
124 | * @pid_filter_ctrl: called to en/disable the PID filter, if any. | ||
125 | * @pid_filter: called to set/unset a PID for filtering. | ||
126 | * @frontend_attach: called to attach the possible frontends (fill fe-field | ||
127 | * of struct dvb_usb_device). | ||
128 | * @tuner_attach: called to attach the correct tuner and to fill pll_addr, | ||
129 | * pll_desc and pll_init_buf of struct dvb_usb_device). | ||
130 | * @stream: configuration of the USB streaming | ||
131 | */ | ||
132 | struct dvb_usb_adapter_properties { | ||
133 | #define DVB_USB_ADAP_HAS_PID_FILTER 0x01 | ||
134 | #define DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF 0x02 | ||
135 | #define DVB_USB_ADAP_NEED_PID_FILTERING 0x04 | ||
136 | #define DVB_USB_ADAP_RECEIVES_204_BYTE_TS 0x08 | ||
137 | int caps; | ||
138 | int pid_filter_count; | ||
139 | |||
140 | int (*streaming_ctrl) (struct dvb_usb_adapter *, int); | ||
141 | int (*pid_filter_ctrl) (struct dvb_usb_adapter *, int); | ||
142 | int (*pid_filter) (struct dvb_usb_adapter *, int, u16, int); | ||
143 | |||
144 | int (*frontend_attach) (struct dvb_usb_adapter *); | ||
145 | int (*tuner_attach) (struct dvb_usb_adapter *); | ||
146 | |||
147 | struct usb_data_stream_properties stream; | ||
148 | |||
149 | int size_of_priv; | ||
150 | }; | ||
151 | |||
152 | /** | ||
153 | * struct dvb_usb_device_properties - properties of a dvb-usb-device | ||
94 | * @usb_ctrl: which USB device-side controller is in use. Needed for firmware | 154 | * @usb_ctrl: which USB device-side controller is in use. Needed for firmware |
95 | * download. | 155 | * download. |
96 | * @firmware: name of the firmware file. | 156 | * @firmware: name of the firmware file. |
97 | * @download_firmware: called to download the firmware when the usb_ctrl is | 157 | * @download_firmware: called to download the firmware when the usb_ctrl is |
98 | * DEVICE_SPECIFIC. | 158 | * DEVICE_SPECIFIC. |
99 | * @no_reconnect: device doesn't do a reconnect after downloading the firmware, | 159 | * @no_reconnect: device doesn't do a reconnect after downloading the firmware, |
100 | so do the warm initialization right after it | 160 | * so do the warm initialization right after it |
101 | 161 | * | |
102 | * @size_of_priv: how many bytes shall be allocated for the private field | 162 | * @size_of_priv: how many bytes shall be allocated for the private field |
103 | * of struct dvb_usb_device. | 163 | * of struct dvb_usb_device. |
104 | * | 164 | * |
105 | * @power_ctrl: called to enable/disable power of the device. | 165 | * @power_ctrl: called to enable/disable power of the device. |
106 | * @streaming_crtl: called to start and stop the MPEG2-TS streaming of the | ||
107 | * device (not URB submitting/killing). | ||
108 | * @pid_filter_ctrl: called to en/disable the PID filter, if any. | ||
109 | * @pid_filter: called to set/unset a PID for filtering. | ||
110 | * | ||
111 | * @read_mac_address: called to read the MAC address of the device. | 166 | * @read_mac_address: called to read the MAC address of the device. |
112 | * | ||
113 | * @frontend_attach: called to attach the possible frontends (fill fe-field | ||
114 | * of struct dvb_usb_device). | ||
115 | * @tuner_attach: called to attach the correct tuner and to fill pll_addr, | ||
116 | * pll_desc and pll_init_buf of struct dvb_usb_device). | ||
117 | * @identify_state: called to determine the state (cold or warm), when it | 167 | * @identify_state: called to determine the state (cold or warm), when it |
118 | * is not distinguishable by the USB IDs. | 168 | * is not distinguishable by the USB IDs. |
119 | * | 169 | * |
@@ -130,50 +180,40 @@ struct dvb_usb_device; | |||
130 | * is non-zero, one can use dvb_usb_generic_rw and dvb_usb_generic_write- | 180 | * is non-zero, one can use dvb_usb_generic_rw and dvb_usb_generic_write- |
131 | * helper functions. | 181 | * helper functions. |
132 | * | 182 | * |
133 | * @urb: describes the kind of USB transfer used for MPEG2-TS-streaming. | ||
134 | * (BULK or ISOC) | ||
135 | * | ||
136 | * @num_device_descs: number of struct dvb_usb_device_description in @devices | 183 | * @num_device_descs: number of struct dvb_usb_device_description in @devices |
137 | * @devices: array of struct dvb_usb_device_description compatibles with these | 184 | * @devices: array of struct dvb_usb_device_description compatibles with these |
138 | * properties. | 185 | * properties. |
139 | */ | 186 | */ |
140 | struct dvb_usb_properties { | 187 | #define MAX_NO_OF_ADAPTER_PER_DEVICE 2 |
188 | struct dvb_usb_device_properties { | ||
141 | 189 | ||
142 | #define DVB_USB_HAS_PID_FILTER 0x01 | 190 | #define DVB_USB_IS_AN_I2C_ADAPTER 0x01 |
143 | #define DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF 0x02 | ||
144 | #define DVB_USB_NEED_PID_FILTERING 0x04 | ||
145 | #define DVB_USB_IS_AN_I2C_ADAPTER 0x08 | ||
146 | int caps; | 191 | int caps; |
147 | int pid_filter_count; | ||
148 | 192 | ||
149 | #define DEVICE_SPECIFIC 0 | 193 | #define DEVICE_SPECIFIC 0 |
150 | #define CYPRESS_AN2135 1 | 194 | #define CYPRESS_AN2135 1 |
151 | #define CYPRESS_AN2235 2 | 195 | #define CYPRESS_AN2235 2 |
152 | #define CYPRESS_FX2 3 | 196 | #define CYPRESS_FX2 3 |
153 | int usb_ctrl; | 197 | int usb_ctrl; |
198 | int (*download_firmware) (struct usb_device *, const struct firmware *); | ||
154 | const char firmware[FIRMWARE_NAME_MAX]; | 199 | const char firmware[FIRMWARE_NAME_MAX]; |
155 | int (*download_firmware) (struct usb_device *, const struct firmware *); | 200 | int no_reconnect; |
156 | int no_reconnect; | ||
157 | 201 | ||
158 | int size_of_priv; | 202 | int size_of_priv; |
159 | 203 | ||
160 | int (*power_ctrl) (struct dvb_usb_device *, int); | 204 | int num_adapters; |
161 | int (*streaming_ctrl) (struct dvb_usb_device *, int); | 205 | struct dvb_usb_adapter_properties adapter[MAX_NO_OF_ADAPTER_PER_DEVICE]; |
162 | int (*pid_filter_ctrl) (struct dvb_usb_device *, int); | ||
163 | int (*pid_filter) (struct dvb_usb_device *, int, u16, int); | ||
164 | 206 | ||
207 | int (*power_ctrl) (struct dvb_usb_device *, int); | ||
165 | int (*read_mac_address) (struct dvb_usb_device *, u8 []); | 208 | int (*read_mac_address) (struct dvb_usb_device *, u8 []); |
166 | int (*frontend_attach) (struct dvb_usb_device *); | 209 | int (*identify_state) (struct usb_device *, struct dvb_usb_device_properties *, |
167 | int (*tuner_attach) (struct dvb_usb_device *); | ||
168 | |||
169 | int (*identify_state) (struct usb_device *, struct dvb_usb_properties *, | ||
170 | struct dvb_usb_device_description **, int *); | 210 | struct dvb_usb_device_description **, int *); |
171 | 211 | ||
172 | /* remote control properties */ | 212 | /* remote control properties */ |
173 | #define REMOTE_NO_KEY_PRESSED 0x00 | 213 | #define REMOTE_NO_KEY_PRESSED 0x00 |
174 | #define REMOTE_KEY_PRESSED 0x01 | 214 | #define REMOTE_KEY_PRESSED 0x01 |
175 | #define REMOTE_KEY_REPEAT 0x02 | 215 | #define REMOTE_KEY_REPEAT 0x02 |
176 | struct dvb_usb_rc_key *rc_key_map; | 216 | struct dvb_usb_rc_key *rc_key_map; |
177 | int rc_key_map_size; | 217 | int rc_key_map_size; |
178 | int (*rc_query) (struct dvb_usb_device *, u32 *, int *); | 218 | int (*rc_query) (struct dvb_usb_device *, u32 *, int *); |
179 | int rc_interval; | 219 | int rc_interval; |
@@ -182,40 +222,12 @@ struct dvb_usb_properties { | |||
182 | 222 | ||
183 | int generic_bulk_ctrl_endpoint; | 223 | int generic_bulk_ctrl_endpoint; |
184 | 224 | ||
185 | struct { | ||
186 | #define DVB_USB_BULK 1 | ||
187 | #define DVB_USB_ISOC 2 | ||
188 | int type; | ||
189 | int count; | ||
190 | int endpoint; | ||
191 | |||
192 | union { | ||
193 | struct { | ||
194 | int buffersize; /* per URB */ | ||
195 | } bulk; | ||
196 | struct { | ||
197 | int framesperurb; | ||
198 | int framesize; | ||
199 | int interval; | ||
200 | } isoc; | ||
201 | } u; | ||
202 | } urb; | ||
203 | |||
204 | int num_device_descs; | 225 | int num_device_descs; |
205 | struct dvb_usb_device_description devices[9]; | 226 | struct dvb_usb_device_description devices[9]; |
206 | }; | 227 | }; |
207 | 228 | ||
208 | |||
209 | /** | 229 | /** |
210 | * struct dvb_usb_device - object of a DVB USB device | 230 | * struct usb_data_stream - generic object of an USB stream |
211 | * @props: copy of the struct dvb_usb_properties this device belongs to. | ||
212 | * @desc: pointer to the device's struct dvb_usb_device_description. | ||
213 | * @state: initialization and runtime state of the device. | ||
214 | * | ||
215 | * @udev: pointer to the device's struct usb_device. | ||
216 | * @urb_list: array of dynamically allocated struct urb for the MPEG2-TS- | ||
217 | * streaming. | ||
218 | * | ||
219 | * @buf_num: number of buffer allocated. | 231 | * @buf_num: number of buffer allocated. |
220 | * @buf_size: size of each buffer in buf_list. | 232 | * @buf_size: size of each buffer in buf_list. |
221 | * @buf_list: array containing all allocate buffers for streaming. | 233 | * @buf_list: array containing all allocate buffers for streaming. |
@@ -223,18 +235,40 @@ struct dvb_usb_properties { | |||
223 | * | 235 | * |
224 | * @urbs_initialized: number of URBs initialized. | 236 | * @urbs_initialized: number of URBs initialized. |
225 | * @urbs_submitted: number of URBs submitted. | 237 | * @urbs_submitted: number of URBs submitted. |
238 | */ | ||
239 | #define MAX_NO_URBS_FOR_DATA_STREAM 10 | ||
240 | struct usb_data_stream { | ||
241 | struct usb_device *udev; | ||
242 | struct usb_data_stream_properties props; | ||
243 | |||
244 | #define USB_STATE_INIT 0x00 | ||
245 | #define USB_STATE_URB_BUF 0x01 | ||
246 | int state; | ||
247 | |||
248 | void (*complete) (struct usb_data_stream *, u8 *, size_t); | ||
249 | |||
250 | struct urb *urb_list[MAX_NO_URBS_FOR_DATA_STREAM]; | ||
251 | int buf_num; | ||
252 | unsigned long buf_size; | ||
253 | u8 *buf_list[MAX_NO_URBS_FOR_DATA_STREAM]; | ||
254 | dma_addr_t dma_addr[MAX_NO_URBS_FOR_DATA_STREAM]; | ||
255 | |||
256 | int urbs_initialized; | ||
257 | int urbs_submitted; | ||
258 | |||
259 | void *user_priv; | ||
260 | }; | ||
261 | |||
262 | /** | ||
263 | * struct dvb_usb_adapter - a DVB adapter on a USB device | ||
264 | * @id: index of this adapter (starting with 0). | ||
226 | * | 265 | * |
227 | * @feedcount: number of reqested feeds (used for streaming-activation) | 266 | * @feedcount: number of reqested feeds (used for streaming-activation) |
228 | * @pid_filtering: is hardware pid_filtering used or not. | 267 | * @pid_filtering: is hardware pid_filtering used or not. |
229 | * | 268 | * |
230 | * @usb_mutex: semaphore of USB control messages (reading needs two messages) | ||
231 | * @i2c_mutex: semaphore for i2c-transfers | ||
232 | * | ||
233 | * @i2c_adap: device's i2c_adapter if it uses I2CoverUSB | ||
234 | * @pll_addr: I2C address of the tuner for programming | 269 | * @pll_addr: I2C address of the tuner for programming |
235 | * @pll_init: array containing the initialization buffer | 270 | * @pll_init: array containing the initialization buffer |
236 | * @pll_desc: pointer to the appropriate struct dvb_pll_desc | 271 | * @pll_desc: pointer to the appropriate struct dvb_pll_desc |
237 | * | ||
238 | * @tuner_pass_ctrl: called to (de)activate tuner passthru of the demod or the board | 272 | * @tuner_pass_ctrl: called to (de)activate tuner passthru of the demod or the board |
239 | * | 273 | * |
240 | * @dvb_adap: device's dvb_adapter. | 274 | * @dvb_adap: device's dvb_adapter. |
@@ -244,8 +278,62 @@ struct dvb_usb_properties { | |||
244 | * @dvb_frontend: device's frontend. | 278 | * @dvb_frontend: device's frontend. |
245 | * @max_feed_count: how many feeds can be handled simultaneously by this | 279 | * @max_feed_count: how many feeds can be handled simultaneously by this |
246 | * device | 280 | * device |
281 | * | ||
282 | * @fe_init: rerouted frontend-init (wakeup) function. | ||
247 | * @fe_sleep: rerouted frontend-sleep function. | 283 | * @fe_sleep: rerouted frontend-sleep function. |
248 | * @fe_init: rerouted frontend-init (wakeup) function. | 284 | * |
285 | * @stream: the usb data stream. | ||
286 | */ | ||
287 | struct dvb_usb_adapter { | ||
288 | struct dvb_usb_device *dev; | ||
289 | struct dvb_usb_adapter_properties props; | ||
290 | |||
291 | #define DVB_USB_ADAP_STATE_INIT 0x000 | ||
292 | #define DVB_USB_ADAP_STATE_DVB 0x001 | ||
293 | int state; | ||
294 | |||
295 | u8 id; | ||
296 | |||
297 | int feedcount; | ||
298 | int pid_filtering; | ||
299 | |||
300 | /* tuner programming information */ | ||
301 | u8 pll_addr; | ||
302 | u8 pll_init[4]; | ||
303 | struct dvb_pll_desc *pll_desc; | ||
304 | int (*tuner_pass_ctrl) (struct dvb_frontend *, int, u8); | ||
305 | |||
306 | /* dvb */ | ||
307 | struct dvb_adapter dvb_adap; | ||
308 | struct dmxdev dmxdev; | ||
309 | struct dvb_demux demux; | ||
310 | struct dvb_net dvb_net; | ||
311 | struct dvb_frontend *fe; | ||
312 | int max_feed_count; | ||
313 | |||
314 | int (*fe_init) (struct dvb_frontend *); | ||
315 | int (*fe_sleep) (struct dvb_frontend *); | ||
316 | |||
317 | struct usb_data_stream stream; | ||
318 | |||
319 | void *priv; | ||
320 | }; | ||
321 | |||
322 | /** | ||
323 | * struct dvb_usb_device - object of a DVB USB device | ||
324 | * @props: copy of the struct dvb_usb_properties this device belongs to. | ||
325 | * @desc: pointer to the device's struct dvb_usb_device_description. | ||
326 | * @state: initialization and runtime state of the device. | ||
327 | * | ||
328 | * @powered: indicated whether the device is power or not. | ||
329 | * Powered is in/decremented for each call to modify the state. | ||
330 | * @udev: pointer to the device's struct usb_device. | ||
331 | * | ||
332 | * @usb_mutex: semaphore of USB control messages (reading needs two messages) | ||
333 | * @i2c_mutex: semaphore for i2c-transfers | ||
334 | * | ||
335 | * @i2c_adap: device's i2c_adapter if it uses I2CoverUSB | ||
336 | * | ||
249 | * @rc_input_dev: input device for the remote control. | 337 | * @rc_input_dev: input device for the remote control. |
250 | * @rc_query_work: struct work_struct frequent rc queries | 338 | * @rc_query_work: struct work_struct frequent rc queries |
251 | * @last_event: last triggered event | 339 | * @last_event: last triggered event |
@@ -255,32 +343,18 @@ struct dvb_usb_properties { | |||
255 | * in size_of_priv of dvb_usb_properties). | 343 | * in size_of_priv of dvb_usb_properties). |
256 | */ | 344 | */ |
257 | struct dvb_usb_device { | 345 | struct dvb_usb_device { |
258 | struct dvb_usb_properties props; | 346 | struct dvb_usb_device_properties props; |
259 | struct dvb_usb_device_description *desc; | 347 | struct dvb_usb_device_description *desc; |
260 | 348 | ||
261 | #define DVB_USB_STATE_INIT 0x000 | ||
262 | #define DVB_USB_STATE_URB_LIST 0x001 | ||
263 | #define DVB_USB_STATE_URB_BUF 0x002 | ||
264 | #define DVB_USB_STATE_DVB 0x004 | ||
265 | #define DVB_USB_STATE_I2C 0x008 | ||
266 | #define DVB_USB_STATE_REMOTE 0x010 | ||
267 | #define DVB_USB_STATE_URB_SUBMIT 0x020 | ||
268 | int state; | ||
269 | |||
270 | /* usb */ | ||
271 | struct usb_device *udev; | 349 | struct usb_device *udev; |
272 | struct urb **urb_list; | ||
273 | 350 | ||
274 | int buf_num; | 351 | #define DVB_USB_STATE_INIT 0x000 |
275 | unsigned long buf_size; | 352 | #define DVB_USB_STATE_I2C 0x001 |
276 | u8 **buf_list; | 353 | #define DVB_USB_STATE_DVB 0x002 |
277 | dma_addr_t *dma_addr; | 354 | #define DVB_USB_STATE_REMOTE 0x004 |
278 | 355 | int state; | |
279 | int urbs_initialized; | ||
280 | int urbs_submitted; | ||
281 | 356 | ||
282 | int feedcount; | 357 | int powered; |
283 | int pid_filtering; | ||
284 | 358 | ||
285 | /* locking */ | 359 | /* locking */ |
286 | struct mutex usb_mutex; | 360 | struct mutex usb_mutex; |
@@ -289,22 +363,8 @@ struct dvb_usb_device { | |||
289 | struct mutex i2c_mutex; | 363 | struct mutex i2c_mutex; |
290 | struct i2c_adapter i2c_adap; | 364 | struct i2c_adapter i2c_adap; |
291 | 365 | ||
292 | /* tuner programming information */ | 366 | int num_adapters_initialized; |
293 | u8 pll_addr; | 367 | struct dvb_usb_adapter adapter[MAX_NO_OF_ADAPTER_PER_DEVICE]; |
294 | u8 pll_init[4]; | ||
295 | struct dvb_pll_desc *pll_desc; | ||
296 | int (*tuner_pass_ctrl)(struct dvb_frontend *, int, u8); | ||
297 | |||
298 | /* dvb */ | ||
299 | struct dvb_adapter dvb_adap; | ||
300 | struct dmxdev dmxdev; | ||
301 | struct dvb_demux demux; | ||
302 | struct dvb_net dvb_net; | ||
303 | struct dvb_frontend* fe; | ||
304 | int max_feed_count; | ||
305 | |||
306 | int (*fe_sleep) (struct dvb_frontend *); | ||
307 | int (*fe_init) (struct dvb_frontend *); | ||
308 | 368 | ||
309 | /* remote control */ | 369 | /* remote control */ |
310 | struct input_dev *rc_input_dev; | 370 | struct input_dev *rc_input_dev; |
@@ -318,7 +378,7 @@ struct dvb_usb_device { | |||
318 | void *priv; | 378 | void *priv; |
319 | }; | 379 | }; |
320 | 380 | ||
321 | extern int dvb_usb_device_init(struct usb_interface *, struct dvb_usb_properties *, struct module *, struct dvb_usb_device **); | 381 | extern int dvb_usb_device_init(struct usb_interface *, struct dvb_usb_device_properties *, struct module *, struct dvb_usb_device **); |
322 | extern void dvb_usb_device_exit(struct usb_interface *); | 382 | extern void dvb_usb_device_exit(struct usb_interface *); |
323 | 383 | ||
324 | /* the generic read/write method for device control */ | 384 | /* the generic read/write method for device control */ |
@@ -342,5 +402,7 @@ struct hexline { | |||
342 | u8 chk; | 402 | u8 chk; |
343 | }; | 403 | }; |
344 | extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type); | 404 | extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type); |
405 | extern int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos); | ||
406 | |||
345 | 407 | ||
346 | #endif | 408 | #endif |
diff --git a/drivers/media/dvb/dvb-usb/gp8psk.c b/drivers/media/dvb/dvb-usb/gp8psk.c index 9a98f3fdae31..7375eb20166d 100644 --- a/drivers/media/dvb/dvb-usb/gp8psk.c +++ b/drivers/media/dvb/dvb-usb/gp8psk.c | |||
@@ -161,19 +161,18 @@ static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff) | |||
161 | } | 161 | } |
162 | 162 | ||
163 | 163 | ||
164 | static int gp8psk_streaming_ctrl(struct dvb_usb_device *d, int onoff) | 164 | static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) |
165 | { | 165 | { |
166 | return gp8psk_usb_out_op(d, ARM_TRANSFER, onoff, 0 , NULL, 0); | 166 | return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0); |
167 | } | 167 | } |
168 | 168 | ||
169 | static int gp8psk_frontend_attach(struct dvb_usb_device *d) | 169 | static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap) |
170 | { | 170 | { |
171 | d->fe = gp8psk_fe_attach(d); | 171 | adap->fe = gp8psk_fe_attach(adap->dev); |
172 | |||
173 | return 0; | 172 | return 0; |
174 | } | 173 | } |
175 | 174 | ||
176 | static struct dvb_usb_properties gp8psk_properties; | 175 | static struct dvb_usb_device_properties gp8psk_properties; |
177 | 176 | ||
178 | static int gp8psk_usb_probe(struct usb_interface *intf, | 177 | static int gp8psk_usb_probe(struct usb_interface *intf, |
179 | const struct usb_device_id *id) | 178 | const struct usb_device_id *id) |
@@ -188,20 +187,18 @@ static struct usb_device_id gp8psk_usb_table [] = { | |||
188 | }; | 187 | }; |
189 | MODULE_DEVICE_TABLE(usb, gp8psk_usb_table); | 188 | MODULE_DEVICE_TABLE(usb, gp8psk_usb_table); |
190 | 189 | ||
191 | static struct dvb_usb_properties gp8psk_properties = { | 190 | static struct dvb_usb_device_properties gp8psk_properties = { |
192 | .caps = 0, | ||
193 | |||
194 | .usb_ctrl = CYPRESS_FX2, | 191 | .usb_ctrl = CYPRESS_FX2, |
195 | .firmware = "dvb-usb-gp8psk-01.fw", | 192 | .firmware = "dvb-usb-gp8psk-01.fw", |
196 | 193 | ||
194 | .num_adapters = 1, | ||
195 | .adapter = { | ||
196 | { | ||
197 | .streaming_ctrl = gp8psk_streaming_ctrl, | 197 | .streaming_ctrl = gp8psk_streaming_ctrl, |
198 | .power_ctrl = gp8psk_power_ctrl, | ||
199 | .frontend_attach = gp8psk_frontend_attach, | 198 | .frontend_attach = gp8psk_frontend_attach, |
200 | |||
201 | .generic_bulk_ctrl_endpoint = 0x01, | ||
202 | /* parameter for the MPEG2-data transfer */ | 199 | /* parameter for the MPEG2-data transfer */ |
203 | .urb = { | 200 | .stream = { |
204 | .type = DVB_USB_BULK, | 201 | .type = USB_BULK, |
205 | .count = 7, | 202 | .count = 7, |
206 | .endpoint = 0x82, | 203 | .endpoint = 0x82, |
207 | .u = { | 204 | .u = { |
@@ -210,6 +207,11 @@ static struct dvb_usb_properties gp8psk_properties = { | |||
210 | } | 207 | } |
211 | } | 208 | } |
212 | }, | 209 | }, |
210 | } | ||
211 | }, | ||
212 | .power_ctrl = gp8psk_power_ctrl, | ||
213 | |||
214 | .generic_bulk_ctrl_endpoint = 0x01, | ||
213 | 215 | ||
214 | .num_device_descs = 1, | 216 | .num_device_descs = 1, |
215 | .devices = { | 217 | .devices = { |
@@ -217,7 +219,7 @@ static struct dvb_usb_properties gp8psk_properties = { | |||
217 | .cold_ids = { &gp8psk_usb_table[0], NULL }, | 219 | .cold_ids = { &gp8psk_usb_table[0], NULL }, |
218 | .warm_ids = { &gp8psk_usb_table[1], NULL }, | 220 | .warm_ids = { &gp8psk_usb_table[1], NULL }, |
219 | }, | 221 | }, |
220 | { 0 }, | 222 | { NULL }, |
221 | } | 223 | } |
222 | }; | 224 | }; |
223 | 225 | ||
diff --git a/drivers/media/dvb/dvb-usb/nova-t-usb2.c b/drivers/media/dvb/dvb-usb/nova-t-usb2.c index 79f0a02ce987..a9219bf69b89 100644 --- a/drivers/media/dvb/dvb-usb/nova-t-usb2.c +++ b/drivers/media/dvb/dvb-usb/nova-t-usb2.c | |||
@@ -135,7 +135,7 @@ static int nova_t_read_mac_address (struct dvb_usb_device *d, u8 mac[6]) | |||
135 | } | 135 | } |
136 | 136 | ||
137 | /* USB Driver stuff */ | 137 | /* USB Driver stuff */ |
138 | static struct dvb_usb_properties nova_t_properties; | 138 | static struct dvb_usb_device_properties nova_t_properties; |
139 | 139 | ||
140 | static int nova_t_probe(struct usb_interface *intf, | 140 | static int nova_t_probe(struct usb_interface *intf, |
141 | const struct usb_device_id *id) | 141 | const struct usb_device_id *id) |
@@ -151,34 +151,27 @@ static struct usb_device_id nova_t_table [] = { | |||
151 | }; | 151 | }; |
152 | MODULE_DEVICE_TABLE(usb, nova_t_table); | 152 | MODULE_DEVICE_TABLE(usb, nova_t_table); |
153 | 153 | ||
154 | static struct dvb_usb_properties nova_t_properties = { | 154 | static struct dvb_usb_device_properties nova_t_properties = { |
155 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_IS_AN_I2C_ADAPTER, | 155 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
156 | .pid_filter_count = 32, | ||
157 | 156 | ||
158 | .usb_ctrl = CYPRESS_FX2, | 157 | .usb_ctrl = CYPRESS_FX2, |
159 | .firmware = "dvb-usb-nova-t-usb2-02.fw", | 158 | .firmware = "dvb-usb-nova-t-usb2-02.fw", |
160 | 159 | ||
161 | .size_of_priv = sizeof(struct dibusb_state), | 160 | .num_adapters = 1, |
161 | .adapter = { | ||
162 | { | ||
163 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | ||
164 | .pid_filter_count = 32, | ||
162 | 165 | ||
163 | .streaming_ctrl = dibusb2_0_streaming_ctrl, | 166 | .streaming_ctrl = dibusb2_0_streaming_ctrl, |
164 | .pid_filter = dibusb_pid_filter, | 167 | .pid_filter = dibusb_pid_filter, |
165 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, | 168 | .pid_filter_ctrl = dibusb_pid_filter_ctrl, |
166 | .power_ctrl = dibusb2_0_power_ctrl, | ||
167 | .frontend_attach = dibusb_dib3000mc_frontend_attach, | 169 | .frontend_attach = dibusb_dib3000mc_frontend_attach, |
168 | .tuner_attach = dibusb_dib3000mc_tuner_attach, | 170 | .tuner_attach = dibusb_dib3000mc_tuner_attach, |
169 | .read_mac_address = nova_t_read_mac_address, | ||
170 | |||
171 | .rc_interval = 100, | ||
172 | .rc_key_map = haupp_rc_keys, | ||
173 | .rc_key_map_size = ARRAY_SIZE(haupp_rc_keys), | ||
174 | .rc_query = nova_t_rc_query, | ||
175 | 171 | ||
176 | .i2c_algo = &dibusb_i2c_algo, | ||
177 | |||
178 | .generic_bulk_ctrl_endpoint = 0x01, | ||
179 | /* parameter for the MPEG2-data transfer */ | 172 | /* parameter for the MPEG2-data transfer */ |
180 | .urb = { | 173 | .stream = { |
181 | .type = DVB_USB_BULK, | 174 | .type = USB_BULK, |
182 | .count = 7, | 175 | .count = 7, |
183 | .endpoint = 0x06, | 176 | .endpoint = 0x06, |
184 | .u = { | 177 | .u = { |
@@ -188,6 +181,22 @@ static struct dvb_usb_properties nova_t_properties = { | |||
188 | } | 181 | } |
189 | }, | 182 | }, |
190 | 183 | ||
184 | .size_of_priv = sizeof(struct dibusb_state), | ||
185 | } | ||
186 | }, | ||
187 | |||
188 | .power_ctrl = dibusb2_0_power_ctrl, | ||
189 | .read_mac_address = nova_t_read_mac_address, | ||
190 | |||
191 | .rc_interval = 100, | ||
192 | .rc_key_map = haupp_rc_keys, | ||
193 | .rc_key_map_size = ARRAY_SIZE(haupp_rc_keys), | ||
194 | .rc_query = nova_t_rc_query, | ||
195 | |||
196 | .i2c_algo = &dibusb_i2c_algo, | ||
197 | |||
198 | .generic_bulk_ctrl_endpoint = 0x01, | ||
199 | |||
191 | .num_device_descs = 1, | 200 | .num_device_descs = 1, |
192 | .devices = { | 201 | .devices = { |
193 | { "Hauppauge WinTV-NOVA-T usb2", | 202 | { "Hauppauge WinTV-NOVA-T usb2", |
diff --git a/drivers/media/dvb/dvb-usb/umt-010.c b/drivers/media/dvb/dvb-usb/umt-010.c index 418a0b707151..f9941ea88b3e 100644 --- a/drivers/media/dvb/dvb-usb/umt-010.c +++ b/drivers/media/dvb/dvb-usb/umt-010.c | |||
@@ -50,7 +50,7 @@ static int umt_mt352_demod_init(struct dvb_frontend *fe) | |||
50 | return 0; | 50 | return 0; |
51 | } | 51 | } |
52 | 52 | ||
53 | static int umt_mt352_frontend_attach(struct dvb_usb_device *d) | 53 | static int umt_mt352_frontend_attach(struct dvb_usb_adapter *adap) |
54 | { | 54 | { |
55 | struct mt352_config umt_config; | 55 | struct mt352_config umt_config; |
56 | 56 | ||
@@ -58,21 +58,21 @@ static int umt_mt352_frontend_attach(struct dvb_usb_device *d) | |||
58 | umt_config.demod_init = umt_mt352_demod_init; | 58 | umt_config.demod_init = umt_mt352_demod_init; |
59 | umt_config.demod_address = 0xf; | 59 | umt_config.demod_address = 0xf; |
60 | 60 | ||
61 | d->fe = dvb_attach(mt352_attach, &umt_config, &d->i2c_adap); | 61 | adap->fe = dvb_attach(mt352_attach, &umt_config, &adap->dev->i2c_adap); |
62 | 62 | ||
63 | return 0; | 63 | return 0; |
64 | } | 64 | } |
65 | 65 | ||
66 | static int umt_tuner_attach (struct dvb_usb_device *d) | 66 | static int umt_tuner_attach (struct dvb_usb_adapter *adap) |
67 | { | 67 | { |
68 | d->pll_addr = 0x61; | 68 | adap->pll_addr = 0x61; |
69 | d->pll_desc = &dvb_pll_tua6034; | 69 | adap->pll_desc = &dvb_pll_tua6034; |
70 | d->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; | 70 | adap->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs; |
71 | return 0; | 71 | return 0; |
72 | } | 72 | } |
73 | 73 | ||
74 | /* USB Driver stuff */ | 74 | /* USB Driver stuff */ |
75 | static struct dvb_usb_properties umt_properties; | 75 | static struct dvb_usb_device_properties umt_properties; |
76 | 76 | ||
77 | static int umt_probe(struct usb_interface *intf, | 77 | static int umt_probe(struct usb_interface *intf, |
78 | const struct usb_device_id *id) | 78 | const struct usb_device_id *id) |
@@ -90,25 +90,22 @@ static struct usb_device_id umt_table [] = { | |||
90 | }; | 90 | }; |
91 | MODULE_DEVICE_TABLE (usb, umt_table); | 91 | MODULE_DEVICE_TABLE (usb, umt_table); |
92 | 92 | ||
93 | static struct dvb_usb_properties umt_properties = { | 93 | static struct dvb_usb_device_properties umt_properties = { |
94 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | 94 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, |
95 | 95 | ||
96 | .usb_ctrl = CYPRESS_FX2, | 96 | .usb_ctrl = CYPRESS_FX2, |
97 | .firmware = "dvb-usb-umt-010-02.fw", | 97 | .firmware = "dvb-usb-umt-010-02.fw", |
98 | 98 | ||
99 | .size_of_priv = sizeof(struct dibusb_state), | 99 | .num_adapters = 1, |
100 | 100 | .adapter = { | |
101 | { | ||
101 | .streaming_ctrl = dibusb2_0_streaming_ctrl, | 102 | .streaming_ctrl = dibusb2_0_streaming_ctrl, |
102 | .power_ctrl = dibusb_power_ctrl, | ||
103 | .frontend_attach = umt_mt352_frontend_attach, | 103 | .frontend_attach = umt_mt352_frontend_attach, |
104 | .tuner_attach = umt_tuner_attach, | 104 | .tuner_attach = umt_tuner_attach, |
105 | 105 | ||
106 | .i2c_algo = &dibusb_i2c_algo, | ||
107 | |||
108 | .generic_bulk_ctrl_endpoint = 0x01, | ||
109 | /* parameter for the MPEG2-data transfer */ | 106 | /* parameter for the MPEG2-data transfer */ |
110 | .urb = { | 107 | .stream = { |
111 | .type = DVB_USB_BULK, | 108 | .type = USB_BULK, |
112 | .count = 20, | 109 | .count = 20, |
113 | .endpoint = 0x06, | 110 | .endpoint = 0x06, |
114 | .u = { | 111 | .u = { |
@@ -118,6 +115,15 @@ static struct dvb_usb_properties umt_properties = { | |||
118 | } | 115 | } |
119 | }, | 116 | }, |
120 | 117 | ||
118 | .size_of_priv = sizeof(struct dibusb_state), | ||
119 | } | ||
120 | }, | ||
121 | .power_ctrl = dibusb_power_ctrl, | ||
122 | |||
123 | .i2c_algo = &dibusb_i2c_algo, | ||
124 | |||
125 | .generic_bulk_ctrl_endpoint = 0x01, | ||
126 | |||
121 | .num_device_descs = 1, | 127 | .num_device_descs = 1, |
122 | .devices = { | 128 | .devices = { |
123 | { "Hanftek UMT-010 DVB-T USB2.0", | 129 | { "Hanftek UMT-010 DVB-T USB2.0", |
diff --git a/drivers/media/dvb/dvb-usb/usb-urb.c b/drivers/media/dvb/dvb-usb/usb-urb.c new file mode 100644 index 000000000000..8728cf347a71 --- /dev/null +++ b/drivers/media/dvb/dvb-usb/usb-urb.c | |||
@@ -0,0 +1,242 @@ | |||
1 | /* usb-urb.c is part of the DVB USB library. | ||
2 | * | ||
3 | * Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de) | ||
4 | * see dvb-usb-init.c for copyright information. | ||
5 | * | ||
6 | * This file keeps functions for initializing and handling the | ||
7 | * BULK and ISOC USB data transfers in a generic way. | ||
8 | * Can be used for DVB-only and also, that's the plan, for | ||
9 | * Hybrid USB devices (analog and DVB). | ||
10 | */ | ||
11 | #include "dvb-usb-common.h" | ||
12 | |||
13 | /* URB stuff for streaming */ | ||
14 | static void usb_urb_complete(struct urb *urb, struct pt_regs *ptregs) | ||
15 | { | ||
16 | struct usb_data_stream *stream = urb->context; | ||
17 | int ptype = usb_pipetype(urb->pipe); | ||
18 | int i; | ||
19 | u8 *b; | ||
20 | |||
21 | deb_uxfer("'%s' urb completed. status: %d, length: %d/%d, pack_num: %d, errors: %d\n", | ||
22 | ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk", | ||
23 | urb->status,urb->actual_length,urb->transfer_buffer_length, | ||
24 | urb->number_of_packets,urb->error_count); | ||
25 | |||
26 | switch (urb->status) { | ||
27 | case 0: /* success */ | ||
28 | case -ETIMEDOUT: /* NAK */ | ||
29 | break; | ||
30 | case -ECONNRESET: /* kill */ | ||
31 | case -ENOENT: | ||
32 | case -ESHUTDOWN: | ||
33 | return; | ||
34 | default: /* error */ | ||
35 | deb_ts("urb completition error %d.\n", urb->status); | ||
36 | break; | ||
37 | } | ||
38 | |||
39 | b = (u8 *) urb->transfer_buffer; | ||
40 | switch (ptype) { | ||
41 | case PIPE_ISOCHRONOUS: | ||
42 | for (i = 0; i < urb->number_of_packets; i++) { | ||
43 | |||
44 | if (urb->iso_frame_desc[i].status != 0) | ||
45 | deb_ts("iso frame descriptor has an error: %d\n",urb->iso_frame_desc[i].status); | ||
46 | else if (urb->iso_frame_desc[i].actual_length > 0) | ||
47 | stream->complete(stream, b + urb->iso_frame_desc[i].offset, urb->iso_frame_desc[i].actual_length); | ||
48 | |||
49 | urb->iso_frame_desc[i].status = 0; | ||
50 | urb->iso_frame_desc[i].actual_length = 0; | ||
51 | } | ||
52 | debug_dump(b,20,deb_uxfer); | ||
53 | break; | ||
54 | case PIPE_BULK: | ||
55 | if (urb->actual_length > 0) | ||
56 | stream->complete(stream, b, urb->actual_length); | ||
57 | break; | ||
58 | default: | ||
59 | err("unkown endpoint type in completition handler."); | ||
60 | return; | ||
61 | } | ||
62 | usb_submit_urb(urb,GFP_ATOMIC); | ||
63 | } | ||
64 | |||
65 | int usb_urb_kill(struct usb_data_stream *stream) | ||
66 | { | ||
67 | int i; | ||
68 | for (i = 0; i < stream->urbs_submitted; i++) { | ||
69 | deb_ts("killing URB no. %d.\n",i); | ||
70 | |||
71 | /* stop the URB */ | ||
72 | usb_kill_urb(stream->urb_list[i]); | ||
73 | } | ||
74 | stream->urbs_submitted = 0; | ||
75 | return 0; | ||
76 | } | ||
77 | |||
78 | int usb_urb_submit(struct usb_data_stream *stream) | ||
79 | { | ||
80 | int i,ret; | ||
81 | for (i = 0; i < stream->urbs_initialized; i++) { | ||
82 | deb_ts("submitting URB no. %d\n",i); | ||
83 | if ((ret = usb_submit_urb(stream->urb_list[i],GFP_ATOMIC))) { | ||
84 | err("could not submit URB no. %d - get them all back",i); | ||
85 | usb_urb_kill(stream); | ||
86 | return ret; | ||
87 | } | ||
88 | stream->urbs_submitted++; | ||
89 | } | ||
90 | return 0; | ||
91 | } | ||
92 | |||
93 | static int usb_free_stream_buffers(struct usb_data_stream *stream) | ||
94 | { | ||
95 | if (stream->state & USB_STATE_URB_BUF) { | ||
96 | while (stream->buf_num) { | ||
97 | stream->buf_num--; | ||
98 | deb_mem("freeing buffer %d\n",stream->buf_num); | ||
99 | usb_buffer_free(stream->udev, stream->buf_size, | ||
100 | stream->buf_list[stream->buf_num], stream->dma_addr[stream->buf_num]); | ||
101 | } | ||
102 | } | ||
103 | |||
104 | stream->state &= ~USB_STATE_URB_BUF; | ||
105 | |||
106 | return 0; | ||
107 | } | ||
108 | |||
109 | static int usb_allocate_stream_buffers(struct usb_data_stream *stream, int num, unsigned long size) | ||
110 | { | ||
111 | stream->buf_num = 0; | ||
112 | stream->buf_size = size; | ||
113 | |||
114 | deb_mem("all in all I will use %lu bytes for streaming\n",num*size); | ||
115 | |||
116 | for (stream->buf_num = 0; stream->buf_num < num; stream->buf_num++) { | ||
117 | deb_mem("allocating buffer %d\n",stream->buf_num); | ||
118 | if (( stream->buf_list[stream->buf_num] = | ||
119 | usb_buffer_alloc(stream->udev, size, SLAB_ATOMIC, | ||
120 | &stream->dma_addr[stream->buf_num]) ) == NULL) { | ||
121 | deb_mem("not enough memory for urb-buffer allocation.\n"); | ||
122 | usb_free_stream_buffers(stream); | ||
123 | return -ENOMEM; | ||
124 | } | ||
125 | deb_mem("buffer %d: %p (dma: %u)\n", | ||
126 | stream->buf_num, stream->buf_list[stream->buf_num], stream->dma_addr[stream->buf_num]); | ||
127 | memset(stream->buf_list[stream->buf_num],0,size); | ||
128 | stream->state |= USB_STATE_URB_BUF; | ||
129 | } | ||
130 | deb_mem("allocation successful\n"); | ||
131 | |||
132 | return 0; | ||
133 | } | ||
134 | |||
135 | static int usb_bulk_urb_init(struct usb_data_stream *stream) | ||
136 | { | ||
137 | int i; | ||
138 | |||
139 | if ((i = usb_allocate_stream_buffers(stream,stream->props.count, | ||
140 | stream->props.u.bulk.buffersize)) < 0) | ||
141 | return i; | ||
142 | |||
143 | /* allocate the URBs */ | ||
144 | for (i = 0; i < stream->props.count; i++) { | ||
145 | if ((stream->urb_list[i] = usb_alloc_urb(0,GFP_ATOMIC)) == NULL) | ||
146 | return -ENOMEM; | ||
147 | |||
148 | usb_fill_bulk_urb( stream->urb_list[i], stream->udev, | ||
149 | usb_rcvbulkpipe(stream->udev,stream->props.endpoint), | ||
150 | stream->buf_list[i], | ||
151 | stream->props.u.bulk.buffersize, | ||
152 | usb_urb_complete, stream); | ||
153 | |||
154 | stream->urb_list[i]->transfer_flags = 0; | ||
155 | stream->urbs_initialized++; | ||
156 | } | ||
157 | return 0; | ||
158 | } | ||
159 | |||
160 | static int usb_isoc_urb_init(struct usb_data_stream *stream) | ||
161 | { | ||
162 | int i,j; | ||
163 | |||
164 | if ((i = usb_allocate_stream_buffers(stream,stream->props.count, | ||
165 | stream->props.u.isoc.framesize*stream->props.u.isoc.framesperurb)) < 0) | ||
166 | return i; | ||
167 | |||
168 | /* allocate the URBs */ | ||
169 | for (i = 0; i < stream->props.count; i++) { | ||
170 | struct urb *urb; | ||
171 | int frame_offset = 0; | ||
172 | if ((stream->urb_list[i] = | ||
173 | usb_alloc_urb(stream->props.u.isoc.framesperurb,GFP_ATOMIC)) == NULL) | ||
174 | return -ENOMEM; | ||
175 | |||
176 | urb = stream->urb_list[i]; | ||
177 | |||
178 | urb->dev = stream->udev; | ||
179 | urb->context = stream; | ||
180 | urb->complete = usb_urb_complete; | ||
181 | urb->pipe = usb_rcvisocpipe(stream->udev,stream->props.endpoint); | ||
182 | urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; | ||
183 | urb->interval = stream->props.u.isoc.interval; | ||
184 | urb->number_of_packets = stream->props.u.isoc.framesperurb; | ||
185 | urb->transfer_buffer_length = stream->buf_size; | ||
186 | urb->transfer_buffer = stream->buf_list[i]; | ||
187 | urb->transfer_dma = stream->dma_addr[i]; | ||
188 | |||
189 | for (j = 0; j < stream->props.u.isoc.framesperurb; j++) { | ||
190 | urb->iso_frame_desc[j].offset = frame_offset; | ||
191 | urb->iso_frame_desc[j].length = stream->props.u.isoc.framesize; | ||
192 | frame_offset += stream->props.u.isoc.framesize; | ||
193 | } | ||
194 | |||
195 | stream->urbs_initialized++; | ||
196 | } | ||
197 | return 0; | ||
198 | } | ||
199 | |||
200 | int usb_urb_init(struct usb_data_stream *stream, struct usb_data_stream_properties *props) | ||
201 | { | ||
202 | if (stream == NULL || props == NULL) | ||
203 | return -EINVAL; | ||
204 | |||
205 | memcpy(&stream->props, props, sizeof(*props)); | ||
206 | |||
207 | usb_clear_halt(stream->udev,usb_rcvbulkpipe(stream->udev,stream->props.endpoint)); | ||
208 | |||
209 | if (stream->complete == NULL) { | ||
210 | err("there is no data callback - this doesn't make sense."); | ||
211 | return -EINVAL; | ||
212 | } | ||
213 | |||
214 | switch (stream->props.type) { | ||
215 | case USB_BULK: | ||
216 | return usb_bulk_urb_init(stream); | ||
217 | case USB_ISOC: | ||
218 | return usb_isoc_urb_init(stream); | ||
219 | default: | ||
220 | err("unkown URB-type for data transfer."); | ||
221 | return -EINVAL; | ||
222 | } | ||
223 | } | ||
224 | |||
225 | int usb_urb_exit(struct usb_data_stream *stream) | ||
226 | { | ||
227 | int i; | ||
228 | |||
229 | usb_urb_kill(stream); | ||
230 | |||
231 | for (i = 0; i < stream->urbs_initialized; i++) { | ||
232 | if (stream->urb_list[i] != NULL) { | ||
233 | deb_mem("freeing URB no. %d.\n",i); | ||
234 | /* free the URBs */ | ||
235 | usb_free_urb(stream->urb_list[i]); | ||
236 | } | ||
237 | } | ||
238 | stream->urbs_initialized = 0; | ||
239 | |||
240 | usb_free_stream_buffers(stream); | ||
241 | return 0; | ||
242 | } | ||
diff --git a/drivers/media/dvb/dvb-usb/vp702x-fe.c b/drivers/media/dvb/dvb-usb/vp702x-fe.c index d4da494132ec..3ecb2e0ce80f 100644 --- a/drivers/media/dvb/dvb-usb/vp702x-fe.c +++ b/drivers/media/dvb/dvb-usb/vp702x-fe.c | |||
@@ -24,6 +24,8 @@ struct vp702x_fe_state { | |||
24 | struct dvb_frontend fe; | 24 | struct dvb_frontend fe; |
25 | struct dvb_usb_device *d; | 25 | struct dvb_usb_device *d; |
26 | 26 | ||
27 | struct dvb_frontend_ops ops; | ||
28 | |||
27 | fe_sec_voltage_t voltage; | 29 | fe_sec_voltage_t voltage; |
28 | fe_sec_tone_mode_t tone_mode; | 30 | fe_sec_tone_mode_t tone_mode; |
29 | 31 | ||
@@ -72,9 +74,6 @@ static int vp702x_fe_read_status(struct dvb_frontend* fe, fe_status_t *status) | |||
72 | else | 74 | else |
73 | *status = 0; | 75 | *status = 0; |
74 | 76 | ||
75 | deb_fe("real state: %x\n",*status); | ||
76 | *status = 0x1f; | ||
77 | |||
78 | if (*status & FE_HAS_LOCK) | 77 | if (*status & FE_HAS_LOCK) |
79 | st->status_check_interval = 1000; | 78 | st->status_check_interval = 1000; |
80 | else | 79 | else |
@@ -171,8 +170,6 @@ static int vp702x_fe_set_frontend(struct dvb_frontend* fe, | |||
171 | st->status_check_interval = 250; | 170 | st->status_check_interval = 250; |
172 | st->next_status_check = jiffies; | 171 | st->next_status_check = jiffies; |
173 | 172 | ||
174 | vp702x_usb_in_op(st->d, RESET_TUNER, 0, 0, NULL, 0); | ||
175 | msleep(30); | ||
176 | vp702x_usb_inout_op(st->d,cmd,8,ibuf,10,100); | 173 | vp702x_usb_inout_op(st->d,cmd,8,ibuf,10,100); |
177 | 174 | ||
178 | if (ibuf[2] == 0 && ibuf[3] == 0) | 175 | if (ibuf[2] == 0 && ibuf[3] == 0) |
@@ -183,6 +180,20 @@ static int vp702x_fe_set_frontend(struct dvb_frontend* fe, | |||
183 | return 0; | 180 | return 0; |
184 | } | 181 | } |
185 | 182 | ||
183 | static int vp702x_fe_init(struct dvb_frontend *fe) | ||
184 | { | ||
185 | struct vp702x_fe_state *st = fe->demodulator_priv; | ||
186 | deb_fe("%s\n",__FUNCTION__); | ||
187 | vp702x_usb_in_op(st->d, RESET_TUNER, 0, 0, NULL, 0); | ||
188 | return 0; | ||
189 | } | ||
190 | |||
191 | static int vp702x_fe_sleep(struct dvb_frontend *fe) | ||
192 | { | ||
193 | deb_fe("%s\n",__FUNCTION__); | ||
194 | return 0; | ||
195 | } | ||
196 | |||
186 | static int vp702x_fe_get_frontend(struct dvb_frontend* fe, | 197 | static int vp702x_fe_get_frontend(struct dvb_frontend* fe, |
187 | struct dvb_frontend_parameters *fep) | 198 | struct dvb_frontend_parameters *fep) |
188 | { | 199 | { |
@@ -193,8 +204,8 @@ static int vp702x_fe_get_frontend(struct dvb_frontend* fe, | |||
193 | static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe, | 204 | static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe, |
194 | struct dvb_diseqc_master_cmd *m) | 205 | struct dvb_diseqc_master_cmd *m) |
195 | { | 206 | { |
196 | struct vp702x_fe_state *st = fe->demodulator_priv; | 207 | //struct vp702x_fe_state *st = fe->demodulator_priv; |
197 | u8 cmd[8],ibuf[10]; | 208 | u8 cmd[8];//,ibuf[10]; |
198 | memset(cmd,0,8); | 209 | memset(cmd,0,8); |
199 | 210 | ||
200 | deb_fe("%s\n",__FUNCTION__); | 211 | deb_fe("%s\n",__FUNCTION__); |
@@ -207,12 +218,12 @@ static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe, | |||
207 | memcpy(&cmd[3], m->msg, m->msg_len); | 218 | memcpy(&cmd[3], m->msg, m->msg_len); |
208 | cmd[7] = vp702x_chksum(cmd,0,7); | 219 | cmd[7] = vp702x_chksum(cmd,0,7); |
209 | 220 | ||
210 | vp702x_usb_inout_op(st->d,cmd,8,ibuf,10,100); | 221 | // vp702x_usb_inout_op(st->d,cmd,8,ibuf,10,100); |
211 | 222 | ||
212 | if (ibuf[2] == 0 && ibuf[3] == 0) | 223 | // if (ibuf[2] == 0 && ibuf[3] == 0) |
213 | deb_fe("diseqc cmd failed.\n"); | 224 | // deb_fe("diseqc cmd failed.\n"); |
214 | else | 225 | // else |
215 | deb_fe("diseqc cmd succeeded.\n"); | 226 | // deb_fe("diseqc cmd succeeded.\n"); |
216 | 227 | ||
217 | return 0; | 228 | return 0; |
218 | } | 229 | } |
@@ -318,8 +329,8 @@ static struct dvb_frontend_ops vp702x_fe_ops = { | |||
318 | }, | 329 | }, |
319 | .release = vp702x_fe_release, | 330 | .release = vp702x_fe_release, |
320 | 331 | ||
321 | .init = NULL, | 332 | .init = vp702x_fe_init, |
322 | .sleep = NULL, | 333 | .sleep = vp702x_fe_sleep, |
323 | 334 | ||
324 | .set_frontend = vp702x_fe_set_frontend, | 335 | .set_frontend = vp702x_fe_set_frontend, |
325 | .get_frontend = vp702x_fe_get_frontend, | 336 | .get_frontend = vp702x_fe_get_frontend, |
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c index b2f098a2d5f7..02bd61aaac66 100644 --- a/drivers/media/dvb/dvb-usb/vp702x.c +++ b/drivers/media/dvb/dvb-usb/vp702x.c | |||
@@ -22,50 +22,54 @@ module_param_named(debug,dvb_usb_vp702x_debug, int, 0644); | |||
22 | MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS); | 22 | MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS); |
23 | 23 | ||
24 | struct vp702x_state { | 24 | struct vp702x_state { |
25 | u8 pid_table[17]; /* [16] controls the pid_table state */ | 25 | int pid_filter_count; |
26 | int pid_filter_can_bypass; | ||
27 | u8 pid_filter_state; | ||
28 | }; | ||
29 | |||
30 | struct vp702x_device_state { | ||
31 | u8 power_state; | ||
26 | }; | 32 | }; |
27 | 33 | ||
28 | /* check for mutex FIXME */ | 34 | /* check for mutex FIXME */ |
29 | int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen) | 35 | int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen) |
30 | { | 36 | { |
31 | int ret = 0,try = 0; | 37 | int ret = -1; |
32 | 38 | ||
33 | while (ret >= 0 && ret != blen && try < 3) { | ||
34 | ret = usb_control_msg(d->udev, | 39 | ret = usb_control_msg(d->udev, |
35 | usb_rcvctrlpipe(d->udev,0), | 40 | usb_rcvctrlpipe(d->udev,0), |
36 | req, | 41 | req, |
37 | USB_TYPE_VENDOR | USB_DIR_IN, | 42 | USB_TYPE_VENDOR | USB_DIR_IN, |
38 | value,index,b,blen, | 43 | value,index,b,blen, |
39 | 2000); | 44 | 2000); |
40 | deb_info("reading number %d (ret: %d)\n",try,ret); | ||
41 | try++; | ||
42 | } | ||
43 | 45 | ||
44 | if (ret < 0 || ret != blen) { | 46 | if (ret < 0) { |
45 | warn("usb in operation failed."); | 47 | warn("usb in operation failed. (%d)", ret); |
46 | ret = -EIO; | 48 | ret = -EIO; |
47 | } else | 49 | } else |
48 | ret = 0; | 50 | ret = 0; |
49 | 51 | ||
50 | deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index); | 52 | |
53 | deb_xfer("in: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index); | ||
51 | debug_dump(b,blen,deb_xfer); | 54 | debug_dump(b,blen,deb_xfer); |
52 | 55 | ||
53 | return ret; | 56 | return ret; |
54 | } | 57 | } |
55 | 58 | ||
56 | static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, | 59 | int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, |
57 | u16 index, u8 *b, int blen) | 60 | u16 index, u8 *b, int blen) |
58 | { | 61 | { |
59 | deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index); | 62 | int ret; |
63 | deb_xfer("out: req. %02x, val: %04x, ind: %04x, buffer: ",req,value,index); | ||
60 | debug_dump(b,blen,deb_xfer); | 64 | debug_dump(b,blen,deb_xfer); |
61 | 65 | ||
62 | if (usb_control_msg(d->udev, | 66 | if ((ret = usb_control_msg(d->udev, |
63 | usb_sndctrlpipe(d->udev,0), | 67 | usb_sndctrlpipe(d->udev,0), |
64 | req, | 68 | req, |
65 | USB_TYPE_VENDOR | USB_DIR_OUT, | 69 | USB_TYPE_VENDOR | USB_DIR_OUT, |
66 | value,index,b,blen, | 70 | value,index,b,blen, |
67 | 2000) != blen) { | 71 | 2000)) != blen) { |
68 | warn("usb out operation failed."); | 72 | warn("usb out operation failed. (%d)",ret); |
69 | return -EIO; | 73 | return -EIO; |
70 | } else | 74 | } else |
71 | return 0; | 75 | return 0; |
@@ -78,12 +82,10 @@ int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int il | |||
78 | if ((ret = mutex_lock_interruptible(&d->usb_mutex))) | 82 | if ((ret = mutex_lock_interruptible(&d->usb_mutex))) |
79 | return ret; | 83 | return ret; |
80 | 84 | ||
81 | if ((ret = vp702x_usb_out_op(d,REQUEST_OUT,0,0,o,olen)) < 0) | 85 | ret = vp702x_usb_out_op(d,REQUEST_OUT,0,0,o,olen); |
82 | goto unlock; | ||
83 | msleep(msec); | 86 | msleep(msec); |
84 | ret = vp702x_usb_in_op(d,REQUEST_IN,0,0,i,ilen); | 87 | ret = vp702x_usb_in_op(d,REQUEST_IN,0,0,i,ilen); |
85 | 88 | ||
86 | unlock: | ||
87 | mutex_unlock(&d->usb_mutex); | 89 | mutex_unlock(&d->usb_mutex); |
88 | 90 | ||
89 | return ret; | 91 | return ret; |
@@ -108,29 +110,65 @@ static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, | |||
108 | return ret; | 110 | return ret; |
109 | } | 111 | } |
110 | 112 | ||
111 | static int vp702x_pid_filter(struct dvb_usb_device *d, int index, u16 pid, int onoff) | 113 | static int vp702x_set_pld_mode(struct dvb_usb_adapter *adap, u8 bypass) |
114 | { | ||
115 | u8 buf[16] = { 0 }; | ||
116 | return vp702x_usb_in_op(adap->dev, 0xe0, (bypass << 8) | 0x0e, 0, buf, 16); | ||
117 | } | ||
118 | |||
119 | static int vp702x_set_pld_state(struct dvb_usb_adapter *adap, u8 state) | ||
120 | { | ||
121 | u8 buf[16] = { 0 }; | ||
122 | return vp702x_usb_in_op(adap->dev, 0xe0, (state << 8) | 0x0f, 0, buf, 16); | ||
123 | } | ||
124 | |||
125 | static int vp702x_set_pid(struct dvb_usb_adapter *adap, u16 pid, u8 id, int onoff) | ||
112 | { | 126 | { |
113 | struct vp702x_state *st = d->priv; | 127 | struct vp702x_state *st = adap->priv; |
114 | u8 buf[9]; | 128 | u8 buf[16] = { 0 }; |
115 | 129 | ||
116 | if (onoff) { | 130 | if (onoff) |
117 | st->pid_table[16] |= 1 << index; | 131 | st->pid_filter_state |= (1 << id); |
118 | st->pid_table[index*2] = (pid >> 8) & 0xff; | 132 | else { |
119 | st->pid_table[index*2+1] = pid & 0xff; | 133 | st->pid_filter_state &= ~(1 << id); |
120 | } else { | 134 | pid = 0xffff; |
121 | st->pid_table[16] &= ~(1 << index); | ||
122 | st->pid_table[index*2] = st->pid_table[index*2+1] = 0; | ||
123 | } | 135 | } |
124 | 136 | ||
125 | return vp702x_usb_inout_cmd(d,SET_PID_FILTER,st->pid_table,17,buf,9,10); | 137 | id = 0x10 + id*2; |
138 | |||
139 | vp702x_set_pld_state(adap, st->pid_filter_state); | ||
140 | vp702x_usb_in_op(adap->dev, 0xe0, (((pid >> 8) & 0xff) << 8) | (id), 0, buf, 16); | ||
141 | vp702x_usb_in_op(adap->dev, 0xe0, (((pid ) & 0xff) << 8) | (id+1), 0, buf, 16); | ||
142 | return 0; | ||
126 | } | 143 | } |
127 | 144 | ||
128 | static int vp702x_power_ctrl(struct dvb_usb_device *d, int onoff) | 145 | |
146 | static int vp702x_init_pid_filter(struct dvb_usb_adapter *adap) | ||
129 | { | 147 | { |
130 | vp702x_usb_in_op(d,RESET_TUNER,0,0,NULL,0); | 148 | struct vp702x_state *st = adap->priv; |
149 | int i; | ||
150 | u8 b[10] = { 0 }; | ||
151 | |||
152 | st->pid_filter_count = 8; | ||
153 | st->pid_filter_can_bypass = 1; | ||
154 | st->pid_filter_state = 0x00; | ||
155 | |||
156 | vp702x_set_pld_mode(adap, 1); // bypass | ||
157 | |||
158 | for (i = 0; i < st->pid_filter_count; i++) | ||
159 | vp702x_set_pid(adap, 0xffff, i, 1); | ||
131 | 160 | ||
132 | vp702x_usb_in_op(d,SET_TUNER_POWER_REQ,0,onoff,NULL,0); | 161 | vp702x_usb_in_op(adap->dev, 0xb5, 3, 0, b, 10); |
133 | return vp702x_usb_in_op(d,SET_TUNER_POWER_REQ,0,onoff,NULL,0); | 162 | vp702x_usb_in_op(adap->dev, 0xb5, 0, 0, b, 10); |
163 | vp702x_usb_in_op(adap->dev, 0xb5, 1, 0, b, 10); | ||
164 | |||
165 | //vp702x_set_pld_mode(d, 0); // filter | ||
166 | return 0; | ||
167 | } | ||
168 | |||
169 | static int vp702x_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) | ||
170 | { | ||
171 | return 0; | ||
134 | } | 172 | } |
135 | 173 | ||
136 | /* keys for the enclosed remote control */ | 174 | /* keys for the enclosed remote control */ |
@@ -166,74 +204,83 @@ static int vp702x_rc_query(struct dvb_usb_device *d, u32 *event, int *state) | |||
166 | return 0; | 204 | return 0; |
167 | } | 205 | } |
168 | 206 | ||
207 | int vp702x_power_ctrl(struct dvb_usb_device *d, int onoff) | ||
208 | { | ||
209 | struct vp702x_device_state *st = d->priv; | ||
210 | |||
211 | if (st->power_state == 0 && onoff) | ||
212 | vp702x_usb_out_op(d, SET_TUNER_POWER_REQ, 1, 7, NULL, 0); | ||
213 | else if (st->power_state == 1 && onoff == 0) | ||
214 | vp702x_usb_out_op(d, SET_TUNER_POWER_REQ, 0, 7, NULL, 0); | ||
215 | |||
216 | st->power_state = onoff; | ||
217 | |||
218 | return 0; | ||
219 | } | ||
220 | |||
169 | static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6]) | 221 | static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6]) |
170 | { | 222 | { |
171 | u8 macb[9]; | 223 | u8 i; |
172 | if (vp702x_usb_inout_cmd(d, GET_MAC_ADDRESS, NULL, 0, macb, 9, 10)) | 224 | for (i = 6; i < 12; i++) |
173 | return -EIO; | 225 | vp702x_usb_in_op(d, READ_EEPROM_REQ, i, 1, &mac[i - 6], 1); |
174 | memcpy(mac,&macb[3],6); | ||
175 | return 0; | 226 | return 0; |
176 | } | 227 | } |
177 | 228 | ||
178 | static int vp702x_frontend_attach(struct dvb_usb_device *d) | 229 | static int vp702x_frontend_attach(struct dvb_usb_adapter *adap) |
179 | { | 230 | { |
180 | u8 buf[9] = { 0 }; | 231 | u8 buf[10] = { 0 }; |
232 | |||
233 | vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 0, 7, NULL, 0); | ||
181 | 234 | ||
182 | if (vp702x_usb_inout_cmd(d, GET_SYSTEM_STRING, NULL, 0, buf, 9, 10)) | 235 | if (vp702x_usb_inout_cmd(adap->dev, GET_SYSTEM_STRING, NULL, 0, buf, 10, 10)) |
183 | return -EIO; | 236 | return -EIO; |
184 | 237 | ||
185 | buf[8] = '\0'; | 238 | buf[9] = '\0'; |
186 | info("system string: %s",&buf[1]); | 239 | info("system string: %s",&buf[1]); |
187 | 240 | ||
188 | d->fe = vp702x_fe_attach(d); | 241 | vp702x_init_pid_filter(adap); |
242 | |||
243 | adap->fe = vp702x_fe_attach(adap->dev); | ||
244 | vp702x_usb_out_op(adap->dev, SET_TUNER_POWER_REQ, 1, 7, NULL, 0); | ||
245 | |||
189 | return 0; | 246 | return 0; |
190 | } | 247 | } |
191 | 248 | ||
192 | static struct dvb_usb_properties vp702x_properties; | 249 | static struct dvb_usb_device_properties vp702x_properties; |
193 | 250 | ||
194 | static int vp702x_usb_probe(struct usb_interface *intf, | 251 | static int vp702x_usb_probe(struct usb_interface *intf, |
195 | const struct usb_device_id *id) | 252 | const struct usb_device_id *id) |
196 | { | 253 | { |
197 | struct usb_device *udev = interface_to_usbdev(intf); | ||
198 | |||
199 | usb_clear_halt(udev,usb_sndctrlpipe(udev,0)); | ||
200 | usb_clear_halt(udev,usb_rcvctrlpipe(udev,0)); | ||
201 | |||
202 | return dvb_usb_device_init(intf,&vp702x_properties,THIS_MODULE,NULL); | 254 | return dvb_usb_device_init(intf,&vp702x_properties,THIS_MODULE,NULL); |
203 | } | 255 | } |
204 | 256 | ||
205 | static struct usb_device_id vp702x_usb_table [] = { | 257 | static struct usb_device_id vp702x_usb_table [] = { |
206 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) }, | 258 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) }, |
207 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_WARM) }, | 259 | // { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) }, |
208 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) }, | 260 | // { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) }, |
209 | { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) }, | ||
210 | { 0 }, | 261 | { 0 }, |
211 | }; | 262 | }; |
212 | MODULE_DEVICE_TABLE(usb, vp702x_usb_table); | 263 | MODULE_DEVICE_TABLE(usb, vp702x_usb_table); |
213 | 264 | ||
214 | static struct dvb_usb_properties vp702x_properties = { | 265 | static struct dvb_usb_device_properties vp702x_properties = { |
215 | .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_NEED_PID_FILTERING, | ||
216 | .pid_filter_count = 8, /* !!! */ | ||
217 | |||
218 | .usb_ctrl = CYPRESS_FX2, | 266 | .usb_ctrl = CYPRESS_FX2, |
219 | .firmware = "dvb-usb-vp702x-01.fw", | 267 | .firmware = "dvb-usb-vp702x-02.fw", |
268 | .no_reconnect = 1, | ||
220 | 269 | ||
221 | .pid_filter = vp702x_pid_filter, | 270 | .size_of_priv = sizeof(struct vp702x_device_state), |
222 | .power_ctrl = vp702x_power_ctrl, | ||
223 | .frontend_attach = vp702x_frontend_attach, | ||
224 | .read_mac_address = vp702x_read_mac_addr, | ||
225 | 271 | ||
226 | .rc_key_map = vp702x_rc_keys, | 272 | .num_adapters = 1, |
227 | .rc_key_map_size = ARRAY_SIZE(vp702x_rc_keys), | 273 | .adapter = { |
228 | .rc_interval = 400, | 274 | { |
229 | .rc_query = vp702x_rc_query, | 275 | .caps = DVB_USB_ADAP_RECEIVES_204_BYTE_TS, |
230 | 276 | ||
231 | .size_of_priv = sizeof(struct vp702x_state), | 277 | .streaming_ctrl = vp702x_streaming_ctrl, |
278 | .frontend_attach = vp702x_frontend_attach, | ||
232 | 279 | ||
233 | /* parameter for the MPEG2-data transfer */ | 280 | /* parameter for the MPEG2-data transfer */ |
234 | .urb = { | 281 | .stream = { |
235 | .type = DVB_USB_BULK, | 282 | .type = USB_BULK, |
236 | .count = 7, | 283 | .count = 10, |
237 | .endpoint = 0x02, | 284 | .endpoint = 0x02, |
238 | .u = { | 285 | .u = { |
239 | .bulk = { | 286 | .bulk = { |
@@ -241,24 +288,33 @@ static struct dvb_usb_properties vp702x_properties = { | |||
241 | } | 288 | } |
242 | } | 289 | } |
243 | }, | 290 | }, |
291 | .size_of_priv = sizeof(struct vp702x_state), | ||
292 | } | ||
293 | }, | ||
294 | .read_mac_address = vp702x_read_mac_addr, | ||
295 | |||
296 | .rc_key_map = vp702x_rc_keys, | ||
297 | .rc_key_map_size = ARRAY_SIZE(vp702x_rc_keys), | ||
298 | .rc_interval = 400, | ||
299 | .rc_query = vp702x_rc_query, | ||
244 | 300 | ||
245 | .num_device_descs = 2, | 301 | .num_device_descs = 1, |
246 | .devices = { | 302 | .devices = { |
247 | { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)", | 303 | { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)", |
248 | .cold_ids = { &vp702x_usb_table[0], NULL }, | 304 | .cold_ids = { &vp702x_usb_table[0], NULL }, |
249 | .warm_ids = { &vp702x_usb_table[1], NULL }, | 305 | .warm_ids = { NULL }, |
250 | }, | 306 | }, |
251 | { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)", | 307 | /* { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)", |
252 | .cold_ids = { &vp702x_usb_table[2], NULL }, | 308 | .cold_ids = { &vp702x_usb_table[2], NULL }, |
253 | .warm_ids = { &vp702x_usb_table[3], NULL }, | 309 | .warm_ids = { &vp702x_usb_table[3], NULL }, |
254 | }, | 310 | }, |
255 | { 0 }, | 311 | */ { NULL }, |
256 | } | 312 | } |
257 | }; | 313 | }; |
258 | 314 | ||
259 | /* usb specific object needed to register this driver with the usb subsystem */ | 315 | /* usb specific object needed to register this driver with the usb subsystem */ |
260 | static struct usb_driver vp702x_usb_driver = { | 316 | static struct usb_driver vp702x_usb_driver = { |
261 | .name = "dvb-usb-vp702x", | 317 | .name = "dvb_usb_vp702x", |
262 | .probe = vp702x_usb_probe, | 318 | .probe = vp702x_usb_probe, |
263 | .disconnect = dvb_usb_device_exit, | 319 | .disconnect = dvb_usb_device_exit, |
264 | .id_table = vp702x_usb_table, | 320 | .id_table = vp702x_usb_table, |
@@ -287,5 +343,5 @@ module_exit(vp702x_usb_module_exit); | |||
287 | 343 | ||
288 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); | 344 | MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>"); |
289 | MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones"); | 345 | MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones"); |
290 | MODULE_VERSION("1.0-alpha"); | 346 | MODULE_VERSION("1.0"); |
291 | MODULE_LICENSE("GPL"); | 347 | MODULE_LICENSE("GPL"); |
diff --git a/drivers/media/dvb/dvb-usb/vp702x.h b/drivers/media/dvb/dvb-usb/vp702x.h index c2f97f96c21f..25a9dee4c824 100644 --- a/drivers/media/dvb/dvb-usb/vp702x.h +++ b/drivers/media/dvb/dvb-usb/vp702x.h | |||
@@ -102,5 +102,7 @@ extern struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d); | |||
102 | 102 | ||
103 | extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec); | 103 | extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec); |
104 | extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen); | 104 | extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen); |
105 | extern int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen); | ||
106 | extern int vp702x_power_ctrl(struct dvb_usb_device *d, int onoff); | ||
105 | 107 | ||
106 | #endif | 108 | #endif |
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c index 8ea3834a6cf8..b4cf002703a7 100644 --- a/drivers/media/dvb/dvb-usb/vp7045.c +++ b/drivers/media/dvb/dvb-usb/vp7045.c | |||
@@ -169,31 +169,31 @@ static int vp7045_read_mac_addr(struct dvb_usb_device *d,u8 mac[6]) | |||
169 | return vp7045_read_eeprom(d,mac, 6, MAC_0_ADDR); | 169 | return vp7045_read_eeprom(d,mac, 6, MAC_0_ADDR); |
170 | } | 170 | } |
171 | 171 | ||
172 | static int vp7045_frontend_attach(struct dvb_usb_device *d) | 172 | static int vp7045_frontend_attach(struct dvb_usb_adapter *adap) |
173 | { | 173 | { |
174 | u8 buf[255] = { 0 }; | 174 | u8 buf[255] = { 0 }; |
175 | 175 | ||
176 | vp7045_usb_op(d,VENDOR_STRING_READ,NULL,0,buf,20,0); | 176 | vp7045_usb_op(adap->dev,VENDOR_STRING_READ,NULL,0,buf,20,0); |
177 | buf[10] = '\0'; | 177 | buf[10] = '\0'; |
178 | deb_info("firmware says: %s ",buf); | 178 | deb_info("firmware says: %s ",buf); |
179 | 179 | ||
180 | vp7045_usb_op(d,PRODUCT_STRING_READ,NULL,0,buf,20,0); | 180 | vp7045_usb_op(adap->dev,PRODUCT_STRING_READ,NULL,0,buf,20,0); |
181 | buf[10] = '\0'; | 181 | buf[10] = '\0'; |
182 | deb_info("%s ",buf); | 182 | deb_info("%s ",buf); |
183 | 183 | ||
184 | vp7045_usb_op(d,FW_VERSION_READ,NULL,0,buf,20,0); | 184 | vp7045_usb_op(adap->dev,FW_VERSION_READ,NULL,0,buf,20,0); |
185 | buf[10] = '\0'; | 185 | buf[10] = '\0'; |
186 | deb_info("v%s\n",buf); | 186 | deb_info("v%s\n",buf); |
187 | 187 | ||
188 | /* Dump the EEPROM */ | 188 | /* Dump the EEPROM */ |
189 | /* vp7045_read_eeprom(d,buf, 255, FX2_ID_ADDR); */ | 189 | /* vp7045_read_eeprom(d,buf, 255, FX2_ID_ADDR); */ |
190 | 190 | ||
191 | d->fe = vp7045_fe_attach(d); | 191 | adap->fe = vp7045_fe_attach(adap->dev); |
192 | 192 | ||
193 | return 0; | 193 | return 0; |
194 | } | 194 | } |
195 | 195 | ||
196 | static struct dvb_usb_properties vp7045_properties; | 196 | static struct dvb_usb_device_properties vp7045_properties; |
197 | 197 | ||
198 | static int vp7045_usb_probe(struct usb_interface *intf, | 198 | static int vp7045_usb_probe(struct usb_interface *intf, |
199 | const struct usb_device_id *id) | 199 | const struct usb_device_id *id) |
@@ -210,24 +210,17 @@ static struct usb_device_id vp7045_usb_table [] = { | |||
210 | }; | 210 | }; |
211 | MODULE_DEVICE_TABLE(usb, vp7045_usb_table); | 211 | MODULE_DEVICE_TABLE(usb, vp7045_usb_table); |
212 | 212 | ||
213 | static struct dvb_usb_properties vp7045_properties = { | 213 | static struct dvb_usb_device_properties vp7045_properties = { |
214 | .caps = 0, | ||
215 | |||
216 | .usb_ctrl = CYPRESS_FX2, | 214 | .usb_ctrl = CYPRESS_FX2, |
217 | .firmware = "dvb-usb-vp7045-01.fw", | 215 | .firmware = "dvb-usb-vp7045-01.fw", |
218 | 216 | ||
219 | .power_ctrl = vp7045_power_ctrl, | 217 | .num_adapters = 1, |
218 | .adapter = { | ||
219 | { | ||
220 | .frontend_attach = vp7045_frontend_attach, | 220 | .frontend_attach = vp7045_frontend_attach, |
221 | .read_mac_address = vp7045_read_mac_addr, | ||
222 | |||
223 | .rc_interval = 400, | ||
224 | .rc_key_map = vp7045_rc_keys, | ||
225 | .rc_key_map_size = ARRAY_SIZE(vp7045_rc_keys), | ||
226 | .rc_query = vp7045_rc_query, | ||
227 | |||
228 | /* parameter for the MPEG2-data transfer */ | 221 | /* parameter for the MPEG2-data transfer */ |
229 | .urb = { | 222 | .stream = { |
230 | .type = DVB_USB_BULK, | 223 | .type = USB_BULK, |
231 | .count = 7, | 224 | .count = 7, |
232 | .endpoint = 0x02, | 225 | .endpoint = 0x02, |
233 | .u = { | 226 | .u = { |
@@ -236,6 +229,15 @@ static struct dvb_usb_properties vp7045_properties = { | |||
236 | } | 229 | } |
237 | } | 230 | } |
238 | }, | 231 | }, |
232 | } | ||
233 | }, | ||
234 | .power_ctrl = vp7045_power_ctrl, | ||
235 | .read_mac_address = vp7045_read_mac_addr, | ||
236 | |||
237 | .rc_interval = 400, | ||
238 | .rc_key_map = vp7045_rc_keys, | ||
239 | .rc_key_map_size = ARRAY_SIZE(vp7045_rc_keys), | ||
240 | .rc_query = vp7045_rc_query, | ||
239 | 241 | ||
240 | .num_device_descs = 2, | 242 | .num_device_descs = 2, |
241 | .devices = { | 243 | .devices = { |
diff --git a/drivers/media/dvb/frontends/cx24123.c b/drivers/media/dvb/frontends/cx24123.c index 62d69a6ea699..a356d28fc3bb 100644 --- a/drivers/media/dvb/frontends/cx24123.c +++ b/drivers/media/dvb/frontends/cx24123.c | |||
@@ -553,8 +553,8 @@ static int cx24123_pll_calculate(struct dvb_frontend* fe, struct dvb_frontend_pa | |||
553 | ndiv = ( ((p->frequency * vco_div * 10) / (2 * XTAL / 1000)) / 32) & 0x1ff; | 553 | ndiv = ( ((p->frequency * vco_div * 10) / (2 * XTAL / 1000)) / 32) & 0x1ff; |
554 | adiv = ( ((p->frequency * vco_div * 10) / (2 * XTAL / 1000)) % 32) & 0x1f; | 554 | adiv = ( ((p->frequency * vco_div * 10) / (2 * XTAL / 1000)) % 32) & 0x1f; |
555 | 555 | ||
556 | if (adiv == 0) | 556 | if (adiv == 0 && ndiv > 0) |
557 | ndiv++; | 557 | ndiv--; |
558 | 558 | ||
559 | /* control bits 11, refdiv 11, charge pump polarity 1, charge pump current, ndiv, adiv */ | 559 | /* control bits 11, refdiv 11, charge pump polarity 1, charge pump current, ndiv, adiv */ |
560 | state->pllarg = (3 << 19) | (3 << 17) | (1 << 16) | (pump << 14) | (ndiv << 5) | adiv; | 560 | state->pllarg = (3 << 19) | (3 << 17) | (1 << 16) | (pump << 14) | (ndiv << 5) | adiv; |
diff --git a/drivers/media/dvb/frontends/dib3000mc.c b/drivers/media/dvb/frontends/dib3000mc.c index cc28417fa33a..ccc813b525d6 100644 --- a/drivers/media/dvb/frontends/dib3000mc.c +++ b/drivers/media/dvb/frontends/dib3000mc.c | |||
@@ -37,6 +37,8 @@ struct dib3000mc_state { | |||
37 | 37 | ||
38 | struct dibx000_i2c_master i2c_master; | 38 | struct dibx000_i2c_master i2c_master; |
39 | 39 | ||
40 | u32 timf; | ||
41 | |||
40 | fe_bandwidth_t current_bandwidth; | 42 | fe_bandwidth_t current_bandwidth; |
41 | 43 | ||
42 | u16 dev_id; | 44 | u16 dev_id; |
@@ -92,50 +94,31 @@ static int dib3000mc_identify(struct dib3000mc_state *state) | |||
92 | 94 | ||
93 | static int dib3000mc_set_timing(struct dib3000mc_state *state, s16 nfft, u8 bw, u8 update_offset) | 95 | static int dib3000mc_set_timing(struct dib3000mc_state *state, s16 nfft, u8 bw, u8 update_offset) |
94 | { | 96 | { |
95 | /* | 97 | u32 timf; |
96 | u32 timf_msb, timf_lsb, i; | ||
97 | int tim_sgn ; | ||
98 | LUInt comp1, comp2, comp ; | ||
99 | // u32 tim_offset ; | ||
100 | comp = 27700 * BW_INDEX_TO_KHZ(bw) / 1000; | ||
101 | timf_msb = (comp >> 16) & 0x00FF; | ||
102 | timf_lsb = comp & 0xFFFF; | ||
103 | |||
104 | // Update the timing offset ; | ||
105 | if (update_offset) { | ||
106 | if (state->timing_offset_comp_done == 0) { | ||
107 | usleep(200000); | ||
108 | state->timing_offset_comp_done = 1; | ||
109 | } | ||
110 | tim_offset = dib3000mc_read_word(state, 416); | ||
111 | if ((tim_offset & 0x2000) == 0x2000) | ||
112 | tim_offset |= 0xC000; // PB: This only works if tim_offset is s16 - weird | ||
113 | |||
114 | if (nfft == 0) | ||
115 | tim_offset = tim_offset << 2; // PB: Do not store the offset for different things in one variable | ||
116 | state->timing_offset += tim_offset; | ||
117 | } | ||
118 | tim_offset = state->timing_offset; | ||
119 | 98 | ||
120 | if (tim_offset < 0) { | 99 | if (state->timf == 0) { |
121 | tim_sgn = 1; | 100 | timf = 1384402; // default value for 8MHz |
122 | tim_offset = -tim_offset; | 101 | if (update_offset) |
102 | msleep(200); // first time we do an update | ||
123 | } else | 103 | } else |
124 | tim_sgn = 0; | 104 | timf = state->timf; |
125 | 105 | ||
126 | comp1 = tim_offset * timf_lsb; | 106 | timf *= (BW_INDEX_TO_KHZ(bw) / 1000); |
127 | comp2 = tim_offset * timf_msb; | ||
128 | comp = ((comp1 >> 16) + comp2) >> 7; | ||
129 | 107 | ||
130 | if (tim_sgn == 0) | 108 | if (update_offset) { |
131 | comp = timf_msb * (1<<16) + timf_lsb + comp; | 109 | s16 tim_offs = dib3000mc_read_word(state, 416); |
132 | else | 110 | |
133 | comp = timf_msb * (1<<16) + timf_lsb - comp; | 111 | if (tim_offs & 0x2000) |
112 | tim_offs -= 0x4000; | ||
134 | 113 | ||
135 | timf_msb = (comp>>16)&0xFF ; | 114 | if (nfft == 0) |
136 | timf_lsb = comp&0xFFFF; | 115 | tim_offs *= 4; |
137 | */ | 116 | |
138 | u32 timf = 1384402 * (BW_INDEX_TO_KHZ(bw) / 1000); | 117 | timf += tim_offs; |
118 | state->timf = timf / (BW_INDEX_TO_KHZ(bw) / 1000); | ||
119 | } | ||
120 | |||
121 | dprintk("timf: %d\n", timf); | ||
139 | 122 | ||
140 | dib3000mc_write_word(state, 23, timf >> 16); | 123 | dib3000mc_write_word(state, 23, timf >> 16); |
141 | dib3000mc_write_word(state, 24, timf & 0xffff); | 124 | dib3000mc_write_word(state, 24, timf & 0xffff); |
@@ -143,15 +126,18 @@ static int dib3000mc_set_timing(struct dib3000mc_state *state, s16 nfft, u8 bw, | |||
143 | return 0; | 126 | return 0; |
144 | } | 127 | } |
145 | 128 | ||
146 | static int dib3000mc_setup_pwm3_state(struct dib3000mc_state *state) | 129 | static int dib3000mc_setup_pwm_state(struct dib3000mc_state *state) |
147 | { | 130 | { |
131 | u16 reg_51, reg_52 = state->cfg->agc->setup & 0xfefb; | ||
148 | if (state->cfg->pwm3_inversion) { | 132 | if (state->cfg->pwm3_inversion) { |
149 | dib3000mc_write_word(state, 51, (2 << 14) | (0 << 10) | (7 << 6) | (2 << 2) | (2 << 0)); | 133 | reg_51 = (2 << 14) | (0 << 10) | (7 << 6) | (2 << 2) | (2 << 0); |
150 | dib3000mc_write_word(state, 52, (0 << 8) | (5 << 5) | (1 << 4) | (1 << 3) | (1 << 2) | (2 << 0)); | 134 | reg_52 |= (1 << 2); |
151 | } else { | 135 | } else { |
152 | dib3000mc_write_word(state, 51, (2 << 14) | (4 << 10) | (7 << 6) | (2 << 2) | (2 << 0)); | 136 | reg_51 = (2 << 14) | (4 << 10) | (7 << 6) | (2 << 2) | (2 << 0); |
153 | dib3000mc_write_word(state, 52, (1 << 8) | (5 << 5) | (1 << 4) | (1 << 3) | (0 << 2) | (2 << 0)); | 137 | reg_52 |= (1 << 8); |
154 | } | 138 | } |
139 | dib3000mc_write_word(state, 51, reg_51); | ||
140 | dib3000mc_write_word(state, 52, reg_52); | ||
155 | 141 | ||
156 | if (state->cfg->use_pwm3) | 142 | if (state->cfg->use_pwm3) |
157 | dib3000mc_write_word(state, 245, (1 << 3) | (1 << 0)); | 143 | dib3000mc_write_word(state, 245, (1 << 3) | (1 << 0)); |
@@ -326,10 +312,10 @@ static int dib3000mc_init(struct dvb_frontend *demod) | |||
326 | dib3000mc_write_word(state, 175, 0x0000); | 312 | dib3000mc_write_word(state, 175, 0x0000); |
327 | dib3000mc_write_word(state, 1032, 0x012C); | 313 | dib3000mc_write_word(state, 1032, 0x012C); |
328 | } | 314 | } |
329 | dib3000mc_write_word(state, 1033, 0); | 315 | dib3000mc_write_word(state, 1033, 0x0000); |
330 | 316 | ||
331 | // P_clk_cfg | 317 | // P_clk_cfg |
332 | dib3000mc_write_word(state, 1037, 12592); | 318 | dib3000mc_write_word(state, 1037, 0x3130); |
333 | 319 | ||
334 | // other configurations | 320 | // other configurations |
335 | 321 | ||
@@ -350,7 +336,7 @@ static int dib3000mc_init(struct dvb_frontend *demod) | |||
350 | dib3000mc_write_word(state, 50, 0x8000); | 336 | dib3000mc_write_word(state, 50, 0x8000); |
351 | 337 | ||
352 | // agc setup misc | 338 | // agc setup misc |
353 | dib3000mc_setup_pwm3_state(state); | 339 | dib3000mc_setup_pwm_state(state); |
354 | 340 | ||
355 | // P_agc_counter_lock | 341 | // P_agc_counter_lock |
356 | dib3000mc_write_word(state, 53, 0x87); | 342 | dib3000mc_write_word(state, 53, 0x87); |
@@ -426,10 +412,9 @@ static int dib3000mc_sleep(struct dvb_frontend *demod) | |||
426 | { | 412 | { |
427 | struct dib3000mc_state *state = demod->demodulator_priv; | 413 | struct dib3000mc_state *state = demod->demodulator_priv; |
428 | 414 | ||
429 | dib3000mc_write_word(state, 1037, dib3000mc_read_word(state, 1037) | 0x0003); | ||
430 | dib3000mc_write_word(state, 1031, 0xFFFF); | 415 | dib3000mc_write_word(state, 1031, 0xFFFF); |
431 | dib3000mc_write_word(state, 1032, 0xFFFF); | 416 | dib3000mc_write_word(state, 1032, 0xFFFF); |
432 | dib3000mc_write_word(state, 1033, 0xFFF4); // **** Bin2 | 417 | dib3000mc_write_word(state, 1033, 0xFFF0); |
433 | 418 | ||
434 | return 0; | 419 | return 0; |
435 | } | 420 | } |
@@ -539,6 +524,7 @@ static int dib3000mc_autosearch_start(struct dvb_frontend *demod, struct dibx000 | |||
539 | 524 | ||
540 | reg = dib3000mc_read_word(state, 0); | 525 | reg = dib3000mc_read_word(state, 0); |
541 | dib3000mc_write_word(state, 0, reg | (1 << 8)); | 526 | dib3000mc_write_word(state, 0, reg | (1 << 8)); |
527 | dib3000mc_read_word(state, 511); | ||
542 | dib3000mc_write_word(state, 0, reg); | 528 | dib3000mc_write_word(state, 0, reg); |
543 | 529 | ||
544 | return 0; | 530 | return 0; |
@@ -578,59 +564,9 @@ static int dib3000mc_tune(struct dvb_frontend *demod, struct dibx000_ofdm_channe | |||
578 | dib3000mc_write_word(state, 33, 6); | 564 | dib3000mc_write_word(state, 33, 6); |
579 | } | 565 | } |
580 | 566 | ||
581 | // if (lock) | 567 | if (dib3000mc_read_word(state, 509) & 0x80) |
582 | // dib3000mc_set_timing(state, ch->nfft, ch->Bw, 1); | 568 | dib3000mc_set_timing(state, ch->nfft, ch->Bw, 1); |
583 | |||
584 | return 0; | ||
585 | } | ||
586 | |||
587 | static int dib3000mc_demod_output_mode(struct dvb_frontend *demod, int mode) | ||
588 | { | ||
589 | struct dib3000mc_state *state = demod->demodulator_priv; | ||
590 | return dib3000mc_set_output_mode(state, mode); | ||
591 | } | ||
592 | |||
593 | static int dib3000mc_i2c_enumeration(struct dvb_frontend *demod[], int no_of_demods, u8 default_addr) | ||
594 | { | ||
595 | struct dib3000mc_state *st; | ||
596 | int k,ret=0; | ||
597 | u8 new_addr; | ||
598 | |||
599 | static u8 DIB3000MC_I2C_ADDRESS[] = {20,22,24,26}; | ||
600 | |||
601 | for (k = no_of_demods-1; k >= 0; k--) { | ||
602 | st = demod[k]->demodulator_priv; | ||
603 | |||
604 | /* designated i2c address */ | ||
605 | new_addr = DIB3000MC_I2C_ADDRESS[k]; | ||
606 | |||
607 | st->i2c_addr = new_addr; | ||
608 | if (dib3000mc_identify(st) != 0) { | ||
609 | st->i2c_addr = default_addr; | ||
610 | if (dib3000mc_identify(st) != 0) { | ||
611 | dprintk("-E- DiB3000P/MC #%d: not identified\n", k); | ||
612 | return -EINVAL; | ||
613 | } | ||
614 | } | ||
615 | |||
616 | /* turn on div_out */ | ||
617 | dib3000mc_demod_output_mode(demod[k], OUTMODE_MPEG2_PAR_CONT_CLK); | ||
618 | |||
619 | // set new i2c address and force divstr (Bit 1) to value 0 (Bit 0) | ||
620 | ret |= dib3000mc_write_word(st, 1024, (new_addr << 3) | 0x1); | ||
621 | st->i2c_addr = new_addr; | ||
622 | } | ||
623 | |||
624 | for (k = 0; k < no_of_demods; k++) { | ||
625 | st = demod[k]->demodulator_priv; | ||
626 | |||
627 | ret |= dib3000mc_write_word(st, 1024, st->i2c_addr << 3); | ||
628 | |||
629 | /* turn off data output */ | ||
630 | dib3000mc_demod_output_mode(demod[k],OUTMODE_HIGH_Z); | ||
631 | dib3000mc_write_word(st, 769, (1 << 7) ); | ||
632 | 569 | ||
633 | } | ||
634 | return 0; | 570 | return 0; |
635 | } | 571 | } |
636 | 572 | ||
@@ -826,61 +762,79 @@ void dib3000mc_set_config(struct dvb_frontend *fe, struct dib3000mc_config *cfg) | |||
826 | } | 762 | } |
827 | EXPORT_SYMBOL(dib3000mc_set_config); | 763 | EXPORT_SYMBOL(dib3000mc_set_config); |
828 | 764 | ||
829 | static struct dvb_frontend_ops dib3000mc_ops; | 765 | int dib3000mc_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib3000mc_config cfg[]) |
830 | |||
831 | int dib3000mc_attach(struct i2c_adapter *i2c_adap, int no_of_demods, u8 default_addr, u8 do_i2c_enum, struct dib3000mc_config cfg[], struct dvb_frontend *demod[]) | ||
832 | { | 766 | { |
833 | struct dib3000mc_state *st; | 767 | struct dib3000mc_state st = { .i2c_adap = i2c }; |
834 | int k, num=0; | 768 | int k; |
835 | 769 | u8 new_addr; | |
836 | if (no_of_demods < 1) | ||
837 | return -EINVAL; | ||
838 | 770 | ||
839 | for (k = 0; k < no_of_demods; k++) { | 771 | static u8 DIB3000MC_I2C_ADDRESS[] = {20,22,24,26}; |
840 | st = kzalloc(sizeof(struct dib3000mc_state), GFP_KERNEL); | ||
841 | if (st == NULL) | ||
842 | goto error; | ||
843 | 772 | ||
844 | num++; | 773 | for (k = no_of_demods-1; k >= 0; k--) { |
774 | st.cfg = &cfg[k]; | ||
845 | 775 | ||
846 | st->cfg = &cfg[k]; | 776 | /* designated i2c address */ |
847 | // st->gpio_val = cfg[k].gpio_val; | 777 | new_addr = DIB3000MC_I2C_ADDRESS[k]; |
848 | // st->gpio_dir = cfg[k].gpio_dir; | 778 | st.i2c_addr = new_addr; |
849 | st->i2c_adap = i2c_adap; | 779 | if (dib3000mc_identify(&st) != 0) { |
780 | st.i2c_addr = default_addr; | ||
781 | if (dib3000mc_identify(&st) != 0) { | ||
782 | dprintk("-E- DiB3000P/MC #%d: not identified\n", k); | ||
783 | return -ENODEV; | ||
784 | } | ||
785 | } | ||
850 | 786 | ||
851 | demod[k] = &st->demod; | 787 | dib3000mc_set_output_mode(&st, OUTMODE_MPEG2_PAR_CONT_CLK); |
852 | demod[k]->demodulator_priv = st; | ||
853 | memcpy(&st->demod.ops, &dib3000mc_ops, sizeof(struct dvb_frontend_ops)); | ||
854 | 788 | ||
855 | // INIT_COMPONENT_REGISTER_ACCESS(&st->register_access, 12, 16, dib7000p_register_read, dib7000p_register_write, st); | 789 | // set new i2c address and force divstr (Bit 1) to value 0 (Bit 0) |
856 | // demod[k]->register_access = &st->register_access; | 790 | dib3000mc_write_word(&st, 1024, (new_addr << 3) | 0x1); |
791 | st.i2c_addr = new_addr; | ||
857 | } | 792 | } |
858 | 793 | ||
859 | if (do_i2c_enum) { | 794 | for (k = 0; k < no_of_demods; k++) { |
860 | if (dib3000mc_i2c_enumeration(demod,no_of_demods,default_addr) != 0) | 795 | st.cfg = &cfg[k]; |
861 | goto error; | 796 | st.i2c_addr = DIB3000MC_I2C_ADDRESS[k]; |
862 | } else { | ||
863 | st = demod[0]->demodulator_priv; | ||
864 | st->i2c_addr = default_addr; | ||
865 | if (dib3000mc_identify(st) != 0) | ||
866 | goto error; | ||
867 | } | ||
868 | 797 | ||
869 | for (k = 0; k < num; k++) { | 798 | dib3000mc_write_word(&st, 1024, st.i2c_addr << 3); |
870 | st = demod[k]->demodulator_priv; | ||
871 | dibx000_init_i2c_master(&st->i2c_master, DIB3000MC, st->i2c_adap, st->i2c_addr); | ||
872 | } | ||
873 | 799 | ||
800 | /* turn off data output */ | ||
801 | dib3000mc_set_output_mode(&st, OUTMODE_HIGH_Z); | ||
802 | } | ||
874 | return 0; | 803 | return 0; |
804 | } | ||
805 | EXPORT_SYMBOL(dib3000mc_i2c_enumeration); | ||
806 | |||
807 | static struct dvb_frontend_ops dib3000mc_ops; | ||
808 | |||
809 | struct dvb_frontend * dib3000mc_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib3000mc_config *cfg) | ||
810 | { | ||
811 | struct dvb_frontend *demod; | ||
812 | struct dib3000mc_state *st; | ||
813 | st = kzalloc(sizeof(struct dib3000mc_state), GFP_KERNEL); | ||
814 | if (st == NULL) | ||
815 | return NULL; | ||
816 | |||
817 | st->cfg = cfg; | ||
818 | st->i2c_adap = i2c_adap; | ||
819 | st->i2c_addr = i2c_addr; | ||
820 | |||
821 | demod = &st->demod; | ||
822 | demod->demodulator_priv = st; | ||
823 | memcpy(&st->demod.ops, &dib3000mc_ops, sizeof(struct dvb_frontend_ops)); | ||
824 | |||
825 | if (dib3000mc_identify(st) != 0) | ||
826 | goto error; | ||
827 | |||
828 | dibx000_init_i2c_master(&st->i2c_master, DIB3000MC, st->i2c_adap, st->i2c_addr); | ||
829 | |||
830 | dib3000mc_write_word(st, 1037, 0x3130); | ||
831 | |||
832 | return demod; | ||
875 | 833 | ||
876 | error: | 834 | error: |
877 | for (k = 0; k < num; k++) { | 835 | kfree(st); |
878 | kfree(demod[k]->demodulator_priv); | 836 | return NULL; |
879 | demod[k] = NULL; | ||
880 | } | ||
881 | return -EINVAL; | ||
882 | } | 837 | } |
883 | |||
884 | EXPORT_SYMBOL(dib3000mc_attach); | 838 | EXPORT_SYMBOL(dib3000mc_attach); |
885 | 839 | ||
886 | static struct dvb_frontend_ops dib3000mc_ops = { | 840 | static struct dvb_frontend_ops dib3000mc_ops = { |
diff --git a/drivers/media/dvb/frontends/dib3000mc.h b/drivers/media/dvb/frontends/dib3000mc.h index fd0b2e755993..b198cd5b1843 100644 --- a/drivers/media/dvb/frontends/dib3000mc.h +++ b/drivers/media/dvb/frontends/dib3000mc.h | |||
@@ -37,17 +37,17 @@ struct dib3000mc_config { | |||
37 | #define DEFAULT_DIB3000P_I2C_ADDRESS 24 | 37 | #define DEFAULT_DIB3000P_I2C_ADDRESS 24 |
38 | 38 | ||
39 | #if defined(CONFIG_DVB_DIB3000MC) || defined(CONFIG_DVB_DIB3000MC_MODULE) | 39 | #if defined(CONFIG_DVB_DIB3000MC) || defined(CONFIG_DVB_DIB3000MC_MODULE) |
40 | extern int dib3000mc_attach(struct i2c_adapter *i2c_adap, int no_of_demods, u8 default_addr, | 40 | extern struct dvb_frontend * dib3000mc_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib3000mc_config *cfg); |
41 | u8 do_i2c_enum, struct dib3000mc_config cfg[], struct dvb_frontend *demod[]); | ||
42 | #else | 41 | #else |
43 | static inline struct dvb_frontend* dib3000mc_attach(const struct dib3000_config* config, | 42 | static inline struct dvb_frontend * dib3000mc_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib3000mc_config *cfg) |
44 | struct i2c_adapter* i2c, struct dib_fe_xfer_ops *xfer_ops) | ||
45 | { | 43 | { |
46 | printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__); | 44 | printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__); |
47 | return NULL; | 45 | return NULL; |
48 | } | 46 | } |
49 | #endif // CONFIG_DVB_DIB3000MC | 47 | #endif // CONFIG_DVB_DIB3000MC |
50 | 48 | ||
49 | extern int dib3000mc_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib3000mc_config cfg[]); | ||
50 | |||
51 | extern struct i2c_adapter * dib3000mc_get_tuner_i2c_master(struct dvb_frontend *demod, int gating); | 51 | extern struct i2c_adapter * dib3000mc_get_tuner_i2c_master(struct dvb_frontend *demod, int gating); |
52 | 52 | ||
53 | extern int dib3000mc_pid_control(struct dvb_frontend *fe, int index, int pid,int onoff); | 53 | extern int dib3000mc_pid_control(struct dvb_frontend *fe, int index, int pid,int onoff); |
diff --git a/drivers/media/dvb/frontends/mt2060.c b/drivers/media/dvb/frontends/mt2060.c index 508ec1b6d1fb..450fad8d9b65 100644 --- a/drivers/media/dvb/frontends/mt2060.c +++ b/drivers/media/dvb/frontends/mt2060.c | |||
@@ -247,6 +247,9 @@ static void mt2060_calibrate(struct mt2060_priv *priv) | |||
247 | if (mt2060_writeregs(priv,mt2060_config2,sizeof(mt2060_config2))) | 247 | if (mt2060_writeregs(priv,mt2060_config2,sizeof(mt2060_config2))) |
248 | return; | 248 | return; |
249 | 249 | ||
250 | /* initialize the clock output */ | ||
251 | mt2060_writereg(priv, REG_VGAG, (priv->cfg->clock_out << 6) | 0x30); | ||
252 | |||
250 | do { | 253 | do { |
251 | b |= (1 << 6); // FM1SS; | 254 | b |= (1 << 6); // FM1SS; |
252 | mt2060_writereg(priv, REG_LO2C1,b); | 255 | mt2060_writereg(priv, REG_LO2C1,b); |
@@ -294,13 +297,13 @@ static int mt2060_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) | |||
294 | static int mt2060_init(struct dvb_frontend *fe) | 297 | static int mt2060_init(struct dvb_frontend *fe) |
295 | { | 298 | { |
296 | struct mt2060_priv *priv = fe->tuner_priv; | 299 | struct mt2060_priv *priv = fe->tuner_priv; |
297 | return mt2060_writereg(priv, REG_VGAG,0x33); | 300 | return mt2060_writereg(priv, REG_VGAG, (priv->cfg->clock_out << 6) | 0x33); |
298 | } | 301 | } |
299 | 302 | ||
300 | static int mt2060_sleep(struct dvb_frontend *fe) | 303 | static int mt2060_sleep(struct dvb_frontend *fe) |
301 | { | 304 | { |
302 | struct mt2060_priv *priv = fe->tuner_priv; | 305 | struct mt2060_priv *priv = fe->tuner_priv; |
303 | return mt2060_writereg(priv, REG_VGAG,0x30); | 306 | return mt2060_writereg(priv, REG_VGAG, (priv->cfg->clock_out << 6) | 0x30); |
304 | } | 307 | } |
305 | 308 | ||
306 | static int mt2060_release(struct dvb_frontend *fe) | 309 | static int mt2060_release(struct dvb_frontend *fe) |
@@ -329,14 +332,14 @@ static const struct dvb_tuner_ops mt2060_tuner_ops = { | |||
329 | }; | 332 | }; |
330 | 333 | ||
331 | /* This functions tries to identify a MT2060 tuner by reading the PART/REV register. This is hasty. */ | 334 | /* This functions tries to identify a MT2060 tuner by reading the PART/REV register. This is hasty. */ |
332 | int mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1) | 335 | struct dvb_frontend * mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1) |
333 | { | 336 | { |
334 | struct mt2060_priv *priv = NULL; | 337 | struct mt2060_priv *priv = NULL; |
335 | u8 id = 0; | 338 | u8 id = 0; |
336 | 339 | ||
337 | priv = kzalloc(sizeof(struct mt2060_priv), GFP_KERNEL); | 340 | priv = kzalloc(sizeof(struct mt2060_priv), GFP_KERNEL); |
338 | if (priv == NULL) | 341 | if (priv == NULL) |
339 | return -ENOMEM; | 342 | return NULL; |
340 | 343 | ||
341 | priv->cfg = cfg; | 344 | priv->cfg = cfg; |
342 | priv->i2c = i2c; | 345 | priv->i2c = i2c; |
@@ -344,12 +347,12 @@ int mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt206 | |||
344 | 347 | ||
345 | if (mt2060_readreg(priv,REG_PART_REV,&id) != 0) { | 348 | if (mt2060_readreg(priv,REG_PART_REV,&id) != 0) { |
346 | kfree(priv); | 349 | kfree(priv); |
347 | return -ENODEV; | 350 | return NULL; |
348 | } | 351 | } |
349 | 352 | ||
350 | if (id != PART_REV) { | 353 | if (id != PART_REV) { |
351 | kfree(priv); | 354 | kfree(priv); |
352 | return -ENODEV; | 355 | return NULL; |
353 | } | 356 | } |
354 | printk(KERN_INFO "MT2060: successfully identified (IF1 = %d)\n", if1); | 357 | printk(KERN_INFO "MT2060: successfully identified (IF1 = %d)\n", if1); |
355 | memcpy(&fe->ops.tuner_ops, &mt2060_tuner_ops, sizeof(struct dvb_tuner_ops)); | 358 | memcpy(&fe->ops.tuner_ops, &mt2060_tuner_ops, sizeof(struct dvb_tuner_ops)); |
@@ -358,7 +361,7 @@ int mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt206 | |||
358 | 361 | ||
359 | mt2060_calibrate(priv); | 362 | mt2060_calibrate(priv); |
360 | 363 | ||
361 | return 0; | 364 | return fe; |
362 | } | 365 | } |
363 | EXPORT_SYMBOL(mt2060_attach); | 366 | EXPORT_SYMBOL(mt2060_attach); |
364 | 367 | ||
diff --git a/drivers/media/dvb/frontends/mt2060.h b/drivers/media/dvb/frontends/mt2060.h index c58b03e82345..34a37c2b556f 100644 --- a/drivers/media/dvb/frontends/mt2060.h +++ b/drivers/media/dvb/frontends/mt2060.h | |||
@@ -27,9 +27,9 @@ struct i2c_adapter; | |||
27 | 27 | ||
28 | struct mt2060_config { | 28 | struct mt2060_config { |
29 | u8 i2c_address; | 29 | u8 i2c_address; |
30 | /* Shall we add settings for the discrete outputs ? */ | 30 | u8 clock_out; /* 0 = off, 1 = CLK/4, 2 = CLK/2, 3 = CLK/1 */ |
31 | }; | 31 | }; |
32 | 32 | ||
33 | extern int mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1); | 33 | extern struct dvb_frontend * mt2060_attach(struct dvb_frontend *fe, struct i2c_adapter *i2c, struct mt2060_config *cfg, u16 if1); |
34 | 34 | ||
35 | #endif | 35 | #endif |
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig index f6779a422f1b..afb734df6e05 100644 --- a/drivers/media/video/Kconfig +++ b/drivers/media/video/Kconfig | |||
@@ -36,7 +36,7 @@ config VIDEO_HELPER_CHIPS_AUTO | |||
36 | menu "Encoders/decoders and other helper chips" | 36 | menu "Encoders/decoders and other helper chips" |
37 | depends on VIDEO_DEV && !VIDEO_HELPER_CHIPS_AUTO | 37 | depends on VIDEO_DEV && !VIDEO_HELPER_CHIPS_AUTO |
38 | 38 | ||
39 | comment "Audio Decoders" | 39 | comment "Audio decoders" |
40 | 40 | ||
41 | config VIDEO_TVAUDIO | 41 | config VIDEO_TVAUDIO |
42 | tristate "Simple audio decoder chips" | 42 | tristate "Simple audio decoder chips" |
@@ -51,7 +51,7 @@ config VIDEO_TVAUDIO | |||
51 | module will be called tvaudio. | 51 | module will be called tvaudio. |
52 | 52 | ||
53 | config VIDEO_TDA7432 | 53 | config VIDEO_TDA7432 |
54 | tristate "Philips TDA7432 audio processor chip" | 54 | tristate "Philips TDA7432 audio processor" |
55 | depends on VIDEO_V4L1 && I2C | 55 | depends on VIDEO_V4L1 && I2C |
56 | ---help--- | 56 | ---help--- |
57 | Support for tda7432 audio decoder chip found on some bt8xx boards. | 57 | Support for tda7432 audio decoder chip found on some bt8xx boards. |
@@ -60,7 +60,7 @@ config VIDEO_TDA7432 | |||
60 | module will be called tda7432. | 60 | module will be called tda7432. |
61 | 61 | ||
62 | config VIDEO_TDA9840 | 62 | config VIDEO_TDA9840 |
63 | tristate "Philips TDA9840 audio processor chip" | 63 | tristate "Philips TDA9840 audio processor" |
64 | depends on VIDEO_DEV && I2C | 64 | depends on VIDEO_DEV && I2C |
65 | ---help--- | 65 | ---help--- |
66 | Support for tda9840 audio decoder chip found on some Zoran boards. | 66 | Support for tda9840 audio decoder chip found on some Zoran boards. |
@@ -69,7 +69,7 @@ config VIDEO_TDA9840 | |||
69 | module will be called tda9840. | 69 | module will be called tda9840. |
70 | 70 | ||
71 | config VIDEO_TDA9875 | 71 | config VIDEO_TDA9875 |
72 | tristate "Philips TDA9875 audio processor chip" | 72 | tristate "Philips TDA9875 audio processor" |
73 | depends on VIDEO_V4L1 && I2C | 73 | depends on VIDEO_V4L1 && I2C |
74 | ---help--- | 74 | ---help--- |
75 | Support for tda9875 audio decoder chip found on some bt8xx boards. | 75 | Support for tda9875 audio decoder chip found on some bt8xx boards. |
@@ -78,7 +78,7 @@ config VIDEO_TDA9875 | |||
78 | module will be called tda9875. | 78 | module will be called tda9875. |
79 | 79 | ||
80 | config VIDEO_TEA6415C | 80 | config VIDEO_TEA6415C |
81 | tristate "Philips TEA6415C audio processor chip" | 81 | tristate "Philips TEA6415C audio processor" |
82 | depends on VIDEO_DEV && I2C | 82 | depends on VIDEO_DEV && I2C |
83 | ---help--- | 83 | ---help--- |
84 | Support for tea6415c audio decoder chip found on some bt8xx boards. | 84 | Support for tea6415c audio decoder chip found on some bt8xx boards. |
@@ -87,7 +87,7 @@ config VIDEO_TEA6415C | |||
87 | module will be called tea6415c. | 87 | module will be called tea6415c. |
88 | 88 | ||
89 | config VIDEO_TEA6420 | 89 | config VIDEO_TEA6420 |
90 | tristate "Philips TEA6420 audio processor chip" | 90 | tristate "Philips TEA6420 audio processor" |
91 | depends on VIDEO_DEV && I2C | 91 | depends on VIDEO_DEV && I2C |
92 | ---help--- | 92 | ---help--- |
93 | Support for tea6420 audio decoder chip found on some bt8xx boards. | 93 | Support for tea6420 audio decoder chip found on some bt8xx boards. |
@@ -143,64 +143,10 @@ config VIDEO_WM8739 | |||
143 | To compile this driver as a module, choose M here: the | 143 | To compile this driver as a module, choose M here: the |
144 | module will be called wm8739. | 144 | module will be called wm8739. |
145 | 145 | ||
146 | comment "MPEG video encoders" | ||
147 | |||
148 | config VIDEO_CX2341X | ||
149 | tristate "Conexant CX2341x MPEG encoders" | ||
150 | depends on VIDEO_V4L2 && EXPERIMENTAL | ||
151 | ---help--- | ||
152 | Support for the Conexant CX23416 MPEG encoders | ||
153 | and CX23415 MPEG encoder/decoders. | ||
154 | |||
155 | This module currently supports the encoding functions only. | ||
156 | |||
157 | To compile this driver as a module, choose M here: the | ||
158 | module will be called cx2341x. | ||
159 | |||
160 | source "drivers/media/video/cx25840/Kconfig" | ||
161 | |||
162 | comment "Video encoders" | ||
163 | |||
164 | config VIDEO_SAA7127 | ||
165 | tristate "Philips SAA7127/9 digital video encoders" | ||
166 | depends on VIDEO_V4L2 && I2C && EXPERIMENTAL | ||
167 | ---help--- | ||
168 | Support for the Philips SAA7127/9 digital video encoders. | ||
169 | |||
170 | To compile this driver as a module, choose M here: the | ||
171 | module will be called saa7127. | ||
172 | |||
173 | config VIDEO_SAA7185 | ||
174 | tristate "Philips SAA7185 video encoder" | ||
175 | depends on VIDEO_V4L1 && I2C | ||
176 | ---help--- | ||
177 | Support for the Philips SAA7185 video encoder. | ||
178 | |||
179 | To compile this driver as a module, choose M here: the | ||
180 | module will be called saa7185. | ||
181 | |||
182 | config VIDEO_ADV7170 | ||
183 | tristate "Analog Devices ADV7170 video encoder driver" | ||
184 | depends on VIDEO_V4L1 && I2C | ||
185 | ---help--- | ||
186 | Support for the Analog Devices ADV7170 video encoder driver | ||
187 | |||
188 | To compile this driver as a module, choose M here: the | ||
189 | module will be called adv7170. | ||
190 | |||
191 | config VIDEO_ADV7175 | ||
192 | tristate "Analog Devices ADV7175 video encoder driver" | ||
193 | depends on VIDEO_V4L1 && I2C | ||
194 | ---help--- | ||
195 | Support for the Analog Devices ADV7175 video encoder driver | ||
196 | |||
197 | To compile this driver as a module, choose M here: the | ||
198 | module will be called adv7175. | ||
199 | |||
200 | comment "Video decoders" | 146 | comment "Video decoders" |
201 | 147 | ||
202 | config VIDEO_BT819 | 148 | config VIDEO_BT819 |
203 | tristate "BT819A VideoStream Decoder" | 149 | tristate "BT819A VideoStream decoder" |
204 | depends on VIDEO_V4L1 && I2C | 150 | depends on VIDEO_V4L1 && I2C |
205 | ---help--- | 151 | ---help--- |
206 | Support for BT819A video decoder. | 152 | Support for BT819A video decoder. |
@@ -209,7 +155,7 @@ config VIDEO_BT819 | |||
209 | module will be called bt819. | 155 | module will be called bt819. |
210 | 156 | ||
211 | config VIDEO_BT856 | 157 | config VIDEO_BT856 |
212 | tristate "BT856 VideoStream Decoder" | 158 | tristate "BT856 VideoStream decoder" |
213 | depends on VIDEO_V4L1 && I2C | 159 | depends on VIDEO_V4L1 && I2C |
214 | ---help--- | 160 | ---help--- |
215 | Support for BT856 video decoder. | 161 | Support for BT856 video decoder. |
@@ -218,7 +164,7 @@ config VIDEO_BT856 | |||
218 | module will be called bt856. | 164 | module will be called bt856. |
219 | 165 | ||
220 | config VIDEO_BT866 | 166 | config VIDEO_BT866 |
221 | tristate "BT866 VideoStream Decoder" | 167 | tristate "BT866 VideoStream decoder" |
222 | depends on VIDEO_V4L1 && I2C | 168 | depends on VIDEO_V4L1 && I2C |
223 | ---help--- | 169 | ---help--- |
224 | Support for BT866 video decoder. | 170 | Support for BT866 video decoder. |
@@ -295,7 +241,7 @@ config VIDEO_TVP5150 | |||
295 | module will be called tvp5150. | 241 | module will be called tvp5150. |
296 | 242 | ||
297 | config VIDEO_VPX3220 | 243 | config VIDEO_VPX3220 |
298 | tristate "vpx3220a, vpx3216b & vpx3214c video decoder driver" | 244 | tristate "vpx3220a, vpx3216b & vpx3214c video decoders" |
299 | depends on VIDEO_V4L1 && I2C | 245 | depends on VIDEO_V4L1 && I2C |
300 | ---help--- | 246 | ---help--- |
301 | Support for VPX322x video decoders. | 247 | Support for VPX322x video decoders. |
@@ -303,6 +249,62 @@ config VIDEO_VPX3220 | |||
303 | To compile this driver as a module, choose M here: the | 249 | To compile this driver as a module, choose M here: the |
304 | module will be called vpx3220. | 250 | module will be called vpx3220. |
305 | 251 | ||
252 | comment "Video and audio decoders" | ||
253 | |||
254 | source "drivers/media/video/cx25840/Kconfig" | ||
255 | |||
256 | comment "MPEG video encoders" | ||
257 | |||
258 | config VIDEO_CX2341X | ||
259 | tristate "Conexant CX2341x MPEG encoders" | ||
260 | depends on VIDEO_V4L2 && EXPERIMENTAL | ||
261 | ---help--- | ||
262 | Support for the Conexant CX23416 MPEG encoders | ||
263 | and CX23415 MPEG encoder/decoders. | ||
264 | |||
265 | This module currently supports the encoding functions only. | ||
266 | |||
267 | To compile this driver as a module, choose M here: the | ||
268 | module will be called cx2341x. | ||
269 | |||
270 | comment "Video encoders" | ||
271 | |||
272 | config VIDEO_SAA7127 | ||
273 | tristate "Philips SAA7127/9 digital video encoders" | ||
274 | depends on VIDEO_V4L2 && I2C && EXPERIMENTAL | ||
275 | ---help--- | ||
276 | Support for the Philips SAA7127/9 digital video encoders. | ||
277 | |||
278 | To compile this driver as a module, choose M here: the | ||
279 | module will be called saa7127. | ||
280 | |||
281 | config VIDEO_SAA7185 | ||
282 | tristate "Philips SAA7185 video encoder" | ||
283 | depends on VIDEO_V4L1 && I2C | ||
284 | ---help--- | ||
285 | Support for the Philips SAA7185 video encoder. | ||
286 | |||
287 | To compile this driver as a module, choose M here: the | ||
288 | module will be called saa7185. | ||
289 | |||
290 | config VIDEO_ADV7170 | ||
291 | tristate "Analog Devices ADV7170 video encoder" | ||
292 | depends on VIDEO_V4L1 && I2C | ||
293 | ---help--- | ||
294 | Support for the Analog Devices ADV7170 video encoder driver | ||
295 | |||
296 | To compile this driver as a module, choose M here: the | ||
297 | module will be called adv7170. | ||
298 | |||
299 | config VIDEO_ADV7175 | ||
300 | tristate "Analog Devices ADV7175 video encoder" | ||
301 | depends on VIDEO_V4L1 && I2C | ||
302 | ---help--- | ||
303 | Support for the Analog Devices ADV7175 video encoder driver | ||
304 | |||
305 | To compile this driver as a module, choose M here: the | ||
306 | module will be called adv7175. | ||
307 | |||
306 | comment "Video improvement chips" | 308 | comment "Video improvement chips" |
307 | 309 | ||
308 | config VIDEO_UPD64031A | 310 | config VIDEO_UPD64031A |
diff --git a/drivers/media/video/bt8xx/bttv-cards.c b/drivers/media/video/bt8xx/bttv-cards.c index d23a42b1504f..a84903e0d810 100644 --- a/drivers/media/video/bt8xx/bttv-cards.c +++ b/drivers/media/video/bt8xx/bttv-cards.c | |||
@@ -2000,7 +2000,7 @@ struct tvcard bttv_tvcards[] = { | |||
2000 | .no_msp34xx = 1, | 2000 | .no_msp34xx = 1, |
2001 | .no_tda9875 = 1, | 2001 | .no_tda9875 = 1, |
2002 | .no_tda7432 = 1, | 2002 | .no_tda7432 = 1, |
2003 | .muxsel = { 3, 0, 1, 2 }, | 2003 | .muxsel = { 3, 1 }, |
2004 | .pll = PLL_28, | 2004 | .pll = PLL_28, |
2005 | .no_gpioirq = 1, | 2005 | .no_gpioirq = 1, |
2006 | .has_dvb = 1, | 2006 | .has_dvb = 1, |
diff --git a/drivers/media/video/cx88/cx88-blackbird.c b/drivers/media/video/cx88/cx88-blackbird.c index a7921f9d45d8..46738321adaf 100644 --- a/drivers/media/video/cx88/cx88-blackbird.c +++ b/drivers/media/video/cx88/cx88-blackbird.c | |||
@@ -896,7 +896,7 @@ static int mpeg_do_ioctl(struct inode *inode, struct file *file, | |||
896 | snprintf(name, sizeof(name), "%s/2", core->name); | 896 | snprintf(name, sizeof(name), "%s/2", core->name); |
897 | printk("%s/2: ============ START LOG STATUS ============\n", | 897 | printk("%s/2: ============ START LOG STATUS ============\n", |
898 | core->name); | 898 | core->name); |
899 | cx88_call_i2c_clients(core, VIDIOC_LOG_STATUS, 0); | 899 | cx88_call_i2c_clients(core, VIDIOC_LOG_STATUS, NULL); |
900 | cx2341x_log_status(&dev->params, name); | 900 | cx2341x_log_status(&dev->params, name); |
901 | printk("%s/2: ============= END LOG STATUS =============\n", | 901 | printk("%s/2: ============= END LOG STATUS =============\n", |
902 | core->name); | 902 | core->name); |
@@ -1086,7 +1086,7 @@ static int __devinit blackbird_probe(struct pci_dev *pci_dev, | |||
1086 | return -EINVAL; | 1086 | return -EINVAL; |
1087 | 1087 | ||
1088 | err = -ENODEV; | 1088 | err = -ENODEV; |
1089 | if (!cx88_boards[core->board].blackbird) | 1089 | if (!(cx88_boards[core->board].mpeg & CX88_MPEG_BLACKBIRD)) |
1090 | goto fail_core; | 1090 | goto fail_core; |
1091 | 1091 | ||
1092 | err = -ENOMEM; | 1092 | err = -ENOMEM; |
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c index 6214eb823b29..af71d4225c76 100644 --- a/drivers/media/video/cx88/cx88-cards.c +++ b/drivers/media/video/cx88/cx88-cards.c | |||
@@ -294,7 +294,7 @@ struct cx88_board cx88_boards[] = { | |||
294 | .type = CX88_RADIO, | 294 | .type = CX88_RADIO, |
295 | .gpio0 = 0x0000bd62, | 295 | .gpio0 = 0x0000bd62, |
296 | }, | 296 | }, |
297 | .blackbird = 1, | 297 | .mpeg = CX88_MPEG_BLACKBIRD, |
298 | }, | 298 | }, |
299 | [CX88_BOARD_IODATA_GVVCP3PCI] = { | 299 | [CX88_BOARD_IODATA_GVVCP3PCI] = { |
300 | .name = "IODATA GV-VCP3/PCI", | 300 | .name = "IODATA GV-VCP3/PCI", |
@@ -358,7 +358,7 @@ struct cx88_board cx88_boards[] = { | |||
358 | .type = CX88_RADIO, | 358 | .type = CX88_RADIO, |
359 | .gpio0 = 0x0000fde2, | 359 | .gpio0 = 0x0000fde2, |
360 | }, | 360 | }, |
361 | .blackbird = 1, | 361 | .mpeg = CX88_MPEG_BLACKBIRD, |
362 | }, | 362 | }, |
363 | [CX88_BOARD_MSI_TVANYWHERE] = { | 363 | [CX88_BOARD_MSI_TVANYWHERE] = { |
364 | .name = "MSI TV-@nywhere", | 364 | .name = "MSI TV-@nywhere", |
@@ -401,7 +401,7 @@ struct cx88_board cx88_boards[] = { | |||
401 | .gpio0 = 0x0700, | 401 | .gpio0 = 0x0700, |
402 | .gpio2 = 0x0101, | 402 | .gpio2 = 0x0101, |
403 | }}, | 403 | }}, |
404 | .dvb = 1, | 404 | .mpeg = CX88_MPEG_DVB, |
405 | }, | 405 | }, |
406 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1] = { | 406 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1] = { |
407 | .name = "DViCO FusionHDTV DVB-T1", | 407 | .name = "DViCO FusionHDTV DVB-T1", |
@@ -418,7 +418,7 @@ struct cx88_board cx88_boards[] = { | |||
418 | .vmux = 2, | 418 | .vmux = 2, |
419 | .gpio0 = 0x000027df, | 419 | .gpio0 = 0x000027df, |
420 | }}, | 420 | }}, |
421 | .dvb = 1, | 421 | .mpeg = CX88_MPEG_DVB, |
422 | }, | 422 | }, |
423 | [CX88_BOARD_KWORLD_LTV883] = { | 423 | [CX88_BOARD_KWORLD_LTV883] = { |
424 | .name = "KWorld LTV883RF", | 424 | .name = "KWorld LTV883RF", |
@@ -488,7 +488,7 @@ struct cx88_board cx88_boards[] = { | |||
488 | .vmux = 2, | 488 | .vmux = 2, |
489 | .gpio0 = 0x0f00, | 489 | .gpio0 = 0x0f00, |
490 | }}, | 490 | }}, |
491 | .dvb = 1, | 491 | .mpeg = CX88_MPEG_DVB, |
492 | }, | 492 | }, |
493 | [CX88_BOARD_HAUPPAUGE_DVB_T1] = { | 493 | [CX88_BOARD_HAUPPAUGE_DVB_T1] = { |
494 | .name = "Hauppauge Nova-T DVB-T", | 494 | .name = "Hauppauge Nova-T DVB-T", |
@@ -500,7 +500,7 @@ struct cx88_board cx88_boards[] = { | |||
500 | .type = CX88_VMUX_DVB, | 500 | .type = CX88_VMUX_DVB, |
501 | .vmux = 0, | 501 | .vmux = 0, |
502 | }}, | 502 | }}, |
503 | .dvb = 1, | 503 | .mpeg = CX88_MPEG_DVB, |
504 | }, | 504 | }, |
505 | [CX88_BOARD_CONEXANT_DVB_T1] = { | 505 | [CX88_BOARD_CONEXANT_DVB_T1] = { |
506 | .name = "Conexant DVB-T reference design", | 506 | .name = "Conexant DVB-T reference design", |
@@ -512,7 +512,7 @@ struct cx88_board cx88_boards[] = { | |||
512 | .type = CX88_VMUX_DVB, | 512 | .type = CX88_VMUX_DVB, |
513 | .vmux = 0, | 513 | .vmux = 0, |
514 | }}, | 514 | }}, |
515 | .dvb = 1, | 515 | .mpeg = CX88_MPEG_DVB, |
516 | }, | 516 | }, |
517 | [CX88_BOARD_PROVIDEO_PV259] = { | 517 | [CX88_BOARD_PROVIDEO_PV259] = { |
518 | .name = "Provideo PV259", | 518 | .name = "Provideo PV259", |
@@ -524,7 +524,7 @@ struct cx88_board cx88_boards[] = { | |||
524 | .type = CX88_VMUX_TELEVISION, | 524 | .type = CX88_VMUX_TELEVISION, |
525 | .vmux = 0, | 525 | .vmux = 0, |
526 | }}, | 526 | }}, |
527 | .blackbird = 1, | 527 | .mpeg = CX88_MPEG_BLACKBIRD, |
528 | }, | 528 | }, |
529 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS] = { | 529 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS] = { |
530 | .name = "DViCO FusionHDTV DVB-T Plus", | 530 | .name = "DViCO FusionHDTV DVB-T Plus", |
@@ -541,7 +541,7 @@ struct cx88_board cx88_boards[] = { | |||
541 | .vmux = 2, | 541 | .vmux = 2, |
542 | .gpio0 = 0x000027df, | 542 | .gpio0 = 0x000027df, |
543 | }}, | 543 | }}, |
544 | .dvb = 1, | 544 | .mpeg = CX88_MPEG_DVB, |
545 | }, | 545 | }, |
546 | [CX88_BOARD_DNTV_LIVE_DVB_T] = { | 546 | [CX88_BOARD_DNTV_LIVE_DVB_T] = { |
547 | .name = "digitalnow DNTV Live! DVB-T", | 547 | .name = "digitalnow DNTV Live! DVB-T", |
@@ -560,7 +560,7 @@ struct cx88_board cx88_boards[] = { | |||
560 | .gpio0 = 0x00000700, | 560 | .gpio0 = 0x00000700, |
561 | .gpio2 = 0x00000101, | 561 | .gpio2 = 0x00000101, |
562 | }}, | 562 | }}, |
563 | .dvb = 1, | 563 | .mpeg = CX88_MPEG_DVB, |
564 | }, | 564 | }, |
565 | [CX88_BOARD_PCHDTV_HD3000] = { | 565 | [CX88_BOARD_PCHDTV_HD3000] = { |
566 | .name = "pcHDTV HD3000 HDTV", | 566 | .name = "pcHDTV HD3000 HDTV", |
@@ -599,7 +599,7 @@ struct cx88_board cx88_boards[] = { | |||
599 | .gpio2 = 0x00000000, | 599 | .gpio2 = 0x00000000, |
600 | .gpio3 = 0x00000000, | 600 | .gpio3 = 0x00000000, |
601 | }, | 601 | }, |
602 | .dvb = 1, | 602 | .mpeg = CX88_MPEG_DVB, |
603 | }, | 603 | }, |
604 | [CX88_BOARD_HAUPPAUGE_ROSLYN] = { | 604 | [CX88_BOARD_HAUPPAUGE_ROSLYN] = { |
605 | // entry added by Kaustubh D. Bhalerao <bhalerao.1@osu.edu> | 605 | // entry added by Kaustubh D. Bhalerao <bhalerao.1@osu.edu> |
@@ -633,7 +633,7 @@ struct cx88_board cx88_boards[] = { | |||
633 | .gpio0 = 0xed96, | 633 | .gpio0 = 0xed96, |
634 | .gpio2 = 0x00ff, | 634 | .gpio2 = 0x00ff, |
635 | }, | 635 | }, |
636 | .blackbird = 1, | 636 | .mpeg = CX88_MPEG_BLACKBIRD, |
637 | }, | 637 | }, |
638 | [CX88_BOARD_DIGITALLOGIC_MEC] = { | 638 | [CX88_BOARD_DIGITALLOGIC_MEC] = { |
639 | .name = "Digital-Logic MICROSPACE Entertainment Center (MEC)", | 639 | .name = "Digital-Logic MICROSPACE Entertainment Center (MEC)", |
@@ -659,7 +659,7 @@ struct cx88_board cx88_boards[] = { | |||
659 | .type = CX88_RADIO, | 659 | .type = CX88_RADIO, |
660 | .gpio0 = 0x00009d00, | 660 | .gpio0 = 0x00009d00, |
661 | }, | 661 | }, |
662 | .blackbird = 1, | 662 | .mpeg = CX88_MPEG_BLACKBIRD, |
663 | }, | 663 | }, |
664 | [CX88_BOARD_IODATA_GVBCTV7E] = { | 664 | [CX88_BOARD_IODATA_GVBCTV7E] = { |
665 | .name = "IODATA GV/BCTV7E", | 665 | .name = "IODATA GV/BCTV7E", |
@@ -727,7 +727,7 @@ struct cx88_board cx88_boards[] = { | |||
727 | .vmux = 2, | 727 | .vmux = 2, |
728 | .gpio0 = 0x97e9, | 728 | .gpio0 = 0x97e9, |
729 | }}, | 729 | }}, |
730 | .dvb = 1, | 730 | .mpeg = CX88_MPEG_DVB, |
731 | }, | 731 | }, |
732 | [CX88_BOARD_ADSTECH_DVB_T_PCI] = { | 732 | [CX88_BOARD_ADSTECH_DVB_T_PCI] = { |
733 | .name = "ADS Tech Instant TV DVB-T PCI", | 733 | .name = "ADS Tech Instant TV DVB-T PCI", |
@@ -746,7 +746,7 @@ struct cx88_board cx88_boards[] = { | |||
746 | .gpio0 = 0x0700, | 746 | .gpio0 = 0x0700, |
747 | .gpio2 = 0x0101, | 747 | .gpio2 = 0x0101, |
748 | }}, | 748 | }}, |
749 | .dvb = 1, | 749 | .mpeg = CX88_MPEG_DVB, |
750 | }, | 750 | }, |
751 | [CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1] = { | 751 | [CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1] = { |
752 | .name = "TerraTec Cinergy 1400 DVB-T", | 752 | .name = "TerraTec Cinergy 1400 DVB-T", |
@@ -755,7 +755,7 @@ struct cx88_board cx88_boards[] = { | |||
755 | .type = CX88_VMUX_DVB, | 755 | .type = CX88_VMUX_DVB, |
756 | .vmux = 0, | 756 | .vmux = 0, |
757 | }}, | 757 | }}, |
758 | .dvb = 1, | 758 | .mpeg = CX88_MPEG_DVB, |
759 | }, | 759 | }, |
760 | [CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD] = { | 760 | [CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD] = { |
761 | .name = "DViCO FusionHDTV 5 Gold", | 761 | .name = "DViCO FusionHDTV 5 Gold", |
@@ -777,7 +777,7 @@ struct cx88_board cx88_boards[] = { | |||
777 | .vmux = 2, | 777 | .vmux = 2, |
778 | .gpio0 = 0x87f9, | 778 | .gpio0 = 0x87f9, |
779 | }}, | 779 | }}, |
780 | .dvb = 1, | 780 | .mpeg = CX88_MPEG_DVB, |
781 | }, | 781 | }, |
782 | [CX88_BOARD_AVERMEDIA_ULTRATV_MC_550] = { | 782 | [CX88_BOARD_AVERMEDIA_ULTRATV_MC_550] = { |
783 | .name = "AverMedia UltraTV Media Center PCI 550", | 783 | .name = "AverMedia UltraTV Media Center PCI 550", |
@@ -786,7 +786,7 @@ struct cx88_board cx88_boards[] = { | |||
786 | .tuner_addr = ADDR_UNSET, | 786 | .tuner_addr = ADDR_UNSET, |
787 | .radio_addr = ADDR_UNSET, | 787 | .radio_addr = ADDR_UNSET, |
788 | .tda9887_conf = TDA9887_PRESENT, | 788 | .tda9887_conf = TDA9887_PRESENT, |
789 | .blackbird = 1, | 789 | .mpeg = CX88_MPEG_BLACKBIRD, |
790 | .input = {{ | 790 | .input = {{ |
791 | .type = CX88_VMUX_COMPOSITE1, | 791 | .type = CX88_VMUX_COMPOSITE1, |
792 | .vmux = 0, | 792 | .vmux = 0, |
@@ -854,7 +854,7 @@ struct cx88_board cx88_boards[] = { | |||
854 | .gpio2 = 0x00000001, | 854 | .gpio2 = 0x00000001, |
855 | .gpio3 = 0x00000000, | 855 | .gpio3 = 0x00000000, |
856 | }}, | 856 | }}, |
857 | .dvb = 1, | 857 | .mpeg = CX88_MPEG_DVB, |
858 | }, | 858 | }, |
859 | [CX88_BOARD_WINFAST_DTV1000] = { | 859 | [CX88_BOARD_WINFAST_DTV1000] = { |
860 | .name = "WinFast DTV1000-T", | 860 | .name = "WinFast DTV1000-T", |
@@ -866,7 +866,7 @@ struct cx88_board cx88_boards[] = { | |||
866 | .type = CX88_VMUX_DVB, | 866 | .type = CX88_VMUX_DVB, |
867 | .vmux = 0, | 867 | .vmux = 0, |
868 | }}, | 868 | }}, |
869 | .dvb = 1, | 869 | .mpeg = CX88_MPEG_DVB, |
870 | }, | 870 | }, |
871 | [CX88_BOARD_AVERTV_303] = { | 871 | [CX88_BOARD_AVERTV_303] = { |
872 | .name = "AVerTV 303 (M126)", | 872 | .name = "AVerTV 303 (M126)", |
@@ -914,7 +914,7 @@ struct cx88_board cx88_boards[] = { | |||
914 | .type = CX88_VMUX_SVIDEO, | 914 | .type = CX88_VMUX_SVIDEO, |
915 | .vmux = 2, | 915 | .vmux = 2, |
916 | }}, | 916 | }}, |
917 | .dvb = 1, | 917 | .mpeg = CX88_MPEG_DVB, |
918 | }, | 918 | }, |
919 | [CX88_BOARD_HAUPPAUGE_NOVASE2_S1] = { | 919 | [CX88_BOARD_HAUPPAUGE_NOVASE2_S1] = { |
920 | .name = "Hauppauge Nova-SE2 DVB-S", | 920 | .name = "Hauppauge Nova-SE2 DVB-S", |
@@ -926,7 +926,7 @@ struct cx88_board cx88_boards[] = { | |||
926 | .type = CX88_VMUX_DVB, | 926 | .type = CX88_VMUX_DVB, |
927 | .vmux = 0, | 927 | .vmux = 0, |
928 | }}, | 928 | }}, |
929 | .dvb = 1, | 929 | .mpeg = CX88_MPEG_DVB, |
930 | }, | 930 | }, |
931 | [CX88_BOARD_KWORLD_DVBS_100] = { | 931 | [CX88_BOARD_KWORLD_DVBS_100] = { |
932 | .name = "KWorld DVB-S 100", | 932 | .name = "KWorld DVB-S 100", |
@@ -944,7 +944,7 @@ struct cx88_board cx88_boards[] = { | |||
944 | .type = CX88_VMUX_SVIDEO, | 944 | .type = CX88_VMUX_SVIDEO, |
945 | .vmux = 2, | 945 | .vmux = 2, |
946 | }}, | 946 | }}, |
947 | .dvb = 1, | 947 | .mpeg = CX88_MPEG_DVB, |
948 | }, | 948 | }, |
949 | [CX88_BOARD_HAUPPAUGE_HVR1100] = { | 949 | [CX88_BOARD_HAUPPAUGE_HVR1100] = { |
950 | .name = "Hauppauge WinTV-HVR1100 DVB-T/Hybrid", | 950 | .name = "Hauppauge WinTV-HVR1100 DVB-T/Hybrid", |
@@ -964,7 +964,7 @@ struct cx88_board cx88_boards[] = { | |||
964 | .vmux = 2, | 964 | .vmux = 2, |
965 | }}, | 965 | }}, |
966 | /* fixme: Add radio support */ | 966 | /* fixme: Add radio support */ |
967 | .dvb = 1, | 967 | .mpeg = CX88_MPEG_DVB, |
968 | }, | 968 | }, |
969 | [CX88_BOARD_HAUPPAUGE_HVR1100LP] = { | 969 | [CX88_BOARD_HAUPPAUGE_HVR1100LP] = { |
970 | .name = "Hauppauge WinTV-HVR1100 DVB-T/Hybrid (Low Profile)", | 970 | .name = "Hauppauge WinTV-HVR1100 DVB-T/Hybrid (Low Profile)", |
@@ -981,7 +981,7 @@ struct cx88_board cx88_boards[] = { | |||
981 | .vmux = 1, | 981 | .vmux = 1, |
982 | }}, | 982 | }}, |
983 | /* fixme: Add radio support */ | 983 | /* fixme: Add radio support */ |
984 | .dvb = 1, | 984 | .mpeg = CX88_MPEG_DVB, |
985 | }, | 985 | }, |
986 | [CX88_BOARD_DNTV_LIVE_DVB_T_PRO] = { | 986 | [CX88_BOARD_DNTV_LIVE_DVB_T_PRO] = { |
987 | .name = "digitalnow DNTV Live! DVB-T Pro", | 987 | .name = "digitalnow DNTV Live! DVB-T Pro", |
@@ -1008,7 +1008,7 @@ struct cx88_board cx88_boards[] = { | |||
1008 | .type = CX88_RADIO, | 1008 | .type = CX88_RADIO, |
1009 | .gpio0 = 0xf80808, | 1009 | .gpio0 = 0xf80808, |
1010 | }, | 1010 | }, |
1011 | .dvb = 1, | 1011 | .mpeg = CX88_MPEG_DVB, |
1012 | }, | 1012 | }, |
1013 | [CX88_BOARD_KWORLD_DVB_T_CX22702] = { | 1013 | [CX88_BOARD_KWORLD_DVB_T_CX22702] = { |
1014 | /* Kworld V-stream Xpert DVB-T with Thomson tuner */ | 1014 | /* Kworld V-stream Xpert DVB-T with Thomson tuner */ |
@@ -1030,7 +1030,7 @@ struct cx88_board cx88_boards[] = { | |||
1030 | .gpio0 = 0x0700, | 1030 | .gpio0 = 0x0700, |
1031 | .gpio2 = 0x0101, | 1031 | .gpio2 = 0x0101, |
1032 | }}, | 1032 | }}, |
1033 | .dvb = 1, | 1033 | .mpeg = CX88_MPEG_DVB, |
1034 | }, | 1034 | }, |
1035 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL] = { | 1035 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL] = { |
1036 | .name = "DViCO FusionHDTV DVB-T Dual Digital", | 1036 | .name = "DViCO FusionHDTV DVB-T Dual Digital", |
@@ -1047,7 +1047,7 @@ struct cx88_board cx88_boards[] = { | |||
1047 | .vmux = 2, | 1047 | .vmux = 2, |
1048 | .gpio0 = 0x000067df, | 1048 | .gpio0 = 0x000067df, |
1049 | }}, | 1049 | }}, |
1050 | .dvb = 1, | 1050 | .mpeg = CX88_MPEG_DVB, |
1051 | }, | 1051 | }, |
1052 | [CX88_BOARD_KWORLD_HARDWARE_MPEG_TV_XPERT] = { | 1052 | [CX88_BOARD_KWORLD_HARDWARE_MPEG_TV_XPERT] = { |
1053 | /* FIXME: Audio not working for s-video / composite inputs. */ | 1053 | /* FIXME: Audio not working for s-video / composite inputs. */ |
@@ -1075,7 +1075,7 @@ struct cx88_board cx88_boards[] = { | |||
1075 | .gpio0 = 0x3de6, | 1075 | .gpio0 = 0x3de6, |
1076 | .gpio2 = 0x00ff, | 1076 | .gpio2 = 0x00ff, |
1077 | }, | 1077 | }, |
1078 | .blackbird = 1, | 1078 | .mpeg = CX88_MPEG_BLACKBIRD, |
1079 | }, | 1079 | }, |
1080 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID] = { | 1080 | [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID] = { |
1081 | .name = "DViCO FusionHDTV DVB-T Hybrid", | 1081 | .name = "DViCO FusionHDTV DVB-T Hybrid", |
@@ -1096,7 +1096,7 @@ struct cx88_board cx88_boards[] = { | |||
1096 | .vmux = 2, | 1096 | .vmux = 2, |
1097 | .gpio0 = 0x0000a75b, | 1097 | .gpio0 = 0x0000a75b, |
1098 | }}, | 1098 | }}, |
1099 | .dvb = 1, | 1099 | .mpeg = CX88_MPEG_DVB, |
1100 | }, | 1100 | }, |
1101 | [CX88_BOARD_PCHDTV_HD5500] = { | 1101 | [CX88_BOARD_PCHDTV_HD5500] = { |
1102 | .name = "pcHDTV HD5500 HDTV", | 1102 | .name = "pcHDTV HD5500 HDTV", |
@@ -1118,7 +1118,7 @@ struct cx88_board cx88_boards[] = { | |||
1118 | .vmux = 2, | 1118 | .vmux = 2, |
1119 | .gpio0 = 0x87f9, | 1119 | .gpio0 = 0x87f9, |
1120 | }}, | 1120 | }}, |
1121 | .dvb = 1, | 1121 | .mpeg = CX88_MPEG_DVB, |
1122 | }, | 1122 | }, |
1123 | [CX88_BOARD_KWORLD_MCE200_DELUXE] = { | 1123 | [CX88_BOARD_KWORLD_MCE200_DELUXE] = { |
1124 | /* FIXME: tested TV input only, disabled composite, | 1124 | /* FIXME: tested TV input only, disabled composite, |
@@ -1134,7 +1134,7 @@ struct cx88_board cx88_boards[] = { | |||
1134 | .vmux = 0, | 1134 | .vmux = 0, |
1135 | .gpio0 = 0x0000BDE6 | 1135 | .gpio0 = 0x0000BDE6 |
1136 | }}, | 1136 | }}, |
1137 | .blackbird = 1, | 1137 | .mpeg = CX88_MPEG_BLACKBIRD, |
1138 | }, | 1138 | }, |
1139 | [CX88_BOARD_PIXELVIEW_PLAYTV_P7000] = { | 1139 | [CX88_BOARD_PIXELVIEW_PLAYTV_P7000] = { |
1140 | /* FIXME: SVideo, Composite and FM inputs are untested */ | 1140 | /* FIXME: SVideo, Composite and FM inputs are untested */ |
@@ -1150,7 +1150,7 @@ struct cx88_board cx88_boards[] = { | |||
1150 | .vmux = 0, | 1150 | .vmux = 0, |
1151 | .gpio0 = 0x5da6, | 1151 | .gpio0 = 0x5da6, |
1152 | }}, | 1152 | }}, |
1153 | .blackbird = 1, | 1153 | .mpeg = CX88_MPEG_BLACKBIRD, |
1154 | }, | 1154 | }, |
1155 | [CX88_BOARD_NPGTECH_REALTV_TOP10FM] = { | 1155 | [CX88_BOARD_NPGTECH_REALTV_TOP10FM] = { |
1156 | .name = "NPG Tech Real TV FM Top 10", | 1156 | .name = "NPG Tech Real TV FM Top 10", |
@@ -1192,7 +1192,7 @@ struct cx88_board cx88_boards[] = { | |||
1192 | .gpio2 = 0x00017304, | 1192 | .gpio2 = 0x00017304, |
1193 | .gpio3 = 0x02000000, | 1193 | .gpio3 = 0x02000000, |
1194 | }}, | 1194 | }}, |
1195 | .dvb = 1, | 1195 | .mpeg = CX88_MPEG_DVB, |
1196 | }, | 1196 | }, |
1197 | [CX88_BOARD_GENIATECH_DVBS] = { | 1197 | [CX88_BOARD_GENIATECH_DVBS] = { |
1198 | .name = "Geniatech DVB-S", | 1198 | .name = "Geniatech DVB-S", |
@@ -1207,7 +1207,7 @@ struct cx88_board cx88_boards[] = { | |||
1207 | .type = CX88_VMUX_COMPOSITE1, | 1207 | .type = CX88_VMUX_COMPOSITE1, |
1208 | .vmux = 1, | 1208 | .vmux = 1, |
1209 | }}, | 1209 | }}, |
1210 | .dvb = 1, | 1210 | .mpeg = CX88_MPEG_DVB, |
1211 | }, | 1211 | }, |
1212 | [CX88_BOARD_HAUPPAUGE_HVR3000] = { | 1212 | [CX88_BOARD_HAUPPAUGE_HVR3000] = { |
1213 | /* FIXME: Add dvb & radio support */ | 1213 | /* FIXME: Add dvb & radio support */ |
@@ -1287,6 +1287,7 @@ struct cx88_board cx88_boards[] = { | |||
1287 | .tuner_addr = ADDR_UNSET, | 1287 | .tuner_addr = ADDR_UNSET, |
1288 | .radio_addr = ADDR_UNSET, | 1288 | .radio_addr = ADDR_UNSET, |
1289 | .tda9887_conf = TDA9887_PRESENT, | 1289 | .tda9887_conf = TDA9887_PRESENT, |
1290 | .audio_chip = AUDIO_CHIP_WM8775, | ||
1290 | .input = {{ | 1291 | .input = {{ |
1291 | .type = CX88_VMUX_TELEVISION, | 1292 | .type = CX88_VMUX_TELEVISION, |
1292 | .vmux = 0, | 1293 | .vmux = 0, |
@@ -1301,7 +1302,7 @@ struct cx88_board cx88_boards[] = { | |||
1301 | .gpio0 = 0xe780, | 1302 | .gpio0 = 0xe780, |
1302 | }}, | 1303 | }}, |
1303 | /* fixme: Add radio support */ | 1304 | /* fixme: Add radio support */ |
1304 | .dvb = 1, | 1305 | .mpeg = CX88_MPEG_DVB, |
1305 | }, | 1306 | }, |
1306 | }; | 1307 | }; |
1307 | const unsigned int cx88_bcount = ARRAY_SIZE(cx88_boards); | 1308 | const unsigned int cx88_bcount = ARRAY_SIZE(cx88_boards); |
@@ -1581,6 +1582,14 @@ struct cx88_subid cx88_subids[] = { | |||
1581 | .subvendor = 0x107d, | 1582 | .subvendor = 0x107d, |
1582 | .subdevice = 0x6632, | 1583 | .subdevice = 0x6632, |
1583 | .card = CX88_BOARD_LEADTEK_PVR2000, | 1584 | .card = CX88_BOARD_LEADTEK_PVR2000, |
1585 | },{ | ||
1586 | .subvendor = 0x12ab, | ||
1587 | .subdevice = 0x2300, /* Club3D Zap TV2100 */ | ||
1588 | .card = CX88_BOARD_KWORLD_DVB_T_CX22702, | ||
1589 | },{ | ||
1590 | .subvendor = 0x0070, | ||
1591 | .subdevice = 0x9000, | ||
1592 | .card = CX88_BOARD_HAUPPAUGE_DVB_T1, | ||
1584 | }, | 1593 | }, |
1585 | }; | 1594 | }; |
1586 | const unsigned int cx88_idcount = ARRAY_SIZE(cx88_subids); | 1595 | const unsigned int cx88_idcount = ARRAY_SIZE(cx88_subids); |
diff --git a/drivers/media/video/cx88/cx88-core.c b/drivers/media/video/cx88/cx88-core.c index f379ede3049a..4b655f2ef278 100644 --- a/drivers/media/video/cx88/cx88-core.c +++ b/drivers/media/video/cx88/cx88-core.c | |||
@@ -658,13 +658,6 @@ static unsigned int inline norm_fsc8(struct cx88_tvnorm *norm) | |||
658 | return (norm->id & V4L2_STD_625_50) ? pal : ntsc; | 658 | return (norm->id & V4L2_STD_625_50) ? pal : ntsc; |
659 | } | 659 | } |
660 | 660 | ||
661 | static unsigned int inline norm_notchfilter(struct cx88_tvnorm *norm) | ||
662 | { | ||
663 | return (norm->id & V4L2_STD_625_50) | ||
664 | ? HLNotchFilter135PAL | ||
665 | : HLNotchFilter135NTSC; | ||
666 | } | ||
667 | |||
668 | static unsigned int inline norm_htotal(struct cx88_tvnorm *norm) | 661 | static unsigned int inline norm_htotal(struct cx88_tvnorm *norm) |
669 | { | 662 | { |
670 | /* Should always be Line Draw Time / (4*FSC) */ | 663 | /* Should always be Line Draw Time / (4*FSC) */ |
@@ -937,7 +930,7 @@ int cx88_set_tvnorm(struct cx88_core *core, struct cx88_tvnorm *norm) | |||
937 | // htotal | 930 | // htotal |
938 | tmp64 = norm_htotal(norm) * (u64)vdec_clock; | 931 | tmp64 = norm_htotal(norm) * (u64)vdec_clock; |
939 | do_div(tmp64, fsc8); | 932 | do_div(tmp64, fsc8); |
940 | htotal = (u32)tmp64 | (norm_notchfilter(norm) << 11); | 933 | htotal = (u32)tmp64 | (HLNotchFilter4xFsc << 11); |
941 | dprintk(1,"set_tvnorm: MO_HTOTAL 0x%08x [old=0x%08x,htotal=%d]\n", | 934 | dprintk(1,"set_tvnorm: MO_HTOTAL 0x%08x [old=0x%08x,htotal=%d]\n", |
942 | htotal, cx_read(MO_HTOTAL), (u32)tmp64); | 935 | htotal, cx_read(MO_HTOTAL), (u32)tmp64); |
943 | cx_write(MO_HTOTAL, htotal); | 936 | cx_write(MO_HTOTAL, htotal); |
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c index c87041dee21e..bd0c8797f26d 100644 --- a/drivers/media/video/cx88/cx88-dvb.c +++ b/drivers/media/video/cx88/cx88-dvb.c | |||
@@ -802,7 +802,7 @@ static int __devinit dvb_probe(struct pci_dev *pci_dev, | |||
802 | return -EINVAL; | 802 | return -EINVAL; |
803 | 803 | ||
804 | err = -ENODEV; | 804 | err = -ENODEV; |
805 | if (!cx88_boards[core->board].dvb) | 805 | if (!(cx88_boards[core->board].mpeg & CX88_MPEG_DVB)) |
806 | goto fail_core; | 806 | goto fail_core; |
807 | 807 | ||
808 | err = -ENOMEM; | 808 | err = -ENOMEM; |
diff --git a/drivers/media/video/cx88/cx88-i2c.c b/drivers/media/video/cx88/cx88-i2c.c index 27b5dbb2ca1a..88af23a93870 100644 --- a/drivers/media/video/cx88/cx88-i2c.c +++ b/drivers/media/video/cx88/cx88-i2c.c | |||
@@ -145,7 +145,7 @@ void cx88_call_i2c_clients(struct cx88_core *core, unsigned int cmd, void *arg) | |||
145 | if (0 != core->i2c_rc) | 145 | if (0 != core->i2c_rc) |
146 | return; | 146 | return; |
147 | 147 | ||
148 | if (core->dvbdev) { | 148 | if ( (core->dvbdev) && (core->dvbdev->dvb.frontend) ) { |
149 | if (core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl) | 149 | if (core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl) |
150 | core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl(core->dvbdev->dvb.frontend, 1); | 150 | core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl(core->dvbdev->dvb.frontend, 1); |
151 | 151 | ||
@@ -220,7 +220,7 @@ int cx88_i2c_init(struct cx88_core *core, struct pci_dev *pci) | |||
220 | 220 | ||
221 | if (core->tuner_type != TUNER_ABSENT) | 221 | if (core->tuner_type != TUNER_ABSENT) |
222 | core->i2c_adap.class |= I2C_CLASS_TV_ANALOG; | 222 | core->i2c_adap.class |= I2C_CLASS_TV_ANALOG; |
223 | if (cx88_boards[core->board].dvb) | 223 | if (cx88_boards[core->board].mpeg & CX88_MPEG_DVB) |
224 | core->i2c_adap.class |= I2C_CLASS_TV_DIGITAL; | 224 | core->i2c_adap.class |= I2C_CLASS_TV_DIGITAL; |
225 | 225 | ||
226 | core->i2c_adap.dev.parent = &pci->dev; | 226 | core->i2c_adap.dev.parent = &pci->dev; |
diff --git a/drivers/media/video/cx88/cx88-mpeg.c b/drivers/media/video/cx88/cx88-mpeg.c index 138a4f692501..d6d980774c21 100644 --- a/drivers/media/video/cx88/cx88-mpeg.c +++ b/drivers/media/video/cx88/cx88-mpeg.c | |||
@@ -65,8 +65,17 @@ static int cx8802_start_dma(struct cx8802_dev *dev, | |||
65 | 65 | ||
66 | /* FIXME: this needs a review. | 66 | /* FIXME: this needs a review. |
67 | * also: move to cx88-blackbird + cx88-dvb source files? */ | 67 | * also: move to cx88-blackbird + cx88-dvb source files? */ |
68 | if (cx88_boards[core->board].mpeg == (CX88_MPEG_DVB | CX88_MPEG_BLACKBIRD) ) { | ||
69 | /* Report a warning until the mini driver patch is applied, | ||
70 | * else the following conditions will set the dma registers incorrectly. | ||
71 | * This will be removed in the next major patch and changes to the conditions | ||
72 | * will be made. | ||
73 | */ | ||
74 | printk(KERN_INFO "%s() board->(CX88_MPEG_DVB | CX88_MPEG_BLACKBIRD) is invalid\n", __FUNCTION__); | ||
75 | return -EINVAL; | ||
76 | } | ||
68 | 77 | ||
69 | if (cx88_boards[core->board].dvb) { | 78 | if (cx88_boards[core->board].mpeg & CX88_MPEG_DVB) { |
70 | /* negedge driven & software reset */ | 79 | /* negedge driven & software reset */ |
71 | cx_write(TS_GEN_CNTRL, 0x0040 | dev->ts_gen_cntrl); | 80 | cx_write(TS_GEN_CNTRL, 0x0040 | dev->ts_gen_cntrl); |
72 | udelay(100); | 81 | udelay(100); |
@@ -92,7 +101,7 @@ static int cx8802_start_dma(struct cx8802_dev *dev, | |||
92 | udelay(100); | 101 | udelay(100); |
93 | } | 102 | } |
94 | 103 | ||
95 | if (cx88_boards[core->board].blackbird) { | 104 | if (cx88_boards[core->board].mpeg & CX88_MPEG_BLACKBIRD) { |
96 | cx_write(MO_PINMUX_IO, 0x88); /* enable MPEG parallel IO */ | 105 | cx_write(MO_PINMUX_IO, 0x88); /* enable MPEG parallel IO */ |
97 | 106 | ||
98 | cx_write(TS_GEN_CNTRL, 0x46); /* punctured clock TS & posedge driven & software reset */ | 107 | cx_write(TS_GEN_CNTRL, 0x46); /* punctured clock TS & posedge driven & software reset */ |
diff --git a/drivers/media/video/cx88/cx88-tvaudio.c b/drivers/media/video/cx88/cx88-tvaudio.c index 741e7c5e69ec..58ba9f773524 100644 --- a/drivers/media/video/cx88/cx88-tvaudio.c +++ b/drivers/media/video/cx88/cx88-tvaudio.c | |||
@@ -142,7 +142,7 @@ static void set_audio_finish(struct cx88_core *core, u32 ctl) | |||
142 | cx_write(AUD_RATE_THRES_DMD, 0x000000C0); | 142 | cx_write(AUD_RATE_THRES_DMD, 0x000000C0); |
143 | cx88_start_audio_dma(core); | 143 | cx88_start_audio_dma(core); |
144 | 144 | ||
145 | if (cx88_boards[core->board].blackbird) { | 145 | if (cx88_boards[core->board].mpeg & CX88_MPEG_BLACKBIRD) { |
146 | /* sets sound input from external adc */ | 146 | /* sets sound input from external adc */ |
147 | switch (core->board) { | 147 | switch (core->board) { |
148 | case CX88_BOARD_HAUPPAUGE_ROSLYN: | 148 | case CX88_BOARD_HAUPPAUGE_ROSLYN: |
@@ -164,7 +164,7 @@ static void set_audio_finish(struct cx88_core *core, u32 ctl) | |||
164 | cx_write(AUD_I2SCNTL, 0); | 164 | cx_write(AUD_I2SCNTL, 0); |
165 | /* cx_write(AUD_APB_IN_RATE_ADJ, 0); */ | 165 | /* cx_write(AUD_APB_IN_RATE_ADJ, 0); */ |
166 | } | 166 | } |
167 | if ((always_analog) || (!cx88_boards[core->board].blackbird)) { | 167 | if ((always_analog) || (!(cx88_boards[core->board].mpeg & CX88_MPEG_BLACKBIRD))) { |
168 | ctl |= EN_DAC_ENABLE; | 168 | ctl |= EN_DAC_ENABLE; |
169 | cx_write(AUD_CTL, ctl); | 169 | cx_write(AUD_CTL, ctl); |
170 | } | 170 | } |
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c index fbc79e9842aa..cb0c0eea20f9 100644 --- a/drivers/media/video/cx88/cx88-video.c +++ b/drivers/media/video/cx88/cx88-video.c | |||
@@ -1928,6 +1928,9 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev, | |||
1928 | if (TUNER_ABSENT != core->tuner_type) | 1928 | if (TUNER_ABSENT != core->tuner_type) |
1929 | request_module("tuner"); | 1929 | request_module("tuner"); |
1930 | 1930 | ||
1931 | if (cx88_boards[ core->board ].audio_chip == AUDIO_CHIP_WM8775) | ||
1932 | request_module("wm8775"); | ||
1933 | |||
1931 | /* register v4l devices */ | 1934 | /* register v4l devices */ |
1932 | dev->video_dev = cx88_vdev_init(core,dev->pci, | 1935 | dev->video_dev = cx88_vdev_init(core,dev->pci, |
1933 | &cx8800_video_template,"video"); | 1936 | &cx8800_video_template,"video"); |
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h index 89f12e273b7f..3bc91aad4fe5 100644 --- a/drivers/media/video/cx88/cx88.h +++ b/drivers/media/video/cx88/cx88.h | |||
@@ -30,6 +30,7 @@ | |||
30 | #include <media/tveeprom.h> | 30 | #include <media/tveeprom.h> |
31 | #include <media/video-buf.h> | 31 | #include <media/video-buf.h> |
32 | #include <media/cx2341x.h> | 32 | #include <media/cx2341x.h> |
33 | #include <media/audiochip.h> | ||
33 | #include <media/video-buf-dvb.h> | 34 | #include <media/video-buf-dvb.h> |
34 | 35 | ||
35 | #include "btcx-risc.h" | 36 | #include "btcx-risc.h" |
@@ -39,12 +40,6 @@ | |||
39 | #include <linux/mutex.h> | 40 | #include <linux/mutex.h> |
40 | #define CX88_VERSION_CODE KERNEL_VERSION(0,0,6) | 41 | #define CX88_VERSION_CODE KERNEL_VERSION(0,0,6) |
41 | 42 | ||
42 | #ifndef TRUE | ||
43 | # define TRUE (1==1) | ||
44 | #endif | ||
45 | #ifndef FALSE | ||
46 | # define FALSE (1==0) | ||
47 | #endif | ||
48 | #define UNSET (-1U) | 43 | #define UNSET (-1U) |
49 | 44 | ||
50 | #define CX88_MAXBOARDS 8 | 45 | #define CX88_MAXBOARDS 8 |
@@ -73,6 +68,12 @@ enum cx88_deemph_type { | |||
73 | FM_DEEMPH_75 | 68 | FM_DEEMPH_75 |
74 | }; | 69 | }; |
75 | 70 | ||
71 | enum cx88_board_type { | ||
72 | CX88_BOARD_NONE = 0, | ||
73 | CX88_MPEG_DVB, | ||
74 | CX88_MPEG_BLACKBIRD | ||
75 | }; | ||
76 | |||
76 | /* ----------------------------------------------------------- */ | 77 | /* ----------------------------------------------------------- */ |
77 | /* tv norms */ | 78 | /* tv norms */ |
78 | 79 | ||
@@ -230,8 +231,8 @@ struct cx88_board { | |||
230 | int tda9887_conf; | 231 | int tda9887_conf; |
231 | struct cx88_input input[MAX_CX88_INPUT]; | 232 | struct cx88_input input[MAX_CX88_INPUT]; |
232 | struct cx88_input radio; | 233 | struct cx88_input radio; |
233 | unsigned int blackbird:1; | 234 | enum cx88_board_type mpeg; |
234 | unsigned int dvb:1; | 235 | enum audiochip audio_chip; |
235 | }; | 236 | }; |
236 | 237 | ||
237 | struct cx88_subid { | 238 | struct cx88_subid { |
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c index fba30a40e9c6..1457b1602221 100644 --- a/drivers/media/video/ir-kbd-i2c.c +++ b/drivers/media/video/ir-kbd-i2c.c | |||
@@ -64,23 +64,32 @@ MODULE_PARM_DESC(hauppauge, "Specify Hauppauge remote: 0=black, 1=grey (defaults | |||
64 | static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) | 64 | static int get_key_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw) |
65 | { | 65 | { |
66 | unsigned char buf[3]; | 66 | unsigned char buf[3]; |
67 | int start, toggle, dev, code; | 67 | int start, range, toggle, dev, code; |
68 | 68 | ||
69 | /* poll IR chip */ | 69 | /* poll IR chip */ |
70 | if (3 != i2c_master_recv(&ir->c,buf,3)) | 70 | if (3 != i2c_master_recv(&ir->c,buf,3)) |
71 | return -EIO; | 71 | return -EIO; |
72 | 72 | ||
73 | /* split rc5 data block ... */ | 73 | /* split rc5 data block ... */ |
74 | start = (buf[0] >> 6) & 3; | 74 | start = (buf[0] >> 7) & 1; |
75 | range = (buf[0] >> 6) & 1; | ||
75 | toggle = (buf[0] >> 5) & 1; | 76 | toggle = (buf[0] >> 5) & 1; |
76 | dev = buf[0] & 0x1f; | 77 | dev = buf[0] & 0x1f; |
77 | code = (buf[1] >> 2) & 0x3f; | 78 | code = (buf[1] >> 2) & 0x3f; |
78 | 79 | ||
79 | if (3 != start) | 80 | /* rc5 has two start bits |
81 | * the first bit must be one | ||
82 | * the second bit defines the command range (1 = 0-63, 0 = 64 - 127) | ||
83 | */ | ||
84 | if (!start) | ||
80 | /* no key pressed */ | 85 | /* no key pressed */ |
81 | return 0; | 86 | return 0; |
82 | dprintk(1,"ir hauppauge (rc5): s%d t%d dev=%d code=%d\n", | 87 | |
83 | start, toggle, dev, code); | 88 | if (!range) |
89 | code += 64; | ||
90 | |||
91 | dprintk(1,"ir hauppauge (rc5): s%d r%d t%d dev=%d code=%d\n", | ||
92 | start, range, toggle, dev, code); | ||
84 | 93 | ||
85 | /* return key */ | 94 | /* return key */ |
86 | *ir_key = code; | 95 | *ir_key = code; |
diff --git a/drivers/media/video/msp3400-driver.c b/drivers/media/video/msp3400-driver.c index 56246b8578f3..cf43df3fe708 100644 --- a/drivers/media/video/msp3400-driver.c +++ b/drivers/media/video/msp3400-driver.c | |||
@@ -904,6 +904,8 @@ static int msp_attach(struct i2c_adapter *adapter, int address, int kind) | |||
904 | state->has_virtual_dolby_surround = msp_revision == 'G' && msp_prod_lo == 1; | 904 | state->has_virtual_dolby_surround = msp_revision == 'G' && msp_prod_lo == 1; |
905 | /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */ | 905 | /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */ |
906 | state->has_dolby_pro_logic = msp_revision == 'G' && msp_prod_lo == 2; | 906 | state->has_dolby_pro_logic = msp_revision == 'G' && msp_prod_lo == 2; |
907 | /* The msp343xG supports BTSC only and cannot do Automatic Standard Detection. */ | ||
908 | state->force_btsc = msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3; | ||
907 | 909 | ||
908 | state->opmode = opmode; | 910 | state->opmode = opmode; |
909 | if (state->opmode == OPMODE_AUTO) { | 911 | if (state->opmode == OPMODE_AUTO) { |
diff --git a/drivers/media/video/msp3400-driver.h b/drivers/media/video/msp3400-driver.h index 545e4ac094f2..7531efa1615e 100644 --- a/drivers/media/video/msp3400-driver.h +++ b/drivers/media/video/msp3400-driver.h | |||
@@ -64,6 +64,7 @@ struct msp_state { | |||
64 | u8 has_sound_processing; | 64 | u8 has_sound_processing; |
65 | u8 has_virtual_dolby_surround; | 65 | u8 has_virtual_dolby_surround; |
66 | u8 has_dolby_pro_logic; | 66 | u8 has_dolby_pro_logic; |
67 | u8 force_btsc; | ||
67 | 68 | ||
68 | int radio; | 69 | int radio; |
69 | int opmode; | 70 | int opmode; |
diff --git a/drivers/media/video/msp3400-kthreads.c b/drivers/media/video/msp3400-kthreads.c index ed02ff811388..4c7f85b566a0 100644 --- a/drivers/media/video/msp3400-kthreads.c +++ b/drivers/media/video/msp3400-kthreads.c | |||
@@ -960,9 +960,10 @@ int msp34xxg_thread(void *data) | |||
960 | 960 | ||
961 | /* setup the chip*/ | 961 | /* setup the chip*/ |
962 | msp34xxg_reset(client); | 962 | msp34xxg_reset(client); |
963 | state->std = state->radio ? 0x40 : msp_standard; | 963 | state->std = state->radio ? 0x40 : |
964 | /* start autodetect */ | 964 | (state->force_btsc && msp_standard == 1) ? 32 : msp_standard; |
965 | msp_write_dem(client, 0x20, state->std); | 965 | msp_write_dem(client, 0x20, state->std); |
966 | /* start autodetect */ | ||
966 | if (state->std != 1) | 967 | if (state->std != 1) |
967 | goto unmute; | 968 | goto unmute; |
968 | 969 | ||
diff --git a/drivers/media/video/pvrusb2/Kconfig b/drivers/media/video/pvrusb2/Kconfig index a52171ef6134..5645c9318890 100644 --- a/drivers/media/video/pvrusb2/Kconfig +++ b/drivers/media/video/pvrusb2/Kconfig | |||
@@ -18,8 +18,8 @@ config VIDEO_PVRUSB2_29XXX | |||
18 | select VIDEO_SAA711X | 18 | select VIDEO_SAA711X |
19 | select VIDEO_MSP3400 | 19 | select VIDEO_MSP3400 |
20 | ---help--- | 20 | ---help--- |
21 | This option enables support for WinTV-PVR USB2 devices whose | 21 | This option enables support for WinTV-PVR USB2 devices whose |
22 | model number is of the form "29xxx" (leading prefix of "29" | 22 | model number is of the form "29xxx" (leading prefix of "29" |
23 | followed by 3 digits). | 23 | followed by 3 digits). |
24 | To see if you may need this option, examine the white | 24 | To see if you may need this option, examine the white |
25 | sticker on the underside of your device. | 25 | sticker on the underside of your device. |
@@ -37,14 +37,9 @@ config VIDEO_PVRUSB2_24XXX | |||
37 | form "24xxx" (leading prefix of "24" followed by 3 digits). | 37 | form "24xxx" (leading prefix of "24" followed by 3 digits). |
38 | To see if you may need this option, examine the white | 38 | To see if you may need this option, examine the white |
39 | sticker on the underside of your device. Enabling this | 39 | sticker on the underside of your device. Enabling this |
40 | option will not harm support for older devices, however it | 40 | option will not harm support for older devices. |
41 | is a separate option because of the experimental nature of | ||
42 | this new feature. | ||
43 | 41 | ||
44 | If you are in doubt, say N. | 42 | If you are in doubt, say Y. |
45 | |||
46 | Note: This feature is _very_ experimental. You have been | ||
47 | warned. | ||
48 | 43 | ||
49 | config VIDEO_PVRUSB2_SYSFS | 44 | config VIDEO_PVRUSB2_SYSFS |
50 | bool "pvrusb2 sysfs support (EXPERIMENTAL)" | 45 | bool "pvrusb2 sysfs support (EXPERIMENTAL)" |
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c index 88604365777c..3d8cd0daf6a9 100644 --- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c +++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c | |||
@@ -24,6 +24,7 @@ | |||
24 | #include <linux/slab.h> | 24 | #include <linux/slab.h> |
25 | #include <linux/firmware.h> | 25 | #include <linux/firmware.h> |
26 | #include <linux/videodev2.h> | 26 | #include <linux/videodev2.h> |
27 | #include <media/v4l2-common.h> | ||
27 | #include <asm/semaphore.h> | 28 | #include <asm/semaphore.h> |
28 | #include "pvrusb2.h" | 29 | #include "pvrusb2.h" |
29 | #include "pvrusb2-std.h" | 30 | #include "pvrusb2-std.h" |
@@ -3131,6 +3132,42 @@ static int pvr2_hdw_get_eeprom_addr(struct pvr2_hdw *hdw) | |||
3131 | } | 3132 | } |
3132 | 3133 | ||
3133 | 3134 | ||
3135 | int pvr2_hdw_register_access(struct pvr2_hdw *hdw, | ||
3136 | u32 chip_id,unsigned long reg_id, | ||
3137 | int setFl,u32 *val_ptr) | ||
3138 | { | ||
3139 | #ifdef CONFIG_VIDEO_ADV_DEBUG | ||
3140 | struct list_head *item; | ||
3141 | struct pvr2_i2c_client *cp; | ||
3142 | struct v4l2_register req; | ||
3143 | int stat = 0; | ||
3144 | int okFl = 0; | ||
3145 | |||
3146 | req.i2c_id = chip_id; | ||
3147 | req.reg = reg_id; | ||
3148 | if (setFl) req.val = *val_ptr; | ||
3149 | mutex_lock(&hdw->i2c_list_lock); do { | ||
3150 | list_for_each(item,&hdw->i2c_clients) { | ||
3151 | cp = list_entry(item,struct pvr2_i2c_client,list); | ||
3152 | if (cp->client->driver->id != chip_id) continue; | ||
3153 | stat = pvr2_i2c_client_cmd( | ||
3154 | cp,(setFl ? VIDIOC_INT_S_REGISTER : | ||
3155 | VIDIOC_INT_G_REGISTER),&req); | ||
3156 | if (!setFl) *val_ptr = req.val; | ||
3157 | okFl = !0; | ||
3158 | break; | ||
3159 | } | ||
3160 | } while (0); mutex_unlock(&hdw->i2c_list_lock); | ||
3161 | if (okFl) { | ||
3162 | return stat; | ||
3163 | } | ||
3164 | return -EINVAL; | ||
3165 | #else | ||
3166 | return -ENOSYS; | ||
3167 | #endif | ||
3168 | } | ||
3169 | |||
3170 | |||
3134 | /* | 3171 | /* |
3135 | Stuff for Emacs to see, in order to encourage consistent editing style: | 3172 | Stuff for Emacs to see, in order to encourage consistent editing style: |
3136 | *** Local Variables: *** | 3173 | *** Local Variables: *** |
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.h b/drivers/media/video/pvrusb2/pvrusb2-hdw.h index fd931b5da490..29979bb2a768 100644 --- a/drivers/media/video/pvrusb2/pvrusb2-hdw.h +++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.h | |||
@@ -211,6 +211,14 @@ int pvr2_hdw_v4l_get_minor_number(struct pvr2_hdw *); | |||
211 | /* Store the v4l minor device number */ | 211 | /* Store the v4l minor device number */ |
212 | void pvr2_hdw_v4l_store_minor_number(struct pvr2_hdw *,int); | 212 | void pvr2_hdw_v4l_store_minor_number(struct pvr2_hdw *,int); |
213 | 213 | ||
214 | /* Direct read/write access to chip's registers: | ||
215 | chip_id - unique id of chip (e.g. I2C_DRIVERD_xxxx) | ||
216 | reg_id - register number to access | ||
217 | setFl - true to set the register, false to read it | ||
218 | val_ptr - storage location for source / result. */ | ||
219 | int pvr2_hdw_register_access(struct pvr2_hdw *, | ||
220 | u32 chip_id,unsigned long reg_id, | ||
221 | int setFl,u32 *val_ptr); | ||
214 | 222 | ||
215 | /* The following entry points are all lower level things you normally don't | 223 | /* The following entry points are all lower level things you normally don't |
216 | want to worry about. */ | 224 | want to worry about. */ |
diff --git a/drivers/media/video/pvrusb2/pvrusb2-i2c-chips-v4l2.c b/drivers/media/video/pvrusb2/pvrusb2-i2c-chips-v4l2.c index ed3e8105292a..05121666b9ba 100644 --- a/drivers/media/video/pvrusb2/pvrusb2-i2c-chips-v4l2.c +++ b/drivers/media/video/pvrusb2/pvrusb2-i2c-chips-v4l2.c | |||
@@ -19,6 +19,7 @@ | |||
19 | * | 19 | * |
20 | */ | 20 | */ |
21 | 21 | ||
22 | #include <linux/kernel.h> | ||
22 | #include "pvrusb2-i2c-core.h" | 23 | #include "pvrusb2-i2c-core.h" |
23 | #include "pvrusb2-hdw-internal.h" | 24 | #include "pvrusb2-hdw-internal.h" |
24 | #include "pvrusb2-debug.h" | 25 | #include "pvrusb2-debug.h" |
@@ -89,7 +90,8 @@ void pvr2_i2c_probe(struct pvr2_hdw *hdw,struct pvr2_i2c_client *cp) | |||
89 | 90 | ||
90 | const struct pvr2_i2c_op *pvr2_i2c_get_op(unsigned int idx) | 91 | const struct pvr2_i2c_op *pvr2_i2c_get_op(unsigned int idx) |
91 | { | 92 | { |
92 | if (idx >= sizeof(ops)/sizeof(ops[0])) return 0; | 93 | if (idx >= ARRAY_SIZE(ops)) |
94 | return NULL; | ||
93 | return ops[idx]; | 95 | return ops[idx]; |
94 | } | 96 | } |
95 | 97 | ||
diff --git a/drivers/media/video/pvrusb2/pvrusb2-v4l2.c b/drivers/media/video/pvrusb2/pvrusb2-v4l2.c index 3608c2f81df9..97e974d9b9c3 100644 --- a/drivers/media/video/pvrusb2/pvrusb2-v4l2.c +++ b/drivers/media/video/pvrusb2/pvrusb2-v4l2.c | |||
@@ -29,27 +29,17 @@ | |||
29 | #include "pvrusb2-v4l2.h" | 29 | #include "pvrusb2-v4l2.h" |
30 | #include "pvrusb2-ioread.h" | 30 | #include "pvrusb2-ioread.h" |
31 | #include <linux/videodev2.h> | 31 | #include <linux/videodev2.h> |
32 | #include <media/v4l2-dev.h> | ||
32 | #include <media/v4l2-common.h> | 33 | #include <media/v4l2-common.h> |
33 | 34 | ||
34 | struct pvr2_v4l2_dev; | 35 | struct pvr2_v4l2_dev; |
35 | struct pvr2_v4l2_fh; | 36 | struct pvr2_v4l2_fh; |
36 | struct pvr2_v4l2; | 37 | struct pvr2_v4l2; |
37 | 38 | ||
38 | /* V4L no longer provide the ability to set / get a private context pointer | ||
39 | (i.e. video_get_drvdata / video_set_drvdata), which means we have to | ||
40 | concoct our own context locating mechanism. Supposedly this is intended | ||
41 | to simplify driver implementation. It's not clear to me how that can | ||
42 | possibly be true. Our solution here is to maintain a lookup table of | ||
43 | our context instances, indexed by the minor device number of the V4L | ||
44 | device. See pvr2_v4l2_open() for some implications of this approach. */ | ||
45 | static struct pvr2_v4l2_dev *devices[256]; | ||
46 | static DEFINE_MUTEX(device_lock); | ||
47 | |||
48 | struct pvr2_v4l2_dev { | 39 | struct pvr2_v4l2_dev { |
40 | struct video_device devbase; /* MUST be first! */ | ||
49 | struct pvr2_v4l2 *v4lp; | 41 | struct pvr2_v4l2 *v4lp; |
50 | struct video_device *vdev; | ||
51 | struct pvr2_context_stream *stream; | 42 | struct pvr2_context_stream *stream; |
52 | int ctxt_idx; | ||
53 | enum pvr2_config config; | 43 | enum pvr2_config config; |
54 | }; | 44 | }; |
55 | 45 | ||
@@ -74,7 +64,7 @@ struct pvr2_v4l2 { | |||
74 | struct v4l2_prio_state prio; | 64 | struct v4l2_prio_state prio; |
75 | 65 | ||
76 | /* streams */ | 66 | /* streams */ |
77 | struct pvr2_v4l2_dev video_dev; | 67 | struct pvr2_v4l2_dev *vdev; |
78 | }; | 68 | }; |
79 | 69 | ||
80 | static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1}; | 70 | static int video_nr[PVR_NUM] = {[0 ... PVR_NUM-1] = -1}; |
@@ -671,6 +661,20 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file, | |||
671 | ret = 0; | 661 | ret = 0; |
672 | break; | 662 | break; |
673 | } | 663 | } |
664 | #ifdef CONFIG_VIDEO_ADV_DEBUG | ||
665 | case VIDIOC_INT_G_REGISTER: | ||
666 | case VIDIOC_INT_S_REGISTER: | ||
667 | { | ||
668 | u32 val; | ||
669 | struct v4l2_register *req = (struct v4l2_register *)arg; | ||
670 | if (cmd == VIDIOC_INT_S_REGISTER) val = req->val; | ||
671 | ret = pvr2_hdw_register_access( | ||
672 | hdw,req->i2c_id,req->reg, | ||
673 | cmd == VIDIOC_INT_S_REGISTER,&val); | ||
674 | if (cmd == VIDIOC_INT_G_REGISTER) req->val = val; | ||
675 | break; | ||
676 | } | ||
677 | #endif | ||
674 | 678 | ||
675 | default : | 679 | default : |
676 | ret = v4l_compat_translate_ioctl(inode,file,cmd, | 680 | ret = v4l_compat_translate_ioctl(inode,file,cmd, |
@@ -704,21 +708,22 @@ static int pvr2_v4l2_do_ioctl(struct inode *inode, struct file *file, | |||
704 | static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip) | 708 | static void pvr2_v4l2_dev_destroy(struct pvr2_v4l2_dev *dip) |
705 | { | 709 | { |
706 | printk(KERN_INFO "pvrusb2: unregistering device video%d [%s]\n", | 710 | printk(KERN_INFO "pvrusb2: unregistering device video%d [%s]\n", |
707 | dip->vdev->minor,pvr2_config_get_name(dip->config)); | 711 | dip->devbase.minor,pvr2_config_get_name(dip->config)); |
708 | if (dip->ctxt_idx >= 0) { | 712 | |
709 | mutex_lock(&device_lock); | 713 | /* Paranoia */ |
710 | devices[dip->ctxt_idx] = NULL; | 714 | dip->v4lp = 0; |
711 | dip->ctxt_idx = -1; | 715 | dip->stream = 0; |
712 | mutex_unlock(&device_lock); | 716 | |
713 | } | 717 | /* Actual deallocation happens later when all internal references |
714 | video_unregister_device(dip->vdev); | 718 | are gone. */ |
719 | video_unregister_device(&dip->devbase); | ||
715 | } | 720 | } |
716 | 721 | ||
717 | 722 | ||
718 | static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp) | 723 | static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp) |
719 | { | 724 | { |
720 | pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,-1); | 725 | pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw,-1); |
721 | pvr2_v4l2_dev_destroy(&vp->video_dev); | 726 | pvr2_v4l2_dev_destroy(vp->vdev); |
722 | 727 | ||
723 | pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp); | 728 | pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_v4l2 id=%p",vp); |
724 | pvr2_channel_done(&vp->channel); | 729 | pvr2_channel_done(&vp->channel); |
@@ -726,6 +731,14 @@ static void pvr2_v4l2_destroy_no_lock(struct pvr2_v4l2 *vp) | |||
726 | } | 731 | } |
727 | 732 | ||
728 | 733 | ||
734 | static void pvr2_video_device_release(struct video_device *vdev) | ||
735 | { | ||
736 | struct pvr2_v4l2_dev *dev; | ||
737 | dev = container_of(vdev,struct pvr2_v4l2_dev,devbase); | ||
738 | kfree(dev); | ||
739 | } | ||
740 | |||
741 | |||
729 | static void pvr2_v4l2_internal_check(struct pvr2_channel *chp) | 742 | static void pvr2_v4l2_internal_check(struct pvr2_channel *chp) |
730 | { | 743 | { |
731 | struct pvr2_v4l2 *vp; | 744 | struct pvr2_v4l2 *vp; |
@@ -797,40 +810,12 @@ static int pvr2_v4l2_release(struct inode *inode, struct file *file) | |||
797 | 810 | ||
798 | static int pvr2_v4l2_open(struct inode *inode, struct file *file) | 811 | static int pvr2_v4l2_open(struct inode *inode, struct file *file) |
799 | { | 812 | { |
800 | struct pvr2_v4l2_dev *dip = NULL; /* Our own context pointer */ | 813 | struct pvr2_v4l2_dev *dip; /* Our own context pointer */ |
801 | struct pvr2_v4l2_fh *fhp; | 814 | struct pvr2_v4l2_fh *fhp; |
802 | struct pvr2_v4l2 *vp; | 815 | struct pvr2_v4l2 *vp; |
803 | struct pvr2_hdw *hdw; | 816 | struct pvr2_hdw *hdw; |
804 | 817 | ||
805 | mutex_lock(&device_lock); | 818 | dip = container_of(video_devdata(file),struct pvr2_v4l2_dev,devbase); |
806 | /* MCI 7-Jun-2006 Even though we're just doing what amounts to an | ||
807 | atomic read of the device mapping array here, we still need the | ||
808 | mutex. The problem is that there is a tiny race possible when | ||
809 | we register the device. We can't update the device mapping | ||
810 | array until after the device has been registered, owing to the | ||
811 | fact that we can't know the minor device number until after the | ||
812 | registration succeeds. And if another thread tries to open the | ||
813 | device in the window of time after registration but before the | ||
814 | map is updated, then it will get back an erroneous null pointer | ||
815 | and the open will result in a spurious failure. The only way to | ||
816 | prevent that is to (a) be inside the mutex here before we access | ||
817 | the array, and (b) cover the entire registration process later | ||
818 | on with this same mutex. Thus if we get inside the mutex here, | ||
819 | then we can be assured that the registration process actually | ||
820 | completed correctly. This is an unhappy complication from the | ||
821 | use of global data in a driver that lives in a preemptible | ||
822 | environment. It sure would be nice if the video device itself | ||
823 | had a means for storing and retrieving a local context pointer. | ||
824 | Oh wait. It did. But now it's gone. Silly me. */ | ||
825 | { | ||
826 | unsigned int midx = iminor(file->f_dentry->d_inode); | ||
827 | if (midx < sizeof(devices)/sizeof(devices[0])) { | ||
828 | dip = devices[midx]; | ||
829 | } | ||
830 | } | ||
831 | mutex_unlock(&device_lock); | ||
832 | |||
833 | if (!dip) return -ENODEV; /* Should be impossible but I'm paranoid */ | ||
834 | 819 | ||
835 | vp = dip->v4lp; | 820 | vp = dip->v4lp; |
836 | hdw = vp->channel.hdw; | 821 | hdw = vp->channel.hdw; |
@@ -1060,38 +1045,24 @@ static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip, | |||
1060 | return; | 1045 | return; |
1061 | } | 1046 | } |
1062 | 1047 | ||
1063 | dip->vdev = video_device_alloc(); | 1048 | memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template)); |
1064 | if (!dip->vdev) { | 1049 | dip->devbase.release = pvr2_video_device_release; |
1065 | err("Alloc of pvrusb2 v4l video device failed"); | ||
1066 | return; | ||
1067 | } | ||
1068 | |||
1069 | memcpy(dip->vdev,&vdev_template,sizeof(vdev_template)); | ||
1070 | dip->vdev->release = video_device_release; | ||
1071 | mutex_lock(&device_lock); | ||
1072 | 1050 | ||
1073 | mindevnum = -1; | 1051 | mindevnum = -1; |
1074 | unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw); | 1052 | unit_number = pvr2_hdw_get_unit_number(vp->channel.mc_head->hdw); |
1075 | if ((unit_number >= 0) && (unit_number < PVR_NUM)) { | 1053 | if ((unit_number >= 0) && (unit_number < PVR_NUM)) { |
1076 | mindevnum = video_nr[unit_number]; | 1054 | mindevnum = video_nr[unit_number]; |
1077 | } | 1055 | } |
1078 | if ((video_register_device(dip->vdev, v4l_type, mindevnum) < 0) && | 1056 | if ((video_register_device(&dip->devbase, v4l_type, mindevnum) < 0) && |
1079 | (video_register_device(dip->vdev, v4l_type, -1) < 0)) { | 1057 | (video_register_device(&dip->devbase, v4l_type, -1) < 0)) { |
1080 | err("Failed to register pvrusb2 v4l video device"); | 1058 | err("Failed to register pvrusb2 v4l video device"); |
1081 | } else { | 1059 | } else { |
1082 | printk(KERN_INFO "pvrusb2: registered device video%d [%s]\n", | 1060 | printk(KERN_INFO "pvrusb2: registered device video%d [%s]\n", |
1083 | dip->vdev->minor,pvr2_config_get_name(dip->config)); | 1061 | dip->devbase.minor,pvr2_config_get_name(dip->config)); |
1084 | } | ||
1085 | |||
1086 | if ((dip->vdev->minor < sizeof(devices)/sizeof(devices[0])) && | ||
1087 | (devices[dip->vdev->minor] == NULL)) { | ||
1088 | dip->ctxt_idx = dip->vdev->minor; | ||
1089 | devices[dip->ctxt_idx] = dip; | ||
1090 | } | 1062 | } |
1091 | mutex_unlock(&device_lock); | ||
1092 | 1063 | ||
1093 | pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw, | 1064 | pvr2_hdw_v4l_store_minor_number(vp->channel.mc_head->hdw, |
1094 | dip->vdev->minor); | 1065 | dip->devbase.minor); |
1095 | } | 1066 | } |
1096 | 1067 | ||
1097 | 1068 | ||
@@ -1102,15 +1073,19 @@ struct pvr2_v4l2 *pvr2_v4l2_create(struct pvr2_context *mnp) | |||
1102 | vp = kmalloc(sizeof(*vp),GFP_KERNEL); | 1073 | vp = kmalloc(sizeof(*vp),GFP_KERNEL); |
1103 | if (!vp) return vp; | 1074 | if (!vp) return vp; |
1104 | memset(vp,0,sizeof(*vp)); | 1075 | memset(vp,0,sizeof(*vp)); |
1105 | vp->video_dev.ctxt_idx = -1; | 1076 | vp->vdev = kmalloc(sizeof(*vp->vdev),GFP_KERNEL); |
1077 | if (!vp->vdev) { | ||
1078 | kfree(vp); | ||
1079 | return 0; | ||
1080 | } | ||
1081 | memset(vp->vdev,0,sizeof(*vp->vdev)); | ||
1106 | pvr2_channel_init(&vp->channel,mnp); | 1082 | pvr2_channel_init(&vp->channel,mnp); |
1107 | pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp); | 1083 | pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_v4l2 id=%p",vp); |
1108 | 1084 | ||
1109 | vp->channel.check_func = pvr2_v4l2_internal_check; | 1085 | vp->channel.check_func = pvr2_v4l2_internal_check; |
1110 | 1086 | ||
1111 | /* register streams */ | 1087 | /* register streams */ |
1112 | pvr2_v4l2_dev_init(&vp->video_dev,vp,pvr2_config_mpeg); | 1088 | pvr2_v4l2_dev_init(vp->vdev,vp,pvr2_config_mpeg); |
1113 | |||
1114 | 1089 | ||
1115 | return vp; | 1090 | return vp; |
1116 | } | 1091 | } |
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c index aa1db509f3d4..fe3c83ca3de3 100644 --- a/drivers/media/video/saa7134/saa7134-cards.c +++ b/drivers/media/video/saa7134/saa7134-cards.c | |||
@@ -2965,6 +2965,35 @@ struct saa7134_board saa7134_boards[] = { | |||
2965 | .amux = LINE1, | 2965 | .amux = LINE1, |
2966 | }, | 2966 | }, |
2967 | }, | 2967 | }, |
2968 | [SAA7134_BOARD_AVERMEDIA_A16AR] = { | ||
2969 | /* Petr Baudis <pasky@ucw.cz> */ | ||
2970 | .name = "AVerMedia TV Hybrid A16AR", | ||
2971 | .audio_clock = 0x187de7, | ||
2972 | .tuner_type = TUNER_PHILIPS_TDA8290, /* untested */ | ||
2973 | .radio_type = TUNER_TEA5767, /* untested */ | ||
2974 | .tuner_addr = ADDR_UNSET, | ||
2975 | .radio_addr = ADDR_UNSET, | ||
2976 | .tda9887_conf = TDA9887_PRESENT, | ||
2977 | .mpeg = SAA7134_MPEG_DVB, | ||
2978 | .inputs = {{ | ||
2979 | .name = name_tv, | ||
2980 | .vmux = 1, | ||
2981 | .amux = TV, | ||
2982 | .tv = 1, | ||
2983 | },{ | ||
2984 | .name = name_comp1, | ||
2985 | .vmux = 3, | ||
2986 | .amux = LINE2, | ||
2987 | },{ | ||
2988 | .name = name_svideo, | ||
2989 | .vmux = 8, | ||
2990 | .amux = LINE1, | ||
2991 | }}, | ||
2992 | .radio = { | ||
2993 | .name = name_radio, | ||
2994 | .amux = LINE1, | ||
2995 | }, | ||
2996 | }, | ||
2968 | }; | 2997 | }; |
2969 | 2998 | ||
2970 | const unsigned int saa7134_bcount = ARRAY_SIZE(saa7134_boards); | 2999 | const unsigned int saa7134_bcount = ARRAY_SIZE(saa7134_boards); |
@@ -3562,6 +3591,12 @@ struct pci_device_id saa7134_pci_tbl[] = { | |||
3562 | .subdevice = 0x2003, | 3591 | .subdevice = 0x2003, |
3563 | .driver_data = SAA7134_BOARD_PROTEUS_2309, | 3592 | .driver_data = SAA7134_BOARD_PROTEUS_2309, |
3564 | },{ | 3593 | },{ |
3594 | .vendor = PCI_VENDOR_ID_PHILIPS, | ||
3595 | .device = PCI_DEVICE_ID_PHILIPS_SAA7134, | ||
3596 | .subvendor = 0x1461, | ||
3597 | .subdevice = 0x2c00, | ||
3598 | .driver_data = SAA7134_BOARD_AVERMEDIA_A16AR, | ||
3599 | },{ | ||
3565 | /* --- boards without eeprom + subsystem ID --- */ | 3600 | /* --- boards without eeprom + subsystem ID --- */ |
3566 | .vendor = PCI_VENDOR_ID_PHILIPS, | 3601 | .vendor = PCI_VENDOR_ID_PHILIPS, |
3567 | .device = PCI_DEVICE_ID_PHILIPS_SAA7134, | 3602 | .device = PCI_DEVICE_ID_PHILIPS_SAA7134, |
@@ -3703,6 +3738,7 @@ int saa7134_board_init1(struct saa7134_dev *dev) | |||
3703 | saa_writeb(SAA7134_GPIO_GPMODE3, 0x08); | 3738 | saa_writeb(SAA7134_GPIO_GPMODE3, 0x08); |
3704 | saa_writeb(SAA7134_GPIO_GPSTATUS3, 0x00); | 3739 | saa_writeb(SAA7134_GPIO_GPSTATUS3, 0x00); |
3705 | break; | 3740 | break; |
3741 | case SAA7134_BOARD_AVERMEDIA_A16AR: | ||
3706 | case SAA7134_BOARD_AVERMEDIA_CARDBUS: | 3742 | case SAA7134_BOARD_AVERMEDIA_CARDBUS: |
3707 | /* power-up tuner chip */ | 3743 | /* power-up tuner chip */ |
3708 | saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0xffffffff, 0xffffffff); | 3744 | saa_andorl(SAA7134_GPIO_GPMODE0 >> 2, 0xffffffff, 0xffffffff); |
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c index b6881541e704..fb741fa465a5 100644 --- a/drivers/media/video/saa7134/saa7134-dvb.c +++ b/drivers/media/video/saa7134/saa7134-dvb.c | |||
@@ -1055,6 +1055,7 @@ static int dvb_init(struct saa7134_dev *dev) | |||
1055 | } | 1055 | } |
1056 | break; | 1056 | break; |
1057 | case SAA7134_BOARD_AVERMEDIA_777: | 1057 | case SAA7134_BOARD_AVERMEDIA_777: |
1058 | case SAA7134_BOARD_AVERMEDIA_A16AR: | ||
1058 | printk("%s: avertv 777 dvb setup\n",dev->name); | 1059 | printk("%s: avertv 777 dvb setup\n",dev->name); |
1059 | dev->dvb.frontend = dvb_attach(mt352_attach, &avermedia_777, | 1060 | dev->dvb.frontend = dvb_attach(mt352_attach, &avermedia_777, |
1060 | &dev->i2c_adap); | 1061 | &dev->i2c_adap); |
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c index f7ea857d5d73..ff5991136f4e 100644 --- a/drivers/media/video/saa7134/saa7134-input.c +++ b/drivers/media/video/saa7134/saa7134-input.c | |||
@@ -185,6 +185,7 @@ int saa7134_input_init1(struct saa7134_dev *dev) | |||
185 | case SAA7134_BOARD_AVERMEDIA_STUDIO_305: | 185 | case SAA7134_BOARD_AVERMEDIA_STUDIO_305: |
186 | case SAA7134_BOARD_AVERMEDIA_STUDIO_307: | 186 | case SAA7134_BOARD_AVERMEDIA_STUDIO_307: |
187 | case SAA7134_BOARD_AVERMEDIA_GO_007_FM: | 187 | case SAA7134_BOARD_AVERMEDIA_GO_007_FM: |
188 | case SAA7134_BOARD_AVERMEDIA_A16AR: | ||
188 | ir_codes = ir_codes_avermedia; | 189 | ir_codes = ir_codes_avermedia; |
189 | mask_keycode = 0x0007C8; | 190 | mask_keycode = 0x0007C8; |
190 | mask_keydown = 0x000010; | 191 | mask_keydown = 0x000010; |
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h index 7db7b9705953..701a90942108 100644 --- a/drivers/media/video/saa7134/saa7134.h +++ b/drivers/media/video/saa7134/saa7134.h | |||
@@ -226,6 +226,7 @@ struct saa7134_format { | |||
226 | #define SAA7134_BOARD_MEDION_MD8800_QUADRO 96 | 226 | #define SAA7134_BOARD_MEDION_MD8800_QUADRO 96 |
227 | #define SAA7134_BOARD_FLYDVBS_LR300 97 | 227 | #define SAA7134_BOARD_FLYDVBS_LR300 97 |
228 | #define SAA7134_BOARD_PROTEUS_2309 98 | 228 | #define SAA7134_BOARD_PROTEUS_2309 98 |
229 | #define SAA7134_BOARD_AVERMEDIA_A16AR 99 | ||
229 | 230 | ||
230 | #define SAA7134_MAXBOARDS 8 | 231 | #define SAA7134_MAXBOARDS 8 |
231 | #define SAA7134_INPUT_MAX 8 | 232 | #define SAA7134_INPUT_MAX 8 |
diff --git a/drivers/media/video/video-buf.c b/drivers/media/video/video-buf.c index acc5ea936687..f429f49901b9 100644 --- a/drivers/media/video/video-buf.c +++ b/drivers/media/video/video-buf.c | |||
@@ -365,7 +365,12 @@ videobuf_iolock(struct videobuf_queue* q, struct videobuf_buffer *vb, | |||
365 | if (NULL == fbuf) | 365 | if (NULL == fbuf) |
366 | return -EINVAL; | 366 | return -EINVAL; |
367 | /* FIXME: need sanity checks for vb->boff */ | 367 | /* FIXME: need sanity checks for vb->boff */ |
368 | bus = (dma_addr_t)fbuf->base + vb->boff; | 368 | /* |
369 | * Using a double cast to avoid compiler warnings when | ||
370 | * building for PAE. Compiler doesn't like direct casting | ||
371 | * of a 32 bit ptr to 64 bit integer. | ||
372 | */ | ||
373 | bus = (dma_addr_t)(unsigned long)fbuf->base + vb->boff; | ||
369 | pages = PAGE_ALIGN(vb->size) >> PAGE_SHIFT; | 374 | pages = PAGE_ALIGN(vb->size) >> PAGE_SHIFT; |
370 | err = videobuf_dma_init_overlay(&vb->dma,PCI_DMA_FROMDEVICE, | 375 | err = videobuf_dma_init_overlay(&vb->dma,PCI_DMA_FROMDEVICE, |
371 | bus, pages); | 376 | bus, pages); |