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