~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/aw2/aw2-alsa.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*****************************************************************************
  3  *
  4  * Copyright (C) 2008 Cedric Bregardis <cedric.bregardis@free.fr> and
  5  * Jean-Christian Hassler <jhassler@free.fr>
  6  *
  7  * This file is part of the Audiowerk2 ALSA driver
  8  *
  9  *****************************************************************************/
 10 #include <linux/init.h>
 11 #include <linux/pci.h>
 12 #include <linux/dma-mapping.h>
 13 #include <linux/slab.h>
 14 #include <linux/interrupt.h>
 15 #include <linux/delay.h>
 16 #include <linux/io.h>
 17 #include <linux/module.h>
 18 #include <sound/core.h>
 19 #include <sound/initval.h>
 20 #include <sound/pcm.h>
 21 #include <sound/pcm_params.h>
 22 #include <sound/control.h>
 23 
 24 #include "saa7146.h"
 25 #include "aw2-saa7146.h"
 26 
 27 MODULE_AUTHOR("Cedric Bregardis <cedric.bregardis@free.fr>, "
 28               "Jean-Christian Hassler <jhassler@free.fr>");
 29 MODULE_DESCRIPTION("Emagic Audiowerk 2 sound driver");
 30 MODULE_LICENSE("GPL");
 31 
 32 /*********************************
 33  * DEFINES
 34  ********************************/
 35 #define CTL_ROUTE_ANALOG 0
 36 #define CTL_ROUTE_DIGITAL 1
 37 
 38 /*********************************
 39  * TYPEDEFS
 40  ********************************/
 41   /* hardware definition */
 42 static const struct snd_pcm_hardware snd_aw2_playback_hw = {
 43         .info = (SNDRV_PCM_INFO_MMAP |
 44                  SNDRV_PCM_INFO_INTERLEAVED |
 45                  SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
 46         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 47         .rates = SNDRV_PCM_RATE_44100,
 48         .rate_min = 44100,
 49         .rate_max = 44100,
 50         .channels_min = 2,
 51         .channels_max = 4,
 52         .buffer_bytes_max = 32768,
 53         .period_bytes_min = 4096,
 54         .period_bytes_max = 32768,
 55         .periods_min = 1,
 56         .periods_max = 1024,
 57 };
 58 
 59 static const struct snd_pcm_hardware snd_aw2_capture_hw = {
 60         .info = (SNDRV_PCM_INFO_MMAP |
 61                  SNDRV_PCM_INFO_INTERLEAVED |
 62                  SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
 63         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 64         .rates = SNDRV_PCM_RATE_44100,
 65         .rate_min = 44100,
 66         .rate_max = 44100,
 67         .channels_min = 2,
 68         .channels_max = 2,
 69         .buffer_bytes_max = 32768,
 70         .period_bytes_min = 4096,
 71         .period_bytes_max = 32768,
 72         .periods_min = 1,
 73         .periods_max = 1024,
 74 };
 75 
 76 struct aw2_pcm_device {
 77         struct snd_pcm *pcm;
 78         unsigned int stream_number;
 79         struct aw2 *chip;
 80 };
 81 
 82 struct aw2 {
 83         struct snd_aw2_saa7146 saa7146;
 84 
 85         struct pci_dev *pci;
 86         int irq;
 87         spinlock_t reg_lock;
 88         struct mutex mtx;
 89 
 90         unsigned long iobase_phys;
 91         void __iomem *iobase_virt;
 92 
 93         struct snd_card *card;
 94 
 95         struct aw2_pcm_device device_playback[NB_STREAM_PLAYBACK];
 96         struct aw2_pcm_device device_capture[NB_STREAM_CAPTURE];
 97 };
 98 
 99 /*********************************
100  * FUNCTION DECLARATIONS
101  ********************************/
102 static int snd_aw2_dev_free(struct snd_device *device);
103 static int snd_aw2_create(struct snd_card *card,
104                           struct pci_dev *pci, struct aw2 **rchip);
105 static int snd_aw2_probe(struct pci_dev *pci,
106                          const struct pci_device_id *pci_id);
107 static void snd_aw2_remove(struct pci_dev *pci);
108 static int snd_aw2_pcm_playback_open(struct snd_pcm_substream *substream);
109 static int snd_aw2_pcm_playback_close(struct snd_pcm_substream *substream);
110 static int snd_aw2_pcm_capture_open(struct snd_pcm_substream *substream);
111 static int snd_aw2_pcm_capture_close(struct snd_pcm_substream *substream);
112 static int snd_aw2_pcm_hw_params(struct snd_pcm_substream *substream,
113                                  struct snd_pcm_hw_params *hw_params);
114 static int snd_aw2_pcm_hw_free(struct snd_pcm_substream *substream);
115 static int snd_aw2_pcm_prepare_playback(struct snd_pcm_substream *substream);
116 static int snd_aw2_pcm_prepare_capture(struct snd_pcm_substream *substream);
117 static int snd_aw2_pcm_trigger_playback(struct snd_pcm_substream *substream,
118                                         int cmd);
119 static int snd_aw2_pcm_trigger_capture(struct snd_pcm_substream *substream,
120                                        int cmd);
121 static snd_pcm_uframes_t snd_aw2_pcm_pointer_playback(struct snd_pcm_substream
122                                                       *substream);
123 static snd_pcm_uframes_t snd_aw2_pcm_pointer_capture(struct snd_pcm_substream
124                                                      *substream);
125 static int snd_aw2_new_pcm(struct aw2 *chip);
126 
127 static int snd_aw2_control_switch_capture_info(struct snd_kcontrol *kcontrol,
128                                                struct snd_ctl_elem_info *uinfo);
129 static int snd_aw2_control_switch_capture_get(struct snd_kcontrol *kcontrol,
130                                               struct snd_ctl_elem_value
131                                               *ucontrol);
132 static int snd_aw2_control_switch_capture_put(struct snd_kcontrol *kcontrol,
133                                               struct snd_ctl_elem_value
134                                               *ucontrol);
135 
136 /*********************************
137  * VARIABLES
138  ********************************/
139 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
140 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
141 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
142 
143 module_param_array(index, int, NULL, 0444);
144 MODULE_PARM_DESC(index, "Index value for Audiowerk2 soundcard.");
145 module_param_array(id, charp, NULL, 0444);
146 MODULE_PARM_DESC(id, "ID string for the Audiowerk2 soundcard.");
147 module_param_array(enable, bool, NULL, 0444);
148 MODULE_PARM_DESC(enable, "Enable Audiowerk2 soundcard.");
149 
150 static const struct pci_device_id snd_aw2_ids[] = {
151         {PCI_VENDOR_ID_PHILIPS, PCI_DEVICE_ID_PHILIPS_SAA7146, 0, 0,
152          0, 0, 0},
153         {0}
154 };
155 
156 MODULE_DEVICE_TABLE(pci, snd_aw2_ids);
157 
158 /* pci_driver definition */
159 static struct pci_driver aw2_driver = {
160         .name = KBUILD_MODNAME,
161         .id_table = snd_aw2_ids,
162         .probe = snd_aw2_probe,
163         .remove = snd_aw2_remove,
164 };
165 
166 module_pci_driver(aw2_driver);
167 
168 /* operators for playback PCM alsa interface */
169 static const struct snd_pcm_ops snd_aw2_playback_ops = {
170         .open = snd_aw2_pcm_playback_open,
171         .close = snd_aw2_pcm_playback_close,
172         .ioctl = snd_pcm_lib_ioctl,
173         .hw_params = snd_aw2_pcm_hw_params,
174         .hw_free = snd_aw2_pcm_hw_free,
175         .prepare = snd_aw2_pcm_prepare_playback,
176         .trigger = snd_aw2_pcm_trigger_playback,
177         .pointer = snd_aw2_pcm_pointer_playback,
178 };
179 
180 /* operators for capture PCM alsa interface */
181 static const struct snd_pcm_ops snd_aw2_capture_ops = {
182         .open = snd_aw2_pcm_capture_open,
183         .close = snd_aw2_pcm_capture_close,
184         .ioctl = snd_pcm_lib_ioctl,
185         .hw_params = snd_aw2_pcm_hw_params,
186         .hw_free = snd_aw2_pcm_hw_free,
187         .prepare = snd_aw2_pcm_prepare_capture,
188         .trigger = snd_aw2_pcm_trigger_capture,
189         .pointer = snd_aw2_pcm_pointer_capture,
190 };
191 
192 static const struct snd_kcontrol_new aw2_control = {
193         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
194         .name = "PCM Capture Route",
195         .index = 0,
196         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
197         .private_value = 0xffff,
198         .info = snd_aw2_control_switch_capture_info,
199         .get = snd_aw2_control_switch_capture_get,
200         .put = snd_aw2_control_switch_capture_put
201 };
202 
203 /*********************************
204  * FUNCTION IMPLEMENTATIONS
205  ********************************/
206 
207 /* component-destructor */
208 static int snd_aw2_dev_free(struct snd_device *device)
209 {
210         struct aw2 *chip = device->device_data;
211 
212         /* Free hardware */
213         snd_aw2_saa7146_free(&chip->saa7146);
214 
215         /* release the irq */
216         if (chip->irq >= 0)
217                 free_irq(chip->irq, (void *)chip);
218         /* release the i/o ports & memory */
219         iounmap(chip->iobase_virt);
220         pci_release_regions(chip->pci);
221         /* disable the PCI entry */
222         pci_disable_device(chip->pci);
223         /* release the data */
224         kfree(chip);
225 
226         return 0;
227 }
228 
229 /* chip-specific constructor */
230 static int snd_aw2_create(struct snd_card *card,
231                           struct pci_dev *pci, struct aw2 **rchip)
232 {
233         struct aw2 *chip;
234         int err;
235         static struct snd_device_ops ops = {
236                 .dev_free = snd_aw2_dev_free,
237         };
238 
239         *rchip = NULL;
240 
241         /* initialize the PCI entry */
242         err = pci_enable_device(pci);
243         if (err < 0)
244                 return err;
245         pci_set_master(pci);
246 
247         /* check PCI availability (32bit DMA) */
248         if ((dma_set_mask(&pci->dev, DMA_BIT_MASK(32)) < 0) ||
249             (dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(32)) < 0)) {
250                 dev_err(card->dev, "Impossible to set 32bit mask DMA\n");
251                 pci_disable_device(pci);
252                 return -ENXIO;
253         }
254         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
255         if (chip == NULL) {
256                 pci_disable_device(pci);
257                 return -ENOMEM;
258         }
259 
260         /* initialize the stuff */
261         chip->card = card;
262         chip->pci = pci;
263         chip->irq = -1;
264 
265         /* (1) PCI resource allocation */
266         err = pci_request_regions(pci, "Audiowerk2");
267         if (err < 0) {
268                 pci_disable_device(pci);
269                 kfree(chip);
270                 return err;
271         }
272         chip->iobase_phys = pci_resource_start(pci, 0);
273         chip->iobase_virt =
274                 ioremap_nocache(chip->iobase_phys,
275                                 pci_resource_len(pci, 0));
276 
277         if (chip->iobase_virt == NULL) {
278                 dev_err(card->dev, "unable to remap memory region");
279                 pci_release_regions(pci);
280                 pci_disable_device(pci);
281                 kfree(chip);
282                 return -ENOMEM;
283         }
284 
285         /* (2) initialization of the chip hardware */
286         snd_aw2_saa7146_setup(&chip->saa7146, chip->iobase_virt);
287 
288         if (request_irq(pci->irq, snd_aw2_saa7146_interrupt,
289                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
290                 dev_err(card->dev, "Cannot grab irq %d\n", pci->irq);
291 
292                 iounmap(chip->iobase_virt);
293                 pci_release_regions(chip->pci);
294                 pci_disable_device(chip->pci);
295                 kfree(chip);
296                 return -EBUSY;
297         }
298         chip->irq = pci->irq;
299 
300         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
301         if (err < 0) {
302                 free_irq(chip->irq, (void *)chip);
303                 iounmap(chip->iobase_virt);
304                 pci_release_regions(chip->pci);
305                 pci_disable_device(chip->pci);
306                 kfree(chip);
307                 return err;
308         }
309 
310         *rchip = chip;
311 
312         dev_info(card->dev,
313                  "Audiowerk 2 sound card (saa7146 chipset) detected and managed\n");
314         return 0;
315 }
316 
317 /* constructor */
318 static int snd_aw2_probe(struct pci_dev *pci,
319                          const struct pci_device_id *pci_id)
320 {
321         static int dev;
322         struct snd_card *card;
323         struct aw2 *chip;
324         int err;
325 
326         /* (1) Continue if device is not enabled, else inc dev */
327         if (dev >= SNDRV_CARDS)
328                 return -ENODEV;
329         if (!enable[dev]) {
330                 dev++;
331                 return -ENOENT;
332         }
333 
334         /* (2) Create card instance */
335         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
336                            0, &card);
337         if (err < 0)
338                 return err;
339 
340         /* (3) Create main component */
341         err = snd_aw2_create(card, pci, &chip);
342         if (err < 0) {
343                 snd_card_free(card);
344                 return err;
345         }
346 
347         /* initialize mutex */
348         mutex_init(&chip->mtx);
349         /* init spinlock */
350         spin_lock_init(&chip->reg_lock);
351         /* (4) Define driver ID and name string */
352         strcpy(card->driver, "aw2");
353         strcpy(card->shortname, "Audiowerk2");
354 
355         sprintf(card->longname, "%s with SAA7146 irq %i",
356                 card->shortname, chip->irq);
357 
358         /* (5) Create other components */
359         snd_aw2_new_pcm(chip);
360 
361         /* (6) Register card instance */
362         err = snd_card_register(card);
363         if (err < 0) {
364                 snd_card_free(card);
365                 return err;
366         }
367 
368         /* (7) Set PCI driver data */
369         pci_set_drvdata(pci, card);
370 
371         dev++;
372         return 0;
373 }
374 
375 /* destructor */
376 static void snd_aw2_remove(struct pci_dev *pci)
377 {
378         snd_card_free(pci_get_drvdata(pci));
379 }
380 
381 /* open callback */
382 static int snd_aw2_pcm_playback_open(struct snd_pcm_substream *substream)
383 {
384         struct snd_pcm_runtime *runtime = substream->runtime;
385 
386         dev_dbg(substream->pcm->card->dev, "Playback_open\n");
387         runtime->hw = snd_aw2_playback_hw;
388         return 0;
389 }
390 
391 /* close callback */
392 static int snd_aw2_pcm_playback_close(struct snd_pcm_substream *substream)
393 {
394         return 0;
395 
396 }
397 
398 static int snd_aw2_pcm_capture_open(struct snd_pcm_substream *substream)
399 {
400         struct snd_pcm_runtime *runtime = substream->runtime;
401 
402         dev_dbg(substream->pcm->card->dev, "Capture_open\n");
403         runtime->hw = snd_aw2_capture_hw;
404         return 0;
405 }
406 
407 /* close callback */
408 static int snd_aw2_pcm_capture_close(struct snd_pcm_substream *substream)
409 {
410         /* TODO: something to do ? */
411         return 0;
412 }
413 
414  /* hw_params callback */
415 static int snd_aw2_pcm_hw_params(struct snd_pcm_substream *substream,
416                                  struct snd_pcm_hw_params *hw_params)
417 {
418         return snd_pcm_lib_malloc_pages(substream,
419                                         params_buffer_bytes(hw_params));
420 }
421 
422 /* hw_free callback */
423 static int snd_aw2_pcm_hw_free(struct snd_pcm_substream *substream)
424 {
425         return snd_pcm_lib_free_pages(substream);
426 }
427 
428 /* prepare callback for playback */
429 static int snd_aw2_pcm_prepare_playback(struct snd_pcm_substream *substream)
430 {
431         struct aw2_pcm_device *pcm_device = snd_pcm_substream_chip(substream);
432         struct aw2 *chip = pcm_device->chip;
433         struct snd_pcm_runtime *runtime = substream->runtime;
434         unsigned long period_size, buffer_size;
435 
436         mutex_lock(&chip->mtx);
437 
438         period_size = snd_pcm_lib_period_bytes(substream);
439         buffer_size = snd_pcm_lib_buffer_bytes(substream);
440 
441         snd_aw2_saa7146_pcm_init_playback(&chip->saa7146,
442                                           pcm_device->stream_number,
443                                           runtime->dma_addr, period_size,
444                                           buffer_size);
445 
446         /* Define Interrupt callback */
447         snd_aw2_saa7146_define_it_playback_callback(pcm_device->stream_number,
448                                                     (snd_aw2_saa7146_it_cb)
449                                                     snd_pcm_period_elapsed,
450                                                     (void *)substream);
451 
452         mutex_unlock(&chip->mtx);
453 
454         return 0;
455 }
456 
457 /* prepare callback for capture */
458 static int snd_aw2_pcm_prepare_capture(struct snd_pcm_substream *substream)
459 {
460         struct aw2_pcm_device *pcm_device = snd_pcm_substream_chip(substream);
461         struct aw2 *chip = pcm_device->chip;
462         struct snd_pcm_runtime *runtime = substream->runtime;
463         unsigned long period_size, buffer_size;
464 
465         mutex_lock(&chip->mtx);
466 
467         period_size = snd_pcm_lib_period_bytes(substream);
468         buffer_size = snd_pcm_lib_buffer_bytes(substream);
469 
470         snd_aw2_saa7146_pcm_init_capture(&chip->saa7146,
471                                          pcm_device->stream_number,
472                                          runtime->dma_addr, period_size,
473                                          buffer_size);
474 
475         /* Define Interrupt callback */
476         snd_aw2_saa7146_define_it_capture_callback(pcm_device->stream_number,
477                                                    (snd_aw2_saa7146_it_cb)
478                                                    snd_pcm_period_elapsed,
479                                                    (void *)substream);
480 
481         mutex_unlock(&chip->mtx);
482 
483         return 0;
484 }
485 
486 /* playback trigger callback */
487 static int snd_aw2_pcm_trigger_playback(struct snd_pcm_substream *substream,
488                                         int cmd)
489 {
490         int status = 0;
491         struct aw2_pcm_device *pcm_device = snd_pcm_substream_chip(substream);
492         struct aw2 *chip = pcm_device->chip;
493         spin_lock(&chip->reg_lock);
494         switch (cmd) {
495         case SNDRV_PCM_TRIGGER_START:
496                 snd_aw2_saa7146_pcm_trigger_start_playback(&chip->saa7146,
497                                                            pcm_device->
498                                                            stream_number);
499                 break;
500         case SNDRV_PCM_TRIGGER_STOP:
501                 snd_aw2_saa7146_pcm_trigger_stop_playback(&chip->saa7146,
502                                                           pcm_device->
503                                                           stream_number);
504                 break;
505         default:
506                 status = -EINVAL;
507         }
508         spin_unlock(&chip->reg_lock);
509         return status;
510 }
511 
512 /* capture trigger callback */
513 static int snd_aw2_pcm_trigger_capture(struct snd_pcm_substream *substream,
514                                        int cmd)
515 {
516         int status = 0;
517         struct aw2_pcm_device *pcm_device = snd_pcm_substream_chip(substream);
518         struct aw2 *chip = pcm_device->chip;
519         spin_lock(&chip->reg_lock);
520         switch (cmd) {
521         case SNDRV_PCM_TRIGGER_START:
522                 snd_aw2_saa7146_pcm_trigger_start_capture(&chip->saa7146,
523                                                           pcm_device->
524                                                           stream_number);
525                 break;
526         case SNDRV_PCM_TRIGGER_STOP:
527                 snd_aw2_saa7146_pcm_trigger_stop_capture(&chip->saa7146,
528                                                          pcm_device->
529                                                          stream_number);
530                 break;
531         default:
532                 status = -EINVAL;
533         }
534         spin_unlock(&chip->reg_lock);
535         return status;
536 }
537 
538 /* playback pointer callback */
539 static snd_pcm_uframes_t snd_aw2_pcm_pointer_playback(struct snd_pcm_substream
540                                                       *substream)
541 {
542         struct aw2_pcm_device *pcm_device = snd_pcm_substream_chip(substream);
543         struct aw2 *chip = pcm_device->chip;
544         unsigned int current_ptr;
545 
546         /* get the current hardware pointer */
547         struct snd_pcm_runtime *runtime = substream->runtime;
548         current_ptr =
549                 snd_aw2_saa7146_get_hw_ptr_playback(&chip->saa7146,
550                                                     pcm_device->stream_number,
551                                                     runtime->dma_area,
552                                                     runtime->buffer_size);
553 
554         return bytes_to_frames(substream->runtime, current_ptr);
555 }
556 
557 /* capture pointer callback */
558 static snd_pcm_uframes_t snd_aw2_pcm_pointer_capture(struct snd_pcm_substream
559                                                      *substream)
560 {
561         struct aw2_pcm_device *pcm_device = snd_pcm_substream_chip(substream);
562         struct aw2 *chip = pcm_device->chip;
563         unsigned int current_ptr;
564 
565         /* get the current hardware pointer */
566         struct snd_pcm_runtime *runtime = substream->runtime;
567         current_ptr =
568                 snd_aw2_saa7146_get_hw_ptr_capture(&chip->saa7146,
569                                                    pcm_device->stream_number,
570                                                    runtime->dma_area,
571                                                    runtime->buffer_size);
572 
573         return bytes_to_frames(substream->runtime, current_ptr);
574 }
575 
576 /* create a pcm device */
577 static int snd_aw2_new_pcm(struct aw2 *chip)
578 {
579         struct snd_pcm *pcm_playback_ana;
580         struct snd_pcm *pcm_playback_num;
581         struct snd_pcm *pcm_capture;
582         struct aw2_pcm_device *pcm_device;
583         int err = 0;
584 
585         /* Create new Alsa PCM device */
586 
587         err = snd_pcm_new(chip->card, "Audiowerk2 analog playback", 0, 1, 0,
588                           &pcm_playback_ana);
589         if (err < 0) {
590                 dev_err(chip->card->dev, "snd_pcm_new error (0x%X)\n", err);
591                 return err;
592         }
593 
594         /* Creation ok */
595         pcm_device = &chip->device_playback[NUM_STREAM_PLAYBACK_ANA];
596 
597         /* Set PCM device name */
598         strcpy(pcm_playback_ana->name, "Analog playback");
599         /* Associate private data to PCM device */
600         pcm_playback_ana->private_data = pcm_device;
601         /* set operators of PCM device */
602         snd_pcm_set_ops(pcm_playback_ana, SNDRV_PCM_STREAM_PLAYBACK,
603                         &snd_aw2_playback_ops);
604         /* store PCM device */
605         pcm_device->pcm = pcm_playback_ana;
606         /* give base chip pointer to our internal pcm device
607            structure */
608         pcm_device->chip = chip;
609         /* Give stream number to PCM device */
610         pcm_device->stream_number = NUM_STREAM_PLAYBACK_ANA;
611 
612         /* pre-allocation of buffers */
613         /* Preallocate continuous pages. */
614         snd_pcm_lib_preallocate_pages_for_all(pcm_playback_ana,
615                                               SNDRV_DMA_TYPE_DEV,
616                                               snd_dma_pci_data(chip->pci),
617                                               64 * 1024, 64 * 1024);
618 
619         err = snd_pcm_new(chip->card, "Audiowerk2 digital playback", 1, 1, 0,
620                           &pcm_playback_num);
621 
622         if (err < 0) {
623                 dev_err(chip->card->dev, "snd_pcm_new error (0x%X)\n", err);
624                 return err;
625         }
626         /* Creation ok */
627         pcm_device = &chip->device_playback[NUM_STREAM_PLAYBACK_DIG];
628 
629         /* Set PCM device name */
630         strcpy(pcm_playback_num->name, "Digital playback");
631         /* Associate private data to PCM device */
632         pcm_playback_num->private_data = pcm_device;
633         /* set operators of PCM device */
634         snd_pcm_set_ops(pcm_playback_num, SNDRV_PCM_STREAM_PLAYBACK,
635                         &snd_aw2_playback_ops);
636         /* store PCM device */
637         pcm_device->pcm = pcm_playback_num;
638         /* give base chip pointer to our internal pcm device
639            structure */
640         pcm_device->chip = chip;
641         /* Give stream number to PCM device */
642         pcm_device->stream_number = NUM_STREAM_PLAYBACK_DIG;
643 
644         /* pre-allocation of buffers */
645         /* Preallocate continuous pages. */
646         snd_pcm_lib_preallocate_pages_for_all(pcm_playback_num,
647                                               SNDRV_DMA_TYPE_DEV,
648                                               snd_dma_pci_data(chip->pci),
649                                               64 * 1024, 64 * 1024);
650 
651         err = snd_pcm_new(chip->card, "Audiowerk2 capture", 2, 0, 1,
652                           &pcm_capture);
653 
654         if (err < 0) {
655                 dev_err(chip->card->dev, "snd_pcm_new error (0x%X)\n", err);
656                 return err;
657         }
658 
659         /* Creation ok */
660         pcm_device = &chip->device_capture[NUM_STREAM_CAPTURE_ANA];
661 
662         /* Set PCM device name */
663         strcpy(pcm_capture->name, "Capture");
664         /* Associate private data to PCM device */
665         pcm_capture->private_data = pcm_device;
666         /* set operators of PCM device */
667         snd_pcm_set_ops(pcm_capture, SNDRV_PCM_STREAM_CAPTURE,
668                         &snd_aw2_capture_ops);
669         /* store PCM device */
670         pcm_device->pcm = pcm_capture;
671         /* give base chip pointer to our internal pcm device
672            structure */
673         pcm_device->chip = chip;
674         /* Give stream number to PCM device */
675         pcm_device->stream_number = NUM_STREAM_CAPTURE_ANA;
676 
677         /* pre-allocation of buffers */
678         /* Preallocate continuous pages. */
679         snd_pcm_lib_preallocate_pages_for_all(pcm_capture,
680                                               SNDRV_DMA_TYPE_DEV,
681                                               snd_dma_pci_data(chip->pci),
682                                               64 * 1024, 64 * 1024);
683 
684         /* Create control */
685         err = snd_ctl_add(chip->card, snd_ctl_new1(&aw2_control, chip));
686         if (err < 0) {
687                 dev_err(chip->card->dev, "snd_ctl_add error (0x%X)\n", err);
688                 return err;
689         }
690 
691         return 0;
692 }
693 
694 static int snd_aw2_control_switch_capture_info(struct snd_kcontrol *kcontrol,
695                                                struct snd_ctl_elem_info *uinfo)
696 {
697         static const char * const texts[2] = {
698                 "Analog", "Digital"
699         };
700         return snd_ctl_enum_info(uinfo, 1, 2, texts);
701 }
702 
703 static int snd_aw2_control_switch_capture_get(struct snd_kcontrol *kcontrol,
704                                               struct snd_ctl_elem_value
705                                               *ucontrol)
706 {
707         struct aw2 *chip = snd_kcontrol_chip(kcontrol);
708         if (snd_aw2_saa7146_is_using_digital_input(&chip->saa7146))
709                 ucontrol->value.enumerated.item[0] = CTL_ROUTE_DIGITAL;
710         else
711                 ucontrol->value.enumerated.item[0] = CTL_ROUTE_ANALOG;
712         return 0;
713 }
714 
715 static int snd_aw2_control_switch_capture_put(struct snd_kcontrol *kcontrol,
716                                               struct snd_ctl_elem_value
717                                               *ucontrol)
718 {
719         struct aw2 *chip = snd_kcontrol_chip(kcontrol);
720         int changed = 0;
721         int is_disgital =
722             snd_aw2_saa7146_is_using_digital_input(&chip->saa7146);
723 
724         if (((ucontrol->value.integer.value[0] == CTL_ROUTE_DIGITAL)
725              && !is_disgital)
726             || ((ucontrol->value.integer.value[0] == CTL_ROUTE_ANALOG)
727                 && is_disgital)) {
728                 snd_aw2_saa7146_use_digital_input(&chip->saa7146, !is_disgital);
729                 changed = 1;
730         }
731         return changed;
732 }
733 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp