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

TOMOYO Linux Cross Reference
Linux/sound/firewire/bebob/bebob_maudio.c

Version: ~ [ linux-5.7-rc7 ] ~ [ linux-5.6.14 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.42 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.124 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.181 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.224 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.224 ] ~ [ 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.84 ] ~ [ 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 /*
  2  * bebob_maudio.c - a part of driver for BeBoB based devices
  3  *
  4  * Copyright (c) 2013-2014 Takashi Sakamoto
  5  *
  6  * Licensed under the terms of the GNU General Public License, version 2.
  7  */
  8 
  9 #include "./bebob.h"
 10 #include <sound/control.h>
 11 
 12 /*
 13  * Just powering on, Firewire 410/Audiophile/1814 and ProjectMix I/O wait to
 14  * download firmware blob. To enable these devices, drivers should upload
 15  * firmware blob and send a command to initialize configuration to factory
 16  * settings when completing uploading. Then these devices generate bus reset
 17  * and are recognized as new devices with the firmware.
 18  *
 19  * But with firmware version 5058 or later, the firmware is stored to flash
 20  * memory in the device and drivers can tell bootloader to load the firmware
 21  * by sending a cue. This cue must be sent one time.
 22  *
 23  * For streaming, both of output and input streams are needed for Firewire 410
 24  * and Ozonic. The single stream is OK for the other devices even if the clock
 25  * source is not SYT-Match (I note no devices use SYT-Match).
 26  *
 27  * Without streaming, the devices except for Firewire Audiophile can mix any
 28  * input and output. For this reason, Audiophile cannot be used as standalone
 29  * mixer.
 30  *
 31  * Firewire 1814 and ProjectMix I/O uses special firmware. It will be freezed
 32  * when receiving any commands which the firmware can't understand. These
 33  * devices utilize completely different system to control. It is some
 34  * write-transaction directly into a certain address. All of addresses for mixer
 35  * functionality is between 0xffc700700000 to 0xffc70070009c.
 36  */
 37 
 38 /* Offset from information register */
 39 #define INFO_OFFSET_SW_DATE     0x20
 40 
 41 /* Bootloader Protocol Version 1 */
 42 #define MAUDIO_BOOTLOADER_CUE1  0x00000001
 43 /*
 44  * Initializing configuration to factory settings (= 0x1101), (swapped in line),
 45  * Command code is zero (= 0x00),
 46  * the number of operands is zero (= 0x00)(at least significant byte)
 47  */
 48 #define MAUDIO_BOOTLOADER_CUE2  0x01110000
 49 /* padding */
 50 #define MAUDIO_BOOTLOADER_CUE3  0x00000000
 51 
 52 #define MAUDIO_SPECIFIC_ADDRESS 0xffc700000000ULL
 53 
 54 #define METER_OFFSET            0x00600000
 55 
 56 /* some device has sync info after metering data */
 57 #define METER_SIZE_SPECIAL      84      /* with sync info */
 58 #define METER_SIZE_FW410        76      /* with sync info */
 59 #define METER_SIZE_AUDIOPHILE   60      /* with sync info */
 60 #define METER_SIZE_SOLO         52      /* with sync info */
 61 #define METER_SIZE_OZONIC       48
 62 #define METER_SIZE_NRV10        80
 63 
 64 /* labels for metering */
 65 #define ANA_IN          "Analog In"
 66 #define ANA_OUT         "Analog Out"
 67 #define DIG_IN          "Digital In"
 68 #define SPDIF_IN        "S/PDIF In"
 69 #define ADAT_IN         "ADAT In"
 70 #define DIG_OUT         "Digital Out"
 71 #define SPDIF_OUT       "S/PDIF Out"
 72 #define ADAT_OUT        "ADAT Out"
 73 #define STRM_IN         "Stream In"
 74 #define AUX_OUT         "Aux Out"
 75 #define HP_OUT          "HP Out"
 76 /* for NRV */
 77 #define UNKNOWN_METER   "Unknown"
 78 
 79 struct special_params {
 80         bool is1814;
 81         unsigned int clk_src;
 82         unsigned int dig_in_fmt;
 83         unsigned int dig_out_fmt;
 84         unsigned int clk_lock;
 85         struct snd_ctl_elem_id *ctl_id_sync;
 86 };
 87 
 88 /*
 89  * For some M-Audio devices, this module just send cue to load firmware. After
 90  * loading, the device generates bus reset and newly detected.
 91  *
 92  * If we make any transactions to load firmware, the operation may failed.
 93  */
 94 int snd_bebob_maudio_load_firmware(struct fw_unit *unit)
 95 {
 96         struct fw_device *device = fw_parent_device(unit);
 97         int err, rcode;
 98         u64 date;
 99         __le32 *cues;
100 
101         /* check date of software used to build */
102         err = snd_bebob_read_block(unit, INFO_OFFSET_SW_DATE,
103                                    &date, sizeof(u64));
104         if (err < 0)
105                 return err;
106         /*
107          * firmware version 5058 or later has date later than "20070401", but
108          * 'date' is not null-terminated.
109          */
110         if (date < 0x3230303730343031LL) {
111                 dev_err(&unit->device,
112                         "Use firmware version 5058 or later\n");
113                 return -ENXIO;
114         }
115 
116         cues = kmalloc_array(3, sizeof(*cues), GFP_KERNEL);
117         if (!cues)
118                 return -ENOMEM;
119 
120         cues[0] = cpu_to_le32(MAUDIO_BOOTLOADER_CUE1);
121         cues[1] = cpu_to_le32(MAUDIO_BOOTLOADER_CUE2);
122         cues[2] = cpu_to_le32(MAUDIO_BOOTLOADER_CUE3);
123 
124         rcode = fw_run_transaction(device->card, TCODE_WRITE_BLOCK_REQUEST,
125                                    device->node_id, device->generation,
126                                    device->max_speed, BEBOB_ADDR_REG_REQ,
127                                    cues, 3 * sizeof(*cues));
128         kfree(cues);
129         if (rcode != RCODE_COMPLETE) {
130                 dev_err(&unit->device,
131                         "Failed to send a cue to load firmware\n");
132                 err = -EIO;
133         }
134 
135         return err;
136 }
137 
138 static inline int
139 get_meter(struct snd_bebob *bebob, void *buf, unsigned int size)
140 {
141         return snd_fw_transaction(bebob->unit, TCODE_READ_BLOCK_REQUEST,
142                                   MAUDIO_SPECIFIC_ADDRESS + METER_OFFSET,
143                                   buf, size, 0);
144 }
145 
146 static int
147 check_clk_sync(struct snd_bebob *bebob, unsigned int size, bool *sync)
148 {
149         int err;
150         u8 *buf;
151 
152         buf = kmalloc(size, GFP_KERNEL);
153         if (buf == NULL)
154                 return -ENOMEM;
155 
156         err = get_meter(bebob, buf, size);
157         if (err < 0)
158                 goto end;
159 
160         /* if synced, this value is the same as SFC of FDF in CIP header */
161         *sync = (buf[size - 2] != 0xff);
162 end:
163         kfree(buf);
164         return err;
165 }
166 
167 /*
168  * dig_fmt: 0x00:S/PDIF, 0x01:ADAT
169  * clk_lock: 0x00:unlock, 0x01:lock
170  */
171 static int
172 avc_maudio_set_special_clk(struct snd_bebob *bebob, unsigned int clk_src,
173                            unsigned int dig_in_fmt, unsigned int dig_out_fmt,
174                            unsigned int clk_lock)
175 {
176         struct special_params *params = bebob->maudio_special_quirk;
177         int err;
178         u8 *buf;
179 
180         if (amdtp_stream_running(&bebob->rx_stream) ||
181             amdtp_stream_running(&bebob->tx_stream))
182                 return -EBUSY;
183 
184         buf = kmalloc(12, GFP_KERNEL);
185         if (buf == NULL)
186                 return -ENOMEM;
187 
188         buf[0]  = 0x00;         /* CONTROL */
189         buf[1]  = 0xff;         /* UNIT */
190         buf[2]  = 0x00;         /* vendor dependent */
191         buf[3]  = 0x04;         /* company ID high */
192         buf[4]  = 0x00;         /* company ID middle */
193         buf[5]  = 0x04;         /* company ID low */
194         buf[6]  = 0xff & clk_src;       /* clock source */
195         buf[7]  = 0xff & dig_in_fmt;    /* input digital format */
196         buf[8]  = 0xff & dig_out_fmt;   /* output digital format */
197         buf[9]  = 0xff & clk_lock;      /* lock these settings */
198         buf[10] = 0x00;         /* padding  */
199         buf[11] = 0x00;         /* padding */
200 
201         err = fcp_avc_transaction(bebob->unit, buf, 12, buf, 12,
202                                   BIT(1) | BIT(2) | BIT(3) | BIT(4) |
203                                   BIT(5) | BIT(6) | BIT(7) | BIT(8) |
204                                   BIT(9));
205         if ((err > 0) && (err < 10))
206                 err = -EIO;
207         else if (buf[0] == 0x08) /* NOT IMPLEMENTED */
208                 err = -ENOSYS;
209         else if (buf[0] == 0x0a) /* REJECTED */
210                 err = -EINVAL;
211         if (err < 0)
212                 goto end;
213 
214         params->clk_src         = buf[6];
215         params->dig_in_fmt      = buf[7];
216         params->dig_out_fmt     = buf[8];
217         params->clk_lock        = buf[9];
218 
219         if (params->ctl_id_sync)
220                 snd_ctl_notify(bebob->card, SNDRV_CTL_EVENT_MASK_VALUE,
221                                params->ctl_id_sync);
222 
223         err = 0;
224 end:
225         kfree(buf);
226         return err;
227 }
228 static void
229 special_stream_formation_set(struct snd_bebob *bebob)
230 {
231         static const unsigned int ch_table[2][2][3] = {
232                 /* AMDTP_OUT_STREAM */
233                 { {  6,  6,  4 },       /* SPDIF */
234                   { 12,  8,  4 } },     /* ADAT */
235                 /* AMDTP_IN_STREAM */
236                 { { 10, 10,  2 },       /* SPDIF */
237                   { 16, 12,  2 } }      /* ADAT */
238         };
239         struct special_params *params = bebob->maudio_special_quirk;
240         unsigned int i, max;
241 
242         max = SND_BEBOB_STRM_FMT_ENTRIES - 1;
243         if (!params->is1814)
244                 max -= 2;
245 
246         for (i = 0; i < max; i++) {
247                 bebob->tx_stream_formations[i + 1].pcm =
248                         ch_table[AMDTP_IN_STREAM][params->dig_in_fmt][i / 2];
249                 bebob->tx_stream_formations[i + 1].midi = 1;
250 
251                 bebob->rx_stream_formations[i + 1].pcm =
252                         ch_table[AMDTP_OUT_STREAM][params->dig_out_fmt][i / 2];
253                 bebob->rx_stream_formations[i + 1].midi = 1;
254         }
255 }
256 
257 static int add_special_controls(struct snd_bebob *bebob);
258 int
259 snd_bebob_maudio_special_discover(struct snd_bebob *bebob, bool is1814)
260 {
261         struct special_params *params;
262         int err;
263 
264         params = devm_kzalloc(&bebob->card->card_dev,
265                               sizeof(struct special_params), GFP_KERNEL);
266         if (!params)
267                 return -ENOMEM;
268 
269         mutex_lock(&bebob->mutex);
270 
271         bebob->maudio_special_quirk = (void *)params;
272         params->is1814 = is1814;
273 
274         /* initialize these parameters because driver is not allowed to ask */
275         bebob->rx_stream.context = ERR_PTR(-1);
276         bebob->tx_stream.context = ERR_PTR(-1);
277         err = avc_maudio_set_special_clk(bebob, 0x03, 0x00, 0x00, 0x00);
278         if (err < 0) {
279                 dev_err(&bebob->unit->device,
280                         "fail to initialize clock params: %d\n", err);
281                 goto end;
282         }
283 
284         err = add_special_controls(bebob);
285         if (err < 0)
286                 goto end;
287 
288         special_stream_formation_set(bebob);
289 
290         if (params->is1814) {
291                 bebob->midi_input_ports = 1;
292                 bebob->midi_output_ports = 1;
293         } else {
294                 bebob->midi_input_ports = 2;
295                 bebob->midi_output_ports = 2;
296         }
297 end:
298         mutex_unlock(&bebob->mutex);
299         return err;
300 }
301 
302 /* Input plug shows actual rate. Output plug is needless for this purpose. */
303 static int special_get_rate(struct snd_bebob *bebob, unsigned int *rate)
304 {
305         int err, trials;
306 
307         trials = 0;
308         do {
309                 err = avc_general_get_sig_fmt(bebob->unit, rate,
310                                               AVC_GENERAL_PLUG_DIR_IN, 0);
311         } while (err == -EAGAIN && ++trials < 3);
312 
313         return err;
314 }
315 static int special_set_rate(struct snd_bebob *bebob, unsigned int rate)
316 {
317         struct special_params *params = bebob->maudio_special_quirk;
318         int err;
319 
320         err = avc_general_set_sig_fmt(bebob->unit, rate,
321                                       AVC_GENERAL_PLUG_DIR_OUT, 0);
322         if (err < 0)
323                 goto end;
324 
325         /*
326          * Just after changing sampling rate for output, a followed command
327          * for input is easy to fail. This is a workaround fot this issue.
328          */
329         msleep(100);
330 
331         err = avc_general_set_sig_fmt(bebob->unit, rate,
332                                       AVC_GENERAL_PLUG_DIR_IN, 0);
333         if (err < 0)
334                 goto end;
335 
336         if (params->ctl_id_sync)
337                 snd_ctl_notify(bebob->card, SNDRV_CTL_EVENT_MASK_VALUE,
338                                params->ctl_id_sync);
339 end:
340         return err;
341 }
342 
343 /* Clock source control for special firmware */
344 static const enum snd_bebob_clock_type special_clk_types[] = {
345         SND_BEBOB_CLOCK_TYPE_INTERNAL,  /* With digital mute */
346         SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* SPDIF/ADAT */
347         SND_BEBOB_CLOCK_TYPE_EXTERNAL,  /* Word Clock */
348         SND_BEBOB_CLOCK_TYPE_INTERNAL,
349 };
350 static int special_clk_get(struct snd_bebob *bebob, unsigned int *id)
351 {
352         struct special_params *params = bebob->maudio_special_quirk;
353         *id = params->clk_src;
354         return 0;
355 }
356 static int special_clk_ctl_info(struct snd_kcontrol *kctl,
357                                 struct snd_ctl_elem_info *einf)
358 {
359         static const char *const special_clk_labels[] = {
360                 "Internal with Digital Mute",
361                 "Digital",
362                 "Word Clock",
363                 "Internal"
364         };
365         return snd_ctl_enum_info(einf, 1, ARRAY_SIZE(special_clk_types),
366                                  special_clk_labels);
367 }
368 static int special_clk_ctl_get(struct snd_kcontrol *kctl,
369                                struct snd_ctl_elem_value *uval)
370 {
371         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
372         struct special_params *params = bebob->maudio_special_quirk;
373         uval->value.enumerated.item[0] = params->clk_src;
374         return 0;
375 }
376 static int special_clk_ctl_put(struct snd_kcontrol *kctl,
377                                struct snd_ctl_elem_value *uval)
378 {
379         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
380         struct special_params *params = bebob->maudio_special_quirk;
381         int err, id;
382 
383         id = uval->value.enumerated.item[0];
384         if (id >= ARRAY_SIZE(special_clk_types))
385                 return -EINVAL;
386 
387         mutex_lock(&bebob->mutex);
388 
389         err = avc_maudio_set_special_clk(bebob, id,
390                                          params->dig_in_fmt,
391                                          params->dig_out_fmt,
392                                          params->clk_lock);
393         mutex_unlock(&bebob->mutex);
394 
395         if (err >= 0)
396                 err = 1;
397 
398         return err;
399 }
400 static const struct snd_kcontrol_new special_clk_ctl = {
401         .name   = "Clock Source",
402         .iface  = SNDRV_CTL_ELEM_IFACE_MIXER,
403         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
404         .info   = special_clk_ctl_info,
405         .get    = special_clk_ctl_get,
406         .put    = special_clk_ctl_put
407 };
408 
409 /* Clock synchronization control for special firmware */
410 static int special_sync_ctl_info(struct snd_kcontrol *kctl,
411                                  struct snd_ctl_elem_info *einf)
412 {
413         einf->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
414         einf->count = 1;
415         einf->value.integer.min = 0;
416         einf->value.integer.max = 1;
417 
418         return 0;
419 }
420 static int special_sync_ctl_get(struct snd_kcontrol *kctl,
421                                 struct snd_ctl_elem_value *uval)
422 {
423         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
424         int err;
425         bool synced = 0;
426 
427         err = check_clk_sync(bebob, METER_SIZE_SPECIAL, &synced);
428         if (err >= 0)
429                 uval->value.integer.value[0] = synced;
430 
431         return 0;
432 }
433 static const struct snd_kcontrol_new special_sync_ctl = {
434         .name   = "Sync Status",
435         .iface  = SNDRV_CTL_ELEM_IFACE_MIXER,
436         .access = SNDRV_CTL_ELEM_ACCESS_READ,
437         .info   = special_sync_ctl_info,
438         .get    = special_sync_ctl_get,
439 };
440 
441 /* Digital input interface control for special firmware */
442 static const char *const special_dig_in_iface_labels[] = {
443         "S/PDIF Optical", "S/PDIF Coaxial", "ADAT Optical"
444 };
445 static int special_dig_in_iface_ctl_info(struct snd_kcontrol *kctl,
446                                          struct snd_ctl_elem_info *einf)
447 {
448         return snd_ctl_enum_info(einf, 1,
449                                  ARRAY_SIZE(special_dig_in_iface_labels),
450                                  special_dig_in_iface_labels);
451 }
452 static int special_dig_in_iface_ctl_get(struct snd_kcontrol *kctl,
453                                         struct snd_ctl_elem_value *uval)
454 {
455         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
456         struct special_params *params = bebob->maudio_special_quirk;
457         unsigned int dig_in_iface;
458         int err, val;
459 
460         mutex_lock(&bebob->mutex);
461 
462         err = avc_audio_get_selector(bebob->unit, 0x00, 0x04,
463                                      &dig_in_iface);
464         if (err < 0) {
465                 dev_err(&bebob->unit->device,
466                         "fail to get digital input interface: %d\n", err);
467                 goto end;
468         }
469 
470         /* encoded id for user value */
471         val = (params->dig_in_fmt << 1) | (dig_in_iface & 0x01);
472 
473         /* for ADAT Optical */
474         if (val > 2)
475                 val = 2;
476 
477         uval->value.enumerated.item[0] = val;
478 end:
479         mutex_unlock(&bebob->mutex);
480         return err;
481 }
482 static int special_dig_in_iface_ctl_set(struct snd_kcontrol *kctl,
483                                         struct snd_ctl_elem_value *uval)
484 {
485         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
486         struct special_params *params = bebob->maudio_special_quirk;
487         unsigned int id, dig_in_fmt, dig_in_iface;
488         int err;
489 
490         id = uval->value.enumerated.item[0];
491         if (id >= ARRAY_SIZE(special_dig_in_iface_labels))
492                 return -EINVAL;
493 
494         /* decode user value */
495         dig_in_fmt = (id >> 1) & 0x01;
496         dig_in_iface = id & 0x01;
497 
498         mutex_lock(&bebob->mutex);
499 
500         err = avc_maudio_set_special_clk(bebob,
501                                          params->clk_src,
502                                          dig_in_fmt,
503                                          params->dig_out_fmt,
504                                          params->clk_lock);
505         if (err < 0)
506                 goto end;
507 
508         /* For ADAT, optical interface is only available. */
509         if (params->dig_in_fmt > 0) {
510                 err = 1;
511                 goto end;
512         }
513 
514         /* For S/PDIF, optical/coaxial interfaces are selectable. */
515         err = avc_audio_set_selector(bebob->unit, 0x00, 0x04, dig_in_iface);
516         if (err < 0)
517                 dev_err(&bebob->unit->device,
518                         "fail to set digital input interface: %d\n", err);
519         err = 1;
520 end:
521         special_stream_formation_set(bebob);
522         mutex_unlock(&bebob->mutex);
523         return err;
524 }
525 static const struct snd_kcontrol_new special_dig_in_iface_ctl = {
526         .name   = "Digital Input Interface",
527         .iface  = SNDRV_CTL_ELEM_IFACE_MIXER,
528         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
529         .info   = special_dig_in_iface_ctl_info,
530         .get    = special_dig_in_iface_ctl_get,
531         .put    = special_dig_in_iface_ctl_set
532 };
533 
534 /* Digital output interface control for special firmware */
535 static const char *const special_dig_out_iface_labels[] = {
536         "S/PDIF Optical and Coaxial", "ADAT Optical"
537 };
538 static int special_dig_out_iface_ctl_info(struct snd_kcontrol *kctl,
539                                           struct snd_ctl_elem_info *einf)
540 {
541         return snd_ctl_enum_info(einf, 1,
542                                  ARRAY_SIZE(special_dig_out_iface_labels),
543                                  special_dig_out_iface_labels);
544 }
545 static int special_dig_out_iface_ctl_get(struct snd_kcontrol *kctl,
546                                          struct snd_ctl_elem_value *uval)
547 {
548         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
549         struct special_params *params = bebob->maudio_special_quirk;
550         mutex_lock(&bebob->mutex);
551         uval->value.enumerated.item[0] = params->dig_out_fmt;
552         mutex_unlock(&bebob->mutex);
553         return 0;
554 }
555 static int special_dig_out_iface_ctl_set(struct snd_kcontrol *kctl,
556                                          struct snd_ctl_elem_value *uval)
557 {
558         struct snd_bebob *bebob = snd_kcontrol_chip(kctl);
559         struct special_params *params = bebob->maudio_special_quirk;
560         unsigned int id;
561         int err;
562 
563         id = uval->value.enumerated.item[0];
564         if (id >= ARRAY_SIZE(special_dig_out_iface_labels))
565                 return -EINVAL;
566 
567         mutex_lock(&bebob->mutex);
568 
569         err = avc_maudio_set_special_clk(bebob,
570                                          params->clk_src,
571                                          params->dig_in_fmt,
572                                          id, params->clk_lock);
573         if (err >= 0) {
574                 special_stream_formation_set(bebob);
575                 err = 1;
576         }
577 
578         mutex_unlock(&bebob->mutex);
579         return err;
580 }
581 static const struct snd_kcontrol_new special_dig_out_iface_ctl = {
582         .name   = "Digital Output Interface",
583         .iface  = SNDRV_CTL_ELEM_IFACE_MIXER,
584         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
585         .info   = special_dig_out_iface_ctl_info,
586         .get    = special_dig_out_iface_ctl_get,
587         .put    = special_dig_out_iface_ctl_set
588 };
589 
590 static int add_special_controls(struct snd_bebob *bebob)
591 {
592         struct snd_kcontrol *kctl;
593         struct special_params *params = bebob->maudio_special_quirk;
594         int err;
595 
596         kctl = snd_ctl_new1(&special_clk_ctl, bebob);
597         err = snd_ctl_add(bebob->card, kctl);
598         if (err < 0)
599                 goto end;
600 
601         kctl = snd_ctl_new1(&special_sync_ctl, bebob);
602         err = snd_ctl_add(bebob->card, kctl);
603         if (err < 0)
604                 goto end;
605         params->ctl_id_sync = &kctl->id;
606 
607         kctl = snd_ctl_new1(&special_dig_in_iface_ctl, bebob);
608         err = snd_ctl_add(bebob->card, kctl);
609         if (err < 0)
610                 goto end;
611 
612         kctl = snd_ctl_new1(&special_dig_out_iface_ctl, bebob);
613         err = snd_ctl_add(bebob->card, kctl);
614 end:
615         return err;
616 }
617 
618 /* Hardware metering for special firmware */
619 static const char *const special_meter_labels[] = {
620         ANA_IN, ANA_IN, ANA_IN, ANA_IN,
621         SPDIF_IN,
622         ADAT_IN, ADAT_IN, ADAT_IN, ADAT_IN,
623         ANA_OUT, ANA_OUT,
624         SPDIF_OUT,
625         ADAT_OUT, ADAT_OUT, ADAT_OUT, ADAT_OUT,
626         HP_OUT, HP_OUT,
627         AUX_OUT
628 };
629 static int
630 special_meter_get(struct snd_bebob *bebob, u32 *target, unsigned int size)
631 {
632         __be16 *buf;
633         unsigned int i, c, channels;
634         int err;
635 
636         channels = ARRAY_SIZE(special_meter_labels) * 2;
637         if (size < channels * sizeof(u32))
638                 return -EINVAL;
639 
640         /* omit last 4 bytes because it's clock info. */
641         buf = kmalloc(METER_SIZE_SPECIAL - 4, GFP_KERNEL);
642         if (buf == NULL)
643                 return -ENOMEM;
644 
645         err = get_meter(bebob, (void *)buf, METER_SIZE_SPECIAL - 4);
646         if (err < 0)
647                 goto end;
648 
649         /* Its format is u16 and some channels are unknown. */
650         i = 0;
651         for (c = 2; c < channels + 2; c++)
652                 target[i++] = be16_to_cpu(buf[c]) << 16;
653 end:
654         kfree(buf);
655         return err;
656 }
657 
658 /* last 4 bytes are omitted because it's clock info. */
659 static const char *const fw410_meter_labels[] = {
660         ANA_IN, DIG_IN,
661         ANA_OUT, ANA_OUT, ANA_OUT, ANA_OUT, DIG_OUT,
662         HP_OUT
663 };
664 static const char *const audiophile_meter_labels[] = {
665         ANA_IN, DIG_IN,
666         ANA_OUT, ANA_OUT, DIG_OUT,
667         HP_OUT, AUX_OUT,
668 };
669 static const char *const solo_meter_labels[] = {
670         ANA_IN, DIG_IN,
671         STRM_IN, STRM_IN,
672         ANA_OUT, DIG_OUT
673 };
674 
675 /* no clock info */
676 static const char *const ozonic_meter_labels[] = {
677         ANA_IN, ANA_IN,
678         STRM_IN, STRM_IN,
679         ANA_OUT, ANA_OUT
680 };
681 /* TODO: need testers. these positions are based on authour's assumption */
682 static const char *const nrv10_meter_labels[] = {
683         ANA_IN, ANA_IN, ANA_IN, ANA_IN,
684         DIG_IN,
685         ANA_OUT, ANA_OUT, ANA_OUT, ANA_OUT,
686         DIG_IN
687 };
688 static int
689 normal_meter_get(struct snd_bebob *bebob, u32 *buf, unsigned int size)
690 {
691         const struct snd_bebob_meter_spec *spec = bebob->spec->meter;
692         unsigned int c, channels;
693         int err;
694 
695         channels = spec->num * 2;
696         if (size < channels * sizeof(u32))
697                 return -EINVAL;
698 
699         err = get_meter(bebob, (void *)buf, size);
700         if (err < 0)
701                 goto end;
702 
703         for (c = 0; c < channels; c++)
704                 be32_to_cpus(&buf[c]);
705 
706         /* swap stream channels because inverted */
707         if (spec->labels == solo_meter_labels) {
708                 swap(buf[4], buf[6]);
709                 swap(buf[5], buf[7]);
710         }
711 end:
712         return err;
713 }
714 
715 /* for special customized devices */
716 static const struct snd_bebob_rate_spec special_rate_spec = {
717         .get    = &special_get_rate,
718         .set    = &special_set_rate,
719 };
720 static const struct snd_bebob_clock_spec special_clk_spec = {
721         .num    = ARRAY_SIZE(special_clk_types),
722         .types  = special_clk_types,
723         .get    = &special_clk_get,
724 };
725 static const struct snd_bebob_meter_spec special_meter_spec = {
726         .num    = ARRAY_SIZE(special_meter_labels),
727         .labels = special_meter_labels,
728         .get    = &special_meter_get
729 };
730 const struct snd_bebob_spec maudio_special_spec = {
731         .clock  = &special_clk_spec,
732         .rate   = &special_rate_spec,
733         .meter  = &special_meter_spec
734 };
735 
736 /* Firewire 410 specification */
737 static const struct snd_bebob_rate_spec usual_rate_spec = {
738         .get    = &snd_bebob_stream_get_rate,
739         .set    = &snd_bebob_stream_set_rate,
740 };
741 static const struct snd_bebob_meter_spec fw410_meter_spec = {
742         .num    = ARRAY_SIZE(fw410_meter_labels),
743         .labels = fw410_meter_labels,
744         .get    = &normal_meter_get
745 };
746 const struct snd_bebob_spec maudio_fw410_spec = {
747         .clock  = NULL,
748         .rate   = &usual_rate_spec,
749         .meter  = &fw410_meter_spec
750 };
751 
752 /* Firewire Audiophile specification */
753 static const struct snd_bebob_meter_spec audiophile_meter_spec = {
754         .num    = ARRAY_SIZE(audiophile_meter_labels),
755         .labels = audiophile_meter_labels,
756         .get    = &normal_meter_get
757 };
758 const struct snd_bebob_spec maudio_audiophile_spec = {
759         .clock  = NULL,
760         .rate   = &usual_rate_spec,
761         .meter  = &audiophile_meter_spec
762 };
763 
764 /* Firewire Solo specification */
765 static const struct snd_bebob_meter_spec solo_meter_spec = {
766         .num    = ARRAY_SIZE(solo_meter_labels),
767         .labels = solo_meter_labels,
768         .get    = &normal_meter_get
769 };
770 const struct snd_bebob_spec maudio_solo_spec = {
771         .clock  = NULL,
772         .rate   = &usual_rate_spec,
773         .meter  = &solo_meter_spec
774 };
775 
776 /* Ozonic specification */
777 static const struct snd_bebob_meter_spec ozonic_meter_spec = {
778         .num    = ARRAY_SIZE(ozonic_meter_labels),
779         .labels = ozonic_meter_labels,
780         .get    = &normal_meter_get
781 };
782 const struct snd_bebob_spec maudio_ozonic_spec = {
783         .clock  = NULL,
784         .rate   = &usual_rate_spec,
785         .meter  = &ozonic_meter_spec
786 };
787 
788 /* NRV10 specification */
789 static const struct snd_bebob_meter_spec nrv10_meter_spec = {
790         .num    = ARRAY_SIZE(nrv10_meter_labels),
791         .labels = nrv10_meter_labels,
792         .get    = &normal_meter_get
793 };
794 const struct snd_bebob_spec maudio_nrv10_spec = {
795         .clock  = NULL,
796         .rate   = &usual_rate_spec,
797         .meter  = &nrv10_meter_spec
798 };
799 

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