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