diff options
Diffstat (limited to 'drivers/media/dvb/b2c2/flexcop-pci.c')
-rw-r--r-- | drivers/media/dvb/b2c2/flexcop-pci.c | 450 |
1 files changed, 450 insertions, 0 deletions
diff --git a/drivers/media/dvb/b2c2/flexcop-pci.c b/drivers/media/dvb/b2c2/flexcop-pci.c new file mode 100644 index 00000000000..44f8fb5f17f --- /dev/null +++ b/drivers/media/dvb/b2c2/flexcop-pci.c | |||
@@ -0,0 +1,450 @@ | |||
1 | /* | ||
2 | * Linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III | ||
3 | * flexcop-pci.c - covers the PCI part including DMA transfers | ||
4 | * see flexcop.c for copyright information | ||
5 | */ | ||
6 | |||
7 | #define FC_LOG_PREFIX "flexcop-pci" | ||
8 | #include "flexcop-common.h" | ||
9 | |||
10 | static int enable_pid_filtering = 1; | ||
11 | module_param(enable_pid_filtering, int, 0444); | ||
12 | MODULE_PARM_DESC(enable_pid_filtering, | ||
13 | "enable hardware pid filtering: supported values: 0 (fullts), 1"); | ||
14 | |||
15 | static int irq_chk_intv = 100; | ||
16 | module_param(irq_chk_intv, int, 0644); | ||
17 | MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ streaming watchdog."); | ||
18 | |||
19 | #ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG | ||
20 | #define dprintk(level,args...) \ | ||
21 | do { if ((debug & level)) printk(args); } while (0) | ||
22 | #define DEBSTATUS "" | ||
23 | #else | ||
24 | #define dprintk(level,args...) | ||
25 | #define DEBSTATUS " (debugging is not enabled)" | ||
26 | #endif | ||
27 | |||
28 | #define deb_info(args...) dprintk(0x01, args) | ||
29 | #define deb_reg(args...) dprintk(0x02, args) | ||
30 | #define deb_ts(args...) dprintk(0x04, args) | ||
31 | #define deb_irq(args...) dprintk(0x08, args) | ||
32 | #define deb_chk(args...) dprintk(0x10, args) | ||
33 | |||
34 | static int debug; | ||
35 | module_param(debug, int, 0644); | ||
36 | MODULE_PARM_DESC(debug, | ||
37 | "set debug level (1=info,2=regs,4=TS,8=irqdma,16=check (|-able))." | ||
38 | DEBSTATUS); | ||
39 | |||
40 | #define DRIVER_VERSION "0.1" | ||
41 | #define DRIVER_NAME "flexcop-pci" | ||
42 | #define DRIVER_AUTHOR "Patrick Boettcher <patrick.boettcher@desy.de>" | ||
43 | |||
44 | struct flexcop_pci { | ||
45 | struct pci_dev *pdev; | ||
46 | |||
47 | #define FC_PCI_INIT 0x01 | ||
48 | #define FC_PCI_DMA_INIT 0x02 | ||
49 | int init_state; | ||
50 | |||
51 | void __iomem *io_mem; | ||
52 | u32 irq; | ||
53 | /* buffersize (at least for DMA1, need to be % 188 == 0, | ||
54 | * this logic is required */ | ||
55 | #define FC_DEFAULT_DMA1_BUFSIZE (1280 * 188) | ||
56 | #define FC_DEFAULT_DMA2_BUFSIZE (10 * 188) | ||
57 | struct flexcop_dma dma[2]; | ||
58 | |||
59 | int active_dma1_addr; /* 0 = addr0 of dma1; 1 = addr1 of dma1 */ | ||
60 | u32 last_dma1_cur_pos; | ||
61 | /* position of the pointer last time the timer/packet irq occurred */ | ||
62 | int count; | ||
63 | int count_prev; | ||
64 | int stream_problem; | ||
65 | |||
66 | spinlock_t irq_lock; | ||
67 | unsigned long last_irq; | ||
68 | |||
69 | struct delayed_work irq_check_work; | ||
70 | struct flexcop_device *fc_dev; | ||
71 | }; | ||
72 | |||
73 | static int lastwreg, lastwval, lastrreg, lastrval; | ||
74 | |||
75 | static flexcop_ibi_value flexcop_pci_read_ibi_reg(struct flexcop_device *fc, | ||
76 | flexcop_ibi_register r) | ||
77 | { | ||
78 | struct flexcop_pci *fc_pci = fc->bus_specific; | ||
79 | flexcop_ibi_value v; | ||
80 | v.raw = readl(fc_pci->io_mem + r); | ||
81 | |||
82 | if (lastrreg != r || lastrval != v.raw) { | ||
83 | lastrreg = r; lastrval = v.raw; | ||
84 | deb_reg("new rd: %3x: %08x\n", r, v.raw); | ||
85 | } | ||
86 | |||
87 | return v; | ||
88 | } | ||
89 | |||
90 | static int flexcop_pci_write_ibi_reg(struct flexcop_device *fc, | ||
91 | flexcop_ibi_register r, flexcop_ibi_value v) | ||
92 | { | ||
93 | struct flexcop_pci *fc_pci = fc->bus_specific; | ||
94 | |||
95 | if (lastwreg != r || lastwval != v.raw) { | ||
96 | lastwreg = r; lastwval = v.raw; | ||
97 | deb_reg("new wr: %3x: %08x\n", r, v.raw); | ||
98 | } | ||
99 | |||
100 | writel(v.raw, fc_pci->io_mem + r); | ||
101 | return 0; | ||
102 | } | ||
103 | |||
104 | static void flexcop_pci_irq_check_work(struct work_struct *work) | ||
105 | { | ||
106 | struct flexcop_pci *fc_pci = | ||
107 | container_of(work, struct flexcop_pci, irq_check_work.work); | ||
108 | struct flexcop_device *fc = fc_pci->fc_dev; | ||
109 | |||
110 | if (fc->feedcount) { | ||
111 | |||
112 | if (fc_pci->count == fc_pci->count_prev) { | ||
113 | deb_chk("no IRQ since the last check\n"); | ||
114 | if (fc_pci->stream_problem++ == 3) { | ||
115 | struct dvb_demux_feed *feed; | ||
116 | deb_info("flexcop-pci: stream problem, resetting pid filter\n"); | ||
117 | |||
118 | spin_lock_irq(&fc->demux.lock); | ||
119 | list_for_each_entry(feed, &fc->demux.feed_list, | ||
120 | list_head) { | ||
121 | flexcop_pid_feed_control(fc, feed, 0); | ||
122 | } | ||
123 | |||
124 | list_for_each_entry(feed, &fc->demux.feed_list, | ||
125 | list_head) { | ||
126 | flexcop_pid_feed_control(fc, feed, 1); | ||
127 | } | ||
128 | spin_unlock_irq(&fc->demux.lock); | ||
129 | |||
130 | fc_pci->stream_problem = 0; | ||
131 | } | ||
132 | } else { | ||
133 | fc_pci->stream_problem = 0; | ||
134 | fc_pci->count_prev = fc_pci->count; | ||
135 | } | ||
136 | } | ||
137 | |||
138 | schedule_delayed_work(&fc_pci->irq_check_work, | ||
139 | msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv)); | ||
140 | } | ||
141 | |||
142 | /* When PID filtering is turned on, we use the timer IRQ, because small amounts | ||
143 | * of data need to be passed to the user space instantly as well. When PID | ||
144 | * filtering is turned off, we use the page-change-IRQ */ | ||
145 | static irqreturn_t flexcop_pci_isr(int irq, void *dev_id) | ||
146 | { | ||
147 | struct flexcop_pci *fc_pci = dev_id; | ||
148 | struct flexcop_device *fc = fc_pci->fc_dev; | ||
149 | unsigned long flags; | ||
150 | flexcop_ibi_value v; | ||
151 | irqreturn_t ret = IRQ_HANDLED; | ||
152 | |||
153 | spin_lock_irqsave(&fc_pci->irq_lock, flags); | ||
154 | v = fc->read_ibi_reg(fc, irq_20c); | ||
155 | |||
156 | /* errors */ | ||
157 | if (v.irq_20c.Data_receiver_error) | ||
158 | deb_chk("data receiver error\n"); | ||
159 | if (v.irq_20c.Continuity_error_flag) | ||
160 | deb_chk("Contunuity error flag is set\n"); | ||
161 | if (v.irq_20c.LLC_SNAP_FLAG_set) | ||
162 | deb_chk("LLC_SNAP_FLAG_set is set\n"); | ||
163 | if (v.irq_20c.Transport_Error) | ||
164 | deb_chk("Transport error\n"); | ||
165 | |||
166 | if ((fc_pci->count % 1000) == 0) | ||
167 | deb_chk("%d valid irq took place so far\n", fc_pci->count); | ||
168 | |||
169 | if (v.irq_20c.DMA1_IRQ_Status == 1) { | ||
170 | if (fc_pci->active_dma1_addr == 0) | ||
171 | flexcop_pass_dmx_packets(fc_pci->fc_dev, | ||
172 | fc_pci->dma[0].cpu_addr0, | ||
173 | fc_pci->dma[0].size / 188); | ||
174 | else | ||
175 | flexcop_pass_dmx_packets(fc_pci->fc_dev, | ||
176 | fc_pci->dma[0].cpu_addr1, | ||
177 | fc_pci->dma[0].size / 188); | ||
178 | |||
179 | deb_irq("page change to page: %d\n",!fc_pci->active_dma1_addr); | ||
180 | fc_pci->active_dma1_addr = !fc_pci->active_dma1_addr; | ||
181 | /* for the timer IRQ we only can use buffer dmx feeding, because we don't have | ||
182 | * complete TS packets when reading from the DMA memory */ | ||
183 | } else if (v.irq_20c.DMA1_Timer_Status == 1) { | ||
184 | dma_addr_t cur_addr = | ||
185 | fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2; | ||
186 | u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0; | ||
187 | |||
188 | deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, " | ||
189 | "last_cur_pos: %08x ", | ||
190 | jiffies_to_usecs(jiffies - fc_pci->last_irq), | ||
191 | v.raw, (unsigned long long)cur_addr, cur_pos, | ||
192 | fc_pci->last_dma1_cur_pos); | ||
193 | fc_pci->last_irq = jiffies; | ||
194 | |||
195 | /* buffer end was reached, restarted from the beginning | ||
196 | * pass the data from last_cur_pos to the buffer end to the demux | ||
197 | */ | ||
198 | if (cur_pos < fc_pci->last_dma1_cur_pos) { | ||
199 | deb_irq(" end was reached: passing %d bytes ", | ||
200 | (fc_pci->dma[0].size*2 - 1) - | ||
201 | fc_pci->last_dma1_cur_pos); | ||
202 | flexcop_pass_dmx_data(fc_pci->fc_dev, | ||
203 | fc_pci->dma[0].cpu_addr0 + | ||
204 | fc_pci->last_dma1_cur_pos, | ||
205 | (fc_pci->dma[0].size*2) - | ||
206 | fc_pci->last_dma1_cur_pos); | ||
207 | fc_pci->last_dma1_cur_pos = 0; | ||
208 | } | ||
209 | |||
210 | if (cur_pos > fc_pci->last_dma1_cur_pos) { | ||
211 | deb_irq(" passing %d bytes ", | ||
212 | cur_pos - fc_pci->last_dma1_cur_pos); | ||
213 | flexcop_pass_dmx_data(fc_pci->fc_dev, | ||
214 | fc_pci->dma[0].cpu_addr0 + | ||
215 | fc_pci->last_dma1_cur_pos, | ||
216 | cur_pos - fc_pci->last_dma1_cur_pos); | ||
217 | } | ||
218 | deb_irq("\n"); | ||
219 | |||
220 | fc_pci->last_dma1_cur_pos = cur_pos; | ||
221 | fc_pci->count++; | ||
222 | } else { | ||
223 | deb_irq("isr for flexcop called, " | ||
224 | "apparently without reason (%08x)\n", v.raw); | ||
225 | ret = IRQ_NONE; | ||
226 | } | ||
227 | |||
228 | spin_unlock_irqrestore(&fc_pci->irq_lock, flags); | ||
229 | return ret; | ||
230 | } | ||
231 | |||
232 | static int flexcop_pci_stream_control(struct flexcop_device *fc, int onoff) | ||
233 | { | ||
234 | struct flexcop_pci *fc_pci = fc->bus_specific; | ||
235 | if (onoff) { | ||
236 | flexcop_dma_config(fc, &fc_pci->dma[0], FC_DMA_1); | ||
237 | flexcop_dma_config(fc, &fc_pci->dma[1], FC_DMA_2); | ||
238 | flexcop_dma_config_timer(fc, FC_DMA_1, 0); | ||
239 | flexcop_dma_xfer_control(fc, FC_DMA_1, | ||
240 | FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1, 1); | ||
241 | deb_irq("DMA xfer enabled\n"); | ||
242 | |||
243 | fc_pci->last_dma1_cur_pos = 0; | ||
244 | flexcop_dma_control_timer_irq(fc, FC_DMA_1, 1); | ||
245 | deb_irq("IRQ enabled\n"); | ||
246 | fc_pci->count_prev = fc_pci->count; | ||
247 | } else { | ||
248 | flexcop_dma_control_timer_irq(fc, FC_DMA_1, 0); | ||
249 | deb_irq("IRQ disabled\n"); | ||
250 | |||
251 | flexcop_dma_xfer_control(fc, FC_DMA_1, | ||
252 | FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1, 0); | ||
253 | deb_irq("DMA xfer disabled\n"); | ||
254 | } | ||
255 | return 0; | ||
256 | } | ||
257 | |||
258 | static int flexcop_pci_dma_init(struct flexcop_pci *fc_pci) | ||
259 | { | ||
260 | int ret; | ||
261 | ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[0], | ||
262 | FC_DEFAULT_DMA1_BUFSIZE); | ||
263 | if (ret != 0) | ||
264 | return ret; | ||
265 | |||
266 | ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[1], | ||
267 | FC_DEFAULT_DMA2_BUFSIZE); | ||
268 | if (ret != 0) { | ||
269 | flexcop_dma_free(&fc_pci->dma[0]); | ||
270 | return ret; | ||
271 | } | ||
272 | |||
273 | flexcop_sram_set_dest(fc_pci->fc_dev, FC_SRAM_DEST_MEDIA | | ||
274 | FC_SRAM_DEST_NET, FC_SRAM_DEST_TARGET_DMA1); | ||
275 | flexcop_sram_set_dest(fc_pci->fc_dev, FC_SRAM_DEST_CAO | | ||
276 | FC_SRAM_DEST_CAI, FC_SRAM_DEST_TARGET_DMA2); | ||
277 | fc_pci->init_state |= FC_PCI_DMA_INIT; | ||
278 | return ret; | ||
279 | } | ||
280 | |||
281 | static void flexcop_pci_dma_exit(struct flexcop_pci *fc_pci) | ||
282 | { | ||
283 | if (fc_pci->init_state & FC_PCI_DMA_INIT) { | ||
284 | flexcop_dma_free(&fc_pci->dma[0]); | ||
285 | flexcop_dma_free(&fc_pci->dma[1]); | ||
286 | } | ||
287 | fc_pci->init_state &= ~FC_PCI_DMA_INIT; | ||
288 | } | ||
289 | |||
290 | static int flexcop_pci_init(struct flexcop_pci *fc_pci) | ||
291 | { | ||
292 | int ret; | ||
293 | |||
294 | info("card revision %x", fc_pci->pdev->revision); | ||
295 | |||
296 | if ((ret = pci_enable_device(fc_pci->pdev)) != 0) | ||
297 | return ret; | ||
298 | pci_set_master(fc_pci->pdev); | ||
299 | |||
300 | if ((ret = pci_request_regions(fc_pci->pdev, DRIVER_NAME)) != 0) | ||
301 | goto err_pci_disable_device; | ||
302 | |||
303 | fc_pci->io_mem = pci_iomap(fc_pci->pdev, 0, 0x800); | ||
304 | |||
305 | if (!fc_pci->io_mem) { | ||
306 | err("cannot map io memory\n"); | ||
307 | ret = -EIO; | ||
308 | goto err_pci_release_regions; | ||
309 | } | ||
310 | |||
311 | pci_set_drvdata(fc_pci->pdev, fc_pci); | ||
312 | spin_lock_init(&fc_pci->irq_lock); | ||
313 | if ((ret = request_irq(fc_pci->pdev->irq, flexcop_pci_isr, | ||
314 | IRQF_SHARED, DRIVER_NAME, fc_pci)) != 0) | ||
315 | goto err_pci_iounmap; | ||
316 | |||
317 | fc_pci->init_state |= FC_PCI_INIT; | ||
318 | return ret; | ||
319 | |||
320 | err_pci_iounmap: | ||
321 | pci_iounmap(fc_pci->pdev, fc_pci->io_mem); | ||
322 | pci_set_drvdata(fc_pci->pdev, NULL); | ||
323 | err_pci_release_regions: | ||
324 | pci_release_regions(fc_pci->pdev); | ||
325 | err_pci_disable_device: | ||
326 | pci_disable_device(fc_pci->pdev); | ||
327 | return ret; | ||
328 | } | ||
329 | |||
330 | static void flexcop_pci_exit(struct flexcop_pci *fc_pci) | ||
331 | { | ||
332 | if (fc_pci->init_state & FC_PCI_INIT) { | ||
333 | free_irq(fc_pci->pdev->irq, fc_pci); | ||
334 | pci_iounmap(fc_pci->pdev, fc_pci->io_mem); | ||
335 | pci_set_drvdata(fc_pci->pdev, NULL); | ||
336 | pci_release_regions(fc_pci->pdev); | ||
337 | pci_disable_device(fc_pci->pdev); | ||
338 | } | ||
339 | fc_pci->init_state &= ~FC_PCI_INIT; | ||
340 | } | ||
341 | |||
342 | static int flexcop_pci_probe(struct pci_dev *pdev, | ||
343 | const struct pci_device_id *ent) | ||
344 | { | ||
345 | struct flexcop_device *fc; | ||
346 | struct flexcop_pci *fc_pci; | ||
347 | int ret = -ENOMEM; | ||
348 | |||
349 | if ((fc = flexcop_device_kmalloc(sizeof(struct flexcop_pci))) == NULL) { | ||
350 | err("out of memory\n"); | ||
351 | return -ENOMEM; | ||
352 | } | ||
353 | |||
354 | /* general flexcop init */ | ||
355 | fc_pci = fc->bus_specific; | ||
356 | fc_pci->fc_dev = fc; | ||
357 | |||
358 | fc->read_ibi_reg = flexcop_pci_read_ibi_reg; | ||
359 | fc->write_ibi_reg = flexcop_pci_write_ibi_reg; | ||
360 | fc->i2c_request = flexcop_i2c_request; | ||
361 | fc->get_mac_addr = flexcop_eeprom_check_mac_addr; | ||
362 | fc->stream_control = flexcop_pci_stream_control; | ||
363 | |||
364 | if (enable_pid_filtering) | ||
365 | info("will use the HW PID filter."); | ||
366 | else | ||
367 | info("will pass the complete TS to the demuxer."); | ||
368 | |||
369 | fc->pid_filtering = enable_pid_filtering; | ||
370 | fc->bus_type = FC_PCI; | ||
371 | fc->dev = &pdev->dev; | ||
372 | fc->owner = THIS_MODULE; | ||
373 | |||
374 | /* bus specific part */ | ||
375 | fc_pci->pdev = pdev; | ||
376 | if ((ret = flexcop_pci_init(fc_pci)) != 0) | ||
377 | goto err_kfree; | ||
378 | |||
379 | /* init flexcop */ | ||
380 | if ((ret = flexcop_device_initialize(fc)) != 0) | ||
381 | goto err_pci_exit; | ||
382 | |||
383 | /* init dma */ | ||
384 | if ((ret = flexcop_pci_dma_init(fc_pci)) != 0) | ||
385 | goto err_fc_exit; | ||
386 | |||
387 | INIT_DELAYED_WORK(&fc_pci->irq_check_work, flexcop_pci_irq_check_work); | ||
388 | |||
389 | if (irq_chk_intv > 0) | ||
390 | schedule_delayed_work(&fc_pci->irq_check_work, | ||
391 | msecs_to_jiffies(irq_chk_intv < 100 ? | ||
392 | 100 : | ||
393 | irq_chk_intv)); | ||
394 | return ret; | ||
395 | |||
396 | err_fc_exit: | ||
397 | flexcop_device_exit(fc); | ||
398 | err_pci_exit: | ||
399 | flexcop_pci_exit(fc_pci); | ||
400 | err_kfree: | ||
401 | flexcop_device_kfree(fc); | ||
402 | return ret; | ||
403 | } | ||
404 | |||
405 | /* in theory every _exit function should be called exactly two times, | ||
406 | * here and in the bail-out-part of the _init-function | ||
407 | */ | ||
408 | static void flexcop_pci_remove(struct pci_dev *pdev) | ||
409 | { | ||
410 | struct flexcop_pci *fc_pci = pci_get_drvdata(pdev); | ||
411 | |||
412 | if (irq_chk_intv > 0) | ||
413 | cancel_delayed_work(&fc_pci->irq_check_work); | ||
414 | |||
415 | flexcop_pci_dma_exit(fc_pci); | ||
416 | flexcop_device_exit(fc_pci->fc_dev); | ||
417 | flexcop_pci_exit(fc_pci); | ||
418 | flexcop_device_kfree(fc_pci->fc_dev); | ||
419 | } | ||
420 | |||
421 | static struct pci_device_id flexcop_pci_tbl[] = { | ||
422 | { PCI_DEVICE(0x13d0, 0x2103) }, | ||
423 | { }, | ||
424 | }; | ||
425 | |||
426 | MODULE_DEVICE_TABLE(pci, flexcop_pci_tbl); | ||
427 | |||
428 | static struct pci_driver flexcop_pci_driver = { | ||
429 | .name = "b2c2_flexcop_pci", | ||
430 | .id_table = flexcop_pci_tbl, | ||
431 | .probe = flexcop_pci_probe, | ||
432 | .remove = flexcop_pci_remove, | ||
433 | }; | ||
434 | |||
435 | static int __init flexcop_pci_module_init(void) | ||
436 | { | ||
437 | return pci_register_driver(&flexcop_pci_driver); | ||
438 | } | ||
439 | |||
440 | static void __exit flexcop_pci_module_exit(void) | ||
441 | { | ||
442 | pci_unregister_driver(&flexcop_pci_driver); | ||
443 | } | ||
444 | |||
445 | module_init(flexcop_pci_module_init); | ||
446 | module_exit(flexcop_pci_module_exit); | ||
447 | |||
448 | MODULE_AUTHOR(DRIVER_AUTHOR); | ||
449 | MODULE_DESCRIPTION(DRIVER_NAME); | ||
450 | MODULE_LICENSE("GPL"); | ||