2 * This file is part of linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III
4 * flexcop-pci.c - covers the PCI part including DMA transfers.
6 * see flexcop.c for copyright information.
9 #define FC_LOG_PREFIX "flexcop-pci"
10 #include "flexcop-common.h"
12 static int enable_pid_filtering
= 1;
13 module_param(enable_pid_filtering
, int, 0444);
14 MODULE_PARM_DESC(enable_pid_filtering
, "enable hardware pid filtering: supported values: 0 (fullts), 1");
16 static int irq_chk_intv
;
17 module_param(irq_chk_intv
, int, 0644);
18 MODULE_PARM_DESC(irq_chk_intv
, "set the interval for IRQ watchdog (currently just debugging).");
20 #ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG
21 #define dprintk(level,args...) \
22 do { if ((debug & level)) printk(args); } while (0)
25 #define dprintk(level,args...)
26 #define DEBSTATUS " (debugging is not enabled)"
29 #define deb_info(args...) dprintk(0x01,args)
30 #define deb_reg(args...) dprintk(0x02,args)
31 #define deb_ts(args...) dprintk(0x04,args)
32 #define deb_irq(args...) dprintk(0x08,args)
33 #define deb_chk(args...) dprintk(0x10,args)
36 module_param(debug
, int, 0644);
37 MODULE_PARM_DESC(debug
, "set debug level (1=info,2=regs,4=TS,8=irqdma (|-able))." DEBSTATUS
);
39 #define DRIVER_VERSION "0.1"
40 #define DRIVER_NAME "Technisat/B2C2 FlexCop II/IIb/III Digital TV PCI Driver"
41 #define DRIVER_AUTHOR "Patrick Boettcher <patrick.boettcher@desy.de>"
46 #define FC_PCI_INIT 0x01
47 #define FC_PCI_DMA_INIT 0x02
52 /* buffersize (at least for DMA1, need to be % 188 == 0,
53 * this logic is required */
54 #define FC_DEFAULT_DMA1_BUFSIZE (1280 * 188)
55 #define FC_DEFAULT_DMA2_BUFSIZE (10 * 188)
56 struct flexcop_dma dma
[2];
58 int active_dma1_addr
; /* 0 = addr0 of dma1; 1 = addr1 of dma1 */
59 u32 last_dma1_cur_pos
; /* position of the pointer last time the timer/packet irq occured */
64 unsigned long last_irq
;
66 struct delayed_work irq_check_work
;
68 struct flexcop_device
*fc_dev
;
71 static int lastwreg
,lastwval
,lastrreg
,lastrval
;
73 static flexcop_ibi_value
flexcop_pci_read_ibi_reg (struct flexcop_device
*fc
, flexcop_ibi_register r
)
75 struct flexcop_pci
*fc_pci
= fc
->bus_specific
;
77 v
.raw
= readl(fc_pci
->io_mem
+ r
);
79 if (lastrreg
!= r
|| lastrval
!= v
.raw
) {
80 lastrreg
= r
; lastrval
= v
.raw
;
81 deb_reg("new rd: %3x: %08x\n",r
,v
.raw
);
87 static int flexcop_pci_write_ibi_reg(struct flexcop_device
*fc
, flexcop_ibi_register r
, flexcop_ibi_value v
)
89 struct flexcop_pci
*fc_pci
= fc
->bus_specific
;
91 if (lastwreg
!= r
|| lastwval
!= v
.raw
) {
92 lastwreg
= r
; lastwval
= v
.raw
;
93 deb_reg("new wr: %3x: %08x\n",r
,v
.raw
);
96 writel(v
.raw
, fc_pci
->io_mem
+ r
);
100 static void flexcop_pci_irq_check_work(struct work_struct
*work
)
102 struct flexcop_pci
*fc_pci
=
103 container_of(work
, struct flexcop_pci
, irq_check_work
.work
);
104 struct flexcop_device
*fc
= fc_pci
->fc_dev
;
106 flexcop_ibi_value v
= fc
->read_ibi_reg(fc
,sram_dest_reg_714
);
108 flexcop_dump_reg(fc_pci
->fc_dev
,dma1_000
,4);
110 if (v
.sram_dest_reg_714
.net_ovflow_error
)
111 deb_chk("sram net_ovflow_error\n");
112 if (v
.sram_dest_reg_714
.media_ovflow_error
)
113 deb_chk("sram media_ovflow_error\n");
114 if (v
.sram_dest_reg_714
.cai_ovflow_error
)
115 deb_chk("sram cai_ovflow_error\n");
116 if (v
.sram_dest_reg_714
.cai_ovflow_error
)
117 deb_chk("sram cai_ovflow_error\n");
119 schedule_delayed_work(&fc_pci
->irq_check_work
,
120 msecs_to_jiffies(irq_chk_intv
< 100 ? 100 : irq_chk_intv
));
123 /* When PID filtering is turned on, we use the timer IRQ, because small amounts
124 * of data need to be passed to the user space instantly as well. When PID
125 * filtering is turned off, we use the page-change-IRQ */
126 static irqreturn_t
flexcop_pci_isr(int irq
, void *dev_id
)
128 struct flexcop_pci
*fc_pci
= dev_id
;
129 struct flexcop_device
*fc
= fc_pci
->fc_dev
;
131 irqreturn_t ret
= IRQ_HANDLED
;
133 spin_lock_irq(&fc_pci
->irq_lock
);
135 v
= fc
->read_ibi_reg(fc
,irq_20c
);
138 if (v
.irq_20c
.Data_receiver_error
)
139 deb_chk("data receiver error\n");
140 if (v
.irq_20c
.Continuity_error_flag
)
141 deb_chk("Contunuity error flag is set\n");
142 if (v
.irq_20c
.LLC_SNAP_FLAG_set
)
143 deb_chk("LLC_SNAP_FLAG_set is set\n");
144 if (v
.irq_20c
.Transport_Error
)
145 deb_chk("Transport error\n");
147 if ((fc_pci
->count
% 1000) == 0)
148 deb_chk("%d valid irq took place so far\n",fc_pci
->count
);
150 if (v
.irq_20c
.DMA1_IRQ_Status
== 1) {
151 if (fc_pci
->active_dma1_addr
== 0)
152 flexcop_pass_dmx_packets(fc_pci
->fc_dev
,fc_pci
->dma
[0].cpu_addr0
,fc_pci
->dma
[0].size
/ 188);
154 flexcop_pass_dmx_packets(fc_pci
->fc_dev
,fc_pci
->dma
[0].cpu_addr1
,fc_pci
->dma
[0].size
/ 188);
156 deb_irq("page change to page: %d\n",!fc_pci
->active_dma1_addr
);
157 fc_pci
->active_dma1_addr
= !fc_pci
->active_dma1_addr
;
158 } else if (v
.irq_20c
.DMA1_Timer_Status
== 1) {
159 /* for the timer IRQ we only can use buffer dmx feeding, because we don't have
160 * complete TS packets when reading from the DMA memory */
161 dma_addr_t cur_addr
=
162 fc
->read_ibi_reg(fc
,dma1_008
).dma_0x8
.dma_cur_addr
<< 2;
163 u32 cur_pos
= cur_addr
- fc_pci
->dma
[0].dma_addr0
;
165 deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, last_cur_pos: %08x ",
166 jiffies_to_usecs(jiffies
- fc_pci
->last_irq
),
167 v
.raw
, (unsigned long long)cur_addr
, cur_pos
,
168 fc_pci
->last_dma1_cur_pos
);
169 fc_pci
->last_irq
= jiffies
;
171 /* buffer end was reached, restarted from the beginning
172 * pass the data from last_cur_pos to the buffer end to the demux
174 if (cur_pos
< fc_pci
->last_dma1_cur_pos
) {
175 deb_irq(" end was reached: passing %d bytes ",(fc_pci
->dma
[0].size
*2 - 1) - fc_pci
->last_dma1_cur_pos
);
176 flexcop_pass_dmx_data(fc_pci
->fc_dev
,
177 fc_pci
->dma
[0].cpu_addr0
+ fc_pci
->last_dma1_cur_pos
,
178 (fc_pci
->dma
[0].size
*2) - fc_pci
->last_dma1_cur_pos
);
179 fc_pci
->last_dma1_cur_pos
= 0;
182 if (cur_pos
> fc_pci
->last_dma1_cur_pos
) {
183 deb_irq(" passing %d bytes ",cur_pos
- fc_pci
->last_dma1_cur_pos
);
184 flexcop_pass_dmx_data(fc_pci
->fc_dev
,
185 fc_pci
->dma
[0].cpu_addr0
+ fc_pci
->last_dma1_cur_pos
,
186 cur_pos
- fc_pci
->last_dma1_cur_pos
);
190 fc_pci
->last_dma1_cur_pos
= cur_pos
;
193 deb_irq("isr for flexcop called, apparently without reason (%08x)\n",v
.raw
);
197 spin_unlock_irq(&fc_pci
->irq_lock
);
202 static int flexcop_pci_stream_control(struct flexcop_device
*fc
, int onoff
)
204 struct flexcop_pci
*fc_pci
= fc
->bus_specific
;
206 flexcop_dma_config(fc
,&fc_pci
->dma
[0],FC_DMA_1
);
207 flexcop_dma_config(fc
,&fc_pci
->dma
[1],FC_DMA_2
);
209 flexcop_dma_config_timer(fc
,FC_DMA_1
,0);
211 flexcop_dma_xfer_control(fc
,FC_DMA_1
,FC_DMA_SUBADDR_0
| FC_DMA_SUBADDR_1
,1);
212 deb_irq("DMA xfer enabled\n");
214 fc_pci
->last_dma1_cur_pos
= 0;
215 flexcop_dma_control_timer_irq(fc
,FC_DMA_1
,1);
216 deb_irq("IRQ enabled\n");
218 // fc_pci->active_dma1_addr = 0;
219 // flexcop_dma_control_size_irq(fc,FC_DMA_1,1);
221 if (irq_chk_intv
> 0)
222 schedule_delayed_work(&fc_pci
->irq_check_work
,
223 msecs_to_jiffies(irq_chk_intv
< 100 ? 100 : irq_chk_intv
));
225 if (irq_chk_intv
> 0)
226 cancel_delayed_work(&fc_pci
->irq_check_work
);
228 flexcop_dma_control_timer_irq(fc
,FC_DMA_1
,0);
229 deb_irq("IRQ disabled\n");
231 // flexcop_dma_control_size_irq(fc,FC_DMA_1,0);
233 flexcop_dma_xfer_control(fc
,FC_DMA_1
,FC_DMA_SUBADDR_0
| FC_DMA_SUBADDR_1
,0);
234 deb_irq("DMA xfer disabled\n");
240 static int flexcop_pci_dma_init(struct flexcop_pci
*fc_pci
)
243 if ((ret
= flexcop_dma_allocate(fc_pci
->pdev
,&fc_pci
->dma
[0],FC_DEFAULT_DMA1_BUFSIZE
)) != 0)
246 if ((ret
= flexcop_dma_allocate(fc_pci
->pdev
,&fc_pci
->dma
[1],FC_DEFAULT_DMA2_BUFSIZE
)) != 0) {
247 flexcop_dma_free(&fc_pci
->dma
[0]);
251 flexcop_sram_set_dest(fc_pci
->fc_dev
,FC_SRAM_DEST_MEDIA
| FC_SRAM_DEST_NET
, FC_SRAM_DEST_TARGET_DMA1
);
252 flexcop_sram_set_dest(fc_pci
->fc_dev
,FC_SRAM_DEST_CAO
| FC_SRAM_DEST_CAI
, FC_SRAM_DEST_TARGET_DMA2
);
254 fc_pci
->init_state
|= FC_PCI_DMA_INIT
;
259 static void flexcop_pci_dma_exit(struct flexcop_pci
*fc_pci
)
261 if (fc_pci
->init_state
& FC_PCI_DMA_INIT
) {
262 flexcop_dma_free(&fc_pci
->dma
[0]);
263 flexcop_dma_free(&fc_pci
->dma
[1]);
265 fc_pci
->init_state
&= ~FC_PCI_DMA_INIT
;
268 static int flexcop_pci_init(struct flexcop_pci
*fc_pci
)
273 pci_read_config_byte(fc_pci
->pdev
, PCI_CLASS_REVISION
, &card_rev
);
274 info("card revision %x", card_rev
);
276 if ((ret
= pci_enable_device(fc_pci
->pdev
)) != 0)
279 pci_set_master(fc_pci
->pdev
);
281 /* enable interrupts */
282 // pci_write_config_dword(pdev, 0x6c, 0x8000);
284 if ((ret
= pci_request_regions(fc_pci
->pdev
, DRIVER_NAME
)) != 0)
285 goto err_pci_disable_device
;
287 fc_pci
->io_mem
= pci_iomap(fc_pci
->pdev
, 0, 0x800);
289 if (!fc_pci
->io_mem
) {
290 err("cannot map io memory\n");
292 goto err_pci_release_regions
;
295 pci_set_drvdata(fc_pci
->pdev
, fc_pci
);
297 if ((ret
= request_irq(fc_pci
->pdev
->irq
, flexcop_pci_isr
,
298 IRQF_SHARED
, DRIVER_NAME
, fc_pci
)) != 0)
299 goto err_pci_iounmap
;
301 spin_lock_init(&fc_pci
->irq_lock
);
303 fc_pci
->init_state
|= FC_PCI_INIT
;
307 pci_iounmap(fc_pci
->pdev
, fc_pci
->io_mem
);
308 pci_set_drvdata(fc_pci
->pdev
, NULL
);
309 err_pci_release_regions
:
310 pci_release_regions(fc_pci
->pdev
);
311 err_pci_disable_device
:
312 pci_disable_device(fc_pci
->pdev
);
316 static void flexcop_pci_exit(struct flexcop_pci
*fc_pci
)
318 if (fc_pci
->init_state
& FC_PCI_INIT
) {
319 free_irq(fc_pci
->pdev
->irq
, fc_pci
);
320 pci_iounmap(fc_pci
->pdev
, fc_pci
->io_mem
);
321 pci_set_drvdata(fc_pci
->pdev
, NULL
);
322 pci_release_regions(fc_pci
->pdev
);
323 pci_disable_device(fc_pci
->pdev
);
325 fc_pci
->init_state
&= ~FC_PCI_INIT
;
329 static int flexcop_pci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
331 struct flexcop_device
*fc
;
332 struct flexcop_pci
*fc_pci
;
335 if ((fc
= flexcop_device_kmalloc(sizeof(struct flexcop_pci
))) == NULL
) {
336 err("out of memory\n");
340 /* general flexcop init */
341 fc_pci
= fc
->bus_specific
;
344 fc
->read_ibi_reg
= flexcop_pci_read_ibi_reg
;
345 fc
->write_ibi_reg
= flexcop_pci_write_ibi_reg
;
346 fc
->i2c_request
= flexcop_i2c_request
;
347 fc
->get_mac_addr
= flexcop_eeprom_check_mac_addr
;
349 fc
->stream_control
= flexcop_pci_stream_control
;
351 if (enable_pid_filtering
)
352 info("will use the HW PID filter.");
354 info("will pass the complete TS to the demuxer.");
356 fc
->pid_filtering
= enable_pid_filtering
;
357 fc
->bus_type
= FC_PCI
;
359 fc
->dev
= &pdev
->dev
;
360 fc
->owner
= THIS_MODULE
;
362 /* bus specific part */
364 if ((ret
= flexcop_pci_init(fc_pci
)) != 0)
368 if ((ret
= flexcop_device_initialize(fc
)) != 0)
372 if ((ret
= flexcop_pci_dma_init(fc_pci
)) != 0)
375 INIT_DELAYED_WORK(&fc_pci
->irq_check_work
, flexcop_pci_irq_check_work
);
380 flexcop_device_exit(fc
);
382 flexcop_pci_exit(fc_pci
);
384 flexcop_device_kfree(fc
);
388 /* in theory every _exit function should be called exactly two times,
389 * here and in the bail-out-part of the _init-function
391 static void flexcop_pci_remove(struct pci_dev
*pdev
)
393 struct flexcop_pci
*fc_pci
= pci_get_drvdata(pdev
);
395 flexcop_pci_dma_exit(fc_pci
);
396 flexcop_device_exit(fc_pci
->fc_dev
);
397 flexcop_pci_exit(fc_pci
);
398 flexcop_device_kfree(fc_pci
->fc_dev
);
401 static struct pci_device_id flexcop_pci_tbl
[] = {
402 { PCI_DEVICE(0x13d0, 0x2103) },
403 /* { PCI_DEVICE(0x13d0, 0x2200) }, ? */
407 MODULE_DEVICE_TABLE(pci
, flexcop_pci_tbl
);
409 static struct pci_driver flexcop_pci_driver
= {
410 .name
= "b2c2_flexcop_pci",
411 .id_table
= flexcop_pci_tbl
,
412 .probe
= flexcop_pci_probe
,
413 .remove
= flexcop_pci_remove
,
416 static int __init
flexcop_pci_module_init(void)
418 return pci_register_driver(&flexcop_pci_driver
);
421 static void __exit
flexcop_pci_module_exit(void)
423 pci_unregister_driver(&flexcop_pci_driver
);
426 module_init(flexcop_pci_module_init
);
427 module_exit(flexcop_pci_module_exit
);
429 MODULE_AUTHOR(DRIVER_AUTHOR
);
430 MODULE_DESCRIPTION(DRIVER_NAME
);
431 MODULE_LICENSE("GPL");