projects / deliverable / linux.git / blob
? search:


0f3ebcdef126b2e3e5a596ea9446f311c48486cb
[deliverable/linux.git] / drivers / media / video / saa7164 / saa7164-core.c
1 /*
2 * Driver for the NXP SAA7164 PCIe bridge
3 *
4 * Copyright (c) 2009 Steven Toth <stoth@kernellabs.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 *
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include <linux/init.h>
23 #include <linux/list.h>
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kmod.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/interrupt.h>
30 #include <linux/delay.h>
31 #include <asm/div64.h>
32
33 #include "saa7164.h"
34
35 MODULE_DESCRIPTION("Driver for NXP SAA7164 based TV cards");
36 MODULE_AUTHOR("Steven Toth <stoth@kernellabs.com>");
37 MODULE_LICENSE("GPL");
38
39 /*
40 1 Basic
41 2
42 4 i2c
43 8 api
44 16 cmd
45 32 bus
46 */
47
48 unsigned int debug;
49 module_param(debug, int, 0644);
50 MODULE_PARM_DESC(debug, "enable debug messages");
51
52 static unsigned int card[] = {[0 ... (SAA7164_MAXBOARDS - 1)] = UNSET };
53 module_param_array(card, int, NULL, 0444);
54 MODULE_PARM_DESC(card, "card type");
55
56 static unsigned int saa7164_devcount;
57
58 static DEFINE_MUTEX(devlist);
59 LIST_HEAD(saa7164_devlist);
60
61 #define INT_SIZE 16
62
63 static void saa7164_work_cmdhandler(struct work_struct *w)
64 {
65 struct saa7164_dev *dev = container_of(w, struct saa7164_dev, workcmd);
66
67 /* Wake up any complete commands */
68 saa7164_cmd_signal(dev, 0);
69 }
70
71 static void saa7164_buffer_deliver(struct saa7164_buffer *buf)
72 {
73 struct saa7164_tsport *port = buf->port;
74
75 /* Feed the transport payload into the kernel demux */
76 dvb_dmx_swfilter_packets(&port->dvb.demux, buf->cpu,
77 SAA7164_TS_NUMBER_OF_LINES);
78
79 }
80
81 static irqreturn_t saa7164_irq_ts(struct saa7164_tsport *port)
82 {
83 struct saa7164_dev *dev = port->dev;
84 struct saa7164_buffer *buf;
85 struct list_head *c, *n;
86 int wp, i = 0, rp;
87
88 /* Find the current write point from the hardware */
89 wp = saa7164_readl(port->bufcounter);
90 if (wp > (port->hwcfg.buffercount - 1))
91 BUG();
92
93 /* Find the previous buffer to the current write point */
94 if (wp == 0)
95 rp = 7;
96 else
97 rp = wp - 1;
98
99 /* Lookup the WP in the buffer list */
100 /* TODO: turn this into a worker thread */
101 list_for_each_safe(c, n, &port->dmaqueue.list) {
102 buf = list_entry(c, struct saa7164_buffer, list);
103 if (i++ > port->hwcfg.buffercount)
104 BUG();
105
106 if (buf->nr == rp) {
107 /* Found the buffer, deal with it */
108 dprintk(DBGLVL_IRQ, "%s() wp: %d processing: %d\n",
109 __func__, wp, rp);
110 saa7164_buffer_deliver(buf);
111 break;
112 }
113
114 }
115 return 0;
116 }
117
118 /* Primary IRQ handler and dispatch mechanism */
119 static irqreturn_t saa7164_irq(int irq, void *dev_id)
120 {
121 struct saa7164_dev *dev = dev_id;
122 u32 hwacc = 0, interruptid;
123 u32 intstat[INT_SIZE/4];
124 int i, handled = 0, bit;
125
126 if (dev == 0) {
127 printk(KERN_ERR "%s() No device specified\n", __func__);
128 handled = 0;
129 goto out;
130 }
131
132 /* Check that the hardware is accessable. If the status bytes are
133 * 0xFF then the device is not accessable, the the IRQ belongs
134 * to another driver.
135 * 4 x u32 interrupt registers.
136 */
137 for (i = 0; i < INT_SIZE/4; i++) {
138
139 /* TODO: Convert into saa7164_readl() */
140 /* Read the 4 hardware interrupt registers */
141 intstat[i] = saa7164_readl(dev->int_status + (i * 4));
142
143 if (intstat[i] != 0xffffffff)
144 hwacc = 1;
145 }
146 if (hwacc == 0) {
147 handled = 0;
148 goto out;
149 }
150
151 handled = 1;
152
153 /* For each of the HW interrupt registers */
154 for (i = 0; i < INT_SIZE/4; i++) {
155
156 if (intstat[i]) {
157 /* Each function of the board has it's own interruptid.
158 * Find the function that triggered then call
159 * it's handler.
160 */
161 for (bit = 0; bit < 32; bit++) {
162
163 if (((intstat[i] >> bit) & 0x00000001) == 0)
164 continue;
165
166 /* Calculate the interrupt id (0x00 to 0x7f) */
167
168 interruptid = (i * 32) + bit;
169 if (interruptid == dev->intfdesc.bInterruptId) {
170 /* A response to an cmd/api call */
171 schedule_work(&dev->workcmd);
172 } else if (interruptid ==
173 dev->ts1.hwcfg.interruptid) {
174
175 /* Transport path 1 */
176 saa7164_irq_ts(&dev->ts1);
177
178 } else if (interruptid ==
179 dev->ts2.hwcfg.interruptid) {
180
181 /* Transport path 2 */
182 saa7164_irq_ts(&dev->ts2);
183
184 } else {
185 /* Find the function */
186 dprintk(DBGLVL_IRQ,
187 "%s() unhandled interrupt "
188 "reg 0x%x bit 0x%x "
189 "intid = 0x%x\n",
190 __func__, i, bit, interruptid);
191 }
192 }
193
194 /* Ack it */
195 saa7164_writel(dev->int_ack + (i * 4), intstat[i]);
196
197 }
198 }
199 out:
200 return IRQ_RETVAL(handled);
201 }
202
203 void saa7164_getfirmwarestatus(struct saa7164_dev *dev)
204 {
205 struct saa7164_fw_status *s = &dev->fw_status;
206
207 dev->fw_status.status = saa7164_readl(SAA_DEVICE_SYSINIT_STATUS);
208 dev->fw_status.mode = saa7164_readl(SAA_DEVICE_SYSINIT_MODE);
209 dev->fw_status.spec = saa7164_readl(SAA_DEVICE_SYSINIT_SPEC);
210 dev->fw_status.inst = saa7164_readl(SAA_DEVICE_SYSINIT_INST);
211 dev->fw_status.cpuload = saa7164_readl(SAA_DEVICE_SYSINIT_CPULOAD);
212 dev->fw_status.remainheap =
213 saa7164_readl(SAA_DEVICE_SYSINIT_REMAINHEAP);
214
215 dprintk(1, "Firmware status:\n");
216 dprintk(1, " .status = 0x%08x\n", s->status);
217 dprintk(1, " .mode = 0x%08x\n", s->mode);
218 dprintk(1, " .spec = 0x%08x\n", s->spec);
219 dprintk(1, " .inst = 0x%08x\n", s->inst);
220 dprintk(1, " .cpuload = 0x%08x\n", s->cpuload);
221 dprintk(1, " .remainheap = 0x%08x\n", s->remainheap);
222 }
223
224 u32 saa7164_getcurrentfirmwareversion(struct saa7164_dev *dev)
225 {
226 u32 reg;
227
228 reg = saa7164_readl(SAA_DEVICE_VERSION);
229 dprintk(1, "Device running firmware version %d.%d.%d.%d (0x%x)\n",
230 (reg & 0x0000fc00) >> 10,
231 (reg & 0x000003e0) >> 5,
232 (reg & 0x0000001f),
233 (reg & 0xffff0000) >> 16,
234 reg);
235
236 return reg;
237 }
238
239 /* TODO: Debugging func, remove */
240 void saa7164_dumphex16(struct saa7164_dev *dev, u8 *buf, int len)
241 {
242 int i;
243
244 printk(KERN_INFO "--------------------> "
245 "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
246
247 for (i = 0; i < len; i += 16)
248 printk(KERN_INFO " [0x%08x] "
249 "%02x %02x %02x %02x %02x %02x %02x %02x "
250 "%02x %02x %02x %02x %02x %02x %02x %02x\n", i,
251 *(buf+i+0), *(buf+i+1), *(buf+i+2), *(buf+i+3),
252 *(buf+i+4), *(buf+i+5), *(buf+i+6), *(buf+i+7),
253 *(buf+i+8), *(buf+i+9), *(buf+i+10), *(buf+i+11),
254 *(buf+i+12), *(buf+i+13), *(buf+i+14), *(buf+i+15));
255 }
256
257 /* TODO: Debugging func, remove */
258 void saa7164_dumpregs(struct saa7164_dev *dev, u32 addr)
259 {
260 int i;
261
262 dprintk(1, "--------------------> "
263 "00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f\n");
264
265 for (i = 0; i < 0x100; i += 16)
266 dprintk(1, "region0[0x%08x] = "
267 "%02x %02x %02x %02x %02x %02x %02x %02x"
268 " %02x %02x %02x %02x %02x %02x %02x %02x\n", i,
269 (u8)saa7164_readb(addr + i + 0),
270 (u8)saa7164_readb(addr + i + 1),
271 (u8)saa7164_readb(addr + i + 2),
272 (u8)saa7164_readb(addr + i + 3),
273 (u8)saa7164_readb(addr + i + 4),
274 (u8)saa7164_readb(addr + i + 5),
275 (u8)saa7164_readb(addr + i + 6),
276 (u8)saa7164_readb(addr + i + 7),
277 (u8)saa7164_readb(addr + i + 8),
278 (u8)saa7164_readb(addr + i + 9),
279 (u8)saa7164_readb(addr + i + 10),
280 (u8)saa7164_readb(addr + i + 11),
281 (u8)saa7164_readb(addr + i + 12),
282 (u8)saa7164_readb(addr + i + 13),
283 (u8)saa7164_readb(addr + i + 14),
284 (u8)saa7164_readb(addr + i + 15)
285 );
286 }
287
288 static void saa7164_dump_hwdesc(struct saa7164_dev *dev)
289 {
290 dprintk(1, "@0x%p hwdesc sizeof(tmComResHWDescr_t) = %d bytes\n",
291 &dev->hwdesc, (u32)sizeof(tmComResHWDescr_t));
292
293 dprintk(1, " .bLength = 0x%x\n", dev->hwdesc.bLength);
294 dprintk(1, " .bDescriptorType = 0x%x\n", dev->hwdesc.bDescriptorType);
295 dprintk(1, " .bDescriptorSubtype = 0x%x\n",
296 dev->hwdesc.bDescriptorSubtype);
297
298 dprintk(1, " .bcdSpecVersion = 0x%x\n", dev->hwdesc.bcdSpecVersion);
299 dprintk(1, " .dwClockFrequency = 0x%x\n", dev->hwdesc.dwClockFrequency);
300 dprintk(1, " .dwClockUpdateRes = 0x%x\n", dev->hwdesc.dwClockUpdateRes);
301 dprintk(1, " .bCapabilities = 0x%x\n", dev->hwdesc.bCapabilities);
302 dprintk(1, " .dwDeviceRegistersLocation = 0x%x\n",
303 dev->hwdesc.dwDeviceRegistersLocation);
304
305 dprintk(1, " .dwHostMemoryRegion = 0x%x\n",
306 dev->hwdesc.dwHostMemoryRegion);
307
308 dprintk(1, " .dwHostMemoryRegionSize = 0x%x\n",
309 dev->hwdesc.dwHostMemoryRegionSize);
310
311 dprintk(1, " .dwHostHibernatMemRegion = 0x%x\n",
312 dev->hwdesc.dwHostHibernatMemRegion);
313
314 dprintk(1, " .dwHostHibernatMemRegionSize = 0x%x\n",
315 dev->hwdesc.dwHostHibernatMemRegionSize);
316 }
317
318 static void saa7164_dump_intfdesc(struct saa7164_dev *dev)
319 {
320 dprintk(1, "@0x%p intfdesc "
321 "sizeof(tmComResInterfaceDescr_t) = %d bytes\n",
322 &dev->intfdesc, (u32)sizeof(tmComResInterfaceDescr_t));
323
324 dprintk(1, " .bLength = 0x%x\n", dev->intfdesc.bLength);
325 dprintk(1, " .bDescriptorType = 0x%x\n", dev->intfdesc.bDescriptorType);
326 dprintk(1, " .bDescriptorSubtype = 0x%x\n",
327 dev->intfdesc.bDescriptorSubtype);
328
329 dprintk(1, " .bFlags = 0x%x\n", dev->intfdesc.bFlags);
330 dprintk(1, " .bInterfaceType = 0x%x\n", dev->intfdesc.bInterfaceType);
331 dprintk(1, " .bInterfaceId = 0x%x\n", dev->intfdesc.bInterfaceId);
332 dprintk(1, " .bBaseInterface = 0x%x\n", dev->intfdesc.bBaseInterface);
333 dprintk(1, " .bInterruptId = 0x%x\n", dev->intfdesc.bInterruptId);
334 dprintk(1, " .bDebugInterruptId = 0x%x\n",
335 dev->intfdesc.bDebugInterruptId);
336
337 dprintk(1, " .BARLocation = 0x%x\n", dev->intfdesc.BARLocation);
338 }
339
340 static void saa7164_dump_busdesc(struct saa7164_dev *dev)
341 {
342 dprintk(1, "@0x%p busdesc sizeof(tmComResBusDescr_t) = %d bytes\n",
343 &dev->busdesc, (u32)sizeof(tmComResBusDescr_t));
344
345 dprintk(1, " .CommandRing = 0x%016Lx\n", dev->busdesc.CommandRing);
346 dprintk(1, " .ResponseRing = 0x%016Lx\n", dev->busdesc.ResponseRing);
347 dprintk(1, " .CommandWrite = 0x%x\n", dev->busdesc.CommandWrite);
348 dprintk(1, " .CommandRead = 0x%x\n", dev->busdesc.CommandRead);
349 dprintk(1, " .ResponseWrite = 0x%x\n", dev->busdesc.ResponseWrite);
350 dprintk(1, " .ResponseRead = 0x%x\n", dev->busdesc.ResponseRead);
351 }
352
353 /* Much of the hardware configuration and PCI registers are configured
354 * dynamically depending on firmware. We have to cache some initial
355 * structures then use these to locate other important structures
356 * from PCI space.
357 */
358 static void saa7164_get_descriptors(struct saa7164_dev *dev)
359 {
360 memcpy(&dev->hwdesc, dev->bmmio, sizeof(tmComResHWDescr_t));
361 memcpy(&dev->intfdesc, dev->bmmio + sizeof(tmComResHWDescr_t),
362 sizeof(tmComResInterfaceDescr_t));
363 memcpy(&dev->busdesc, dev->bmmio + dev->intfdesc.BARLocation,
364 sizeof(tmComResBusDescr_t));
365
366 if (dev->hwdesc.bLength != sizeof(tmComResHWDescr_t)) {
367 printk(KERN_ERR "Structure tmComResHWDescr_t is mangled\n");
368 printk(KERN_ERR "Need %x got %d\n", dev->hwdesc.bLength,
369 (u32)sizeof(tmComResHWDescr_t));
370 } else
371 saa7164_dump_hwdesc(dev);
372
373 if (dev->intfdesc.bLength != sizeof(tmComResInterfaceDescr_t)) {
374 printk(KERN_ERR "struct tmComResInterfaceDescr_t is mangled\n");
375 printk(KERN_ERR "Need %x got %d\n", dev->intfdesc.bLength,
376 (u32)sizeof(tmComResInterfaceDescr_t));
377 } else
378 saa7164_dump_intfdesc(dev);
379
380 saa7164_dump_busdesc(dev);
381 }
382
383 static int saa7164_pci_quirks(struct saa7164_dev *dev)
384 {
385 return 0;
386 }
387
388 static int get_resources(struct saa7164_dev *dev)
389 {
390 if (request_mem_region(pci_resource_start(dev->pci, 0),
391 pci_resource_len(dev->pci, 0), dev->name)) {
392
393 if (request_mem_region(pci_resource_start(dev->pci, 2),
394 pci_resource_len(dev->pci, 2), dev->name))
395 return 0;
396 }
397
398 printk(KERN_ERR "%s: can't get MMIO memory @ 0x%llx or 0x%llx\n",
399 dev->name,
400 (u64)pci_resource_start(dev->pci, 0),
401 (u64)pci_resource_start(dev->pci, 2));
402
403 return -EBUSY;
404 }
405
406 static int saa7164_dev_setup(struct saa7164_dev *dev)
407 {
408 int i;
409
410 mutex_init(&dev->lock);
411 atomic_inc(&dev->refcount);
412 dev->nr = saa7164_devcount++;
413
414 sprintf(dev->name, "saa7164[%d]", dev->nr);
415
416 mutex_lock(&devlist);
417 list_add_tail(&dev->devlist, &saa7164_devlist);
418 mutex_unlock(&devlist);
419
420 /* board config */
421 dev->board = UNSET;
422 if (card[dev->nr] < saa7164_bcount)
423 dev->board = card[dev->nr];
424
425 for (i = 0; UNSET == dev->board && i < saa7164_idcount; i++)
426 if (dev->pci->subsystem_vendor == saa7164_subids[i].subvendor &&
427 dev->pci->subsystem_device ==
428 saa7164_subids[i].subdevice)
429 dev->board = saa7164_subids[i].card;
430
431 if (UNSET == dev->board) {
432 dev->board = SAA7164_BOARD_UNKNOWN;
433 saa7164_card_list(dev);
434 }
435
436 dev->pci_bus = dev->pci->bus->number;
437 dev->pci_slot = PCI_SLOT(dev->pci->devfn);
438
439 /* I2C Defaults / setup */
440 dev->i2c_bus[0].dev = dev;
441 dev->i2c_bus[0].nr = 0;
442 dev->i2c_bus[1].dev = dev;
443 dev->i2c_bus[1].nr = 1;
444 dev->i2c_bus[2].dev = dev;
445 dev->i2c_bus[2].nr = 2;
446
447 /* Transport port A Defaults / setup */
448 dev->ts1.dev = dev;
449 dev->ts1.nr = 0;
450 mutex_init(&dev->ts1.dvb.lock);
451 INIT_LIST_HEAD(&dev->ts1.dmaqueue.list);
452 INIT_LIST_HEAD(&dev->ts1.dummy_dmaqueue.list);
453 mutex_init(&dev->ts1.dmaqueue_lock);
454 mutex_init(&dev->ts1.dummy_dmaqueue_lock);
455
456 /* Transport port B Defaults / setup */
457 dev->ts2.dev = dev;
458 dev->ts2.nr = 1;
459 mutex_init(&dev->ts2.dvb.lock);
460 INIT_LIST_HEAD(&dev->ts2.dmaqueue.list);
461 INIT_LIST_HEAD(&dev->ts2.dummy_dmaqueue.list);
462 mutex_init(&dev->ts2.dmaqueue_lock);
463 mutex_init(&dev->ts2.dummy_dmaqueue_lock);
464
465 if (get_resources(dev) < 0) {
466 printk(KERN_ERR "CORE %s No more PCIe resources for "
467 "subsystem: %04x:%04x\n",
468 dev->name, dev->pci->subsystem_vendor,
469 dev->pci->subsystem_device);
470
471 saa7164_devcount--;
472 return -ENODEV;
473 }
474
475 /* PCI/e allocations */
476 dev->lmmio = ioremap(pci_resource_start(dev->pci, 0),
477 pci_resource_len(dev->pci, 0));
478
479 dev->lmmio2 = ioremap(pci_resource_start(dev->pci, 2),
480 pci_resource_len(dev->pci, 2));
481
482 printk(KERN_INFO "CORE %s: dev->lmmio = 0x%p\n", dev->name,
483 dev->lmmio);
484
485 printk(KERN_INFO "CORE %s: dev->lmmio2 = 0x%p\n", dev->name,
486 dev->lmmio2);
487
488 dev->bmmio = (u8 __iomem *)dev->lmmio;
489 dev->bmmio2 = (u8 __iomem *)dev->lmmio2;
490 printk(KERN_INFO "CORE %s: dev->bmmio = 0x%p\n", dev->name,
491 dev->bmmio);
492
493 printk(KERN_INFO "CORE %s: dev->bmmio2 = 0x%p\n", dev->name,
494 dev->bmmio2);
495
496 /* Inerrupt and ack register locations offset of bmmio */
497 dev->int_status = 0x183000 + 0xf80;
498 dev->int_ack = 0x183000 + 0xf90;
499
500 printk(KERN_INFO
501 "CORE %s: subsystem: %04x:%04x, board: %s [card=%d,%s]\n",
502 dev->name, dev->pci->subsystem_vendor,
503 dev->pci->subsystem_device, saa7164_boards[dev->board].name,
504 dev->board, card[dev->nr] == dev->board ?
505 "insmod option" : "autodetected");
506
507 saa7164_pci_quirks(dev);
508
509 return 0;
510 }
511
512 static void saa7164_dev_unregister(struct saa7164_dev *dev)
513 {
514 dprintk(1, "%s()\n", __func__);
515
516 release_mem_region(pci_resource_start(dev->pci, 0),
517 pci_resource_len(dev->pci, 0));
518
519 release_mem_region(pci_resource_start(dev->pci, 2),
520 pci_resource_len(dev->pci, 2));
521
522 if (!atomic_dec_and_test(&dev->refcount))
523 return;
524
525 iounmap(dev->lmmio);
526 iounmap(dev->lmmio2);
527
528 return;
529 }
530
531 static int __devinit saa7164_initdev(struct pci_dev *pci_dev,
532 const struct pci_device_id *pci_id)
533 {
534 struct saa7164_dev *dev;
535 int err, i;
536 u32 version;
537
538 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
539 if (NULL == dev)
540 return -ENOMEM;
541
542 /* pci init */
543 dev->pci = pci_dev;
544 if (pci_enable_device(pci_dev)) {
545 err = -EIO;
546 goto fail_free;
547 }
548
549 if (saa7164_dev_setup(dev) < 0) {
550 err = -EINVAL;
551 goto fail_free;
552 }
553
554 /* print pci info */
555 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
556 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &dev->pci_lat);
557 printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
558 "latency: %d, mmio: 0x%llx\n", dev->name,
559 pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
560 dev->pci_lat,
561 (unsigned long long)pci_resource_start(pci_dev, 0));
562
563 pci_set_master(pci_dev);
564 /* TODO */
565 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
566 printk("%s/0: Oops: no 32bit PCI DMA ???\n", dev->name);
567 err = -EIO;
568 goto fail_irq;
569 }
570
571 err = request_irq(pci_dev->irq, saa7164_irq,
572 IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
573 if (err < 0) {
574 printk(KERN_ERR "%s: can't get IRQ %d\n", dev->name,
575 pci_dev->irq);
576 err = -EIO;
577 goto fail_irq;
578 }
579
580 pci_set_drvdata(pci_dev, dev);
581
582 saa7164_pci_quirks(dev);
583
584 /* Init the internal command list */
585 for (i = 0; i < SAA_CMD_MAX_MSG_UNITS; i++) {
586 dev->cmds[i].seqno = i;
587 dev->cmds[i].inuse = 0;
588 mutex_init(&dev->cmds[i].lock);
589 init_waitqueue_head(&dev->cmds[i].wait);
590 }
591
592 /* We need a deferred interrupt handler for cmd handling */
593 INIT_WORK(&dev->workcmd, saa7164_work_cmdhandler);
594
595 /* Only load the firmware if we know the board */
596 if (dev->board != SAA7164_BOARD_UNKNOWN) {
597
598 err = saa7164_downloadfirmware(dev);
599 if (err < 0) {
600 printk(KERN_ERR
601 "Failed to boot firmware, cannot continue\n");
602 goto fail_irq;
603 }
604
605 saa7164_get_descriptors(dev);
606 saa7164_dumpregs(dev, 0);
607 saa7164_getcurrentfirmwareversion(dev);
608 saa7164_getfirmwarestatus(dev);
609 err = saa7164_bus_setup(dev);
610 if (err < 0)
611 printk(KERN_ERR
612 "Failed to setup the bus, will continue\n");
613 saa7164_bus_dump(dev);
614
615 /* Ping the running firmware via the command bus and get the
616 * firmware version, this checks the bus is running OK.
617 */
618 version = 0;
619 if (saa7164_api_get_fw_version(dev, &version) == SAA_OK)
620 dprintk(1, "Bus is operating correctly using "
621 "version %d.%d.%d.%d (0x%x)\n",
622 (version & 0x0000fc00) >> 10,
623 (version & 0x000003e0) >> 5,
624 (version & 0x0000001f),
625 (version & 0xffff0000) >> 16,
626 version);
627 else
628 printk(KERN_ERR
629 "Failed to communicate with the firmware\n");
630
631 /* Bring up the I2C buses */
632 saa7164_i2c_register(&dev->i2c_bus[0]);
633 saa7164_i2c_register(&dev->i2c_bus[1]);
634 saa7164_i2c_register(&dev->i2c_bus[2]);
635 saa7164_gpio_setup(dev);
636 saa7164_card_setup(dev);
637
638
639 /* Parse the dynamic device configuration, find various
640 * media endpoints (MPEG, WMV, PS, TS) and cache their
641 * configuration details into the driver, so we can
642 * reference them later during simething_register() func,
643 * interrupt handlers, deferred work handlers etc.
644 */
645 saa7164_api_enum_subdevs(dev);
646
647 /* Begin to create the video sub-systems and register funcs */
648 if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB) {
649 if (saa7164_dvb_register(&dev->ts1) < 0) {
650 printk(KERN_ERR "%s() Failed to register "
651 "dvb adapters on porta\n",
652 __func__);
653 }
654 }
655
656 if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB) {
657 if (saa7164_dvb_register(&dev->ts2) < 0) {
658 printk(KERN_ERR"%s() Failed to register "
659 "dvb adapters on portb\n",
660 __func__);
661 }
662 }
663
664 } /* != BOARD_UNKNOWN */
665 else
666 printk(KERN_ERR "%s() Unsupported board detected, "
667 "registering without firmware\n", __func__);
668
669 return 0;
670
671 fail_irq:
672 saa7164_dev_unregister(dev);
673 fail_free:
674 kfree(dev);
675 return err;
676 }
677
678 static void saa7164_shutdown(struct saa7164_dev *dev)
679 {
680 dprintk(1, "%s()\n", __func__);
681 }
682
683 static void __devexit saa7164_finidev(struct pci_dev *pci_dev)
684 {
685 struct saa7164_dev *dev = pci_get_drvdata(pci_dev);
686
687 saa7164_shutdown(dev);
688
689 if (saa7164_boards[dev->board].porta == SAA7164_MPEG_DVB)
690 saa7164_dvb_unregister(&dev->ts1);
691
692 if (saa7164_boards[dev->board].portb == SAA7164_MPEG_DVB)
693 saa7164_dvb_unregister(&dev->ts2);
694
695 saa7164_i2c_unregister(&dev->i2c_bus[0]);
696 saa7164_i2c_unregister(&dev->i2c_bus[1]);
697 saa7164_i2c_unregister(&dev->i2c_bus[2]);
698
699 pci_disable_device(pci_dev);
700
701 /* unregister stuff */
702 free_irq(pci_dev->irq, dev);
703 pci_set_drvdata(pci_dev, NULL);
704
705 mutex_lock(&devlist);
706 list_del(&dev->devlist);
707 mutex_unlock(&devlist);
708
709 saa7164_dev_unregister(dev);
710 kfree(dev);
711 }
712
713 static struct pci_device_id saa7164_pci_tbl[] = {
714 {
715 /* SAA7164 */
716 .vendor = 0x1131,
717 .device = 0x7164,
718 .subvendor = PCI_ANY_ID,
719 .subdevice = PCI_ANY_ID,
720 }, {
721 /* --- end of list --- */
722 }
723 };
724 MODULE_DEVICE_TABLE(pci, saa7164_pci_tbl);
725
726 static struct pci_driver saa7164_pci_driver = {
727 .name = "saa7164",
728 .id_table = saa7164_pci_tbl,
729 .probe = saa7164_initdev,
730 .remove = __devexit_p(saa7164_finidev),
731 /* TODO */
732 .suspend = NULL,
733 .resume = NULL,
734 };
735
736 static int saa7164_init(void)
737 {
738 printk(KERN_INFO "saa7164 driver loaded\n");
739 return pci_register_driver(&saa7164_pci_driver);
740 }
741
742 static void saa7164_fini(void)
743 {
744 pci_unregister_driver(&saa7164_pci_driver);
745 }
746
747 module_init(saa7164_init);
748 module_exit(saa7164_fini);
749
Linux kernel - Deliverables
This page took 0.046451 seconds and 4 git commands to generate.