Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/sound/pci/cs5535audio/cs5535audio.c

  1 /*
  2  * Driver for audio on multifunction CS5535/6 companion device
  3  * Copyright (C) Jaya Kumar
  4  *
  5  * Based on Jaroslav Kysela and Takashi Iwai's examples.
  6  * This work was sponsored by CIS(M) Sdn Bhd.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 21  *
 22  */
 23 
 24 #include <linux/delay.h>
 25 #include <linux/interrupt.h>
 26 #include <linux/init.h>
 27 #include <linux/pci.h>
 28 #include <linux/slab.h>
 29 #include <linux/module.h>
 30 #include <asm/io.h>
 31 #include <sound/core.h>
 32 #include <sound/control.h>
 33 #include <sound/pcm.h>
 34 #include <sound/rawmidi.h>
 35 #include <sound/ac97_codec.h>
 36 #include <sound/initval.h>
 37 #include <sound/asoundef.h>
 38 #include "cs5535audio.h"
 39 
 40 #define DRIVER_NAME "cs5535audio"
 41 
 42 static char *ac97_quirk;
 43 module_param(ac97_quirk, charp, 0444);
 44 MODULE_PARM_DESC(ac97_quirk, "AC'97 board specific workarounds.");
 45 
 46 static struct ac97_quirk ac97_quirks[] = {
 47 #if 0 /* Not yet confirmed if all 5536 boards are HP only */
 48         {
 49                 .subvendor = PCI_VENDOR_ID_AMD, 
 50                 .subdevice = PCI_DEVICE_ID_AMD_CS5536_AUDIO, 
 51                 .name = "AMD RDK",     
 52                 .type = AC97_TUNE_HP_ONLY
 53         },
 54 #endif
 55         {}
 56 };
 57 
 58 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 59 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 60 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 61 
 62 module_param_array(index, int, NULL, 0444);
 63 MODULE_PARM_DESC(index, "Index value for " DRIVER_NAME);
 64 module_param_array(id, charp, NULL, 0444);
 65 MODULE_PARM_DESC(id, "ID string for " DRIVER_NAME);
 66 module_param_array(enable, bool, NULL, 0444);
 67 MODULE_PARM_DESC(enable, "Enable " DRIVER_NAME);
 68 
 69 static DEFINE_PCI_DEVICE_TABLE(snd_cs5535audio_ids) = {
 70         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO) },
 71         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_AUDIO) },
 72         {}
 73 };
 74 
 75 MODULE_DEVICE_TABLE(pci, snd_cs5535audio_ids);
 76 
 77 static void wait_till_cmd_acked(struct cs5535audio *cs5535au, unsigned long timeout)
 78 {
 79         unsigned int tmp;
 80         do {
 81                 tmp = cs_readl(cs5535au, ACC_CODEC_CNTL);
 82                 if (!(tmp & CMD_NEW))
 83                         break;
 84                 udelay(1);
 85         } while (--timeout);
 86         if (!timeout)
 87                 dev_err(cs5535au->card->dev,
 88                         "Failure writing to cs5535 codec\n");
 89 }
 90 
 91 static unsigned short snd_cs5535audio_codec_read(struct cs5535audio *cs5535au,
 92                                                  unsigned short reg)
 93 {
 94         unsigned int regdata;
 95         unsigned int timeout;
 96         unsigned int val;
 97 
 98         regdata = ((unsigned int) reg) << 24;
 99         regdata |= ACC_CODEC_CNTL_RD_CMD;
100         regdata |= CMD_NEW;
101 
102         cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
103         wait_till_cmd_acked(cs5535au, 50);
104 
105         timeout = 50;
106         do {
107                 val = cs_readl(cs5535au, ACC_CODEC_STATUS);
108                 if ((val & STS_NEW) && reg == (val >> 24))
109                         break;
110                 udelay(1);
111         } while (--timeout);
112         if (!timeout)
113                 dev_err(cs5535au->card->dev,
114                         "Failure reading codec reg 0x%x, Last value=0x%x\n",
115                         reg, val);
116 
117         return (unsigned short) val;
118 }
119 
120 static void snd_cs5535audio_codec_write(struct cs5535audio *cs5535au,
121                                         unsigned short reg, unsigned short val)
122 {
123         unsigned int regdata;
124 
125         regdata = ((unsigned int) reg) << 24;
126         regdata |= val;
127         regdata &= CMD_MASK;
128         regdata |= CMD_NEW;
129         regdata &= ACC_CODEC_CNTL_WR_CMD;
130 
131         cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
132         wait_till_cmd_acked(cs5535au, 50);
133 }
134 
135 static void snd_cs5535audio_ac97_codec_write(struct snd_ac97 *ac97,
136                                              unsigned short reg, unsigned short val)
137 {
138         struct cs5535audio *cs5535au = ac97->private_data;
139         snd_cs5535audio_codec_write(cs5535au, reg, val);
140 }
141 
142 static unsigned short snd_cs5535audio_ac97_codec_read(struct snd_ac97 *ac97,
143                                                       unsigned short reg)
144 {
145         struct cs5535audio *cs5535au = ac97->private_data;
146         return snd_cs5535audio_codec_read(cs5535au, reg);
147 }
148 
149 static int snd_cs5535audio_mixer(struct cs5535audio *cs5535au)
150 {
151         struct snd_card *card = cs5535au->card;
152         struct snd_ac97_bus *pbus;
153         struct snd_ac97_template ac97;
154         int err;
155         static struct snd_ac97_bus_ops ops = {
156                 .write = snd_cs5535audio_ac97_codec_write,
157                 .read = snd_cs5535audio_ac97_codec_read,
158         };
159 
160         if ((err = snd_ac97_bus(card, 0, &ops, NULL, &pbus)) < 0)
161                 return err;
162 
163         memset(&ac97, 0, sizeof(ac97));
164         ac97.scaps = AC97_SCAP_AUDIO | AC97_SCAP_SKIP_MODEM
165                         | AC97_SCAP_POWER_SAVE;
166         ac97.private_data = cs5535au;
167         ac97.pci = cs5535au->pci;
168 
169         /* set any OLPC-specific scaps */
170         olpc_prequirks(card, &ac97);
171 
172         if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
173                 dev_err(card->dev, "mixer failed\n");
174                 return err;
175         }
176 
177         snd_ac97_tune_hardware(cs5535au->ac97, ac97_quirks, ac97_quirk);
178 
179         err = olpc_quirks(card, cs5535au->ac97);
180         if (err < 0) {
181                 dev_err(card->dev, "olpc quirks failed\n");
182                 return err;
183         }
184 
185         return 0;
186 }
187 
188 static void process_bm0_irq(struct cs5535audio *cs5535au)
189 {
190         u8 bm_stat;
191         spin_lock(&cs5535au->reg_lock);
192         bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS);
193         spin_unlock(&cs5535au->reg_lock);
194         if (bm_stat & EOP) {
195                 struct cs5535audio_dma *dma;
196                 dma = cs5535au->playback_substream->runtime->private_data;
197                 snd_pcm_period_elapsed(cs5535au->playback_substream);
198         } else {
199                 dev_err(cs5535au->card->dev,
200                         "unexpected bm0 irq src, bm_stat=%x\n",
201                         bm_stat);
202         }
203 }
204 
205 static void process_bm1_irq(struct cs5535audio *cs5535au)
206 {
207         u8 bm_stat;
208         spin_lock(&cs5535au->reg_lock);
209         bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS);
210         spin_unlock(&cs5535au->reg_lock);
211         if (bm_stat & EOP) {
212                 struct cs5535audio_dma *dma;
213                 dma = cs5535au->capture_substream->runtime->private_data;
214                 snd_pcm_period_elapsed(cs5535au->capture_substream);
215         }
216 }
217 
218 static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id)
219 {
220         u16 acc_irq_stat;
221         unsigned char count;
222         struct cs5535audio *cs5535au = dev_id;
223 
224         if (cs5535au == NULL)
225                 return IRQ_NONE;
226 
227         acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS);
228 
229         if (!acc_irq_stat)
230                 return IRQ_NONE;
231         for (count = 0; count < 4; count++) {
232                 if (acc_irq_stat & (1 << count)) {
233                         switch (count) {
234                         case IRQ_STS:
235                                 cs_readl(cs5535au, ACC_GPIO_STATUS);
236                                 break;
237                         case WU_IRQ_STS:
238                                 cs_readl(cs5535au, ACC_GPIO_STATUS);
239                                 break;
240                         case BM0_IRQ_STS:
241                                 process_bm0_irq(cs5535au);
242                                 break;
243                         case BM1_IRQ_STS:
244                                 process_bm1_irq(cs5535au);
245                                 break;
246                         default:
247                                 dev_err(cs5535au->card->dev,
248                                         "Unexpected irq src: 0x%x\n",
249                                         acc_irq_stat);
250                                 break;
251                         }
252                 }
253         }
254         return IRQ_HANDLED;
255 }
256 
257 static int snd_cs5535audio_free(struct cs5535audio *cs5535au)
258 {
259         synchronize_irq(cs5535au->irq);
260         pci_set_power_state(cs5535au->pci, PCI_D3hot);
261 
262         if (cs5535au->irq >= 0)
263                 free_irq(cs5535au->irq, cs5535au);
264 
265         pci_release_regions(cs5535au->pci);
266         pci_disable_device(cs5535au->pci);
267         kfree(cs5535au);
268         return 0;
269 }
270 
271 static int snd_cs5535audio_dev_free(struct snd_device *device)
272 {
273         struct cs5535audio *cs5535au = device->device_data;
274         return snd_cs5535audio_free(cs5535au);
275 }
276 
277 static int snd_cs5535audio_create(struct snd_card *card,
278                                   struct pci_dev *pci,
279                                   struct cs5535audio **rcs5535au)
280 {
281         struct cs5535audio *cs5535au;
282 
283         int err;
284         static struct snd_device_ops ops = {
285                 .dev_free =     snd_cs5535audio_dev_free,
286         };
287 
288         *rcs5535au = NULL;
289         if ((err = pci_enable_device(pci)) < 0)
290                 return err;
291 
292         if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
293             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
294                 dev_warn(card->dev, "unable to get 32bit dma\n");
295                 err = -ENXIO;
296                 goto pcifail;
297         }
298 
299         cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
300         if (cs5535au == NULL) {
301                 err = -ENOMEM;
302                 goto pcifail;
303         }
304 
305         spin_lock_init(&cs5535au->reg_lock);
306         cs5535au->card = card;
307         cs5535au->pci = pci;
308         cs5535au->irq = -1;
309 
310         if ((err = pci_request_regions(pci, "CS5535 Audio")) < 0) {
311                 kfree(cs5535au);
312                 goto pcifail;
313         }
314 
315         cs5535au->port = pci_resource_start(pci, 0);
316 
317         if (request_irq(pci->irq, snd_cs5535audio_interrupt,
318                         IRQF_SHARED, KBUILD_MODNAME, cs5535au)) {
319                 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
320                 err = -EBUSY;
321                 goto sndfail;
322         }
323 
324         cs5535au->irq = pci->irq;
325         pci_set_master(pci);
326 
327         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
328                                   cs5535au, &ops)) < 0)
329                 goto sndfail;
330 
331         *rcs5535au = cs5535au;
332         return 0;
333 
334 sndfail: /* leave the device alive, just kill the snd */
335         snd_cs5535audio_free(cs5535au);
336         return err;
337 
338 pcifail:
339         pci_disable_device(pci);
340         return err;
341 }
342 
343 static int snd_cs5535audio_probe(struct pci_dev *pci,
344                                  const struct pci_device_id *pci_id)
345 {
346         static int dev;
347         struct snd_card *card;
348         struct cs5535audio *cs5535au;
349         int err;
350 
351         if (dev >= SNDRV_CARDS)
352                 return -ENODEV;
353         if (!enable[dev]) {
354                 dev++;
355                 return -ENOENT;
356         }
357 
358         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
359                            0, &card);
360         if (err < 0)
361                 return err;
362 
363         if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0)
364                 goto probefail_out;
365 
366         card->private_data = cs5535au;
367 
368         if ((err = snd_cs5535audio_mixer(cs5535au)) < 0)
369                 goto probefail_out;
370 
371         if ((err = snd_cs5535audio_pcm(cs5535au)) < 0)
372                 goto probefail_out;
373 
374         strcpy(card->driver, DRIVER_NAME);
375 
376         strcpy(card->shortname, "CS5535 Audio");
377         sprintf(card->longname, "%s %s at 0x%lx, irq %i",
378                 card->shortname, card->driver,
379                 cs5535au->port, cs5535au->irq);
380 
381         if ((err = snd_card_register(card)) < 0)
382                 goto probefail_out;
383 
384         pci_set_drvdata(pci, card);
385         dev++;
386         return 0;
387 
388 probefail_out:
389         snd_card_free(card);
390         return err;
391 }
392 
393 static void snd_cs5535audio_remove(struct pci_dev *pci)
394 {
395         olpc_quirks_cleanup();
396         snd_card_free(pci_get_drvdata(pci));
397 }
398 
399 static struct pci_driver cs5535audio_driver = {
400         .name = KBUILD_MODNAME,
401         .id_table = snd_cs5535audio_ids,
402         .probe = snd_cs5535audio_probe,
403         .remove = snd_cs5535audio_remove,
404 #ifdef CONFIG_PM_SLEEP
405         .driver = {
406                 .pm = &snd_cs5535audio_pm,
407         },
408 #endif
409 };
410 
411 module_pci_driver(cs5535audio_driver);
412 
413 MODULE_AUTHOR("Jaya Kumar");
414 MODULE_LICENSE("GPL");
415 MODULE_DESCRIPTION("CS5535 Audio");
416 MODULE_SUPPORTED_DEVICE("CS5535 Audio");
417 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us