]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - sound/pci/lola/lola.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Support for Digigram Lola PCI-e boards
5 * Copyright (c) 2011 Takashi Iwai <tiwai@suse.de>
8 #include <linux/kernel.h>
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/delay.h>
13 #include <linux/interrupt.h>
14 #include <linux/slab.h>
15 #include <linux/pci.h>
16 #include <sound/core.h>
17 #include <sound/control.h>
18 #include <sound/pcm.h>
19 #include <sound/initval.h>
22 /* Standard options */
23 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
24 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
25 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
27 module_param_array(index
, int, NULL
, 0444);
28 MODULE_PARM_DESC(index
, "Index value for Digigram Lola driver.");
29 module_param_array(id
, charp
, NULL
, 0444);
30 MODULE_PARM_DESC(id
, "ID string for Digigram Lola driver.");
31 module_param_array(enable
, bool, NULL
, 0444);
32 MODULE_PARM_DESC(enable
, "Enable Digigram Lola driver.");
34 /* Lola-specific options */
36 /* for instance use always max granularity which is compatible
37 * with all sample rates
39 static int granularity
[SNDRV_CARDS
] = {
40 [0 ... (SNDRV_CARDS
- 1)] = LOLA_GRANULARITY_MAX
43 /* below a sample_rate of 16kHz the analogue audio quality is NOT excellent */
44 static int sample_rate_min
[SNDRV_CARDS
] = {
45 [0 ... (SNDRV_CARDS
- 1) ] = 16000
48 module_param_array(granularity
, int, NULL
, 0444);
49 MODULE_PARM_DESC(granularity
, "Granularity value");
50 module_param_array(sample_rate_min
, int, NULL
, 0444);
51 MODULE_PARM_DESC(sample_rate_min
, "Minimal sample rate");
56 MODULE_LICENSE("GPL");
57 MODULE_SUPPORTED_DEVICE("{{Digigram, Lola}}");
58 MODULE_DESCRIPTION("Digigram Lola driver");
59 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
61 #ifdef CONFIG_SND_DEBUG_VERBOSE
63 module_param(debug
, int, 0644);
64 #define verbose_debug(fmt, args...) \
65 do { if (debug > 1) pr_debug(SFX fmt, ##args); } while (0)
67 #define verbose_debug(fmt, args...)
71 * pseudo-codec read/write via CORB/RIRB
74 static int corb_send_verb(struct lola
*chip
, unsigned int nid
,
75 unsigned int verb
, unsigned int data
,
81 chip
->last_cmd_nid
= nid
;
82 chip
->last_verb
= verb
;
83 chip
->last_data
= data
;
84 chip
->last_extdata
= extdata
;
85 data
|= (nid
<< 20) | (verb
<< 8);
87 spin_lock_irqsave(&chip
->reg_lock
, flags
);
88 if (chip
->rirb
.cmds
< LOLA_CORB_ENTRIES
- 1) {
89 unsigned int wp
= chip
->corb
.wp
+ 1;
90 wp
%= LOLA_CORB_ENTRIES
;
92 chip
->corb
.buf
[wp
* 2] = cpu_to_le32(data
);
93 chip
->corb
.buf
[wp
* 2 + 1] = cpu_to_le32(extdata
);
94 lola_writew(chip
, BAR0
, CORBWP
, wp
);
99 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
103 static void lola_queue_unsol_event(struct lola
*chip
, unsigned int res
,
106 lola_update_ext_clock_freq(chip
, res
);
109 /* retrieve RIRB entry - called from interrupt handler */
110 static void lola_update_rirb(struct lola
*chip
)
115 wp
= lola_readw(chip
, BAR0
, RIRBWP
);
116 if (wp
== chip
->rirb
.wp
)
120 while (chip
->rirb
.rp
!= wp
) {
122 chip
->rirb
.rp
%= LOLA_CORB_ENTRIES
;
124 rp
= chip
->rirb
.rp
<< 1; /* an RIRB entry is 8-bytes */
125 res_ex
= le32_to_cpu(chip
->rirb
.buf
[rp
+ 1]);
126 res
= le32_to_cpu(chip
->rirb
.buf
[rp
]);
127 if (res_ex
& LOLA_RIRB_EX_UNSOL_EV
)
128 lola_queue_unsol_event(chip
, res
, res_ex
);
129 else if (chip
->rirb
.cmds
) {
131 chip
->res_ex
= res_ex
;
138 static int rirb_get_response(struct lola
*chip
, unsigned int *val
,
139 unsigned int *extval
)
141 unsigned long timeout
;
144 timeout
= jiffies
+ msecs_to_jiffies(1000);
146 if (chip
->polling_mode
) {
147 spin_lock_irq(&chip
->reg_lock
);
148 lola_update_rirb(chip
);
149 spin_unlock_irq(&chip
->reg_lock
);
151 if (!chip
->rirb
.cmds
) {
154 *extval
= chip
->res_ex
;
155 verbose_debug("get_response: %x, %x\n",
156 chip
->res
, chip
->res_ex
);
157 if (chip
->res_ex
& LOLA_RIRB_EX_ERROR
) {
158 dev_warn(chip
->card
->dev
, "RIRB ERROR: "
159 "NID=%x, verb=%x, data=%x, ext=%x\n",
161 chip
->last_verb
, chip
->last_data
,
167 if (time_after(jiffies
, timeout
))
172 dev_warn(chip
->card
->dev
, "RIRB response error\n");
173 if (!chip
->polling_mode
) {
174 dev_warn(chip
->card
->dev
, "switching to polling mode\n");
175 chip
->polling_mode
= 1;
181 /* aynchronous write of a codec verb with data */
182 int lola_codec_write(struct lola
*chip
, unsigned int nid
, unsigned int verb
,
183 unsigned int data
, unsigned int extdata
)
185 verbose_debug("codec_write NID=%x, verb=%x, data=%x, ext=%x\n",
186 nid
, verb
, data
, extdata
);
187 return corb_send_verb(chip
, nid
, verb
, data
, extdata
);
190 /* write a codec verb with data and read the returned status */
191 int lola_codec_read(struct lola
*chip
, unsigned int nid
, unsigned int verb
,
192 unsigned int data
, unsigned int extdata
,
193 unsigned int *val
, unsigned int *extval
)
197 verbose_debug("codec_read NID=%x, verb=%x, data=%x, ext=%x\n",
198 nid
, verb
, data
, extdata
);
199 err
= corb_send_verb(chip
, nid
, verb
, data
, extdata
);
202 err
= rirb_get_response(chip
, val
, extval
);
206 /* flush all pending codec writes */
207 int lola_codec_flush(struct lola
*chip
)
210 return rirb_get_response(chip
, &tmp
, NULL
);
216 static irqreturn_t
lola_interrupt(int irq
, void *dev_id
)
218 struct lola
*chip
= dev_id
;
219 unsigned int notify_ins
, notify_outs
, error_ins
, error_outs
;
223 notify_ins
= notify_outs
= error_ins
= error_outs
= 0;
224 spin_lock(&chip
->reg_lock
);
226 unsigned int status
, in_sts
, out_sts
;
229 status
= lola_readl(chip
, BAR1
, DINTSTS
);
230 if (!status
|| status
== -1)
233 in_sts
= lola_readl(chip
, BAR1
, DIINTSTS
);
234 out_sts
= lola_readl(chip
, BAR1
, DOINTSTS
);
236 /* clear Input Interrupts */
237 for (i
= 0; in_sts
&& i
< chip
->pcm
[CAPT
].num_streams
; i
++) {
238 if (!(in_sts
& (1 << i
)))
241 reg
= lola_dsd_read(chip
, i
, STS
);
242 if (reg
& LOLA_DSD_STS_DESE
) /* error */
243 error_ins
|= (1 << i
);
244 if (reg
& LOLA_DSD_STS_BCIS
) /* notify */
245 notify_ins
|= (1 << i
);
247 lola_dsd_write(chip
, i
, STS
, reg
);
250 /* clear Output Interrupts */
251 for (i
= 0; out_sts
&& i
< chip
->pcm
[PLAY
].num_streams
; i
++) {
252 if (!(out_sts
& (1 << i
)))
254 out_sts
&= ~(1 << i
);
255 reg
= lola_dsd_read(chip
, i
+ MAX_STREAM_IN_COUNT
, STS
);
256 if (reg
& LOLA_DSD_STS_DESE
) /* error */
257 error_outs
|= (1 << i
);
258 if (reg
& LOLA_DSD_STS_BCIS
) /* notify */
259 notify_outs
|= (1 << i
);
260 lola_dsd_write(chip
, i
+ MAX_STREAM_IN_COUNT
, STS
, reg
);
263 if (status
& LOLA_DINT_CTRL
) {
264 unsigned char rbsts
; /* ring status is byte access */
265 rbsts
= lola_readb(chip
, BAR0
, RIRBSTS
);
266 rbsts
&= LOLA_RIRB_INT_MASK
;
268 lola_writeb(chip
, BAR0
, RIRBSTS
, rbsts
);
269 rbsts
= lola_readb(chip
, BAR0
, CORBSTS
);
270 rbsts
&= LOLA_CORB_INT_MASK
;
272 lola_writeb(chip
, BAR0
, CORBSTS
, rbsts
);
274 lola_update_rirb(chip
);
277 if (status
& (LOLA_DINT_FIFOERR
| LOLA_DINT_MUERR
)) {
278 /* clear global fifo error interrupt */
279 lola_writel(chip
, BAR1
, DINTSTS
,
280 (status
& (LOLA_DINT_FIFOERR
| LOLA_DINT_MUERR
)));
284 spin_unlock(&chip
->reg_lock
);
286 lola_pcm_update(chip
, &chip
->pcm
[CAPT
], notify_ins
);
287 lola_pcm_update(chip
, &chip
->pcm
[PLAY
], notify_outs
);
289 return IRQ_RETVAL(handled
);
296 static int reset_controller(struct lola
*chip
)
298 unsigned int gctl
= lola_readl(chip
, BAR0
, GCTL
);
299 unsigned long end_time
;
303 lola_writel(chip
, BAR1
, BOARD_MODE
, 0);
307 chip
->cold_reset
= 1;
308 lola_writel(chip
, BAR0
, GCTL
, LOLA_GCTL_RESET
);
309 end_time
= jiffies
+ msecs_to_jiffies(200);
312 gctl
= lola_readl(chip
, BAR0
, GCTL
);
315 } while (time_before(jiffies
, end_time
));
317 dev_err(chip
->card
->dev
, "cannot reset controller\n");
323 static void lola_irq_enable(struct lola
*chip
)
327 /* enalbe all I/O streams */
328 val
= (1 << chip
->pcm
[PLAY
].num_streams
) - 1;
329 lola_writel(chip
, BAR1
, DOINTCTL
, val
);
330 val
= (1 << chip
->pcm
[CAPT
].num_streams
) - 1;
331 lola_writel(chip
, BAR1
, DIINTCTL
, val
);
333 /* enable global irqs */
334 val
= LOLA_DINT_GLOBAL
| LOLA_DINT_CTRL
| LOLA_DINT_FIFOERR
|
336 lola_writel(chip
, BAR1
, DINTCTL
, val
);
339 static void lola_irq_disable(struct lola
*chip
)
341 lola_writel(chip
, BAR1
, DINTCTL
, 0);
342 lola_writel(chip
, BAR1
, DIINTCTL
, 0);
343 lola_writel(chip
, BAR1
, DOINTCTL
, 0);
346 static int setup_corb_rirb(struct lola
*chip
)
350 unsigned long end_time
;
352 err
= snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
,
353 snd_dma_pci_data(chip
->pci
),
354 PAGE_SIZE
, &chip
->rb
);
358 chip
->corb
.addr
= chip
->rb
.addr
;
359 chip
->corb
.buf
= (__le32
*)chip
->rb
.area
;
360 chip
->rirb
.addr
= chip
->rb
.addr
+ 2048;
361 chip
->rirb
.buf
= (__le32
*)(chip
->rb
.area
+ 2048);
363 /* disable ringbuffer DMAs */
364 lola_writeb(chip
, BAR0
, RIRBCTL
, 0);
365 lola_writeb(chip
, BAR0
, CORBCTL
, 0);
367 end_time
= jiffies
+ msecs_to_jiffies(200);
369 if (!lola_readb(chip
, BAR0
, RIRBCTL
) &&
370 !lola_readb(chip
, BAR0
, CORBCTL
))
373 } while (time_before(jiffies
, end_time
));
376 lola_writel(chip
, BAR0
, CORBLBASE
, (u32
)chip
->corb
.addr
);
377 lola_writel(chip
, BAR0
, CORBUBASE
, upper_32_bits(chip
->corb
.addr
));
378 /* set the corb size to 256 entries */
379 lola_writeb(chip
, BAR0
, CORBSIZE
, 0x02);
380 /* set the corb write pointer to 0 */
381 lola_writew(chip
, BAR0
, CORBWP
, 0);
382 /* reset the corb hw read pointer */
383 lola_writew(chip
, BAR0
, CORBRP
, LOLA_RBRWP_CLR
);
384 /* enable corb dma */
385 lola_writeb(chip
, BAR0
, CORBCTL
, LOLA_RBCTL_DMA_EN
);
386 /* clear flags if set */
387 tmp
= lola_readb(chip
, BAR0
, CORBSTS
) & LOLA_CORB_INT_MASK
;
389 lola_writeb(chip
, BAR0
, CORBSTS
, tmp
);
393 lola_writel(chip
, BAR0
, RIRBLBASE
, (u32
)chip
->rirb
.addr
);
394 lola_writel(chip
, BAR0
, RIRBUBASE
, upper_32_bits(chip
->rirb
.addr
));
395 /* set the rirb size to 256 entries */
396 lola_writeb(chip
, BAR0
, RIRBSIZE
, 0x02);
397 /* reset the rirb hw write pointer */
398 lola_writew(chip
, BAR0
, RIRBWP
, LOLA_RBRWP_CLR
);
399 /* set N=1, get RIRB response interrupt for new entry */
400 lola_writew(chip
, BAR0
, RINTCNT
, 1);
401 /* enable rirb dma and response irq */
402 lola_writeb(chip
, BAR0
, RIRBCTL
, LOLA_RBCTL_DMA_EN
| LOLA_RBCTL_IRQ_EN
);
403 /* clear flags if set */
404 tmp
= lola_readb(chip
, BAR0
, RIRBSTS
) & LOLA_RIRB_INT_MASK
;
406 lola_writeb(chip
, BAR0
, RIRBSTS
, tmp
);
407 chip
->rirb
.rp
= chip
->rirb
.cmds
= 0;
412 static void stop_corb_rirb(struct lola
*chip
)
414 /* disable ringbuffer DMAs */
415 lola_writeb(chip
, BAR0
, RIRBCTL
, 0);
416 lola_writeb(chip
, BAR0
, CORBCTL
, 0);
419 static void lola_reset_setups(struct lola
*chip
)
421 /* update the granularity */
422 lola_set_granularity(chip
, chip
->granularity
, true);
423 /* update the sample clock */
424 lola_set_clock_index(chip
, chip
->clock
.cur_index
);
425 /* enable unsolicited events of the clock widget */
426 lola_enable_clock_events(chip
);
427 /* update the analog gains */
428 lola_setup_all_analog_gains(chip
, CAPT
, false); /* input, update */
429 /* update SRC configuration if applicable */
430 lola_set_src_config(chip
, chip
->input_src_mask
, false);
431 /* update the analog outputs */
432 lola_setup_all_analog_gains(chip
, PLAY
, false); /* output, update */
435 static int lola_parse_tree(struct lola
*chip
)
440 err
= lola_read_param(chip
, 0, LOLA_PAR_VENDOR_ID
, &val
);
442 dev_err(chip
->card
->dev
, "Can't read VENDOR_ID\n");
447 dev_err(chip
->card
->dev
, "Unknown codec vendor 0x%x\n", val
);
451 err
= lola_read_param(chip
, 1, LOLA_PAR_FUNCTION_TYPE
, &val
);
453 dev_err(chip
->card
->dev
, "Can't read FUNCTION_TYPE\n");
457 dev_err(chip
->card
->dev
, "Unknown function type %d\n", val
);
461 err
= lola_read_param(chip
, 1, LOLA_PAR_SPECIFIC_CAPS
, &val
);
463 dev_err(chip
->card
->dev
, "Can't read SPECCAPS\n");
466 chip
->lola_caps
= val
;
467 chip
->pin
[CAPT
].num_pins
= LOLA_AFG_INPUT_PIN_COUNT(chip
->lola_caps
);
468 chip
->pin
[PLAY
].num_pins
= LOLA_AFG_OUTPUT_PIN_COUNT(chip
->lola_caps
);
469 dev_dbg(chip
->card
->dev
, "speccaps=0x%x, pins in=%d, out=%d\n",
471 chip
->pin
[CAPT
].num_pins
, chip
->pin
[PLAY
].num_pins
);
473 if (chip
->pin
[CAPT
].num_pins
> MAX_AUDIO_INOUT_COUNT
||
474 chip
->pin
[PLAY
].num_pins
> MAX_AUDIO_INOUT_COUNT
) {
475 dev_err(chip
->card
->dev
, "Invalid Lola-spec caps 0x%x\n", val
);
480 err
= lola_init_pcm(chip
, CAPT
, &nid
);
483 err
= lola_init_pcm(chip
, PLAY
, &nid
);
487 err
= lola_init_pins(chip
, CAPT
, &nid
);
490 err
= lola_init_pins(chip
, PLAY
, &nid
);
494 if (LOLA_AFG_CLOCK_WIDGET_PRESENT(chip
->lola_caps
)) {
495 err
= lola_init_clock_widget(chip
, nid
);
500 if (LOLA_AFG_MIXER_WIDGET_PRESENT(chip
->lola_caps
)) {
501 err
= lola_init_mixer_widget(chip
, nid
);
507 /* enable unsolicited events of the clock widget */
508 err
= lola_enable_clock_events(chip
);
512 /* if last ResetController was not a ColdReset, we don't know
513 * the state of the card; initialize here again
515 if (!chip
->cold_reset
) {
516 lola_reset_setups(chip
);
517 chip
->cold_reset
= 1;
519 /* set the granularity if it is not the default */
520 if (chip
->granularity
!= LOLA_GRANULARITY_MIN
)
521 lola_set_granularity(chip
, chip
->granularity
, true);
527 static void lola_stop_hw(struct lola
*chip
)
529 stop_corb_rirb(chip
);
530 lola_irq_disable(chip
);
533 static void lola_free(struct lola
*chip
)
535 if (chip
->initialized
)
538 lola_free_mixer(chip
);
540 free_irq(chip
->irq
, (void *)chip
);
541 iounmap(chip
->bar
[0].remap_addr
);
542 iounmap(chip
->bar
[1].remap_addr
);
544 snd_dma_free_pages(&chip
->rb
);
545 pci_release_regions(chip
->pci
);
546 pci_disable_device(chip
->pci
);
550 static int lola_dev_free(struct snd_device
*device
)
552 lola_free(device
->device_data
);
556 static int lola_create(struct snd_card
*card
, struct pci_dev
*pci
,
557 int dev
, struct lola
**rchip
)
562 static struct snd_device_ops ops
= {
563 .dev_free
= lola_dev_free
,
568 err
= pci_enable_device(pci
);
572 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
574 pci_disable_device(pci
);
578 spin_lock_init(&chip
->reg_lock
);
579 mutex_init(&chip
->open_mutex
);
584 chip
->granularity
= granularity
[dev
];
585 switch (chip
->granularity
) {
587 chip
->sample_rate_max
= 48000;
590 chip
->sample_rate_max
= 96000;
593 chip
->sample_rate_max
= 192000;
596 dev_warn(chip
->card
->dev
,
597 "Invalid granularity %d, reset to %d\n",
598 chip
->granularity
, LOLA_GRANULARITY_MAX
);
599 chip
->granularity
= LOLA_GRANULARITY_MAX
;
600 chip
->sample_rate_max
= 192000;
603 chip
->sample_rate_min
= sample_rate_min
[dev
];
604 if (chip
->sample_rate_min
> chip
->sample_rate_max
) {
605 dev_warn(chip
->card
->dev
,
606 "Invalid sample_rate_min %d, reset to 16000\n",
607 chip
->sample_rate_min
);
608 chip
->sample_rate_min
= 16000;
611 err
= pci_request_regions(pci
, DRVNAME
);
614 pci_disable_device(pci
);
618 chip
->bar
[0].addr
= pci_resource_start(pci
, 0);
619 chip
->bar
[0].remap_addr
= pci_ioremap_bar(pci
, 0);
620 chip
->bar
[1].addr
= pci_resource_start(pci
, 2);
621 chip
->bar
[1].remap_addr
= pci_ioremap_bar(pci
, 2);
622 if (!chip
->bar
[0].remap_addr
|| !chip
->bar
[1].remap_addr
) {
623 dev_err(chip
->card
->dev
, "ioremap error\n");
630 err
= reset_controller(chip
);
634 if (request_irq(pci
->irq
, lola_interrupt
, IRQF_SHARED
,
635 KBUILD_MODNAME
, chip
)) {
636 dev_err(chip
->card
->dev
, "unable to grab IRQ %d\n", pci
->irq
);
640 chip
->irq
= pci
->irq
;
641 synchronize_irq(chip
->irq
);
643 dever
= lola_readl(chip
, BAR1
, DEVER
);
644 chip
->pcm
[CAPT
].num_streams
= (dever
>> 0) & 0x3ff;
645 chip
->pcm
[PLAY
].num_streams
= (dever
>> 10) & 0x3ff;
646 chip
->version
= (dever
>> 24) & 0xff;
647 dev_dbg(chip
->card
->dev
, "streams in=%d, out=%d, version=0x%x\n",
648 chip
->pcm
[CAPT
].num_streams
, chip
->pcm
[PLAY
].num_streams
,
651 /* Test LOLA_BAR1_DEVER */
652 if (chip
->pcm
[CAPT
].num_streams
> MAX_STREAM_IN_COUNT
||
653 chip
->pcm
[PLAY
].num_streams
> MAX_STREAM_OUT_COUNT
||
654 (!chip
->pcm
[CAPT
].num_streams
&&
655 !chip
->pcm
[PLAY
].num_streams
)) {
656 dev_err(chip
->card
->dev
, "invalid DEVER = %x\n", dever
);
661 err
= setup_corb_rirb(chip
);
665 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
);
667 dev_err(chip
->card
->dev
, "Error creating device [card]!\n");
671 strcpy(card
->driver
, "Lola");
672 strlcpy(card
->shortname
, "Digigram Lola", sizeof(card
->shortname
));
673 snprintf(card
->longname
, sizeof(card
->longname
),
674 "%s at 0x%lx irq %i",
675 card
->shortname
, chip
->bar
[0].addr
, chip
->irq
);
676 strcpy(card
->mixername
, card
->shortname
);
678 lola_irq_enable(chip
);
680 chip
->initialized
= 1;
689 static int lola_probe(struct pci_dev
*pci
,
690 const struct pci_device_id
*pci_id
)
693 struct snd_card
*card
;
697 if (dev
>= SNDRV_CARDS
)
704 err
= snd_card_new(&pci
->dev
, index
[dev
], id
[dev
], THIS_MODULE
,
707 dev_err(&pci
->dev
, "Error creating card!\n");
711 err
= lola_create(card
, pci
, dev
, &chip
);
714 card
->private_data
= chip
;
716 err
= lola_parse_tree(chip
);
720 err
= lola_create_pcm(chip
);
724 err
= lola_create_mixer(chip
);
728 lola_proc_debug_new(chip
);
730 err
= snd_card_register(card
);
734 pci_set_drvdata(pci
, card
);
742 static void lola_remove(struct pci_dev
*pci
)
744 snd_card_free(pci_get_drvdata(pci
));
748 static const struct pci_device_id lola_ids
[] = {
749 { PCI_VDEVICE(DIGIGRAM
, 0x0001) },
752 MODULE_DEVICE_TABLE(pci
, lola_ids
);
754 /* pci_driver definition */
755 static struct pci_driver lola_driver
= {
756 .name
= KBUILD_MODNAME
,
757 .id_table
= lola_ids
,
759 .remove
= lola_remove
,
762 module_pci_driver(lola_driver
);