Lines Matching +full:irq +full:- +full:status +full:- +full:read +full:- +full:quirk
1 // SPDX-License-Identifier: GPL-2.0-or-later
12 * - Fixed deadlock on capture
13 * - Added Canyon3D-2 support by Rob Riggs <rob@pangalactic.org>
16 #define CARD_NAME "ESS Maestro3/Allegro/Canyon3D-2"
24 #include <linux/dma-mapping.h>
45 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
48 static bool external_amp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
49 static int amp_gpio[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -1};
60 MODULE_PARM_DESC(amp_gpio, "GPIO pin number for external amp. (default = -1)");
365 #define REV_A_CODE_MEMORY_LENGTH (REV_A_CODE_MEMORY_END - REV_A_CODE_MEMORY_BEGIN + 1)
370 #define REV_B_CODE_MEMORY_LENGTH (REV_B_CODE_MEMORY_END - REV_B_CODE_MEMORY_BEGIN + 1)
375 #define REV_A_DATA_MEMORY_LENGTH (REV_A_DATA_MEMORY_END - REV_A_DATA_MEMORY_BEGIN + 1)
380 #define REV_B_DATA_MEMORY_LENGTH (REV_B_DATA_MEMORY_END - REV_B_DATA_MEMORY_BEGIN + 1)
594 #define MAX_INSTANCE_MINISRC (KDATA_INSTANCE_MINISRC_ENDMARK - KDATA_INSTANCE0_MINISRC)
595 #define MAX_VIRTUAL_DMA_CHANNELS (KDATA_DMA_XFER_ENDMARK - KDATA_DMA_XFER0)
596 #define MAX_VIRTUAL_MIXER_CHANNELS (KDATA_MIXER_XFER_ENDMARK - KDATA_MIXER_XFER0)
597 #define MAX_VIRTUAL_ADC1_CHANNELS (KDATA_ADC1_XFER_ENDMARK - KDATA_ADC1_XFER0)
725 int irq;
746 int amp_gpio; /* gpio pin # for external amp, -1 = default */
747 unsigned int hv_config; /* hardware-volume config bits */
805 SND_PCI_QUIRK(0x10f7, 0x833e, "Panasonic CF-28", 0x0d),
806 SND_PCI_QUIRK(0x10f7, 0x833d, "Panasonic CF-72", 0x0d),
910 outw(value, chip->iobase + reg);
915 return inw(chip->iobase + reg);
920 outb(value, chip->iobase + reg);
925 return inb(chip->iobase + reg);
948 chip->reset_state = snd_m3_inb(chip, DSP_PORT_CONTROL_REG_B) & ~REGB_STOP_CLOCK;
950 snd_m3_outb(chip, chip->reset_state & ~REGB_ENABLE_RESET, DSP_PORT_CONTROL_REG_B);
955 snd_m3_outb(chip, chip->reset_state | REGB_ENABLE_RESET, DSP_PORT_CONTROL_REG_B);
970 list->mem_addr + list->curlen,
972 return list->curlen++;
978 int lastindex = list->curlen - 1;
982 list->mem_addr + lastindex);
984 list->mem_addr + index,
989 list->mem_addr + lastindex,
992 list->curlen--;
997 chip->timer_users++;
998 if (chip->timer_users != 1)
1016 chip->timer_users--;
1017 if (chip->timer_users > 0)
1042 return -EINVAL;
1045 switch (subs->stream) {
1047 chip->dacs_active++;
1049 s->inst.data + CDATA_INSTANCE_READY, 1);
1052 chip->dacs_active);
1058 s->inst.data + CDATA_INSTANCE_READY, 1);
1069 return -EINVAL;
1072 s->inst.data + CDATA_INSTANCE_READY, 0);
1074 switch (subs->stream) {
1076 chip->dacs_active--;
1079 chip->dacs_active);
1093 struct m3_dma *s = subs->runtime->private_data;
1094 int err = -EINVAL;
1097 return -ENXIO;
1099 guard(spinlock)(&chip->reg_lock);
1103 if (s->running)
1104 err = -EBUSY;
1106 s->running = 1;
1112 if (! s->running)
1115 s->running = 0;
1130 struct snd_pcm_runtime *runtime = subs->runtime;
1132 if (subs->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1133 dsp_in_size = MINISRC_IN_BUFFER_SIZE - (0x20 * 2);
1134 dsp_out_size = MINISRC_OUT_BUFFER_SIZE - (0x20 * 2);
1136 dsp_in_size = MINISRC_IN_BUFFER_SIZE - (0x10 * 2);
1137 dsp_out_size = MINISRC_OUT_BUFFER_SIZE - (0x10 * 2);
1139 dsp_in_buffer = s->inst.data + (MINISRC_TMP_BUFFER_SIZE / 2);
1142 s->dma_size = frames_to_bytes(runtime, runtime->buffer_size);
1143 s->period_size = frames_to_bytes(runtime, runtime->period_size);
1144 s->hwptr = 0;
1145 s->count = 0;
1152 s->inst.data + CDATA_HOST_SRC_ADDRL,
1153 LO(s->buffer_addr));
1156 s->inst.data + CDATA_HOST_SRC_ADDRH,
1157 HI(s->buffer_addr));
1160 s->inst.data + CDATA_HOST_SRC_END_PLUS_1L,
1161 LO(s->buffer_addr + s->dma_size));
1164 s->inst.data + CDATA_HOST_SRC_END_PLUS_1H,
1165 HI(s->buffer_addr + s->dma_size));
1168 s->inst.data + CDATA_HOST_SRC_CURRENTL,
1169 LO(s->buffer_addr));
1172 s->inst.data + CDATA_HOST_SRC_CURRENTH,
1173 HI(s->buffer_addr));
1180 s->inst.data + CDATA_IN_BUF_BEGIN,
1184 s->inst.data + CDATA_IN_BUF_END_PLUS_1,
1188 s->inst.data + CDATA_IN_BUF_HEAD,
1192 s->inst.data + CDATA_IN_BUF_TAIL,
1196 s->inst.data + CDATA_OUT_BUF_BEGIN,
1200 s->inst.data + CDATA_OUT_BUF_END_PLUS_1,
1204 s->inst.data + CDATA_OUT_BUF_HEAD,
1208 s->inst.data + CDATA_OUT_BUF_TAIL,
1220 if (! s->in_lists) {
1221 s->index[0] = snd_m3_add_list(chip, s->index_list[0],
1222 s->inst.data >> DP_SHIFT_COUNT);
1223 s->index[1] = snd_m3_add_list(chip, s->index_list[1],
1224 s->inst.data >> DP_SHIFT_COUNT);
1225 s->index[2] = snd_m3_add_list(chip, s->index_list[2],
1226 s->inst.data >> DP_SHIFT_COUNT);
1227 s->in_lists = 1;
1232 s->inst.data + SRC3_DIRECTION_OFFSET + 1,
1233 runtime->channels == 2 ? 0 : 1);
1236 s->inst.data + SRC3_DIRECTION_OFFSET + 2,
1237 snd_pcm_format_width(runtime->format) == 16 ? 0 : 1);
1240 freq = DIV_ROUND_CLOSEST(runtime->rate << 15, 48000);
1242 freq--;
1245 s->inst.data + CDATA_FREQUENCY,
1271 {SRC3_DIRECTION_OFFSET + 18, MINISRC_BIQUAD_STAGE - 1}, /* numstage */
1289 s->inst.data + SRC3_DIRECTION_OFFSET + 12,
1290 s->inst.data + 40 + 8);
1293 s->inst.data + SRC3_DIRECTION_OFFSET + 19,
1294 s->inst.code + MINISRC_COEF_LOC);
1298 s->inst.data + SRC3_DIRECTION_OFFSET + 22,
1299 subs->runtime->rate > 45000 ? 0xff : 0);
1303 s->inst.data + CDATA_DMA_CONTROL,
1311 s->inst.data + pv[i].addr, pv[i].val);
1355 s->inst.data + SRC3_DIRECTION_OFFSET + 12,
1356 s->inst.data + 40 + 8);
1360 s->inst.data + CDATA_DMA_CONTROL,
1369 s->inst.data + rv[i].addr, rv[i].val);
1375 struct m3_dma *s = substream->runtime->private_data;
1378 s->buffer_addr = substream->runtime->dma_addr;
1379 if (s->buffer_addr & 0x3) {
1380 dev_err(substream->pcm->card->dev, "oh my, not aligned\n");
1381 s->buffer_addr = s->buffer_addr & ~0x3;
1390 if (substream->runtime->private_data == NULL)
1392 s = substream->runtime->private_data;
1393 s->buffer_addr = 0;
1401 struct snd_pcm_runtime *runtime = subs->runtime;
1402 struct m3_dma *s = runtime->private_data;
1405 return -ENXIO;
1407 if (runtime->format != SNDRV_PCM_FORMAT_U8 &&
1408 runtime->format != SNDRV_PCM_FORMAT_S16_LE)
1409 return -EINVAL;
1410 if (runtime->rate > 48000 ||
1411 runtime->rate < 8000)
1412 return -EINVAL;
1414 guard(spinlock_irq)(&chip->reg_lock);
1418 if (subs->stream == SNDRV_PCM_STREAM_PLAYBACK)
1441 while (retry--) {
1443 s->inst.data + CDATA_HOST_SRC_CURRENTH);
1446 s->inst.data + CDATA_HOST_SRC_CURRENTL);
1449 s->inst.data + CDATA_HOST_SRC_CURRENTH))
1453 return (unsigned int)(addr - s->buffer_addr);
1461 struct m3_dma *s = subs->runtime->private_data;
1466 guard(spinlock)(&chip->reg_lock);
1468 return bytes_to_frames(subs->runtime, ptr);
1476 struct snd_pcm_substream *subs = s->substream;
1480 if (! s->running)
1486 if (hwptr >= s->dma_size)
1487 hwptr %= s->dma_size;
1489 diff = s->dma_size + hwptr - s->hwptr;
1490 if (diff >= s->dma_size)
1491 diff %= s->dma_size;
1493 s->hwptr = hwptr;
1494 s->count += diff;
1496 if (s->count >= (signed)s->period_size) {
1498 if (s->count < 2 * (signed)s->period_size)
1499 s->count -= (signed)s->period_size;
1501 s->count %= s->period_size;
1503 spin_unlock(&chip->reg_lock);
1505 spin_lock(&chip->reg_lock);
1511 generating an interrupt. The pair of counters is stored in bits 1-3 and 5-7
1521 x = inb(chip->iobase + SHADOW_MIX_REG_VOICE) & 0xee;
1532 outb(0x88, chip->iobase + SHADOW_MIX_REG_VOICE);
1533 outb(0x88, chip->iobase + HW_VOL_COUNTER_VOICE);
1534 outb(0x88, chip->iobase + SHADOW_MIX_REG_MASTER);
1535 outb(0x88, chip->iobase + HW_VOL_COUNTER_MASTER);
1539 if (chip->in_suspend)
1543 if (!chip->master_switch || !chip->master_volume)
1546 val = snd_ac97_read(chip->ac97, AC97_MASTER);
1555 /* counters increased by 1 -> volume up */
1557 val--;
1559 val -= 0x0100;
1562 /* counters decreased by 1 -> volume down */
1569 if (snd_ac97_update(chip->ac97, AC97_MASTER, val))
1570 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1571 &chip->master_switch->id);
1573 if (!chip->input_dev)
1585 /* counters increased by 1 -> volume up */
1589 /* counters decreased by 1 -> volume down */
1595 input_report_key(chip->input_dev, val, 1);
1596 input_sync(chip->input_dev);
1597 input_report_key(chip->input_dev, val, 0);
1598 input_sync(chip->input_dev);
1603 static irqreturn_t snd_m3_interrupt(int irq, void *dev_id)
1606 u8 status;
1609 status = inb(chip->iobase + HOST_INT_STATUS);
1611 if (status == 0xff)
1614 if (status & HV_INT_PENDING)
1615 schedule_work(&chip->hwvol_work);
1621 if (status & ASSP_INT_PENDING) {
1622 u8 ctl = inb(chip->iobase + ASSP_CONTROL_B);
1624 ctl = inb(chip->iobase + ASSP_HOST_INT_STATUS);
1626 outb(DSP2HOST_REQ_TIMER, chip->iobase + ASSP_HOST_INT_STATUS);
1628 guard(spinlock)(&chip->reg_lock);
1629 for (i = 0; i < chip->num_substreams; i++) {
1630 struct m3_dma *s = &chip->substreams[i];
1631 if (s->running)
1639 if ((status & MPU401_INT_PENDING) && chip->rmidi)
1640 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1644 outb(status, chip->iobase + HOST_INT_STATUS);
1705 guard(spinlock_irq)(&chip->reg_lock);
1706 for (i = 0; i < chip->num_substreams; i++) {
1707 s = &chip->substreams[i];
1708 if (! s->opened)
1711 return -ENOMEM;
1713 s->opened = 1;
1714 s->running = 0;
1716 subs->runtime->private_data = s;
1717 s->substream = subs;
1720 if (subs->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1721 s->index_list[0] = &chip->mixer_list;
1723 s->index_list[0] = &chip->adc1_list;
1724 s->index_list[1] = &chip->msrc_list;
1725 s->index_list[2] = &chip->dma_list;
1733 struct m3_dma *s = subs->runtime->private_data;
1738 guard(spinlock_irq)(&chip->reg_lock);
1739 if (s->substream && s->running)
1740 snd_m3_pcm_stop(chip, s, s->substream); /* does this happen? */
1741 if (s->in_lists) {
1742 snd_m3_remove_list(chip, s->index_list[0], s->index[0]);
1743 snd_m3_remove_list(chip, s->index_list[1], s->index[1]);
1744 snd_m3_remove_list(chip, s->index_list[2], s->index[2]);
1745 s->in_lists = 0;
1747 s->running = 0;
1748 s->opened = 0;
1755 struct snd_pcm_runtime *runtime = subs->runtime;
1762 runtime->hw = snd_m3_playback;
1780 struct snd_pcm_runtime *runtime = subs->runtime;
1787 runtime->hw = snd_m3_capture;
1831 err = snd_pcm_new(chip->card, chip->card->driver, device,
1839 pcm->private_data = chip;
1840 pcm->info_flags = 0;
1841 strscpy(pcm->name, chip->card->driver);
1842 chip->pcm = pcm;
1845 &chip->pci->dev, 64*1024, 64*1024);
1867 } while (i-- > 0);
1869 dev_err(chip->card->dev, "ac97 serial bus busy\n");
1876 struct snd_m3 *chip = ac97->private_data;
1892 struct snd_m3 *chip = ac97->private_data;
1903 if (ac97->id == 0x45838308 && reg == AC97_MASTER) {
1913 int io = chip->iobase;
1920 if (chip->pci->subsystem_vendor == 0x1028 &&
1921 chip->pci->subsystem_device == 0x00e5)
1954 int io = chip->iobase;
1956 if (chip->allegro_flag) {
1972 if (!chip->irda_workaround)
1989 /* ok, bring back the ac-link */
2001 dev_dbg(chip->card->dev,
2007 /* more gung-ho reset that doesn't
2025 .read = snd_m3_ac97_read,
2028 err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus);
2034 err = snd_ac97_mixer(pbus, &ac97, &chip->ac97);
2039 snd_ac97_write(chip->ac97, AC97_PCM, 0x8000 | (15 << 8) | 15);
2041 snd_ac97_write(chip->ac97, AC97_PCM, 0);
2044 chip->master_switch = snd_ctl_find_id_mixer(chip->card,
2046 chip->master_volume = snd_ctl_find_id_mixer(chip->card,
2085 data = (const __le16 *)chip->assp_kernel_image->data;
2086 for (i = 0 ; i * 2 < chip->assp_kernel_image->size; i++) {
2098 data = (const __le16 *)chip->assp_minisrc_image->data;
2099 for (i = 0; i * 2 < chip->assp_minisrc_image->size; i++) {
2140 chip->mixer_list.curlen = 0;
2141 chip->mixer_list.mem_addr = KDATA_MIXER_XFER0;
2142 chip->mixer_list.max = MAX_VIRTUAL_MIXER_CHANNELS;
2143 chip->adc1_list.curlen = 0;
2144 chip->adc1_list.mem_addr = KDATA_ADC1_XFER0;
2145 chip->adc1_list.max = MAX_VIRTUAL_ADC1_CHANNELS;
2146 chip->dma_list.curlen = 0;
2147 chip->dma_list.mem_addr = KDATA_DMA_XFER0;
2148 chip->dma_list.max = MAX_VIRTUAL_DMA_CHANNELS;
2149 chip->msrc_list.curlen = 0;
2150 chip->msrc_list.mem_addr = KDATA_INSTANCE0_MINISRC;
2151 chip->msrc_list.max = MAX_INSTANCE_MINISRC;
2176 dev_err(chip->card->dev,
2179 return -ENOMEM;
2182 s->number = index;
2183 s->inst.code = 0x400;
2184 s->inst.data = address;
2186 for (i = data_bytes / 2; i > 0; address++, i--) {
2204 int io = chip->iobase;
2207 if (! chip->external_amp)
2211 polarity = polarity << chip->amp_gpio;
2212 gpo = 1 << chip->amp_gpio;
2228 unsigned long io = chip->iobase;
2231 if (!chip->is_omnibook)
2251 struct pci_dev *pcidev = chip->pci;
2252 unsigned long io = chip->iobase;
2265 n |= chip->hv_config;
2271 outb(RESET_ASSP, chip->iobase + ASSP_CONTROL_B);
2274 if (!chip->allegro_flag) {
2281 if (chip->allegro_flag) {
2287 t = inb(chip->iobase + ASSP_CONTROL_A);
2291 outb(t, chip->iobase + ASSP_CONTROL_A);
2294 outb(RUN_ASSP, chip->iobase + ASSP_CONTROL_B);
2308 unsigned long io = chip->iobase;
2313 if (chip->hv_config & HV_CTRL_ENABLE)
2315 outb(val, chip->iobase + HOST_INT_STATUS);
2327 struct snd_m3 *chip = card->private_data;
2331 cancel_work_sync(&chip->hwvol_work);
2333 if (chip->substreams) {
2334 guard(spinlock_irq)(&chip->reg_lock);
2335 for (i = 0; i < chip->num_substreams; i++) {
2336 s = &chip->substreams[i];
2338 if (s->substream && s->running)
2339 snd_m3_pcm_stop(chip, s, s->substream);
2342 if (chip->iobase) {
2343 outw(0, chip->iobase + HOST_INT_CTRL); /* disable ints */
2346 vfree(chip->suspend_mem);
2347 release_firmware(chip->assp_kernel_image);
2348 release_firmware(chip->assp_minisrc_image);
2358 struct snd_m3 *chip = card->private_data;
2361 if (chip->suspend_mem == NULL)
2364 chip->in_suspend = 1;
2365 cancel_work_sync(&chip->hwvol_work);
2367 snd_ac97_suspend(chip->ac97);
2376 chip->suspend_mem[dsp_index++] =
2379 chip->suspend_mem[dsp_index++] =
2387 struct snd_m3 *chip = card->private_data;
2390 if (chip->suspend_mem == NULL)
2405 chip->suspend_mem[dsp_index++]);
2408 chip->suspend_mem[dsp_index++]);
2415 snd_ac97_resume(chip->ac97);
2424 chip->in_suspend = 0;
2436 input_dev = devm_input_allocate_device(&chip->pci->dev);
2438 return -ENOMEM;
2440 snprintf(chip->phys, sizeof(chip->phys), "pci-%s/input0",
2441 pci_name(chip->pci));
2443 input_dev->name = chip->card->driver;
2444 input_dev->phys = chip->phys;
2445 input_dev->id.bustype = BUS_PCI;
2446 input_dev->id.vendor = chip->pci->vendor;
2447 input_dev->id.product = chip->pci->device;
2448 input_dev->dev.parent = &chip->pci->dev;
2450 __set_bit(EV_KEY, input_dev->evbit);
2451 __set_bit(KEY_MUTE, input_dev->keybit);
2452 __set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
2453 __set_bit(KEY_VOLUMEUP, input_dev->keybit);
2459 chip->input_dev = input_dev;
2472 struct snd_m3 *chip = card->private_data;
2474 const struct snd_pci_quirk *quirk;
2477 return -EIO;
2480 if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(28))) {
2481 dev_err(card->dev,
2483 return -ENXIO;
2486 spin_lock_init(&chip->reg_lock);
2488 switch (pci->device) {
2493 chip->allegro_flag = 1;
2497 chip->card = card;
2498 chip->pci = pci;
2499 chip->irq = -1;
2500 INIT_WORK(&chip->hwvol_work, snd_m3_update_hw_volume);
2501 card->private_free = snd_m3_free;
2503 chip->external_amp = enable_amp;
2505 chip->amp_gpio = amp_gpio;
2507 quirk = snd_pci_quirk_lookup(pci, m3_amp_quirk_list);
2508 if (quirk) {
2509 dev_info(card->dev, "set amp-gpio for '%s'\n",
2510 snd_pci_quirk_name(quirk));
2511 chip->amp_gpio = quirk->value;
2512 } else if (chip->allegro_flag)
2513 chip->amp_gpio = GPO_EXT_AMP_ALLEGRO;
2515 chip->amp_gpio = GPO_EXT_AMP_M3;
2518 quirk = snd_pci_quirk_lookup(pci, m3_irda_quirk_list);
2519 if (quirk) {
2520 dev_info(card->dev, "enabled irda workaround for '%s'\n",
2521 snd_pci_quirk_name(quirk));
2522 chip->irda_workaround = 1;
2524 quirk = snd_pci_quirk_lookup(pci, m3_hv_quirk_list);
2525 if (quirk)
2526 chip->hv_config = quirk->value;
2528 chip->is_omnibook = 1;
2530 chip->num_substreams = NR_DSPS;
2531 chip->substreams = devm_kcalloc(&pci->dev, chip->num_substreams,
2533 if (!chip->substreams)
2534 return -ENOMEM;
2536 err = request_firmware(&chip->assp_kernel_image,
2537 "ess/maestro3_assp_kernel.fw", &pci->dev);
2541 err = request_firmware(&chip->assp_minisrc_image,
2542 "ess/maestro3_assp_minisrc.fw", &pci->dev);
2546 err = pcim_request_all_regions(pci, card->driver);
2550 chip->iobase = pci_resource_start(pci, 0);
2564 if (devm_request_irq(&pci->dev, pci->irq, snd_m3_interrupt, IRQF_SHARED,
2566 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
2567 return -ENOMEM;
2569 chip->irq = pci->irq;
2570 card->sync_irq = chip->irq;
2573 chip->suspend_mem =
2577 if (!chip->suspend_mem)
2578 dev_warn(card->dev, "can't allocate apm buffer\n");
2585 for (i = 0; i < chip->num_substreams; i++) {
2586 struct m3_dma *s = &chip->substreams[i];
2597 if (chip->hv_config & HV_CTRL_ENABLE) {
2600 dev_warn(card->dev,
2623 if (((pci->class >> 8) & 0xffff) != PCI_CLASS_MULTIMEDIA_AUDIO)
2624 return -ENODEV;
2627 return -ENODEV;
2630 return -ENOENT;
2633 err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2637 chip = card->private_data;
2639 switch (pci->device) {
2642 strscpy(card->driver, "Allegro");
2646 strscpy(card->driver, "Canyon3D-2");
2649 strscpy(card->driver, "Maestro3");
2657 sprintf(card->shortname, "ESS %s PCI", card->driver);
2658 sprintf(card->longname, "%s at 0x%lx, irq %d",
2659 card->shortname, chip->iobase, chip->irq);
2666 /* TODO enable MIDI IRQ and I/O */
2667 err = snd_mpu401_uart_new(chip->card, 0, MPU401_HW_MPU401,
2668 chip->iobase + MPU401_DATA_PORT,
2670 -1, &chip->rmidi);
2672 dev_warn(card->dev, "no MIDI support.\n");
2683 return snd_card_free_on_error(&pci->dev, __snd_m3_probe(pci, pci_id));