Version:  2.0.40 2.2.26 2.4.37 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 3.16 3.17 3.18

Linux/sound/pci/lx6464es/lx6464es.c

  1 /* -*- linux-c -*- *
  2  *
  3  * ALSA driver for the digigram lx6464es interface
  4  *
  5  * Copyright (c) 2008, 2009 Tim Blechmann <tim@klingt.org>
  6  *
  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; see the file COPYING.  If not, write to
 20  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 21  * Boston, MA 02111-1307, USA.
 22  *
 23  */
 24 
 25 #include <linux/module.h>
 26 #include <linux/init.h>
 27 #include <linux/pci.h>
 28 #include <linux/delay.h>
 29 #include <linux/slab.h>
 30 
 31 #include <sound/initval.h>
 32 #include <sound/control.h>
 33 #include <sound/info.h>
 34 
 35 #include "lx6464es.h"
 36 
 37 MODULE_AUTHOR("Tim Blechmann");
 38 MODULE_LICENSE("GPL");
 39 MODULE_DESCRIPTION("digigram lx6464es");
 40 MODULE_SUPPORTED_DEVICE("{digigram lx6464es{}}");
 41 
 42 
 43 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 44 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 45 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 46 
 47 module_param_array(index, int, NULL, 0444);
 48 MODULE_PARM_DESC(index, "Index value for Digigram LX6464ES interface.");
 49 module_param_array(id, charp, NULL, 0444);
 50 MODULE_PARM_DESC(id, "ID string for  Digigram LX6464ES interface.");
 51 module_param_array(enable, bool, NULL, 0444);
 52 MODULE_PARM_DESC(enable, "Enable/disable specific Digigram LX6464ES soundcards.");
 53 
 54 static const char card_name[] = "LX6464ES";
 55 
 56 
 57 #define PCI_DEVICE_ID_PLX_LX6464ES              PCI_DEVICE_ID_PLX_9056
 58 
 59 static const struct pci_device_id snd_lx6464es_ids[] = {
 60         { PCI_DEVICE(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES),
 61           .subvendor = PCI_VENDOR_ID_DIGIGRAM,
 62           .subdevice = PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_SERIAL_SUBSYSTEM
 63         },                      /* LX6464ES */
 64         { PCI_DEVICE(PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_LX6464ES),
 65           .subvendor = PCI_VENDOR_ID_DIGIGRAM,
 66           .subdevice = PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_CAE_SERIAL_SUBSYSTEM
 67         },                      /* LX6464ES-CAE */
 68         { 0, },
 69 };
 70 
 71 MODULE_DEVICE_TABLE(pci, snd_lx6464es_ids);
 72 
 73 
 74 
 75 /* PGO pour USERo dans le registre pci_0x06/loc_0xEC */
 76 #define CHIPSC_RESET_XILINX (1L<<16)
 77 
 78 
 79 /* alsa callbacks */
 80 static struct snd_pcm_hardware lx_caps = {
 81         .info             = (SNDRV_PCM_INFO_MMAP |
 82                              SNDRV_PCM_INFO_INTERLEAVED |
 83                              SNDRV_PCM_INFO_MMAP_VALID |
 84                              SNDRV_PCM_INFO_SYNC_START),
 85         .formats          = (SNDRV_PCM_FMTBIT_S16_LE |
 86                              SNDRV_PCM_FMTBIT_S16_BE |
 87                              SNDRV_PCM_FMTBIT_S24_3LE |
 88                              SNDRV_PCM_FMTBIT_S24_3BE),
 89         .rates            = (SNDRV_PCM_RATE_CONTINUOUS |
 90                              SNDRV_PCM_RATE_8000_192000),
 91         .rate_min         = 8000,
 92         .rate_max         = 192000,
 93         .channels_min     = 2,
 94         .channels_max     = 64,
 95         .buffer_bytes_max = 64*2*3*MICROBLAZE_IBL_MAX*MAX_STREAM_BUFFER,
 96         .period_bytes_min = (2*2*MICROBLAZE_IBL_MIN*2),
 97         .period_bytes_max = (4*64*MICROBLAZE_IBL_MAX*MAX_STREAM_BUFFER),
 98         .periods_min      = 2,
 99         .periods_max      = MAX_STREAM_BUFFER,
100 };
101 
102 static int lx_set_granularity(struct lx6464es *chip, u32 gran);
103 
104 
105 static int lx_hardware_open(struct lx6464es *chip,
106                             struct snd_pcm_substream *substream)
107 {
108         int err = 0;
109         struct snd_pcm_runtime *runtime = substream->runtime;
110         int channels = runtime->channels;
111         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
112 
113         snd_pcm_uframes_t period_size = runtime->period_size;
114 
115         dev_dbg(chip->card->dev, "allocating pipe for %d channels\n", channels);
116         err = lx_pipe_allocate(chip, 0, is_capture, channels);
117         if (err < 0) {
118                 dev_err(chip->card->dev, LXP "allocating pipe failed\n");
119                 return err;
120         }
121 
122         err = lx_set_granularity(chip, period_size);
123         if (err < 0) {
124                 dev_err(chip->card->dev, "setting granularity to %ld failed\n",
125                            period_size);
126                 return err;
127         }
128 
129         return 0;
130 }
131 
132 static int lx_hardware_start(struct lx6464es *chip,
133                              struct snd_pcm_substream *substream)
134 {
135         int err = 0;
136         struct snd_pcm_runtime *runtime = substream->runtime;
137         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
138 
139         dev_dbg(chip->card->dev, "setting stream format\n");
140         err = lx_stream_set_format(chip, runtime, 0, is_capture);
141         if (err < 0) {
142                 dev_err(chip->card->dev, "setting stream format failed\n");
143                 return err;
144         }
145 
146         dev_dbg(chip->card->dev, "starting pipe\n");
147         err = lx_pipe_start(chip, 0, is_capture);
148         if (err < 0) {
149                 dev_err(chip->card->dev, "starting pipe failed\n");
150                 return err;
151         }
152 
153         dev_dbg(chip->card->dev, "waiting for pipe to start\n");
154         err = lx_pipe_wait_for_start(chip, 0, is_capture);
155         if (err < 0) {
156                 dev_err(chip->card->dev, "waiting for pipe failed\n");
157                 return err;
158         }
159 
160         return err;
161 }
162 
163 
164 static int lx_hardware_stop(struct lx6464es *chip,
165                             struct snd_pcm_substream *substream)
166 {
167         int err = 0;
168         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
169 
170         dev_dbg(chip->card->dev, "pausing pipe\n");
171         err = lx_pipe_pause(chip, 0, is_capture);
172         if (err < 0) {
173                 dev_err(chip->card->dev, "pausing pipe failed\n");
174                 return err;
175         }
176 
177         dev_dbg(chip->card->dev, "waiting for pipe to become idle\n");
178         err = lx_pipe_wait_for_idle(chip, 0, is_capture);
179         if (err < 0) {
180                 dev_err(chip->card->dev, "waiting for pipe failed\n");
181                 return err;
182         }
183 
184         dev_dbg(chip->card->dev, "stopping pipe\n");
185         err = lx_pipe_stop(chip, 0, is_capture);
186         if (err < 0) {
187                 dev_err(chip->card->dev, "stopping pipe failed\n");
188                 return err;
189         }
190 
191         return err;
192 }
193 
194 
195 static int lx_hardware_close(struct lx6464es *chip,
196                              struct snd_pcm_substream *substream)
197 {
198         int err = 0;
199         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
200 
201         dev_dbg(chip->card->dev, "releasing pipe\n");
202         err = lx_pipe_release(chip, 0, is_capture);
203         if (err < 0) {
204                 dev_err(chip->card->dev, "releasing pipe failed\n");
205                 return err;
206         }
207 
208         return err;
209 }
210 
211 
212 static int lx_pcm_open(struct snd_pcm_substream *substream)
213 {
214         struct lx6464es *chip = snd_pcm_substream_chip(substream);
215         struct snd_pcm_runtime *runtime = substream->runtime;
216         int err = 0;
217         int board_rate;
218 
219         dev_dbg(chip->card->dev, "->lx_pcm_open\n");
220         mutex_lock(&chip->setup_mutex);
221 
222         /* copy the struct snd_pcm_hardware struct */
223         runtime->hw = lx_caps;
224 
225 #if 0
226         /* buffer-size should better be multiple of period-size */
227         err = snd_pcm_hw_constraint_integer(runtime,
228                                             SNDRV_PCM_HW_PARAM_PERIODS);
229         if (err < 0) {
230                 dev_warn(chip->card->dev, "could not constrain periods\n");
231                 goto exit;
232         }
233 #endif
234 
235         /* the clock rate cannot be changed */
236         board_rate = chip->board_sample_rate;
237         err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE,
238                                            board_rate, board_rate);
239 
240         if (err < 0) {
241                 dev_warn(chip->card->dev, "could not constrain periods\n");
242                 goto exit;
243         }
244 
245         /* constrain period size */
246         err = snd_pcm_hw_constraint_minmax(runtime,
247                                            SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
248                                            MICROBLAZE_IBL_MIN,
249                                            MICROBLAZE_IBL_MAX);
250         if (err < 0) {
251                 dev_warn(chip->card->dev,
252                            "could not constrain period size\n");
253                 goto exit;
254         }
255 
256         snd_pcm_hw_constraint_step(runtime, 0,
257                                    SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 32);
258 
259         snd_pcm_set_sync(substream);
260         err = 0;
261 
262 exit:
263         runtime->private_data = chip;
264 
265         mutex_unlock(&chip->setup_mutex);
266         dev_dbg(chip->card->dev, "<-lx_pcm_open, %d\n", err);
267         return err;
268 }
269 
270 static int lx_pcm_close(struct snd_pcm_substream *substream)
271 {
272         int err = 0;
273         dev_dbg(substream->pcm->card->dev, "->lx_pcm_close\n");
274         return err;
275 }
276 
277 static snd_pcm_uframes_t lx_pcm_stream_pointer(struct snd_pcm_substream
278                                                *substream)
279 {
280         struct lx6464es *chip = snd_pcm_substream_chip(substream);
281         snd_pcm_uframes_t pos;
282         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
283 
284         struct lx_stream *lx_stream = is_capture ? &chip->capture_stream :
285                 &chip->playback_stream;
286 
287         dev_dbg(chip->card->dev, "->lx_pcm_stream_pointer\n");
288 
289         mutex_lock(&chip->lock);
290         pos = lx_stream->frame_pos * substream->runtime->period_size;
291         mutex_unlock(&chip->lock);
292 
293         dev_dbg(chip->card->dev, "stream_pointer at %ld\n", pos);
294         return pos;
295 }
296 
297 static int lx_pcm_prepare(struct snd_pcm_substream *substream)
298 {
299         struct lx6464es *chip = snd_pcm_substream_chip(substream);
300         int err = 0;
301         const int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
302 
303         dev_dbg(chip->card->dev, "->lx_pcm_prepare\n");
304 
305         mutex_lock(&chip->setup_mutex);
306 
307         if (chip->hardware_running[is_capture]) {
308                 err = lx_hardware_stop(chip, substream);
309                 if (err < 0) {
310                         dev_err(chip->card->dev, "failed to stop hardware. "
311                                    "Error code %d\n", err);
312                         goto exit;
313                 }
314 
315                 err = lx_hardware_close(chip, substream);
316                 if (err < 0) {
317                         dev_err(chip->card->dev, "failed to close hardware. "
318                                    "Error code %d\n", err);
319                         goto exit;
320                 }
321         }
322 
323         dev_dbg(chip->card->dev, "opening hardware\n");
324         err = lx_hardware_open(chip, substream);
325         if (err < 0) {
326                 dev_err(chip->card->dev, "failed to open hardware. "
327                            "Error code %d\n", err);
328                 goto exit;
329         }
330 
331         err = lx_hardware_start(chip, substream);
332         if (err < 0) {
333                 dev_err(chip->card->dev, "failed to start hardware. "
334                            "Error code %d\n", err);
335                 goto exit;
336         }
337 
338         chip->hardware_running[is_capture] = 1;
339 
340         if (chip->board_sample_rate != substream->runtime->rate) {
341                 if (!err)
342                         chip->board_sample_rate = substream->runtime->rate;
343         }
344 
345 exit:
346         mutex_unlock(&chip->setup_mutex);
347         return err;
348 }
349 
350 static int lx_pcm_hw_params(struct snd_pcm_substream *substream,
351                             struct snd_pcm_hw_params *hw_params, int is_capture)
352 {
353         struct lx6464es *chip = snd_pcm_substream_chip(substream);
354         int err = 0;
355 
356         dev_dbg(chip->card->dev, "->lx_pcm_hw_params\n");
357 
358         mutex_lock(&chip->setup_mutex);
359 
360         /* set dma buffer */
361         err = snd_pcm_lib_malloc_pages(substream,
362                                        params_buffer_bytes(hw_params));
363 
364         if (is_capture)
365                 chip->capture_stream.stream = substream;
366         else
367                 chip->playback_stream.stream = substream;
368 
369         mutex_unlock(&chip->setup_mutex);
370         return err;
371 }
372 
373 static int lx_pcm_hw_params_playback(struct snd_pcm_substream *substream,
374                                  struct snd_pcm_hw_params *hw_params)
375 {
376         return lx_pcm_hw_params(substream, hw_params, 0);
377 }
378 
379 static int lx_pcm_hw_params_capture(struct snd_pcm_substream *substream,
380                                  struct snd_pcm_hw_params *hw_params)
381 {
382         return lx_pcm_hw_params(substream, hw_params, 1);
383 }
384 
385 static int lx_pcm_hw_free(struct snd_pcm_substream *substream)
386 {
387         struct lx6464es *chip = snd_pcm_substream_chip(substream);
388         int err = 0;
389         int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
390 
391         dev_dbg(chip->card->dev, "->lx_pcm_hw_free\n");
392         mutex_lock(&chip->setup_mutex);
393 
394         if (chip->hardware_running[is_capture]) {
395                 err = lx_hardware_stop(chip, substream);
396                 if (err < 0) {
397                         dev_err(chip->card->dev, "failed to stop hardware. "
398                                    "Error code %d\n", err);
399                         goto exit;
400                 }
401 
402                 err = lx_hardware_close(chip, substream);
403                 if (err < 0) {
404                         dev_err(chip->card->dev, "failed to close hardware. "
405                                    "Error code %d\n", err);
406                         goto exit;
407                 }
408 
409                 chip->hardware_running[is_capture] = 0;
410         }
411 
412         err = snd_pcm_lib_free_pages(substream);
413 
414         if (is_capture)
415                 chip->capture_stream.stream = 0;
416         else
417                 chip->playback_stream.stream = 0;
418 
419 exit:
420         mutex_unlock(&chip->setup_mutex);
421         return err;
422 }
423 
424 static void lx_trigger_start(struct lx6464es *chip, struct lx_stream *lx_stream)
425 {
426         struct snd_pcm_substream *substream = lx_stream->stream;
427         const unsigned int is_capture = lx_stream->is_capture;
428 
429         int err;
430 
431         const u32 channels = substream->runtime->channels;
432         const u32 bytes_per_frame = channels * 3;
433         const u32 period_size = substream->runtime->period_size;
434         const u32 periods = substream->runtime->periods;
435         const u32 period_bytes = period_size * bytes_per_frame;
436 
437         dma_addr_t buf = substream->dma_buffer.addr;
438         int i;
439 
440         u32 needed, freed;
441         u32 size_array[5];
442 
443         for (i = 0; i != periods; ++i) {
444                 u32 buffer_index = 0;
445 
446                 err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed,
447                                     size_array);
448                 dev_dbg(chip->card->dev, "starting: needed %d, freed %d\n",
449                             needed, freed);
450 
451                 err = lx_buffer_give(chip, 0, is_capture, period_bytes,
452                                      lower_32_bits(buf), upper_32_bits(buf),
453                                      &buffer_index);
454 
455                 dev_dbg(chip->card->dev, "starting: buffer index %x on 0x%lx (%d bytes)\n",
456                             buffer_index, (unsigned long)buf, period_bytes);
457                 buf += period_bytes;
458         }
459 
460         err = lx_buffer_ask(chip, 0, is_capture, &needed, &freed, size_array);
461         dev_dbg(chip->card->dev, "starting: needed %d, freed %d\n", needed, freed);
462 
463         dev_dbg(chip->card->dev, "starting: starting stream\n");
464         err = lx_stream_start(chip, 0, is_capture);
465         if (err < 0)
466                 dev_err(chip->card->dev, "couldn't start stream\n");
467         else
468                 lx_stream->status = LX_STREAM_STATUS_RUNNING;
469 
470         lx_stream->frame_pos = 0;
471 }
472 
473 static void lx_trigger_stop(struct lx6464es *chip, struct lx_stream *lx_stream)
474 {
475         const unsigned int is_capture = lx_stream->is_capture;
476         int err;
477 
478         dev_dbg(chip->card->dev, "stopping: stopping stream\n");
479         err = lx_stream_stop(chip, 0, is_capture);
480         if (err < 0)
481                 dev_err(chip->card->dev, "couldn't stop stream\n");
482         else
483                 lx_stream->status = LX_STREAM_STATUS_FREE;
484 
485 }
486 
487 static void lx_trigger_dispatch_stream(struct lx6464es *chip,
488                                        struct lx_stream *lx_stream)
489 {
490         switch (lx_stream->status) {
491         case LX_STREAM_STATUS_SCHEDULE_RUN:
492                 lx_trigger_start(chip, lx_stream);
493                 break;
494 
495         case LX_STREAM_STATUS_SCHEDULE_STOP:
496                 lx_trigger_stop(chip, lx_stream);
497                 break;
498 
499         default:
500                 break;
501         }
502 }
503 
504 static int lx_pcm_trigger_dispatch(struct lx6464es *chip,
505                                    struct lx_stream *lx_stream, int cmd)
506 {
507         int err = 0;
508 
509         mutex_lock(&chip->lock);
510         switch (cmd) {
511         case SNDRV_PCM_TRIGGER_START:
512                 lx_stream->status = LX_STREAM_STATUS_SCHEDULE_RUN;
513                 break;
514 
515         case SNDRV_PCM_TRIGGER_STOP:
516                 lx_stream->status = LX_STREAM_STATUS_SCHEDULE_STOP;
517                 break;
518 
519         default:
520                 err = -EINVAL;
521                 goto exit;
522         }
523 
524         lx_trigger_dispatch_stream(chip, &chip->capture_stream);
525         lx_trigger_dispatch_stream(chip, &chip->playback_stream);
526 
527 exit:
528         mutex_unlock(&chip->lock);
529         return err;
530 }
531 
532 
533 static int lx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
534 {
535         struct lx6464es *chip = snd_pcm_substream_chip(substream);
536         const int is_capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
537         struct lx_stream *stream = is_capture ? &chip->capture_stream :
538                 &chip->playback_stream;
539 
540         dev_dbg(chip->card->dev, "->lx_pcm_trigger\n");
541 
542         return lx_pcm_trigger_dispatch(chip, stream, cmd);
543 }
544 
545 static int snd_lx6464es_free(struct lx6464es *chip)
546 {
547         dev_dbg(chip->card->dev, "->snd_lx6464es_free\n");
548 
549         lx_irq_disable(chip);
550 
551         if (chip->irq >= 0)
552                 free_irq(chip->irq, chip);
553 
554         iounmap(chip->port_dsp_bar);
555         ioport_unmap(chip->port_plx_remapped);
556 
557         pci_release_regions(chip->pci);
558         pci_disable_device(chip->pci);
559 
560         kfree(chip);
561 
562         return 0;
563 }
564 
565 static int snd_lx6464es_dev_free(struct snd_device *device)
566 {
567         return snd_lx6464es_free(device->device_data);
568 }
569 
570 /* reset the dsp during initialization */
571 static int lx_init_xilinx_reset(struct lx6464es *chip)
572 {
573         int i;
574         u32 plx_reg = lx_plx_reg_read(chip, ePLX_CHIPSC);
575 
576         dev_dbg(chip->card->dev, "->lx_init_xilinx_reset\n");
577 
578         /* activate reset of xilinx */
579         plx_reg &= ~CHIPSC_RESET_XILINX;
580 
581         lx_plx_reg_write(chip, ePLX_CHIPSC, plx_reg);
582         msleep(1);
583 
584         lx_plx_reg_write(chip, ePLX_MBOX3, 0);
585         msleep(1);
586 
587         plx_reg |= CHIPSC_RESET_XILINX;
588         lx_plx_reg_write(chip, ePLX_CHIPSC, plx_reg);
589 
590         /* deactivate reset of xilinx */
591         for (i = 0; i != 100; ++i) {
592                 u32 reg_mbox3;
593                 msleep(10);
594                 reg_mbox3 = lx_plx_reg_read(chip, ePLX_MBOX3);
595                 if (reg_mbox3) {
596                         dev_dbg(chip->card->dev, "xilinx reset done\n");
597                         dev_dbg(chip->card->dev, "xilinx took %d loops\n", i);
598                         break;
599                 }
600         }
601 
602         /* todo: add some error handling? */
603 
604         /* clear mr */
605         lx_dsp_reg_write(chip, eReg_CSM, 0);
606 
607         /* le xilinx ES peut ne pas etre encore pret, on attend. */
608         msleep(600);
609 
610         return 0;
611 }
612 
613 static int lx_init_xilinx_test(struct lx6464es *chip)
614 {
615         u32 reg;
616 
617         dev_dbg(chip->card->dev, "->lx_init_xilinx_test\n");
618 
619         /* TEST if we have access to Xilinx/MicroBlaze */
620         lx_dsp_reg_write(chip, eReg_CSM, 0);
621 
622         reg = lx_dsp_reg_read(chip, eReg_CSM);
623 
624         if (reg) {
625                 dev_err(chip->card->dev, "Problem: Reg_CSM %x.\n", reg);
626 
627                 /* PCI9056_SPACE0_REMAP */
628                 lx_plx_reg_write(chip, ePLX_PCICR, 1);
629 
630                 reg = lx_dsp_reg_read(chip, eReg_CSM);
631                 if (reg) {
632                         dev_err(chip->card->dev, "Error: Reg_CSM %x.\n", reg);
633                         return -EAGAIN; /* seems to be appropriate */
634                 }
635         }
636 
637         dev_dbg(chip->card->dev, "Xilinx/MicroBlaze access test successful\n");
638 
639         return 0;
640 }
641 
642 /* initialize ethersound */
643 static int lx_init_ethersound_config(struct lx6464es *chip)
644 {
645         int i;
646         u32 orig_conf_es = lx_dsp_reg_read(chip, eReg_CONFES);
647 
648         /* configure 64 io channels */
649         u32 conf_es = (orig_conf_es & CONFES_READ_PART_MASK) |
650                 (64 << IOCR_INPUTS_OFFSET) |
651                 (64 << IOCR_OUTPUTS_OFFSET) |
652                 (FREQ_RATIO_SINGLE_MODE << FREQ_RATIO_OFFSET);
653 
654         dev_dbg(chip->card->dev, "->lx_init_ethersound\n");
655 
656         chip->freq_ratio = FREQ_RATIO_SINGLE_MODE;
657 
658         /*
659          * write it to the card !
660          * this actually kicks the ES xilinx, the first time since poweron.
661          * the MAC address in the Reg_ADMACESMSB Reg_ADMACESLSB registers
662          * is not ready before this is done, and the bit 2 in Reg_CSES is set.
663          * */
664         lx_dsp_reg_write(chip, eReg_CONFES, conf_es);
665 
666         for (i = 0; i != 1000; ++i) {
667                 if (lx_dsp_reg_read(chip, eReg_CSES) & 4) {
668                         dev_dbg(chip->card->dev, "ethersound initialized after %dms\n",
669                                    i);
670                         goto ethersound_initialized;
671                 }
672                 msleep(1);
673         }
674         dev_warn(chip->card->dev,
675                    "ethersound could not be initialized after %dms\n", i);
676         return -ETIMEDOUT;
677 
678  ethersound_initialized:
679         dev_dbg(chip->card->dev, "ethersound initialized\n");
680         return 0;
681 }
682 
683 static int lx_init_get_version_features(struct lx6464es *chip)
684 {
685         u32 dsp_version;
686 
687         int err;
688 
689         dev_dbg(chip->card->dev, "->lx_init_get_version_features\n");
690 
691         err = lx_dsp_get_version(chip, &dsp_version);
692 
693         if (err == 0) {
694                 u32 freq;
695 
696                 dev_info(chip->card->dev, "DSP version: V%02d.%02d #%d\n",
697                            (dsp_version>>16) & 0xff, (dsp_version>>8) & 0xff,
698                            dsp_version & 0xff);
699 
700                 /* later: what firmware version do we expect? */
701 
702                 /* retrieve Play/Rec features */
703                 /* done here because we may have to handle alternate
704                  * DSP files. */
705                 /* later */
706 
707                 /* init the EtherSound sample rate */
708                 err = lx_dsp_get_clock_frequency(chip, &freq);
709                 if (err == 0)
710                         chip->board_sample_rate = freq;
711                 dev_dbg(chip->card->dev, "actual clock frequency %d\n", freq);
712         } else {
713                 dev_err(chip->card->dev, "DSP corrupted \n");
714                 err = -EAGAIN;
715         }
716 
717         return err;
718 }
719 
720 static int lx_set_granularity(struct lx6464es *chip, u32 gran)
721 {
722         int err = 0;
723         u32 snapped_gran = MICROBLAZE_IBL_MIN;
724 
725         dev_dbg(chip->card->dev, "->lx_set_granularity\n");
726 
727         /* blocksize is a power of 2 */
728         while ((snapped_gran < gran) &&
729                (snapped_gran < MICROBLAZE_IBL_MAX)) {
730                 snapped_gran *= 2;
731         }
732 
733         if (snapped_gran == chip->pcm_granularity)
734                 return 0;
735 
736         err = lx_dsp_set_granularity(chip, snapped_gran);
737         if (err < 0) {
738                 dev_warn(chip->card->dev, "could not set granularity\n");
739                 err = -EAGAIN;
740         }
741 
742         if (snapped_gran != gran)
743                 dev_err(chip->card->dev, "snapped blocksize to %d\n", snapped_gran);
744 
745         dev_dbg(chip->card->dev, "set blocksize on board %d\n", snapped_gran);
746         chip->pcm_granularity = snapped_gran;
747 
748         return err;
749 }
750 
751 /* initialize and test the xilinx dsp chip */
752 static int lx_init_dsp(struct lx6464es *chip)
753 {
754         int err;
755         int i;
756 
757         dev_dbg(chip->card->dev, "->lx_init_dsp\n");
758 
759         dev_dbg(chip->card->dev, "initialize board\n");
760         err = lx_init_xilinx_reset(chip);
761         if (err)
762                 return err;
763 
764         dev_dbg(chip->card->dev, "testing board\n");
765         err = lx_init_xilinx_test(chip);
766         if (err)
767                 return err;
768 
769         dev_dbg(chip->card->dev, "initialize ethersound configuration\n");
770         err = lx_init_ethersound_config(chip);
771         if (err)
772                 return err;
773 
774         lx_irq_enable(chip);
775 
776         /** \todo the mac address should be ready by not, but it isn't,
777          *  so we wait for it */
778         for (i = 0; i != 1000; ++i) {
779                 err = lx_dsp_get_mac(chip);
780                 if (err)
781                         return err;
782                 if (chip->mac_address[0] || chip->mac_address[1] || chip->mac_address[2] ||
783                     chip->mac_address[3] || chip->mac_address[4] || chip->mac_address[5])
784                         goto mac_ready;
785                 msleep(1);
786         }
787         return -ETIMEDOUT;
788 
789 mac_ready:
790         dev_dbg(chip->card->dev, "mac address ready read after: %dms\n", i);
791         dev_info(chip->card->dev,
792                  "mac address: %02X.%02X.%02X.%02X.%02X.%02X\n",
793                    chip->mac_address[0], chip->mac_address[1], chip->mac_address[2],
794                    chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
795 
796         err = lx_init_get_version_features(chip);
797         if (err)
798                 return err;
799 
800         lx_set_granularity(chip, MICROBLAZE_IBL_DEFAULT);
801 
802         chip->playback_mute = 0;
803 
804         return err;
805 }
806 
807 static struct snd_pcm_ops lx_ops_playback = {
808         .open      = lx_pcm_open,
809         .close     = lx_pcm_close,
810         .ioctl     = snd_pcm_lib_ioctl,
811         .prepare   = lx_pcm_prepare,
812         .hw_params = lx_pcm_hw_params_playback,
813         .hw_free   = lx_pcm_hw_free,
814         .trigger   = lx_pcm_trigger,
815         .pointer   = lx_pcm_stream_pointer,
816 };
817 
818 static struct snd_pcm_ops lx_ops_capture = {
819         .open      = lx_pcm_open,
820         .close     = lx_pcm_close,
821         .ioctl     = snd_pcm_lib_ioctl,
822         .prepare   = lx_pcm_prepare,
823         .hw_params = lx_pcm_hw_params_capture,
824         .hw_free   = lx_pcm_hw_free,
825         .trigger   = lx_pcm_trigger,
826         .pointer   = lx_pcm_stream_pointer,
827 };
828 
829 static int lx_pcm_create(struct lx6464es *chip)
830 {
831         int err;
832         struct snd_pcm *pcm;
833 
834         u32 size = 64 *              /* channels */
835                 3 *                  /* 24 bit samples */
836                 MAX_STREAM_BUFFER *  /* periods */
837                 MICROBLAZE_IBL_MAX * /* frames per period */
838                 2;                   /* duplex */
839 
840         size = PAGE_ALIGN(size);
841 
842         /* hardcoded device name & channel count */
843         err = snd_pcm_new(chip->card, (char *)card_name, 0,
844                           1, 1, &pcm);
845         if (err < 0)
846                 return err;
847 
848         pcm->private_data = chip;
849 
850         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &lx_ops_playback);
851         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &lx_ops_capture);
852 
853         pcm->info_flags = 0;
854         pcm->nonatomic = true;
855         strcpy(pcm->name, card_name);
856 
857         err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
858                                                     snd_dma_pci_data(chip->pci),
859                                                     size, size);
860         if (err < 0)
861                 return err;
862 
863         chip->pcm = pcm;
864         chip->capture_stream.is_capture = 1;
865 
866         return 0;
867 }
868 
869 static int lx_control_playback_info(struct snd_kcontrol *kcontrol,
870                                     struct snd_ctl_elem_info *uinfo)
871 {
872         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
873         uinfo->count = 1;
874         uinfo->value.integer.min = 0;
875         uinfo->value.integer.max = 1;
876         return 0;
877 }
878 
879 static int lx_control_playback_get(struct snd_kcontrol *kcontrol,
880                                    struct snd_ctl_elem_value *ucontrol)
881 {
882         struct lx6464es *chip = snd_kcontrol_chip(kcontrol);
883         ucontrol->value.integer.value[0] = chip->playback_mute;
884         return 0;
885 }
886 
887 static int lx_control_playback_put(struct snd_kcontrol *kcontrol,
888                                    struct snd_ctl_elem_value *ucontrol)
889 {
890         struct lx6464es *chip = snd_kcontrol_chip(kcontrol);
891         int changed = 0;
892         int current_value = chip->playback_mute;
893 
894         if (current_value != ucontrol->value.integer.value[0]) {
895                 lx_level_unmute(chip, 0, !current_value);
896                 chip->playback_mute = !current_value;
897                 changed = 1;
898         }
899         return changed;
900 }
901 
902 static struct snd_kcontrol_new lx_control_playback_switch = {
903         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
904         .name = "PCM Playback Switch",
905         .index = 0,
906         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
907         .private_value = 0,
908         .info = lx_control_playback_info,
909         .get = lx_control_playback_get,
910         .put = lx_control_playback_put
911 };
912 
913 
914 
915 static void lx_proc_levels_read(struct snd_info_entry *entry,
916                                 struct snd_info_buffer *buffer)
917 {
918         u32 levels[64];
919         int err;
920         int i, j;
921         struct lx6464es *chip = entry->private_data;
922 
923         snd_iprintf(buffer, "capture levels:\n");
924         err = lx_level_peaks(chip, 1, 64, levels);
925         if (err < 0)
926                 return;
927 
928         for (i = 0; i != 8; ++i) {
929                 for (j = 0; j != 8; ++j)
930                         snd_iprintf(buffer, "%08x ", levels[i*8+j]);
931                 snd_iprintf(buffer, "\n");
932         }
933 
934         snd_iprintf(buffer, "\nplayback levels:\n");
935 
936         err = lx_level_peaks(chip, 0, 64, levels);
937         if (err < 0)
938                 return;
939 
940         for (i = 0; i != 8; ++i) {
941                 for (j = 0; j != 8; ++j)
942                         snd_iprintf(buffer, "%08x ", levels[i*8+j]);
943                 snd_iprintf(buffer, "\n");
944         }
945 
946         snd_iprintf(buffer, "\n");
947 }
948 
949 static int lx_proc_create(struct snd_card *card, struct lx6464es *chip)
950 {
951         struct snd_info_entry *entry;
952         int err = snd_card_proc_new(card, "levels", &entry);
953         if (err < 0)
954                 return err;
955 
956         snd_info_set_text_ops(entry, chip, lx_proc_levels_read);
957         return 0;
958 }
959 
960 
961 static int snd_lx6464es_create(struct snd_card *card,
962                                struct pci_dev *pci,
963                                struct lx6464es **rchip)
964 {
965         struct lx6464es *chip;
966         int err;
967 
968         static struct snd_device_ops ops = {
969                 .dev_free = snd_lx6464es_dev_free,
970         };
971 
972         dev_dbg(card->dev, "->snd_lx6464es_create\n");
973 
974         *rchip = NULL;
975 
976         /* enable PCI device */
977         err = pci_enable_device(pci);
978         if (err < 0)
979                 return err;
980 
981         pci_set_master(pci);
982 
983         /* check if we can restrict PCI DMA transfers to 32 bits */
984         err = pci_set_dma_mask(pci, DMA_BIT_MASK(32));
985         if (err < 0) {
986                 dev_err(card->dev,
987                         "architecture does not support 32bit PCI busmaster DMA\n");
988                 pci_disable_device(pci);
989                 return -ENXIO;
990         }
991 
992         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
993         if (chip == NULL) {
994                 err = -ENOMEM;
995                 goto alloc_failed;
996         }
997 
998         chip->card = card;
999         chip->pci = pci;
1000         chip->irq = -1;
1001 
1002         /* initialize synchronization structs */
1003         mutex_init(&chip->lock);
1004         mutex_init(&chip->msg_lock);
1005         mutex_init(&chip->setup_mutex);
1006 
1007         /* request resources */
1008         err = pci_request_regions(pci, card_name);
1009         if (err < 0)
1010                 goto request_regions_failed;
1011 
1012         /* plx port */
1013         chip->port_plx = pci_resource_start(pci, 1);
1014         chip->port_plx_remapped = ioport_map(chip->port_plx,
1015                                              pci_resource_len(pci, 1));
1016 
1017         /* dsp port */
1018         chip->port_dsp_bar = pci_ioremap_bar(pci, 2);
1019 
1020         err = request_threaded_irq(pci->irq, lx_interrupt, lx_threaded_irq,
1021                                    IRQF_SHARED, KBUILD_MODNAME, chip);
1022         if (err) {
1023                 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
1024                 goto request_irq_failed;
1025         }
1026         chip->irq = pci->irq;
1027 
1028         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1029         if (err < 0)
1030                 goto device_new_failed;
1031 
1032         err = lx_init_dsp(chip);
1033         if (err < 0) {
1034                 dev_err(card->dev, "error during DSP initialization\n");
1035                 return err;
1036         }
1037 
1038         err = lx_pcm_create(chip);
1039         if (err < 0)
1040                 return err;
1041 
1042         err = lx_proc_create(card, chip);
1043         if (err < 0)
1044                 return err;
1045 
1046         err = snd_ctl_add(card, snd_ctl_new1(&lx_control_playback_switch,
1047                                              chip));
1048         if (err < 0)
1049                 return err;
1050 
1051         *rchip = chip;
1052         return 0;
1053 
1054 device_new_failed:
1055         free_irq(pci->irq, chip);
1056 
1057 request_irq_failed:
1058         pci_release_regions(pci);
1059 
1060 request_regions_failed:
1061         kfree(chip);
1062 
1063 alloc_failed:
1064         pci_disable_device(pci);
1065 
1066         return err;
1067 }
1068 
1069 static int snd_lx6464es_probe(struct pci_dev *pci,
1070                               const struct pci_device_id *pci_id)
1071 {
1072         static int dev;
1073         struct snd_card *card;
1074         struct lx6464es *chip;
1075         int err;
1076 
1077         dev_dbg(&pci->dev, "->snd_lx6464es_probe\n");
1078 
1079         if (dev >= SNDRV_CARDS)
1080                 return -ENODEV;
1081         if (!enable[dev]) {
1082                 dev++;
1083                 return -ENOENT;
1084         }
1085 
1086         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1087                            0, &card);
1088         if (err < 0)
1089                 return err;
1090 
1091         err = snd_lx6464es_create(card, pci, &chip);
1092         if (err < 0) {
1093                 dev_err(card->dev, "error during snd_lx6464es_create\n");
1094                 goto out_free;
1095         }
1096 
1097         strcpy(card->driver, "LX6464ES");
1098         sprintf(card->id, "LX6464ES_%02X%02X%02X",
1099                 chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
1100 
1101         sprintf(card->shortname, "LX6464ES %02X.%02X.%02X.%02X.%02X.%02X",
1102                 chip->mac_address[0], chip->mac_address[1], chip->mac_address[2],
1103                 chip->mac_address[3], chip->mac_address[4], chip->mac_address[5]);
1104 
1105         sprintf(card->longname, "%s at 0x%lx, 0x%p, irq %i",
1106                 card->shortname, chip->port_plx,
1107                 chip->port_dsp_bar, chip->irq);
1108 
1109         err = snd_card_register(card);
1110         if (err < 0)
1111                 goto out_free;
1112 
1113         dev_dbg(chip->card->dev, "initialization successful\n");
1114         pci_set_drvdata(pci, card);
1115         dev++;
1116         return 0;
1117 
1118 out_free:
1119         snd_card_free(card);
1120         return err;
1121 
1122 }
1123 
1124 static void snd_lx6464es_remove(struct pci_dev *pci)
1125 {
1126         snd_card_free(pci_get_drvdata(pci));
1127 }
1128 
1129 
1130 static struct pci_driver lx6464es_driver = {
1131         .name =     KBUILD_MODNAME,
1132         .id_table = snd_lx6464es_ids,
1133         .probe =    snd_lx6464es_probe,
1134         .remove = snd_lx6464es_remove,
1135 };
1136 
1137 module_pci_driver(lx6464es_driver);
1138 

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