Linux Audio

Check our new training course

Loading...
v5.9
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * cs5530.c - Initialisation code for Cyrix/NatSemi VSA1 softaudio
  4 *
  5 * 	(C) Copyright 2007 Ash Willis <ashwillis@programmer.net>
  6 *	(C) Copyright 2003 Red Hat Inc <alan@lxorguk.ukuu.org.uk>
  7 *
  8 * This driver was ported (shamelessly ripped ;) from oss/kahlua.c but I did
  9 * mess with it a bit. The chip seems to have to have trouble with full duplex
 10 * mode. If we're recording in 8bit 8000kHz, say, and we then attempt to
 11 * simultaneously play back audio at 16bit 44100kHz, the device actually plays
 12 * back in the same format in which it is capturing. By forcing the chip to
 13 * always play/capture in 16/44100, we can let alsa-lib convert the samples and
 14 * that way we can hack up some full duplex audio. 
 15 * 
 16 * XpressAudio(tm) is used on the Cyrix MediaGX (now NatSemi Geode) systems.
 17 * The older version (VSA1) provides fairly good soundblaster emulation
 18 * although there are a couple of bugs: large DMA buffers break record,
 19 * and the MPU event handling seems suspect. VSA2 allows the native driver
 20 * to control the AC97 audio engine directly and requires a different driver.
 21 *
 22 * Thanks to National Semiconductor for providing the needed information
 23 * on the XpressAudio(tm) internals.
 24 *
 
 
 
 
 
 
 
 
 
 
 25 * TO DO:
 26 *	Investigate whether we can portably support Cognac (5520) in the
 27 *	same manner.
 28 */
 29
 30#include <linux/delay.h>
 31#include <linux/module.h>
 32#include <linux/pci.h>
 33#include <linux/slab.h>
 34#include <sound/core.h>
 35#include <sound/sb.h>
 36#include <sound/initval.h>
 37
 38MODULE_AUTHOR("Ash Willis");
 39MODULE_DESCRIPTION("CS5530 Audio");
 40MODULE_LICENSE("GPL");
 41
 42static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 43static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 44static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 45
 46module_param_array(index, int, NULL, 0444);
 47MODULE_PARM_DESC(index, "Index value for CS5530 Audio driver.");
 48module_param_array(id, charp, NULL, 0444);
 49MODULE_PARM_DESC(id, "ID string for CS5530 Audio driver.");
 50module_param_array(enable, bool, NULL, 0444);
 51MODULE_PARM_DESC(enable, "Enable CS5530 Audio driver.");
 52
 53struct snd_cs5530 {
 54	struct snd_card *card;
 55	struct pci_dev *pci;
 56	struct snd_sb *sb;
 57	unsigned long pci_base;
 58};
 59
 60static const struct pci_device_id snd_cs5530_ids[] = {
 61	{PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_AUDIO, PCI_ANY_ID,
 62							PCI_ANY_ID, 0, 0},
 63	{0,}
 64};
 65
 66MODULE_DEVICE_TABLE(pci, snd_cs5530_ids);
 67
 68static int snd_cs5530_free(struct snd_cs5530 *chip)
 69{
 70	pci_release_regions(chip->pci);
 71	pci_disable_device(chip->pci);
 72	kfree(chip);
 73	return 0;
 74}
 75
 76static int snd_cs5530_dev_free(struct snd_device *device)
 77{
 78	struct snd_cs5530 *chip = device->device_data;
 79	return snd_cs5530_free(chip);
 80}
 81
 82static void snd_cs5530_remove(struct pci_dev *pci)
 83{
 84	snd_card_free(pci_get_drvdata(pci));
 85}
 86
 87static u8 snd_cs5530_mixer_read(unsigned long io, u8 reg)
 88{
 89	outb(reg, io + 4);
 90	udelay(20);
 91	reg = inb(io + 5);
 92	udelay(20);
 93	return reg;
 94}
 95
 96static int snd_cs5530_create(struct snd_card *card,
 97			     struct pci_dev *pci,
 98			     struct snd_cs5530 **rchip)
 99{
100	struct snd_cs5530 *chip;
101	unsigned long sb_base;
102	u8 irq, dma8, dma16 = 0;
103	u16 map;
104	void __iomem *mem;
105	int err;
106
107	static const struct snd_device_ops ops = {
108		.dev_free = snd_cs5530_dev_free,
109	};
110	*rchip = NULL;
111
112	err = pci_enable_device(pci);
113 	if (err < 0)
114		return err;
115
116	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
117	if (chip == NULL) {
118		pci_disable_device(pci);
119		return -ENOMEM;
120	}
121
122	chip->card = card;
123	chip->pci = pci;
124
125	err = pci_request_regions(pci, "CS5530");
126	if (err < 0) {
127		kfree(chip); 
128		pci_disable_device(pci);
129		return err;
130	}
131	chip->pci_base = pci_resource_start(pci, 0);
132
133	mem = pci_ioremap_bar(pci, 0);
134	if (mem == NULL) {
135		snd_cs5530_free(chip);
136		return -EBUSY;
137	}
138
139	map = readw(mem + 0x18);
140	iounmap(mem);
141
142	/* Map bits
143		0:1	* 0x20 + 0x200 = sb base
144		2	sb enable
145		3	adlib enable
146		5	MPU enable 0x330
147		6	MPU enable 0x300
148
149	   The other bits may be used internally so must be masked */
150
151	sb_base = 0x220 + 0x20 * (map & 3);
152
153	if (map & (1<<2))
154		dev_info(card->dev, "XpressAudio at 0x%lx\n", sb_base);
155	else {
156		dev_err(card->dev, "Could not find XpressAudio!\n");
157		snd_cs5530_free(chip);
158		return -ENODEV;
159	}
160
161	if (map & (1<<5))
162		dev_info(card->dev, "MPU at 0x300\n");
163	else if (map & (1<<6))
164		dev_info(card->dev, "MPU at 0x330\n");
165
166	irq = snd_cs5530_mixer_read(sb_base, 0x80) & 0x0F;
167	dma8 = snd_cs5530_mixer_read(sb_base, 0x81);
168
169	if (dma8 & 0x20)
170		dma16 = 5;
171	else if (dma8 & 0x40)
172		dma16 = 6;
173	else if (dma8 & 0x80)
174		dma16 = 7;
175	else {
176		dev_err(card->dev, "No 16bit DMA enabled\n");
177		snd_cs5530_free(chip);
178		return -ENODEV;
179	}
180
181	if (dma8 & 0x01)
182		dma8 = 0;
183	else if (dma8 & 02)
184		dma8 = 1;
185	else if (dma8 & 0x08)
186		dma8 = 3;
187	else {
188		dev_err(card->dev, "No 8bit DMA enabled\n");
189		snd_cs5530_free(chip);
190		return -ENODEV;
191	}
192
193	if (irq & 1)
194		irq = 9;
195	else if (irq & 2)
196		irq = 5;
197	else if (irq & 4)
198		irq = 7;
199	else if (irq & 8)
200		irq = 10;
201	else {
202		dev_err(card->dev, "SoundBlaster IRQ not set\n");
203		snd_cs5530_free(chip);
204		return -ENODEV;
205	}
206
207	dev_info(card->dev, "IRQ: %d DMA8: %d DMA16: %d\n", irq, dma8, dma16);
208
209	err = snd_sbdsp_create(card, sb_base, irq, snd_sb16dsp_interrupt, dma8,
210						dma16, SB_HW_CS5530, &chip->sb);
211	if (err < 0) {
212		dev_err(card->dev, "Could not create SoundBlaster\n");
213		snd_cs5530_free(chip);
214		return err;
215	}
216
217	err = snd_sb16dsp_pcm(chip->sb, 0);
218	if (err < 0) {
219		dev_err(card->dev, "Could not create PCM\n");
220		snd_cs5530_free(chip);
221		return err;
222	}
223
224	err = snd_sbmixer_new(chip->sb);
225	if (err < 0) {
226		dev_err(card->dev, "Could not create Mixer\n");
227		snd_cs5530_free(chip);
228		return err;
229	}
230
231	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
232	if (err < 0) {
233		snd_cs5530_free(chip);
234		return err;
235	}
236
237	*rchip = chip;
238	return 0;
239}
240
241static int snd_cs5530_probe(struct pci_dev *pci,
242			    const struct pci_device_id *pci_id)
243{
244	static int dev;
245	struct snd_card *card;
246	struct snd_cs5530 *chip = NULL;
247	int err;
248
249	if (dev >= SNDRV_CARDS)
250		return -ENODEV;
251	if (!enable[dev]) {
252		dev++;
253		return -ENOENT;
254	}
255
256	err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
257			   0, &card);
258
259	if (err < 0)
260		return err;
261
262	err = snd_cs5530_create(card, pci, &chip);
263	if (err < 0) {
264		snd_card_free(card);
265		return err;
266	}
267
268	strcpy(card->driver, "CS5530");
269	strcpy(card->shortname, "CS5530 Audio");
270	sprintf(card->longname, "%s at 0x%lx", card->shortname, chip->pci_base);
271
272	err = snd_card_register(card);
273	if (err < 0) {
274		snd_card_free(card);
275		return err;
276	}
277	pci_set_drvdata(pci, card);
278	dev++;
279	return 0;
280}
281
282static struct pci_driver cs5530_driver = {
283	.name = KBUILD_MODNAME,
284	.id_table = snd_cs5530_ids,
285	.probe = snd_cs5530_probe,
286	.remove = snd_cs5530_remove,
287};
288
289module_pci_driver(cs5530_driver);
v3.15
 
  1/*
  2 * cs5530.c - Initialisation code for Cyrix/NatSemi VSA1 softaudio
  3 *
  4 * 	(C) Copyright 2007 Ash Willis <ashwillis@programmer.net>
  5 *	(C) Copyright 2003 Red Hat Inc <alan@lxorguk.ukuu.org.uk>
  6 *
  7 * This driver was ported (shamelessly ripped ;) from oss/kahlua.c but I did
  8 * mess with it a bit. The chip seems to have to have trouble with full duplex
  9 * mode. If we're recording in 8bit 8000kHz, say, and we then attempt to
 10 * simultaneously play back audio at 16bit 44100kHz, the device actually plays
 11 * back in the same format in which it is capturing. By forcing the chip to
 12 * always play/capture in 16/44100, we can let alsa-lib convert the samples and
 13 * that way we can hack up some full duplex audio. 
 14 * 
 15 * XpressAudio(tm) is used on the Cyrix MediaGX (now NatSemi Geode) systems.
 16 * The older version (VSA1) provides fairly good soundblaster emulation
 17 * although there are a couple of bugs: large DMA buffers break record,
 18 * and the MPU event handling seems suspect. VSA2 allows the native driver
 19 * to control the AC97 audio engine directly and requires a different driver.
 20 *
 21 * Thanks to National Semiconductor for providing the needed information
 22 * on the XpressAudio(tm) internals.
 23 *
 24 * This program is free software; you can redistribute it and/or modify it
 25 * under the terms of the GNU General Public License as published by the
 26 * Free Software Foundation; either version 2, or (at your option) any
 27 * later version.
 28 *
 29 * This program is distributed in the hope that it will be useful, but
 30 * WITHOUT ANY WARRANTY; without even the implied warranty of
 31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 32 * General Public License for more details.
 33 *
 34 * TO DO:
 35 *	Investigate whether we can portably support Cognac (5520) in the
 36 *	same manner.
 37 */
 38
 39#include <linux/delay.h>
 40#include <linux/module.h>
 41#include <linux/pci.h>
 42#include <linux/slab.h>
 43#include <sound/core.h>
 44#include <sound/sb.h>
 45#include <sound/initval.h>
 46
 47MODULE_AUTHOR("Ash Willis");
 48MODULE_DESCRIPTION("CS5530 Audio");
 49MODULE_LICENSE("GPL");
 50
 51static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 52static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 53static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 54
 55module_param_array(index, int, NULL, 0444);
 56MODULE_PARM_DESC(index, "Index value for CS5530 Audio driver.");
 57module_param_array(id, charp, NULL, 0444);
 58MODULE_PARM_DESC(id, "ID string for CS5530 Audio driver.");
 59module_param_array(enable, bool, NULL, 0444);
 60MODULE_PARM_DESC(enable, "Enable CS5530 Audio driver.");
 61
 62struct snd_cs5530 {
 63	struct snd_card *card;
 64	struct pci_dev *pci;
 65	struct snd_sb *sb;
 66	unsigned long pci_base;
 67};
 68
 69static DEFINE_PCI_DEVICE_TABLE(snd_cs5530_ids) = {
 70	{PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_AUDIO, PCI_ANY_ID,
 71							PCI_ANY_ID, 0, 0},
 72	{0,}
 73};
 74
 75MODULE_DEVICE_TABLE(pci, snd_cs5530_ids);
 76
 77static int snd_cs5530_free(struct snd_cs5530 *chip)
 78{
 79	pci_release_regions(chip->pci);
 80	pci_disable_device(chip->pci);
 81	kfree(chip);
 82	return 0;
 83}
 84
 85static int snd_cs5530_dev_free(struct snd_device *device)
 86{
 87	struct snd_cs5530 *chip = device->device_data;
 88	return snd_cs5530_free(chip);
 89}
 90
 91static void snd_cs5530_remove(struct pci_dev *pci)
 92{
 93	snd_card_free(pci_get_drvdata(pci));
 94}
 95
 96static u8 snd_cs5530_mixer_read(unsigned long io, u8 reg)
 97{
 98	outb(reg, io + 4);
 99	udelay(20);
100	reg = inb(io + 5);
101	udelay(20);
102	return reg;
103}
104
105static int snd_cs5530_create(struct snd_card *card,
106			     struct pci_dev *pci,
107			     struct snd_cs5530 **rchip)
108{
109	struct snd_cs5530 *chip;
110	unsigned long sb_base;
111	u8 irq, dma8, dma16 = 0;
112	u16 map;
113	void __iomem *mem;
114	int err;
115
116	static struct snd_device_ops ops = {
117		.dev_free = snd_cs5530_dev_free,
118	};
119	*rchip = NULL;
120
121	err = pci_enable_device(pci);
122 	if (err < 0)
123		return err;
124
125	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
126	if (chip == NULL) {
127		pci_disable_device(pci);
128		return -ENOMEM;
129	}
130
131	chip->card = card;
132	chip->pci = pci;
133
134	err = pci_request_regions(pci, "CS5530");
135	if (err < 0) {
136		kfree(chip); 
137		pci_disable_device(pci);
138		return err;
139	}
140	chip->pci_base = pci_resource_start(pci, 0);
141
142	mem = pci_ioremap_bar(pci, 0);
143	if (mem == NULL) {
144		snd_cs5530_free(chip);
145		return -EBUSY;
146	}
147
148	map = readw(mem + 0x18);
149	iounmap(mem);
150
151	/* Map bits
152		0:1	* 0x20 + 0x200 = sb base
153		2	sb enable
154		3	adlib enable
155		5	MPU enable 0x330
156		6	MPU enable 0x300
157
158	   The other bits may be used internally so must be masked */
159
160	sb_base = 0x220 + 0x20 * (map & 3);
161
162	if (map & (1<<2))
163		dev_info(card->dev, "XpressAudio at 0x%lx\n", sb_base);
164	else {
165		dev_err(card->dev, "Could not find XpressAudio!\n");
166		snd_cs5530_free(chip);
167		return -ENODEV;
168	}
169
170	if (map & (1<<5))
171		dev_info(card->dev, "MPU at 0x300\n");
172	else if (map & (1<<6))
173		dev_info(card->dev, "MPU at 0x330\n");
174
175	irq = snd_cs5530_mixer_read(sb_base, 0x80) & 0x0F;
176	dma8 = snd_cs5530_mixer_read(sb_base, 0x81);
177
178	if (dma8 & 0x20)
179		dma16 = 5;
180	else if (dma8 & 0x40)
181		dma16 = 6;
182	else if (dma8 & 0x80)
183		dma16 = 7;
184	else {
185		dev_err(card->dev, "No 16bit DMA enabled\n");
186		snd_cs5530_free(chip);
187		return -ENODEV;
188	}
189
190	if (dma8 & 0x01)
191		dma8 = 0;
192	else if (dma8 & 02)
193		dma8 = 1;
194	else if (dma8 & 0x08)
195		dma8 = 3;
196	else {
197		dev_err(card->dev, "No 8bit DMA enabled\n");
198		snd_cs5530_free(chip);
199		return -ENODEV;
200	}
201
202	if (irq & 1)
203		irq = 9;
204	else if (irq & 2)
205		irq = 5;
206	else if (irq & 4)
207		irq = 7;
208	else if (irq & 8)
209		irq = 10;
210	else {
211		dev_err(card->dev, "SoundBlaster IRQ not set\n");
212		snd_cs5530_free(chip);
213		return -ENODEV;
214	}
215
216	dev_info(card->dev, "IRQ: %d DMA8: %d DMA16: %d\n", irq, dma8, dma16);
217
218	err = snd_sbdsp_create(card, sb_base, irq, snd_sb16dsp_interrupt, dma8,
219						dma16, SB_HW_CS5530, &chip->sb);
220	if (err < 0) {
221		dev_err(card->dev, "Could not create SoundBlaster\n");
222		snd_cs5530_free(chip);
223		return err;
224	}
225
226	err = snd_sb16dsp_pcm(chip->sb, 0, &chip->sb->pcm);
227	if (err < 0) {
228		dev_err(card->dev, "Could not create PCM\n");
229		snd_cs5530_free(chip);
230		return err;
231	}
232
233	err = snd_sbmixer_new(chip->sb);
234	if (err < 0) {
235		dev_err(card->dev, "Could not create Mixer\n");
236		snd_cs5530_free(chip);
237		return err;
238	}
239
240	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
241	if (err < 0) {
242		snd_cs5530_free(chip);
243		return err;
244	}
245
246	*rchip = chip;
247	return 0;
248}
249
250static int snd_cs5530_probe(struct pci_dev *pci,
251			    const struct pci_device_id *pci_id)
252{
253	static int dev;
254	struct snd_card *card;
255	struct snd_cs5530 *chip = NULL;
256	int err;
257
258	if (dev >= SNDRV_CARDS)
259		return -ENODEV;
260	if (!enable[dev]) {
261		dev++;
262		return -ENOENT;
263	}
264
265	err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
266			   0, &card);
267
268	if (err < 0)
269		return err;
270
271	err = snd_cs5530_create(card, pci, &chip);
272	if (err < 0) {
273		snd_card_free(card);
274		return err;
275	}
276
277	strcpy(card->driver, "CS5530");
278	strcpy(card->shortname, "CS5530 Audio");
279	sprintf(card->longname, "%s at 0x%lx", card->shortname, chip->pci_base);
280
281	err = snd_card_register(card);
282	if (err < 0) {
283		snd_card_free(card);
284		return err;
285	}
286	pci_set_drvdata(pci, card);
287	dev++;
288	return 0;
289}
290
291static struct pci_driver cs5530_driver = {
292	.name = KBUILD_MODNAME,
293	.id_table = snd_cs5530_ids,
294	.probe = snd_cs5530_probe,
295	.remove = snd_cs5530_remove,
296};
297
298module_pci_driver(cs5530_driver);