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

TOMOYO Linux Cross Reference
Linux/sound/pci/lx6464es/lx6464es.c

Version: ~ [ linux-6.0 ] ~ [ linux-5.19.12 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.71 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.146 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.215 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.260 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.295 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.330 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ 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