← Back to branch summary

~ubuntu-branches/ubuntu/karmic/linux-ports/karmic

« back to all changes in this revision

Viewing changes to drivers/media/dvb/b2c2/flexcop-pci.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich, Luke Yelavich, Michael Casadevall, Tim Gardner, Upstream Kernel Changes
  • Date: 2009-05-06 18:18:55 UTC
  • Revision ID: james.westby@ubuntu.com-20090506181855-t00baeevpnvd9o7a
Tags: 2.6.30-1.1
[ Luke Yelavich ]
* initial release for karmic
* SAUCE: rebase-ports - adjust for the karmic ports kernel
* SAUCE: rebase-ports - also remove abi dirs/files on rebase
* Update configs after rebase against mainline Jaunty tree
* [Config] Disable CONFIG_BLK_DEV_UB and CONFIG_USB_LIBUSUAL as per
  mainline jaunty
* forward-port patch to drbd for powerpc compilation
* [Config] disable CONFIG_LENOVO_SL_LAPTOP for i386 due to FTBFS
* add .o files found in arch/powerpc/lib to all powerpc kernel header
  packages
* [Config] enable CONFIG_DRM_I915_KMS for i386 as per karmic mainline

[ Michael Casadevall ]

* Disable kgdb on sparc64
* [sparc] [Config] Disable GPIO LEDS
* [ia64] Rename -ia64-generic to -ia64 in line with other architectures
* Correct kernel image path for sparc builds
* [hppa] Fix HPPA config files to build modules for all udebian

Rebase on top of karmic mainline 2.6.30-1.1

[ Tim Gardner ]

* [Config] armel: disable staging drivers, fixes FTBS
* [Config] armel imx51: Disable CONFIG_MTD_NAND_MXC, fixes FTBS

[ Upstream Kernel Changes ]

* mpt2sas: Change reset_type enum to avoid namespace collision.
  Submitted upstream.

* Initial release after rebasing against v2.6.30-rc3

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/dvb/b2c2/flexcop-pci.c
1
1
/*
2
 
 * This file is part of linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III
3
 
 *
4
 
 * flexcop-pci.c - covers the PCI part including DMA transfers.
5
 
 *
6
 
 * see flexcop.c for copyright information.
 
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
7
5
 */
8
6
 
9
7
#define FC_LOG_PREFIX "flexcop-pci"
11
9
 
12
10
static int enable_pid_filtering = 1;
13
11
module_param(enable_pid_filtering, int, 0444);
14
 
MODULE_PARM_DESC(enable_pid_filtering, "enable hardware pid filtering: supported values: 0 (fullts), 1");
 
12
MODULE_PARM_DESC(enable_pid_filtering,
 
13
        "enable hardware pid filtering: supported values: 0 (fullts), 1");
15
14
 
16
 
static int irq_chk_intv;
 
15
static int irq_chk_intv = 100;
17
16
module_param(irq_chk_intv, int, 0644);
18
 
MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ watchdog (currently just debugging).");
 
17
MODULE_PARM_DESC(irq_chk_intv, "set the interval for IRQ streaming watchdog.");
19
18
 
20
19
#ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG
21
20
#define dprintk(level,args...) \
26
25
#define DEBSTATUS " (debugging is not enabled)"
27
26
#endif
28
27
 
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)
 
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)
34
33
 
35
34
static int debug;
36
35
module_param(debug, int, 0644);
37
 
MODULE_PARM_DESC(debug, "set debug level (1=info,2=regs,4=TS,8=irqdma (|-able))." DEBSTATUS);
 
36
MODULE_PARM_DESC(debug,
 
37
        "set debug level (1=info,2=regs,4=TS,8=irqdma,16=check (|-able))."
 
38
        DEBSTATUS);
38
39
 
39
40
#define DRIVER_VERSION "0.1"
40
41
#define DRIVER_NAME "Technisat/B2C2 FlexCop II/IIb/III Digital TV PCI Driver"
49
50
 
50
51
        void __iomem *io_mem;
51
52
        u32 irq;
52
 
/* buffersize (at least for DMA1, need to be % 188 == 0,
53
 
 * this logic is required */
 
53
        /* buffersize (at least for DMA1, need to be % 188 == 0,
 
54
         * this logic is required */
54
55
#define FC_DEFAULT_DMA1_BUFSIZE (1280 * 188)
55
56
#define FC_DEFAULT_DMA2_BUFSIZE (10 * 188)
56
57
        struct flexcop_dma dma[2];
57
58
 
58
59
        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 */
 
60
        u32 last_dma1_cur_pos;
 
61
        /* position of the pointer last time the timer/packet irq occured */
60
62
        int count;
 
63
        int count_prev;
 
64
        int stream_problem;
61
65
 
62
66
        spinlock_t irq_lock;
63
 
 
64
67
        unsigned long last_irq;
65
68
 
66
69
        struct delayed_work irq_check_work;
67
 
 
68
70
        struct flexcop_device *fc_dev;
69
71
};
70
72
 
71
 
static int lastwreg,lastwval,lastrreg,lastrval;
 
73
static int lastwreg, lastwval, lastrreg, lastrval;
72
74
 
73
 
static flexcop_ibi_value flexcop_pci_read_ibi_reg (struct flexcop_device *fc, flexcop_ibi_register r)
 
75
static flexcop_ibi_value flexcop_pci_read_ibi_reg(struct flexcop_device *fc,
 
76
                flexcop_ibi_register r)
74
77
{
75
78
        struct flexcop_pci *fc_pci = fc->bus_specific;
76
79
        flexcop_ibi_value v;
78
81
 
79
82
        if (lastrreg != r || lastrval != v.raw) {
80
83
                lastrreg = r; lastrval = v.raw;
81
 
                deb_reg("new rd: %3x: %08x\n",r,v.raw);
 
84
                deb_reg("new rd: %3x: %08x\n", r, v.raw);
82
85
        }
83
86
 
84
87
        return v;
85
88
}
86
89
 
87
 
static int flexcop_pci_write_ibi_reg(struct flexcop_device *fc, flexcop_ibi_register r, flexcop_ibi_value v)
 
90
static int flexcop_pci_write_ibi_reg(struct flexcop_device *fc,
 
91
                flexcop_ibi_register r, flexcop_ibi_value v)
88
92
{
89
93
        struct flexcop_pci *fc_pci = fc->bus_specific;
90
94
 
91
95
        if (lastwreg != r || lastwval != v.raw) {
92
96
                lastwreg = r; lastwval = v.raw;
93
 
                deb_reg("new wr: %3x: %08x\n",r,v.raw);
 
97
                deb_reg("new wr: %3x: %08x\n", r, v.raw);
94
98
        }
95
99
 
96
100
        writel(v.raw, fc_pci->io_mem + r);
103
107
                container_of(work, struct flexcop_pci, irq_check_work.work);
104
108
        struct flexcop_device *fc = fc_pci->fc_dev;
105
109
 
106
 
        flexcop_ibi_value v = fc->read_ibi_reg(fc,sram_dest_reg_714);
107
 
 
108
 
        flexcop_dump_reg(fc_pci->fc_dev,dma1_000,4);
109
 
 
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");
 
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
        }
118
137
 
119
138
        schedule_delayed_work(&fc_pci->irq_check_work,
120
139
                        msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv));
131
150
        flexcop_ibi_value v;
132
151
        irqreturn_t ret = IRQ_HANDLED;
133
152
 
134
 
        spin_lock_irqsave(&fc_pci->irq_lock,flags);
135
 
 
136
 
        v = fc->read_ibi_reg(fc,irq_20c);
137
 
 
138
 
   /* errors */
 
153
        spin_lock_irqsave(&fc_pci->irq_lock, flags);
 
154
        v = fc->read_ibi_reg(fc, irq_20c);
 
155
 
 
156
        /* errors */
139
157
        if (v.irq_20c.Data_receiver_error)
140
158
                deb_chk("data receiver error\n");
141
159
        if (v.irq_20c.Continuity_error_flag)
146
164
                deb_chk("Transport error\n");
147
165
 
148
166
        if ((fc_pci->count % 1000) == 0)
149
 
                deb_chk("%d valid irq took place so far\n",fc_pci->count);
 
167
                deb_chk("%d valid irq took place so far\n", fc_pci->count);
150
168
 
151
169
        if (v.irq_20c.DMA1_IRQ_Status == 1) {
152
170
                if (fc_pci->active_dma1_addr == 0)
153
 
                        flexcop_pass_dmx_packets(fc_pci->fc_dev,fc_pci->dma[0].cpu_addr0,fc_pci->dma[0].size / 188);
 
171
                        flexcop_pass_dmx_packets(fc_pci->fc_dev,
 
172
                                        fc_pci->dma[0].cpu_addr0,
 
173
                                        fc_pci->dma[0].size / 188);
154
174
                else
155
 
                        flexcop_pass_dmx_packets(fc_pci->fc_dev,fc_pci->dma[0].cpu_addr1,fc_pci->dma[0].size / 188);
 
175
                        flexcop_pass_dmx_packets(fc_pci->fc_dev,
 
176
                                        fc_pci->dma[0].cpu_addr1,
 
177
                                        fc_pci->dma[0].size / 188);
156
178
 
157
179
                deb_irq("page change to page: %d\n",!fc_pci->active_dma1_addr);
158
180
                fc_pci->active_dma1_addr = !fc_pci->active_dma1_addr;
159
 
        } else if (v.irq_20c.DMA1_Timer_Status == 1) {
160
181
                /* for the timer IRQ we only can use buffer dmx feeding, because we don't have
161
182
                 * complete TS packets when reading from the DMA memory */
 
183
        } else if (v.irq_20c.DMA1_Timer_Status == 1) {
162
184
                dma_addr_t cur_addr =
163
185
                        fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2;
164
186
                u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0;
165
187
 
166
 
                deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, last_cur_pos: %08x ",
 
188
                deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, "
 
189
                        "last_cur_pos: %08x ",
167
190
                                jiffies_to_usecs(jiffies - fc_pci->last_irq),
168
191
                                v.raw, (unsigned long long)cur_addr, cur_pos,
169
192
                                fc_pci->last_dma1_cur_pos);
173
196
                 * pass the data from last_cur_pos to the buffer end to the demux
174
197
                 */
175
198
                if (cur_pos < fc_pci->last_dma1_cur_pos) {
176
 
                        deb_irq(" end was reached: passing %d bytes ",(fc_pci->dma[0].size*2 - 1) - 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);
177
202
                        flexcop_pass_dmx_data(fc_pci->fc_dev,
178
 
                                        fc_pci->dma[0].cpu_addr0 + fc_pci->last_dma1_cur_pos,
179
 
                                        (fc_pci->dma[0].size*2) - 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);
180
207
                        fc_pci->last_dma1_cur_pos = 0;
181
208
                }
182
209
 
183
210
                if (cur_pos > fc_pci->last_dma1_cur_pos) {
184
 
                        deb_irq(" passing %d bytes ",cur_pos - fc_pci->last_dma1_cur_pos);
 
211
                        deb_irq(" passing %d bytes ",
 
212
                                cur_pos - fc_pci->last_dma1_cur_pos);
185
213
                        flexcop_pass_dmx_data(fc_pci->fc_dev,
186
 
                                        fc_pci->dma[0].cpu_addr0 + fc_pci->last_dma1_cur_pos,
187
 
                                        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);
188
217
                }
189
218
                deb_irq("\n");
190
219
 
191
220
                fc_pci->last_dma1_cur_pos = cur_pos;
192
221
                fc_pci->count++;
193
222
        } else {
194
 
                deb_irq("isr for flexcop called, apparently without reason (%08x)\n",v.raw);
 
223
                deb_irq("isr for flexcop called, "
 
224
                        "apparently without reason (%08x)\n", v.raw);
195
225
                ret = IRQ_NONE;
196
226
        }
197
227
 
198
 
        spin_unlock_irqrestore(&fc_pci->irq_lock,flags);
199
 
 
 
228
        spin_unlock_irqrestore(&fc_pci->irq_lock, flags);
200
229
        return ret;
201
230
}
202
231
 
204
233
{
205
234
        struct flexcop_pci *fc_pci = fc->bus_specific;
206
235
        if (onoff) {
207
 
                flexcop_dma_config(fc,&fc_pci->dma[0],FC_DMA_1);
208
 
                flexcop_dma_config(fc,&fc_pci->dma[1],FC_DMA_2);
209
 
 
210
 
                flexcop_dma_config_timer(fc,FC_DMA_1,0);
211
 
 
212
 
                flexcop_dma_xfer_control(fc,FC_DMA_1,FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1,1);
 
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);
213
241
                deb_irq("DMA xfer enabled\n");
214
242
 
215
243
                fc_pci->last_dma1_cur_pos = 0;
216
 
                flexcop_dma_control_timer_irq(fc,FC_DMA_1,1);
 
244
                flexcop_dma_control_timer_irq(fc, FC_DMA_1, 1);
217
245
                deb_irq("IRQ enabled\n");
218
 
 
219
 
//              fc_pci->active_dma1_addr = 0;
220
 
//              flexcop_dma_control_size_irq(fc,FC_DMA_1,1);
221
 
 
222
 
                if (irq_chk_intv > 0)
223
 
                        schedule_delayed_work(&fc_pci->irq_check_work,
224
 
                                        msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv));
 
246
                fc_pci->count_prev = fc_pci->count;
225
247
        } else {
226
 
                if (irq_chk_intv > 0)
227
 
                        cancel_delayed_work(&fc_pci->irq_check_work);
228
 
 
229
 
                flexcop_dma_control_timer_irq(fc,FC_DMA_1,0);
 
248
                flexcop_dma_control_timer_irq(fc, FC_DMA_1, 0);
230
249
                deb_irq("IRQ disabled\n");
231
250
 
232
 
//              flexcop_dma_control_size_irq(fc,FC_DMA_1,0);
233
 
 
234
 
                flexcop_dma_xfer_control(fc,FC_DMA_1,FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1,0);
 
251
                flexcop_dma_xfer_control(fc, FC_DMA_1,
 
252
                         FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1, 0);
235
253
                deb_irq("DMA xfer disabled\n");
236
254
        }
237
 
 
238
255
        return 0;
239
256
}
240
257
 
241
258
static int flexcop_pci_dma_init(struct flexcop_pci *fc_pci)
242
259
{
243
260
        int ret;
244
 
        if ((ret = flexcop_dma_allocate(fc_pci->pdev,&fc_pci->dma[0],FC_DEFAULT_DMA1_BUFSIZE)) != 0)
 
261
        ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[0],
 
262
                        FC_DEFAULT_DMA1_BUFSIZE);
 
263
        if (ret != 0)
245
264
                return ret;
246
265
 
247
 
        if ((ret = flexcop_dma_allocate(fc_pci->pdev,&fc_pci->dma[1],FC_DEFAULT_DMA2_BUFSIZE)) != 0) {
 
266
        ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[1],
 
267
                        FC_DEFAULT_DMA2_BUFSIZE);
 
268
        if (ret != 0) {
248
269
                flexcop_dma_free(&fc_pci->dma[0]);
249
270
                return ret;
250
271
        }
251
272
 
252
 
        flexcop_sram_set_dest(fc_pci->fc_dev,FC_SRAM_DEST_MEDIA | FC_SRAM_DEST_NET, FC_SRAM_DEST_TARGET_DMA1);
253
 
        flexcop_sram_set_dest(fc_pci->fc_dev,FC_SRAM_DEST_CAO   | FC_SRAM_DEST_CAI, FC_SRAM_DEST_TARGET_DMA2);
254
 
 
 
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);
255
277
        fc_pci->init_state |= FC_PCI_DMA_INIT;
256
 
 
257
278
        return ret;
258
279
}
259
280
 
276
297
 
277
298
        if ((ret = pci_enable_device(fc_pci->pdev)) != 0)
278
299
                return ret;
279
 
 
280
300
        pci_set_master(fc_pci->pdev);
281
301
 
282
 
        /* enable interrupts */
283
 
        // pci_write_config_dword(pdev, 0x6c, 0x8000);
284
 
 
285
302
        if ((ret = pci_request_regions(fc_pci->pdev, DRIVER_NAME)) != 0)
286
303
                goto err_pci_disable_device;
287
304
 
299
316
                                        IRQF_SHARED, DRIVER_NAME, fc_pci)) != 0)
300
317
                goto err_pci_iounmap;
301
318
 
302
 
 
303
 
 
304
319
        fc_pci->init_state |= FC_PCI_INIT;
305
320
        return ret;
306
321
 
326
341
        fc_pci->init_state &= ~FC_PCI_INIT;
327
342
}
328
343
 
329
 
 
330
 
static int flexcop_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
344
static int flexcop_pci_probe(struct pci_dev *pdev,
 
345
                const struct pci_device_id *ent)
331
346
{
332
347
        struct flexcop_device *fc;
333
348
        struct flexcop_pci *fc_pci;
338
353
                return -ENOMEM;
339
354
        }
340
355
 
341
 
/* general flexcop init */
 
356
        /* general flexcop init */
342
357
        fc_pci = fc->bus_specific;
343
358
        fc_pci->fc_dev = fc;
344
359
 
346
361
        fc->write_ibi_reg = flexcop_pci_write_ibi_reg;
347
362
        fc->i2c_request = flexcop_i2c_request;
348
363
        fc->get_mac_addr = flexcop_eeprom_check_mac_addr;
349
 
 
350
364
        fc->stream_control = flexcop_pci_stream_control;
351
365
 
352
366
        if (enable_pid_filtering)
356
370
 
357
371
        fc->pid_filtering = enable_pid_filtering;
358
372
        fc->bus_type = FC_PCI;
359
 
 
360
373
        fc->dev = &pdev->dev;
361
374
        fc->owner = THIS_MODULE;
362
375
 
363
 
/* bus specific part */
 
376
        /* bus specific part */
364
377
        fc_pci->pdev = pdev;
365
378
        if ((ret = flexcop_pci_init(fc_pci)) != 0)
366
379
                goto err_kfree;
367
380
 
368
 
/* init flexcop */
 
381
        /* init flexcop */
369
382
        if ((ret = flexcop_device_initialize(fc)) != 0)
370
383
                goto err_pci_exit;
371
384
 
372
 
/* init dma */
 
385
        /* init dma */
373
386
        if ((ret = flexcop_pci_dma_init(fc_pci)) != 0)
374
387
                goto err_fc_exit;
375
388
 
376
389
        INIT_DELAYED_WORK(&fc_pci->irq_check_work, flexcop_pci_irq_check_work);
377
390
 
 
391
        if (irq_chk_intv > 0)
 
392
                schedule_delayed_work(&fc_pci->irq_check_work,
 
393
                                msecs_to_jiffies(irq_chk_intv < 100 ?
 
394
                                        100 :
 
395
                                        irq_chk_intv));
378
396
        return ret;
379
397
 
380
398
err_fc_exit:
393
411
{
394
412
        struct flexcop_pci *fc_pci = pci_get_drvdata(pdev);
395
413
 
 
414
        if (irq_chk_intv > 0)
 
415
                cancel_delayed_work(&fc_pci->irq_check_work);
 
416
 
396
417
        flexcop_pci_dma_exit(fc_pci);
397
418
        flexcop_device_exit(fc_pci->fc_dev);
398
419
        flexcop_pci_exit(fc_pci);
401
422
 
402
423
static struct pci_device_id flexcop_pci_tbl[] = {
403
424
        { PCI_DEVICE(0x13d0, 0x2103) },
404
 
/*      { PCI_DEVICE(0x13d0, 0x2200) }, ? */
405
425
        { },
406
426
};
407
427