1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * ALSA modem driver for VIA VT82xx (South Bridge)
4 *
5 * VT82C686A/B/C, VT8233A/C, VT8235
6 *
7 * Copyright (c) 2000 Jaroslav Kysela <perex@perex.cz>
8 * Tjeerd.Mulder <Tjeerd.Mulder@fujitsu-siemens.com>
9 * 2002 Takashi Iwai <tiwai@suse.de>
10 */
11
12 /*
13 * Changes:
14 *
15 * Sep. 2, 2004 Sasha Khapyorsky <sashak@alsa-project.org>
16 * Modified from original audio driver 'via82xx.c' to support AC97
17 * modems.
18 */
19
20 #include <linux/io.h>
21 #include <linux/delay.h>
22 #include <linux/interrupt.h>
23 #include <linux/init.h>
24 #include <linux/pci.h>
25 #include <linux/slab.h>
26 #include <linux/module.h>
27 #include <sound/core.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/info.h>
31 #include <sound/ac97_codec.h>
32 #include <sound/initval.h>
33
34 #if 0
35 #define POINTER_DEBUG
36 #endif
37
38 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
39 MODULE_DESCRIPTION("VIA VT82xx modem");
40 MODULE_LICENSE("GPL");
41
42 static int index = -2; /* Exclude the first card */
43 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
44 static int ac97_clock = 48000;
45
46 module_param(index, int, 0444);
47 MODULE_PARM_DESC(index, "Index value for VIA 82xx bridge.");
48 module_param(id, charp, 0444);
49 MODULE_PARM_DESC(id, "ID string for VIA 82xx bridge.");
50 module_param(ac97_clock, int, 0444);
51 MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
52
53 /* just for backward compatibility */
54 static bool enable;
55 module_param(enable, bool, 0444);
56
57
58 /*
59 * Direct registers
60 */
61
62 #define VIAREG(via, x) ((via)->port + VIA_REG_##x)
63 #define VIADEV_REG(viadev, x) ((viadev)->port + VIA_REG_##x)
64
65 /* common offsets */
66 #define VIA_REG_OFFSET_STATUS 0x00 /* byte - channel status */
67 #define VIA_REG_STAT_ACTIVE 0x80 /* RO */
68 #define VIA_REG_STAT_PAUSED 0x40 /* RO */
69 #define VIA_REG_STAT_TRIGGER_QUEUED 0x08 /* RO */
70 #define VIA_REG_STAT_STOPPED 0x04 /* RWC */
71 #define VIA_REG_STAT_EOL 0x02 /* RWC */
72 #define VIA_REG_STAT_FLAG 0x01 /* RWC */
73 #define VIA_REG_OFFSET_CONTROL 0x01 /* byte - channel control */
74 #define VIA_REG_CTRL_START 0x80 /* WO */
75 #define VIA_REG_CTRL_TERMINATE 0x40 /* WO */
76 #define VIA_REG_CTRL_AUTOSTART 0x20
77 #define VIA_REG_CTRL_PAUSE 0x08 /* RW */
78 #define VIA_REG_CTRL_INT_STOP 0x04
79 #define VIA_REG_CTRL_INT_EOL 0x02
80 #define VIA_REG_CTRL_INT_FLAG 0x01
81 #define VIA_REG_CTRL_RESET 0x01 /* RW - probably reset? undocumented */
82 #define VIA_REG_CTRL_INT (VIA_REG_CTRL_INT_FLAG | VIA_REG_CTRL_INT_EOL | VIA_REG_CTRL_AUTOSTART)
83 #define VIA_REG_OFFSET_TYPE 0x02 /* byte - channel type (686 only) */
84 #define VIA_REG_TYPE_AUTOSTART 0x80 /* RW - autostart at EOL */
85 #define VIA_REG_TYPE_16BIT 0x20 /* RW */
86 #define VIA_REG_TYPE_STEREO 0x10 /* RW */
87 #define VIA_REG_TYPE_INT_LLINE 0x00
88 #define VIA_REG_TYPE_INT_LSAMPLE 0x04
89 #define VIA_REG_TYPE_INT_LESSONE 0x08
90 #define VIA_REG_TYPE_INT_MASK 0x0c
91 #define VIA_REG_TYPE_INT_EOL 0x02
92 #define VIA_REG_TYPE_INT_FLAG 0x01
93 #define VIA_REG_OFFSET_TABLE_PTR 0x04 /* dword - channel table pointer */
94 #define VIA_REG_OFFSET_CURR_PTR 0x04 /* dword - channel current pointer */
95 #define VIA_REG_OFFSET_STOP_IDX 0x08 /* dword - stop index, channel type, sample rate */
96 #define VIA_REG_OFFSET_CURR_COUNT 0x0c /* dword - channel current count (24 bit) */
97 #define VIA_REG_OFFSET_CURR_INDEX 0x0f /* byte - channel current index (for via8233 only) */
98
99 #define DEFINE_VIA_REGSET(name,val) \
100 enum {\
101 VIA_REG_##name##_STATUS = (val),\
102 VIA_REG_##name##_CONTROL = (val) + 0x01,\
103 VIA_REG_##name##_TYPE = (val) + 0x02,\
104 VIA_REG_##name##_TABLE_PTR = (val) + 0x04,\
105 VIA_REG_##name##_CURR_PTR = (val) + 0x04,\
106 VIA_REG_##name##_STOP_IDX = (val) + 0x08,\
107 VIA_REG_##name##_CURR_COUNT = (val) + 0x0c,\
108 }
109
110 /* modem block */
111 DEFINE_VIA_REGSET(MO, 0x40);
112 DEFINE_VIA_REGSET(MI, 0x50);
113
114 /* AC'97 */
115 #define VIA_REG_AC97 0x80 /* dword */
116 #define VIA_REG_AC97_CODEC_ID_MASK (3<<30)
117 #define VIA_REG_AC97_CODEC_ID_SHIFT 30
118 #define VIA_REG_AC97_CODEC_ID_PRIMARY 0x00
119 #define VIA_REG_AC97_CODEC_ID_SECONDARY 0x01
120 #define VIA_REG_AC97_SECONDARY_VALID (1<<27)
121 #define VIA_REG_AC97_PRIMARY_VALID (1<<25)
122 #define VIA_REG_AC97_BUSY (1<<24)
123 #define VIA_REG_AC97_READ (1<<23)
124 #define VIA_REG_AC97_CMD_SHIFT 16
125 #define VIA_REG_AC97_CMD_MASK 0x7e
126 #define VIA_REG_AC97_DATA_SHIFT 0
127 #define VIA_REG_AC97_DATA_MASK 0xffff
128
129 #define VIA_REG_SGD_SHADOW 0x84 /* dword */
130 #define VIA_REG_SGD_STAT_PB_FLAG (1<<0)
131 #define VIA_REG_SGD_STAT_CP_FLAG (1<<1)
132 #define VIA_REG_SGD_STAT_FM_FLAG (1<<2)
133 #define VIA_REG_SGD_STAT_PB_EOL (1<<4)
134 #define VIA_REG_SGD_STAT_CP_EOL (1<<5)
135 #define VIA_REG_SGD_STAT_FM_EOL (1<<6)
136 #define VIA_REG_SGD_STAT_PB_STOP (1<<8)
137 #define VIA_REG_SGD_STAT_CP_STOP (1<<9)
138 #define VIA_REG_SGD_STAT_FM_STOP (1<<10)
139 #define VIA_REG_SGD_STAT_PB_ACTIVE (1<<12)
140 #define VIA_REG_SGD_STAT_CP_ACTIVE (1<<13)
141 #define VIA_REG_SGD_STAT_FM_ACTIVE (1<<14)
142 #define VIA_REG_SGD_STAT_MR_FLAG (1<<16)
143 #define VIA_REG_SGD_STAT_MW_FLAG (1<<17)
144 #define VIA_REG_SGD_STAT_MR_EOL (1<<20)
145 #define VIA_REG_SGD_STAT_MW_EOL (1<<21)
146 #define VIA_REG_SGD_STAT_MR_STOP (1<<24)
147 #define VIA_REG_SGD_STAT_MW_STOP (1<<25)
148 #define VIA_REG_SGD_STAT_MR_ACTIVE (1<<28)
149 #define VIA_REG_SGD_STAT_MW_ACTIVE (1<<29)
150
151 #define VIA_REG_GPI_STATUS 0x88
152 #define VIA_REG_GPI_INTR 0x8c
153
154 #define VIA_TBL_BIT_FLAG 0x40000000
155 #define VIA_TBL_BIT_EOL 0x80000000
156
157 /* pci space */
158 #define VIA_ACLINK_STAT 0x40
159 #define VIA_ACLINK_C11_READY 0x20
160 #define VIA_ACLINK_C10_READY 0x10
161 #define VIA_ACLINK_C01_READY 0x04 /* secondary codec ready */
162 #define VIA_ACLINK_LOWPOWER 0x02 /* low-power state */
163 #define VIA_ACLINK_C00_READY 0x01 /* primary codec ready */
164 #define VIA_ACLINK_CTRL 0x41
165 #define VIA_ACLINK_CTRL_ENABLE 0x80 /* 0: disable, 1: enable */
166 #define VIA_ACLINK_CTRL_RESET 0x40 /* 0: assert, 1: de-assert */
167 #define VIA_ACLINK_CTRL_SYNC 0x20 /* 0: release SYNC, 1: force SYNC hi */
168 #define VIA_ACLINK_CTRL_SDO 0x10 /* 0: release SDO, 1: force SDO hi */
169 #define VIA_ACLINK_CTRL_VRA 0x08 /* 0: disable VRA, 1: enable VRA */
170 #define VIA_ACLINK_CTRL_PCM 0x04 /* 0: disable PCM, 1: enable PCM */
171 #define VIA_ACLINK_CTRL_FM 0x02 /* via686 only */
172 #define VIA_ACLINK_CTRL_SB 0x01 /* via686 only */
173 #define VIA_ACLINK_CTRL_INIT (VIA_ACLINK_CTRL_ENABLE|\
174 VIA_ACLINK_CTRL_RESET|\
175 VIA_ACLINK_CTRL_PCM)
176 #define VIA_FUNC_ENABLE 0x42
177 #define VIA_FUNC_MIDI_PNP 0x80 /* FIXME: it's 0x40 in the datasheet! */
178 #define VIA_FUNC_MIDI_IRQMASK 0x40 /* FIXME: not documented! */
179 #define VIA_FUNC_RX2C_WRITE 0x20
180 #define VIA_FUNC_SB_FIFO_EMPTY 0x10
181 #define VIA_FUNC_ENABLE_GAME 0x08
182 #define VIA_FUNC_ENABLE_FM 0x04
183 #define VIA_FUNC_ENABLE_MIDI 0x02
184 #define VIA_FUNC_ENABLE_SB 0x01
185 #define VIA_PNP_CONTROL 0x43
186 #define VIA_MC97_CTRL 0x44
187 #define VIA_MC97_CTRL_ENABLE 0x80
188 #define VIA_MC97_CTRL_SECONDARY 0x40
189 #define VIA_MC97_CTRL_INIT (VIA_MC97_CTRL_ENABLE|\
190 VIA_MC97_CTRL_SECONDARY)
191
192
193 /*
194 * pcm stream
195 */
196
197 struct snd_via_sg_table {
198 unsigned int offset;
199 unsigned int size;
200 } ;
201
202 #define VIA_TABLE_SIZE 255
203
204 struct viadev {
205 unsigned int reg_offset;
206 unsigned long port;
207 int direction; /* playback = 0, capture = 1 */
208 struct snd_pcm_substream *substream;
209 int running;
210 unsigned int tbl_entries; /* # descriptors */
211 struct snd_dma_buffer table;
212 struct snd_via_sg_table *idx_table;
213 /* for recovery from the unexpected pointer */
214 unsigned int lastpos;
215 unsigned int bufsize;
216 unsigned int bufsize2;
217 };
218
219 enum { TYPE_CARD_VIA82XX_MODEM = 1 };
220
221 #define VIA_MAX_MODEM_DEVS 2
222
223 struct via82xx_modem {
224 int irq;
225
226 unsigned long port;
227
228 unsigned int intr_mask; /* SGD_SHADOW mask to check interrupts */
229
230 struct pci_dev *pci;
231 struct snd_card *card;
232
233 unsigned int num_devs;
234 unsigned int playback_devno, capture_devno;
235 struct viadev devs[VIA_MAX_MODEM_DEVS];
236
237 struct snd_pcm *pcms[2];
238
239 struct snd_ac97_bus *ac97_bus;
240 struct snd_ac97 *ac97;
241 unsigned int ac97_clock;
242 unsigned int ac97_secondary; /* secondary AC'97 codec is present */
243
244 spinlock_t reg_lock;
245 struct snd_info_entry *proc_entry;
246 };
247
248 static const struct pci_device_id snd_via82xx_modem_ids[] = {
249 { PCI_VDEVICE(VIA, 0x3068), TYPE_CARD_VIA82XX_MODEM, },
250 { 0, }
251 };
252
253 MODULE_DEVICE_TABLE(pci, snd_via82xx_modem_ids);
254
255 /*
256 */
257
258 /*
259 * allocate and initialize the descriptor buffers
260 * periods = number of periods
261 * fragsize = period size in bytes
262 */
build_via_table(struct viadev * dev,struct snd_pcm_substream * substream,struct pci_dev * pci,unsigned int periods,unsigned int fragsize)263 static int build_via_table(struct viadev *dev, struct snd_pcm_substream *substream,
264 struct pci_dev *pci,
265 unsigned int periods, unsigned int fragsize)
266 {
267 unsigned int i, idx, ofs, rest;
268 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
269 __le32 *pgtbl;
270
271 if (dev->table.area == NULL) {
272 /* the start of each lists must be aligned to 8 bytes,
273 * but the kernel pages are much bigger, so we don't care
274 */
275 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
276 PAGE_ALIGN(VIA_TABLE_SIZE * 2 * 8),
277 &dev->table) < 0)
278 return -ENOMEM;
279 }
280 if (! dev->idx_table) {
281 dev->idx_table = kmalloc_array(VIA_TABLE_SIZE,
282 sizeof(*dev->idx_table),
283 GFP_KERNEL);
284 if (! dev->idx_table)
285 return -ENOMEM;
286 }
287
288 /* fill the entries */
289 idx = 0;
290 ofs = 0;
291 pgtbl = (__le32 *)dev->table.area;
292 for (i = 0; i < periods; i++) {
293 rest = fragsize;
294 /* fill descriptors for a period.
295 * a period can be split to several descriptors if it's
296 * over page boundary.
297 */
298 do {
299 unsigned int r;
300 unsigned int flag;
301 unsigned int addr;
302
303 if (idx >= VIA_TABLE_SIZE) {
304 dev_err(&pci->dev, "too much table size!\n");
305 return -EINVAL;
306 }
307 addr = snd_pcm_sgbuf_get_addr(substream, ofs);
308 pgtbl[idx << 1] = cpu_to_le32(addr);
309 r = PAGE_SIZE - (ofs % PAGE_SIZE);
310 if (rest < r)
311 r = rest;
312 rest -= r;
313 if (! rest) {
314 if (i == periods - 1)
315 flag = VIA_TBL_BIT_EOL; /* buffer boundary */
316 else
317 flag = VIA_TBL_BIT_FLAG; /* period boundary */
318 } else
319 flag = 0; /* period continues to the next */
320 /*
321 dev_dbg(&pci->dev,
322 "tbl %d: at %d size %d (rest %d)\n",
323 idx, ofs, r, rest);
324 */
325 pgtbl[(idx<<1) + 1] = cpu_to_le32(r | flag);
326 dev->idx_table[idx].offset = ofs;
327 dev->idx_table[idx].size = r;
328 ofs += r;
329 idx++;
330 } while (rest > 0);
331 }
332 dev->tbl_entries = idx;
333 dev->bufsize = periods * fragsize;
334 dev->bufsize2 = dev->bufsize / 2;
335 return 0;
336 }
337
338
clean_via_table(struct viadev * dev,struct snd_pcm_substream * substream,struct pci_dev * pci)339 static int clean_via_table(struct viadev *dev, struct snd_pcm_substream *substream,
340 struct pci_dev *pci)
341 {
342 if (dev->table.area) {
343 snd_dma_free_pages(&dev->table);
344 dev->table.area = NULL;
345 }
346 kfree(dev->idx_table);
347 dev->idx_table = NULL;
348 return 0;
349 }
350
351 /*
352 * Basic I/O
353 */
354
snd_via82xx_codec_xread(struct via82xx_modem * chip)355 static inline unsigned int snd_via82xx_codec_xread(struct via82xx_modem *chip)
356 {
357 return inl(VIAREG(chip, AC97));
358 }
359
snd_via82xx_codec_xwrite(struct via82xx_modem * chip,unsigned int val)360 static inline void snd_via82xx_codec_xwrite(struct via82xx_modem *chip, unsigned int val)
361 {
362 outl(val, VIAREG(chip, AC97));
363 }
364
snd_via82xx_codec_ready(struct via82xx_modem * chip,int secondary)365 static int snd_via82xx_codec_ready(struct via82xx_modem *chip, int secondary)
366 {
367 unsigned int timeout = 1000; /* 1ms */
368 unsigned int val;
369
370 while (timeout-- > 0) {
371 udelay(1);
372 if (!((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY))
373 return val & 0xffff;
374 }
375 dev_err(chip->card->dev, "codec_ready: codec %i is not ready [0x%x]\n",
376 secondary, snd_via82xx_codec_xread(chip));
377 return -EIO;
378 }
379
snd_via82xx_codec_valid(struct via82xx_modem * chip,int secondary)380 static int snd_via82xx_codec_valid(struct via82xx_modem *chip, int secondary)
381 {
382 unsigned int timeout = 1000; /* 1ms */
383 unsigned int val, val1;
384 unsigned int stat = !secondary ? VIA_REG_AC97_PRIMARY_VALID :
385 VIA_REG_AC97_SECONDARY_VALID;
386
387 while (timeout-- > 0) {
388 val = snd_via82xx_codec_xread(chip);
389 val1 = val & (VIA_REG_AC97_BUSY | stat);
390 if (val1 == stat)
391 return val & 0xffff;
392 udelay(1);
393 }
394 return -EIO;
395 }
396
snd_via82xx_codec_wait(struct snd_ac97 * ac97)397 static void snd_via82xx_codec_wait(struct snd_ac97 *ac97)
398 {
399 struct via82xx_modem *chip = ac97->private_data;
400 __always_unused int err;
401 err = snd_via82xx_codec_ready(chip, ac97->num);
402 /* here we need to wait fairly for long time.. */
403 msleep(500);
404 }
405
snd_via82xx_codec_write(struct snd_ac97 * ac97,unsigned short reg,unsigned short val)406 static void snd_via82xx_codec_write(struct snd_ac97 *ac97,
407 unsigned short reg,
408 unsigned short val)
409 {
410 struct via82xx_modem *chip = ac97->private_data;
411 unsigned int xval;
412 if(reg == AC97_GPIO_STATUS) {
413 outl(val, VIAREG(chip, GPI_STATUS));
414 return;
415 }
416 xval = !ac97->num ? VIA_REG_AC97_CODEC_ID_PRIMARY : VIA_REG_AC97_CODEC_ID_SECONDARY;
417 xval <<= VIA_REG_AC97_CODEC_ID_SHIFT;
418 xval |= reg << VIA_REG_AC97_CMD_SHIFT;
419 xval |= val << VIA_REG_AC97_DATA_SHIFT;
420 snd_via82xx_codec_xwrite(chip, xval);
421 snd_via82xx_codec_ready(chip, ac97->num);
422 }
423
snd_via82xx_codec_read(struct snd_ac97 * ac97,unsigned short reg)424 static unsigned short snd_via82xx_codec_read(struct snd_ac97 *ac97, unsigned short reg)
425 {
426 struct via82xx_modem *chip = ac97->private_data;
427 unsigned int xval, val = 0xffff;
428 int again = 0;
429
430 xval = ac97->num << VIA_REG_AC97_CODEC_ID_SHIFT;
431 xval |= ac97->num ? VIA_REG_AC97_SECONDARY_VALID : VIA_REG_AC97_PRIMARY_VALID;
432 xval |= VIA_REG_AC97_READ;
433 xval |= (reg & 0x7f) << VIA_REG_AC97_CMD_SHIFT;
434 while (1) {
435 if (again++ > 3) {
436 dev_err(chip->card->dev,
437 "codec_read: codec %i is not valid [0x%x]\n",
438 ac97->num, snd_via82xx_codec_xread(chip));
439 return 0xffff;
440 }
441 snd_via82xx_codec_xwrite(chip, xval);
442 udelay (20);
443 if (snd_via82xx_codec_valid(chip, ac97->num) >= 0) {
444 udelay(25);
445 val = snd_via82xx_codec_xread(chip);
446 break;
447 }
448 }
449 return val & 0xffff;
450 }
451
snd_via82xx_channel_reset(struct via82xx_modem * chip,struct viadev * viadev)452 static void snd_via82xx_channel_reset(struct via82xx_modem *chip, struct viadev *viadev)
453 {
454 outb(VIA_REG_CTRL_PAUSE | VIA_REG_CTRL_TERMINATE | VIA_REG_CTRL_RESET,
455 VIADEV_REG(viadev, OFFSET_CONTROL));
456 inb(VIADEV_REG(viadev, OFFSET_CONTROL));
457 udelay(50);
458 /* disable interrupts */
459 outb(0x00, VIADEV_REG(viadev, OFFSET_CONTROL));
460 /* clear interrupts */
461 outb(0x03, VIADEV_REG(viadev, OFFSET_STATUS));
462 outb(0x00, VIADEV_REG(viadev, OFFSET_TYPE)); /* for via686 */
463 // outl(0, VIADEV_REG(viadev, OFFSET_CURR_PTR));
464 viadev->lastpos = 0;
465 }
466
467
468 /*
469 * Interrupt handler
470 */
471
snd_via82xx_interrupt(int irq,void * dev_id)472 static irqreturn_t snd_via82xx_interrupt(int irq, void *dev_id)
473 {
474 struct via82xx_modem *chip = dev_id;
475 unsigned int status;
476 unsigned int i;
477
478 status = inl(VIAREG(chip, SGD_SHADOW));
479 if (! (status & chip->intr_mask)) {
480 return IRQ_NONE;
481 }
482 // _skip_sgd:
483
484 /* check status for each stream */
485 spin_lock(&chip->reg_lock);
486 for (i = 0; i < chip->num_devs; i++) {
487 struct viadev *viadev = &chip->devs[i];
488 unsigned char c_status = inb(VIADEV_REG(viadev, OFFSET_STATUS));
489 c_status &= (VIA_REG_STAT_EOL|VIA_REG_STAT_FLAG|VIA_REG_STAT_STOPPED);
490 if (! c_status)
491 continue;
492 if (viadev->substream && viadev->running) {
493 spin_unlock(&chip->reg_lock);
494 snd_pcm_period_elapsed(viadev->substream);
495 spin_lock(&chip->reg_lock);
496 }
497 outb(c_status, VIADEV_REG(viadev, OFFSET_STATUS)); /* ack */
498 }
499 spin_unlock(&chip->reg_lock);
500 return IRQ_HANDLED;
501 }
502
503 /*
504 * PCM callbacks
505 */
506
507 /*
508 * trigger callback
509 */
snd_via82xx_pcm_trigger(struct snd_pcm_substream * substream,int cmd)510 static int snd_via82xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
511 {
512 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
513 struct viadev *viadev = substream->runtime->private_data;
514 unsigned char val = 0;
515
516 switch (cmd) {
517 case SNDRV_PCM_TRIGGER_START:
518 case SNDRV_PCM_TRIGGER_SUSPEND:
519 val |= VIA_REG_CTRL_START;
520 viadev->running = 1;
521 break;
522 case SNDRV_PCM_TRIGGER_STOP:
523 val = VIA_REG_CTRL_TERMINATE;
524 viadev->running = 0;
525 break;
526 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
527 val |= VIA_REG_CTRL_PAUSE;
528 viadev->running = 0;
529 break;
530 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
531 viadev->running = 1;
532 break;
533 default:
534 return -EINVAL;
535 }
536 outb(val, VIADEV_REG(viadev, OFFSET_CONTROL));
537 if (cmd == SNDRV_PCM_TRIGGER_STOP)
538 snd_via82xx_channel_reset(chip, viadev);
539 return 0;
540 }
541
542 /*
543 * pointer callbacks
544 */
545
546 /*
547 * calculate the linear position at the given sg-buffer index and the rest count
548 */
549
550 #define check_invalid_pos(viadev,pos) \
551 ((pos) < viadev->lastpos && ((pos) >= viadev->bufsize2 ||\
552 viadev->lastpos < viadev->bufsize2))
553
calc_linear_pos(struct via82xx_modem * chip,struct viadev * viadev,unsigned int idx,unsigned int count)554 static inline unsigned int calc_linear_pos(struct via82xx_modem *chip,
555 struct viadev *viadev,
556 unsigned int idx,
557 unsigned int count)
558 {
559 unsigned int size, res;
560
561 size = viadev->idx_table[idx].size;
562 res = viadev->idx_table[idx].offset + size - count;
563
564 /* check the validity of the calculated position */
565 if (size < count) {
566 dev_err(chip->card->dev,
567 "invalid via82xx_cur_ptr (size = %d, count = %d)\n",
568 (int)size, (int)count);
569 res = viadev->lastpos;
570 } else if (check_invalid_pos(viadev, res)) {
571 #ifdef POINTER_DEBUG
572 dev_dbg(chip->card->dev,
573 "fail: idx = %i/%i, lastpos = 0x%x, bufsize2 = 0x%x, offsize = 0x%x, size = 0x%x, count = 0x%x\n",
574 idx, viadev->tbl_entries, viadev->lastpos,
575 viadev->bufsize2, viadev->idx_table[idx].offset,
576 viadev->idx_table[idx].size, count);
577 #endif
578 if (count && size < count) {
579 dev_dbg(chip->card->dev,
580 "invalid via82xx_cur_ptr, using last valid pointer\n");
581 res = viadev->lastpos;
582 } else {
583 if (! count)
584 /* bogus count 0 on the DMA boundary? */
585 res = viadev->idx_table[idx].offset;
586 else
587 /* count register returns full size
588 * when end of buffer is reached
589 */
590 res = viadev->idx_table[idx].offset + size;
591 if (check_invalid_pos(viadev, res)) {
592 dev_dbg(chip->card->dev,
593 "invalid via82xx_cur_ptr (2), using last valid pointer\n");
594 res = viadev->lastpos;
595 }
596 }
597 }
598 viadev->lastpos = res; /* remember the last position */
599 if (res >= viadev->bufsize)
600 res -= viadev->bufsize;
601 return res;
602 }
603
604 /*
605 * get the current pointer on via686
606 */
snd_via686_pcm_pointer(struct snd_pcm_substream * substream)607 static snd_pcm_uframes_t snd_via686_pcm_pointer(struct snd_pcm_substream *substream)
608 {
609 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
610 struct viadev *viadev = substream->runtime->private_data;
611 unsigned int idx, ptr, count, res;
612
613 if (snd_BUG_ON(!viadev->tbl_entries))
614 return 0;
615 if (!(inb(VIADEV_REG(viadev, OFFSET_STATUS)) & VIA_REG_STAT_ACTIVE))
616 return 0;
617
618 spin_lock(&chip->reg_lock);
619 count = inl(VIADEV_REG(viadev, OFFSET_CURR_COUNT)) & 0xffffff;
620 /* The via686a does not have the current index register,
621 * so we need to calculate the index from CURR_PTR.
622 */
623 ptr = inl(VIADEV_REG(viadev, OFFSET_CURR_PTR));
624 if (ptr <= (unsigned int)viadev->table.addr)
625 idx = 0;
626 else /* CURR_PTR holds the address + 8 */
627 idx = ((ptr - (unsigned int)viadev->table.addr) / 8 - 1) %
628 viadev->tbl_entries;
629 res = calc_linear_pos(chip, viadev, idx, count);
630 spin_unlock(&chip->reg_lock);
631
632 return bytes_to_frames(substream->runtime, res);
633 }
634
635 /*
636 * hw_params callback:
637 * allocate the buffer and build up the buffer description table
638 */
snd_via82xx_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)639 static int snd_via82xx_hw_params(struct snd_pcm_substream *substream,
640 struct snd_pcm_hw_params *hw_params)
641 {
642 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
643 struct viadev *viadev = substream->runtime->private_data;
644 int err;
645
646 err = build_via_table(viadev, substream, chip->pci,
647 params_periods(hw_params),
648 params_period_bytes(hw_params));
649 if (err < 0)
650 return err;
651
652 snd_ac97_write(chip->ac97, AC97_LINE1_RATE, params_rate(hw_params));
653 snd_ac97_write(chip->ac97, AC97_LINE1_LEVEL, 0);
654
655 return 0;
656 }
657
658 /*
659 * hw_free callback:
660 * clean up the buffer description table and release the buffer
661 */
snd_via82xx_hw_free(struct snd_pcm_substream * substream)662 static int snd_via82xx_hw_free(struct snd_pcm_substream *substream)
663 {
664 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
665 struct viadev *viadev = substream->runtime->private_data;
666
667 clean_via_table(viadev, substream, chip->pci);
668 return 0;
669 }
670
671
672 /*
673 * set up the table pointer
674 */
snd_via82xx_set_table_ptr(struct via82xx_modem * chip,struct viadev * viadev)675 static void snd_via82xx_set_table_ptr(struct via82xx_modem *chip, struct viadev *viadev)
676 {
677 snd_via82xx_codec_ready(chip, chip->ac97_secondary);
678 outl((u32)viadev->table.addr, VIADEV_REG(viadev, OFFSET_TABLE_PTR));
679 udelay(20);
680 snd_via82xx_codec_ready(chip, chip->ac97_secondary);
681 }
682
683 /*
684 * prepare callback for playback and capture
685 */
snd_via82xx_pcm_prepare(struct snd_pcm_substream * substream)686 static int snd_via82xx_pcm_prepare(struct snd_pcm_substream *substream)
687 {
688 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
689 struct viadev *viadev = substream->runtime->private_data;
690
691 snd_via82xx_channel_reset(chip, viadev);
692 /* this must be set after channel_reset */
693 snd_via82xx_set_table_ptr(chip, viadev);
694 outb(VIA_REG_TYPE_AUTOSTART|VIA_REG_TYPE_INT_EOL|VIA_REG_TYPE_INT_FLAG,
695 VIADEV_REG(viadev, OFFSET_TYPE));
696 return 0;
697 }
698
699 /*
700 * pcm hardware definition, identical for both playback and capture
701 */
702 static const struct snd_pcm_hardware snd_via82xx_hw =
703 {
704 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
705 SNDRV_PCM_INFO_BLOCK_TRANSFER |
706 SNDRV_PCM_INFO_MMAP_VALID |
707 /* SNDRV_PCM_INFO_RESUME | */
708 SNDRV_PCM_INFO_PAUSE),
709 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
710 .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_KNOT,
711 .rate_min = 8000,
712 .rate_max = 16000,
713 .channels_min = 1,
714 .channels_max = 1,
715 .buffer_bytes_max = 128 * 1024,
716 .period_bytes_min = 32,
717 .period_bytes_max = 128 * 1024,
718 .periods_min = 2,
719 .periods_max = VIA_TABLE_SIZE / 2,
720 .fifo_size = 0,
721 };
722
723
724 /*
725 * open callback skeleton
726 */
snd_via82xx_modem_pcm_open(struct via82xx_modem * chip,struct viadev * viadev,struct snd_pcm_substream * substream)727 static int snd_via82xx_modem_pcm_open(struct via82xx_modem *chip, struct viadev *viadev,
728 struct snd_pcm_substream *substream)
729 {
730 struct snd_pcm_runtime *runtime = substream->runtime;
731 int err;
732 static const unsigned int rates[] = { 8000, 9600, 12000, 16000 };
733 static const struct snd_pcm_hw_constraint_list hw_constraints_rates = {
734 .count = ARRAY_SIZE(rates),
735 .list = rates,
736 .mask = 0,
737 };
738
739 runtime->hw = snd_via82xx_hw;
740
741 if ((err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
742 &hw_constraints_rates)) < 0)
743 return err;
744
745 /* we may remove following constaint when we modify table entries
746 in interrupt */
747 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
748 return err;
749
750 runtime->private_data = viadev;
751 viadev->substream = substream;
752
753 return 0;
754 }
755
756
757 /*
758 * open callback for playback
759 */
snd_via82xx_playback_open(struct snd_pcm_substream * substream)760 static int snd_via82xx_playback_open(struct snd_pcm_substream *substream)
761 {
762 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
763 struct viadev *viadev = &chip->devs[chip->playback_devno + substream->number];
764
765 return snd_via82xx_modem_pcm_open(chip, viadev, substream);
766 }
767
768 /*
769 * open callback for capture
770 */
snd_via82xx_capture_open(struct snd_pcm_substream * substream)771 static int snd_via82xx_capture_open(struct snd_pcm_substream *substream)
772 {
773 struct via82xx_modem *chip = snd_pcm_substream_chip(substream);
774 struct viadev *viadev = &chip->devs[chip->capture_devno + substream->pcm->device];
775
776 return snd_via82xx_modem_pcm_open(chip, viadev, substream);
777 }
778
779 /*
780 * close callback
781 */
snd_via82xx_pcm_close(struct snd_pcm_substream * substream)782 static int snd_via82xx_pcm_close(struct snd_pcm_substream *substream)
783 {
784 struct viadev *viadev = substream->runtime->private_data;
785
786 viadev->substream = NULL;
787 return 0;
788 }
789
790
791 /* via686 playback callbacks */
792 static const struct snd_pcm_ops snd_via686_playback_ops = {
793 .open = snd_via82xx_playback_open,
794 .close = snd_via82xx_pcm_close,
795 .hw_params = snd_via82xx_hw_params,
796 .hw_free = snd_via82xx_hw_free,
797 .prepare = snd_via82xx_pcm_prepare,
798 .trigger = snd_via82xx_pcm_trigger,
799 .pointer = snd_via686_pcm_pointer,
800 };
801
802 /* via686 capture callbacks */
803 static const struct snd_pcm_ops snd_via686_capture_ops = {
804 .open = snd_via82xx_capture_open,
805 .close = snd_via82xx_pcm_close,
806 .hw_params = snd_via82xx_hw_params,
807 .hw_free = snd_via82xx_hw_free,
808 .prepare = snd_via82xx_pcm_prepare,
809 .trigger = snd_via82xx_pcm_trigger,
810 .pointer = snd_via686_pcm_pointer,
811 };
812
813
init_viadev(struct via82xx_modem * chip,int idx,unsigned int reg_offset,int direction)814 static void init_viadev(struct via82xx_modem *chip, int idx, unsigned int reg_offset,
815 int direction)
816 {
817 chip->devs[idx].reg_offset = reg_offset;
818 chip->devs[idx].direction = direction;
819 chip->devs[idx].port = chip->port + reg_offset;
820 }
821
822 /*
823 * create a pcm instance for via686a/b
824 */
snd_via686_pcm_new(struct via82xx_modem * chip)825 static int snd_via686_pcm_new(struct via82xx_modem *chip)
826 {
827 struct snd_pcm *pcm;
828 int err;
829
830 chip->playback_devno = 0;
831 chip->capture_devno = 1;
832 chip->num_devs = 2;
833 chip->intr_mask = 0x330000; /* FLAGS | EOL for MR, MW */
834
835 err = snd_pcm_new(chip->card, chip->card->shortname, 0, 1, 1, &pcm);
836 if (err < 0)
837 return err;
838 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_via686_playback_ops);
839 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_via686_capture_ops);
840 pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
841 pcm->private_data = chip;
842 strcpy(pcm->name, chip->card->shortname);
843 chip->pcms[0] = pcm;
844 init_viadev(chip, 0, VIA_REG_MO_STATUS, 0);
845 init_viadev(chip, 1, VIA_REG_MI_STATUS, 1);
846
847 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
848 &chip->pci->dev, 64*1024, 128*1024);
849 return 0;
850 }
851
852
853 /*
854 * Mixer part
855 */
856
857
snd_via82xx_mixer_free_ac97_bus(struct snd_ac97_bus * bus)858 static void snd_via82xx_mixer_free_ac97_bus(struct snd_ac97_bus *bus)
859 {
860 struct via82xx_modem *chip = bus->private_data;
861 chip->ac97_bus = NULL;
862 }
863
snd_via82xx_mixer_free_ac97(struct snd_ac97 * ac97)864 static void snd_via82xx_mixer_free_ac97(struct snd_ac97 *ac97)
865 {
866 struct via82xx_modem *chip = ac97->private_data;
867 chip->ac97 = NULL;
868 }
869
870
snd_via82xx_mixer_new(struct via82xx_modem * chip)871 static int snd_via82xx_mixer_new(struct via82xx_modem *chip)
872 {
873 struct snd_ac97_template ac97;
874 int err;
875 static const struct snd_ac97_bus_ops ops = {
876 .write = snd_via82xx_codec_write,
877 .read = snd_via82xx_codec_read,
878 .wait = snd_via82xx_codec_wait,
879 };
880
881 if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &chip->ac97_bus)) < 0)
882 return err;
883 chip->ac97_bus->private_free = snd_via82xx_mixer_free_ac97_bus;
884 chip->ac97_bus->clock = chip->ac97_clock;
885
886 memset(&ac97, 0, sizeof(ac97));
887 ac97.private_data = chip;
888 ac97.private_free = snd_via82xx_mixer_free_ac97;
889 ac97.pci = chip->pci;
890 ac97.scaps = AC97_SCAP_SKIP_AUDIO | AC97_SCAP_POWER_SAVE;
891 ac97.num = chip->ac97_secondary;
892
893 if ((err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97)) < 0)
894 return err;
895
896 return 0;
897 }
898
899
900 /*
901 * proc interface
902 */
snd_via82xx_proc_read(struct snd_info_entry * entry,struct snd_info_buffer * buffer)903 static void snd_via82xx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
904 {
905 struct via82xx_modem *chip = entry->private_data;
906 int i;
907
908 snd_iprintf(buffer, "%s\n\n", chip->card->longname);
909 for (i = 0; i < 0xa0; i += 4) {
910 snd_iprintf(buffer, "%02x: %08x\n", i, inl(chip->port + i));
911 }
912 }
913
snd_via82xx_proc_init(struct via82xx_modem * chip)914 static void snd_via82xx_proc_init(struct via82xx_modem *chip)
915 {
916 snd_card_ro_proc_new(chip->card, "via82xx", chip,
917 snd_via82xx_proc_read);
918 }
919
920 /*
921 *
922 */
923
snd_via82xx_chip_init(struct via82xx_modem * chip)924 static int snd_via82xx_chip_init(struct via82xx_modem *chip)
925 {
926 unsigned int val;
927 unsigned long end_time;
928 unsigned char pval;
929
930 pci_read_config_byte(chip->pci, VIA_MC97_CTRL, &pval);
931 if((pval & VIA_MC97_CTRL_INIT) != VIA_MC97_CTRL_INIT) {
932 pci_write_config_byte(chip->pci, 0x44, pval|VIA_MC97_CTRL_INIT);
933 udelay(100);
934 }
935
936 pci_read_config_byte(chip->pci, VIA_ACLINK_STAT, &pval);
937 if (! (pval & VIA_ACLINK_C00_READY)) { /* codec not ready? */
938 /* deassert ACLink reset, force SYNC */
939 pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL,
940 VIA_ACLINK_CTRL_ENABLE |
941 VIA_ACLINK_CTRL_RESET |
942 VIA_ACLINK_CTRL_SYNC);
943 udelay(100);
944 #if 1 /* FIXME: should we do full reset here for all chip models? */
945 pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL, 0x00);
946 udelay(100);
947 #else
948 /* deassert ACLink reset, force SYNC (warm AC'97 reset) */
949 pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL,
950 VIA_ACLINK_CTRL_RESET|VIA_ACLINK_CTRL_SYNC);
951 udelay(2);
952 #endif
953 /* ACLink on, deassert ACLink reset, VSR, SGD data out */
954 pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL, VIA_ACLINK_CTRL_INIT);
955 udelay(100);
956 }
957
958 pci_read_config_byte(chip->pci, VIA_ACLINK_CTRL, &pval);
959 if ((pval & VIA_ACLINK_CTRL_INIT) != VIA_ACLINK_CTRL_INIT) {
960 /* ACLink on, deassert ACLink reset, VSR, SGD data out */
961 pci_write_config_byte(chip->pci, VIA_ACLINK_CTRL, VIA_ACLINK_CTRL_INIT);
962 udelay(100);
963 }
964
965 /* wait until codec ready */
966 end_time = jiffies + msecs_to_jiffies(750);
967 do {
968 pci_read_config_byte(chip->pci, VIA_ACLINK_STAT, &pval);
969 if (pval & VIA_ACLINK_C00_READY) /* primary codec ready */
970 break;
971 schedule_timeout_uninterruptible(1);
972 } while (time_before(jiffies, end_time));
973
974 if ((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_BUSY)
975 dev_err(chip->card->dev,
976 "AC'97 codec is not ready [0x%x]\n", val);
977
978 snd_via82xx_codec_xwrite(chip, VIA_REG_AC97_READ |
979 VIA_REG_AC97_SECONDARY_VALID |
980 (VIA_REG_AC97_CODEC_ID_SECONDARY << VIA_REG_AC97_CODEC_ID_SHIFT));
981 end_time = jiffies + msecs_to_jiffies(750);
982 snd_via82xx_codec_xwrite(chip, VIA_REG_AC97_READ |
983 VIA_REG_AC97_SECONDARY_VALID |
984 (VIA_REG_AC97_CODEC_ID_SECONDARY << VIA_REG_AC97_CODEC_ID_SHIFT));
985 do {
986 if ((val = snd_via82xx_codec_xread(chip)) & VIA_REG_AC97_SECONDARY_VALID) {
987 chip->ac97_secondary = 1;
988 goto __ac97_ok2;
989 }
990 schedule_timeout_uninterruptible(1);
991 } while (time_before(jiffies, end_time));
992 /* This is ok, the most of motherboards have only one codec */
993
994 __ac97_ok2:
995
996 /* route FM trap to IRQ, disable FM trap */
997 // pci_write_config_byte(chip->pci, VIA_FM_NMI_CTRL, 0);
998 /* disable all GPI interrupts */
999 outl(0, VIAREG(chip, GPI_INTR));
1000
1001 return 0;
1002 }
1003
1004 #ifdef CONFIG_PM_SLEEP
1005 /*
1006 * power management
1007 */
snd_via82xx_suspend(struct device * dev)1008 static int snd_via82xx_suspend(struct device *dev)
1009 {
1010 struct snd_card *card = dev_get_drvdata(dev);
1011 struct via82xx_modem *chip = card->private_data;
1012 int i;
1013
1014 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1015 for (i = 0; i < chip->num_devs; i++)
1016 snd_via82xx_channel_reset(chip, &chip->devs[i]);
1017 snd_ac97_suspend(chip->ac97);
1018 return 0;
1019 }
1020
snd_via82xx_resume(struct device * dev)1021 static int snd_via82xx_resume(struct device *dev)
1022 {
1023 struct snd_card *card = dev_get_drvdata(dev);
1024 struct via82xx_modem *chip = card->private_data;
1025 int i;
1026
1027 snd_via82xx_chip_init(chip);
1028
1029 snd_ac97_resume(chip->ac97);
1030
1031 for (i = 0; i < chip->num_devs; i++)
1032 snd_via82xx_channel_reset(chip, &chip->devs[i]);
1033
1034 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1035 return 0;
1036 }
1037
1038 static SIMPLE_DEV_PM_OPS(snd_via82xx_pm, snd_via82xx_suspend, snd_via82xx_resume);
1039 #define SND_VIA82XX_PM_OPS &snd_via82xx_pm
1040 #else
1041 #define SND_VIA82XX_PM_OPS NULL
1042 #endif /* CONFIG_PM_SLEEP */
1043
snd_via82xx_free(struct via82xx_modem * chip)1044 static int snd_via82xx_free(struct via82xx_modem *chip)
1045 {
1046 unsigned int i;
1047
1048 if (chip->irq < 0)
1049 goto __end_hw;
1050 /* disable interrupts */
1051 for (i = 0; i < chip->num_devs; i++)
1052 snd_via82xx_channel_reset(chip, &chip->devs[i]);
1053
1054 __end_hw:
1055 if (chip->irq >= 0)
1056 free_irq(chip->irq, chip);
1057 pci_release_regions(chip->pci);
1058 pci_disable_device(chip->pci);
1059 kfree(chip);
1060 return 0;
1061 }
1062
snd_via82xx_dev_free(struct snd_device * device)1063 static int snd_via82xx_dev_free(struct snd_device *device)
1064 {
1065 struct via82xx_modem *chip = device->device_data;
1066 return snd_via82xx_free(chip);
1067 }
1068
snd_via82xx_create(struct snd_card * card,struct pci_dev * pci,int chip_type,int revision,unsigned int ac97_clock,struct via82xx_modem ** r_via)1069 static int snd_via82xx_create(struct snd_card *card,
1070 struct pci_dev *pci,
1071 int chip_type,
1072 int revision,
1073 unsigned int ac97_clock,
1074 struct via82xx_modem **r_via)
1075 {
1076 struct via82xx_modem *chip;
1077 int err;
1078 static const struct snd_device_ops ops = {
1079 .dev_free = snd_via82xx_dev_free,
1080 };
1081
1082 if ((err = pci_enable_device(pci)) < 0)
1083 return err;
1084
1085 if ((chip = kzalloc(sizeof(*chip), GFP_KERNEL)) == NULL) {
1086 pci_disable_device(pci);
1087 return -ENOMEM;
1088 }
1089
1090 spin_lock_init(&chip->reg_lock);
1091 chip->card = card;
1092 chip->pci = pci;
1093 chip->irq = -1;
1094
1095 if ((err = pci_request_regions(pci, card->driver)) < 0) {
1096 kfree(chip);
1097 pci_disable_device(pci);
1098 return err;
1099 }
1100 chip->port = pci_resource_start(pci, 0);
1101 if (request_irq(pci->irq, snd_via82xx_interrupt, IRQF_SHARED,
1102 KBUILD_MODNAME, chip)) {
1103 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
1104 snd_via82xx_free(chip);
1105 return -EBUSY;
1106 }
1107 chip->irq = pci->irq;
1108 card->sync_irq = chip->irq;
1109 if (ac97_clock >= 8000 && ac97_clock <= 48000)
1110 chip->ac97_clock = ac97_clock;
1111
1112 if ((err = snd_via82xx_chip_init(chip)) < 0) {
1113 snd_via82xx_free(chip);
1114 return err;
1115 }
1116
1117 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1118 snd_via82xx_free(chip);
1119 return err;
1120 }
1121
1122 /* The 8233 ac97 controller does not implement the master bit
1123 * in the pci command register. IMHO this is a violation of the PCI spec.
1124 * We call pci_set_master here because it does not hurt. */
1125 pci_set_master(pci);
1126
1127 *r_via = chip;
1128 return 0;
1129 }
1130
1131
snd_via82xx_probe(struct pci_dev * pci,const struct pci_device_id * pci_id)1132 static int snd_via82xx_probe(struct pci_dev *pci,
1133 const struct pci_device_id *pci_id)
1134 {
1135 struct snd_card *card;
1136 struct via82xx_modem *chip;
1137 int chip_type = 0, card_type;
1138 unsigned int i;
1139 int err;
1140
1141 err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
1142 if (err < 0)
1143 return err;
1144
1145 card_type = pci_id->driver_data;
1146 switch (card_type) {
1147 case TYPE_CARD_VIA82XX_MODEM:
1148 strcpy(card->driver, "VIA82XX-MODEM");
1149 sprintf(card->shortname, "VIA 82XX modem");
1150 break;
1151 default:
1152 dev_err(card->dev, "invalid card type %d\n", card_type);
1153 err = -EINVAL;
1154 goto __error;
1155 }
1156
1157 if ((err = snd_via82xx_create(card, pci, chip_type, pci->revision,
1158 ac97_clock, &chip)) < 0)
1159 goto __error;
1160 card->private_data = chip;
1161 if ((err = snd_via82xx_mixer_new(chip)) < 0)
1162 goto __error;
1163
1164 if ((err = snd_via686_pcm_new(chip)) < 0 )
1165 goto __error;
1166
1167 /* disable interrupts */
1168 for (i = 0; i < chip->num_devs; i++)
1169 snd_via82xx_channel_reset(chip, &chip->devs[i]);
1170
1171 sprintf(card->longname, "%s at 0x%lx, irq %d",
1172 card->shortname, chip->port, chip->irq);
1173
1174 snd_via82xx_proc_init(chip);
1175
1176 if ((err = snd_card_register(card)) < 0) {
1177 snd_card_free(card);
1178 return err;
1179 }
1180 pci_set_drvdata(pci, card);
1181 return 0;
1182
1183 __error:
1184 snd_card_free(card);
1185 return err;
1186 }
1187
snd_via82xx_remove(struct pci_dev * pci)1188 static void snd_via82xx_remove(struct pci_dev *pci)
1189 {
1190 snd_card_free(pci_get_drvdata(pci));
1191 }
1192
1193 static struct pci_driver via82xx_modem_driver = {
1194 .name = KBUILD_MODNAME,
1195 .id_table = snd_via82xx_modem_ids,
1196 .probe = snd_via82xx_probe,
1197 .remove = snd_via82xx_remove,
1198 .driver = {
1199 .pm = SND_VIA82XX_PM_OPS,
1200 },
1201 };
1202
1203 module_pci_driver(via82xx_modem_driver);
1204