Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flexcop-pci.c
Go to the documentation of this file.
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);
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 <[email protected]>"
43 
44 struct flexcop_pci {
45  struct pci_dev *pdev;
46 
47 #define FC_PCI_INIT 0x01
48 #define FC_PCI_DMA_INIT 0x02
50 
51  void __iomem *io_mem;
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 */
61  /* position of the pointer last time the timer/packet irq occurred */
62  int count;
65 
67  unsigned long last_irq;
68 
71 };
72 
73 static int lastwreg, lastwval, lastrreg, lastrval;
74 
75 static flexcop_ibi_value flexcop_pci_read_ibi_reg(struct flexcop_device *fc,
77 {
78  struct flexcop_pci *fc_pci = fc->bus_specific;
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,
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 
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;
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)
172  fc_pci->dma[0].cpu_addr0,
173  fc_pci->dma[0].size / 188);
174  else
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);
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);
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);
241  deb_irq("DMA xfer enabled\n");
242 
243  fc_pci->last_dma1_cur_pos = 0;
245  deb_irq("IRQ enabled\n");
246  fc_pci->count_prev = fc_pci->count;
247  } else {
249  deb_irq("IRQ disabled\n");
250 
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],
263  if (ret != 0)
264  return ret;
265 
266  ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[1],
268  if (ret != 0) {
269  flexcop_dma_free(&fc_pci->dma[0]);
270  return ret;
271  }
272 
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;
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)
391  msecs_to_jiffies(irq_chk_intv < 100 ?
392  100 :
393  irq_chk_intv));
394  return ret;
395 
396 err_fc_exit:
398 err_pci_exit:
399  flexcop_pci_exit(fc_pci);
400 err_kfree:
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)
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 
450 MODULE_LICENSE("GPL");