sound/firewire/fireworks/fireworks.c

   1 /*
   2  * fireworks.c - a part of driver for Fireworks based devices
   3  *
   4  * Copyright (c) 2009-2010 Clemens Ladisch
   5  * Copyright (c) 2013-2014 Takashi Sakamoto
   6  *
   7  * Licensed under the terms of the GNU General Public License, version 2.
   8  */
   9
  10 /*
  11  * Fireworks is a board module which Echo Audio produced. This module consists
  12  * of three chipsets:
  13  *  - Communication chipset for IEEE1394 PHY/Link and IEC 61883-1/6
  14  *  - DSP or/and FPGA for signal processing
  15  *  - Flash Memory to store firmwares
  16  */
  17
  18 #include "fireworks.h"
  19
  20 MODULE_DESCRIPTION("Echo Fireworks driver");
  21 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
  22 MODULE_LICENSE("GPL v2");
  23
  24 static int index[SNDRV_CARDS]   = SNDRV_DEFAULT_IDX;
  25 static char *id[SNDRV_CARDS]    = SNDRV_DEFAULT_STR;
  26 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  27 unsigned int snd_efw_resp_buf_size      = 1024;
  28 bool snd_efw_resp_buf_debug             = false;
  29
  30 module_param_array(index, int, NULL, 0444);
  31 MODULE_PARM_DESC(index, "card index");
  32 module_param_array(id, charp, NULL, 0444);
  33 MODULE_PARM_DESC(id, "ID string");
  34 module_param_array(enable, bool, NULL, 0444);
  35 MODULE_PARM_DESC(enable, "enable Fireworks sound card");
  36 module_param_named(resp_buf_size, snd_efw_resp_buf_size, uint, 0444);
  37 MODULE_PARM_DESC(resp_buf_size,
  38                  "response buffer size (max 4096, default 1024)");
  39 module_param_named(resp_buf_debug, snd_efw_resp_buf_debug, bool, 0444);
  40 MODULE_PARM_DESC(resp_buf_debug, "store all responses to buffer");
  41
  42 static DEFINE_MUTEX(devices_mutex);
  43 static DECLARE_BITMAP(devices_used, SNDRV_CARDS);
  44
  45 #define VENDOR_LOUD                     0x000ff2
  46 #define  MODEL_MACKIE_400F              0x00400f
  47 #define  MODEL_MACKIE_1200F             0x01200f
  48
  49 #define VENDOR_ECHO                     0x001486
  50 #define  MODEL_ECHO_AUDIOFIRE_12        0x00af12
  51 #define  MODEL_ECHO_AUDIOFIRE_12HD      0x0af12d
  52 #define  MODEL_ECHO_AUDIOFIRE_12_APPLE  0x0af12a
  53 /* This is applied for AudioFire8 (until 2009 July) */
  54 #define  MODEL_ECHO_AUDIOFIRE_8         0x000af8
  55 #define  MODEL_ECHO_AUDIOFIRE_2         0x000af2
  56 #define  MODEL_ECHO_AUDIOFIRE_4         0x000af4
  57 /* AudioFire9 is applied for AudioFire8(since 2009 July) and AudioFirePre8 */
  58 #define  MODEL_ECHO_AUDIOFIRE_9         0x000af9
  59 /* unknown as product */
  60 #define  MODEL_ECHO_FIREWORKS_8         0x0000f8
  61 #define  MODEL_ECHO_FIREWORKS_HDMI      0x00afd1
  62
  63 #define VENDOR_GIBSON                   0x00075b
  64 /* for Robot Interface Pack of Dark Fire, Dusk Tiger, Les Paul Standard 2010 */
  65 #define  MODEL_GIBSON_RIP               0x00afb2
  66 /* unknown as product */
  67 #define  MODEL_GIBSON_GOLDTOP           0x00afb9
  68
  69 /* part of hardware capability flags */
  70 #define FLAG_RESP_ADDR_CHANGABLE        0
  71
  72 static int
  73 get_hardware_info(struct snd_efw *efw)
  74 {
  75         struct fw_device *fw_dev = fw_parent_device(efw->unit);
  76         struct snd_efw_hwinfo *hwinfo;
  77         char version[12] = {0};
  78         int err;
  79
  80         hwinfo = kzalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL);
  81         if (hwinfo == NULL)
  82                 return -ENOMEM;
  83
  84         err = snd_efw_command_get_hwinfo(efw, hwinfo);
  85         if (err < 0)
  86                 goto end;
  87
  88         /* firmware version for communication chipset */
  89         snprintf(version, sizeof(version), "%u.%u",
  90                  (hwinfo->arm_version >> 24) & 0xff,
  91                  (hwinfo->arm_version >> 16) & 0xff);
  92         efw->firmware_version = hwinfo->arm_version;
  93
  94         strcpy(efw->card->driver, "Fireworks");
  95         strcpy(efw->card->shortname, hwinfo->model_name);
  96         strcpy(efw->card->mixername, hwinfo->model_name);
  97         snprintf(efw->card->longname, sizeof(efw->card->longname),
  98                  "%s %s v%s, GUID %08x%08x at %s, S%d",
  99                  hwinfo->vendor_name, hwinfo->model_name, version,
 100                  hwinfo->guid_hi, hwinfo->guid_lo,
 101                  dev_name(&efw->unit->device), 100 << fw_dev->max_speed);
 102
 103         if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE))
 104                 efw->resp_addr_changable = true;
 105
 106         efw->supported_sampling_rate = 0;
 107         if ((hwinfo->min_sample_rate <= 22050)
 108          && (22050 <= hwinfo->max_sample_rate))
 109                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_22050;
 110         if ((hwinfo->min_sample_rate <= 32000)
 111          && (32000 <= hwinfo->max_sample_rate))
 112                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_32000;
 113         if ((hwinfo->min_sample_rate <= 44100)
 114          && (44100 <= hwinfo->max_sample_rate))
 115                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_44100;
 116         if ((hwinfo->min_sample_rate <= 48000)
 117          && (48000 <= hwinfo->max_sample_rate))
 118                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_48000;
 119         if ((hwinfo->min_sample_rate <= 88200)
 120          && (88200 <= hwinfo->max_sample_rate))
 121                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_88200;
 122         if ((hwinfo->min_sample_rate <= 96000)
 123          && (96000 <= hwinfo->max_sample_rate))
 124                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_96000;
 125         if ((hwinfo->min_sample_rate <= 176400)
 126          && (176400 <= hwinfo->max_sample_rate))
 127                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_176400;
 128         if ((hwinfo->min_sample_rate <= 192000)
 129          && (192000 <= hwinfo->max_sample_rate))
 130                 efw->supported_sampling_rate |= SNDRV_PCM_RATE_192000;
 131
 132         /* the number of MIDI ports, not of MIDI conformant data channels */
 133         if (hwinfo->midi_out_ports > SND_EFW_MAX_MIDI_OUT_PORTS ||
 134             hwinfo->midi_in_ports > SND_EFW_MAX_MIDI_IN_PORTS) {
 135                 err = -EIO;
 136                 goto end;
 137         }
 138         efw->midi_out_ports = hwinfo->midi_out_ports;
 139         efw->midi_in_ports = hwinfo->midi_in_ports;
 140
 141         if (hwinfo->amdtp_tx_pcm_channels    > AM824_MAX_CHANNELS_FOR_PCM ||
 142             hwinfo->amdtp_tx_pcm_channels_2x > AM824_MAX_CHANNELS_FOR_PCM ||
 143             hwinfo->amdtp_tx_pcm_channels_4x > AM824_MAX_CHANNELS_FOR_PCM ||
 144             hwinfo->amdtp_rx_pcm_channels    > AM824_MAX_CHANNELS_FOR_PCM ||
 145             hwinfo->amdtp_rx_pcm_channels_2x > AM824_MAX_CHANNELS_FOR_PCM ||
 146             hwinfo->amdtp_rx_pcm_channels_4x > AM824_MAX_CHANNELS_FOR_PCM) {
 147                 err = -ENOSYS;
 148                 goto end;
 149         }
 150         efw->pcm_capture_channels[0] = hwinfo->amdtp_tx_pcm_channels;
 151         efw->pcm_capture_channels[1] = hwinfo->amdtp_tx_pcm_channels_2x;
 152         efw->pcm_capture_channels[2] = hwinfo->amdtp_tx_pcm_channels_4x;
 153         efw->pcm_playback_channels[0] = hwinfo->amdtp_rx_pcm_channels;
 154         efw->pcm_playback_channels[1] = hwinfo->amdtp_rx_pcm_channels_2x;
 155         efw->pcm_playback_channels[2] = hwinfo->amdtp_rx_pcm_channels_4x;
 156
 157         /* Hardware metering. */
 158         if (hwinfo->phys_in_grp_count  > HWINFO_MAX_CAPS_GROUPS ||
 159             hwinfo->phys_out_grp_count > HWINFO_MAX_CAPS_GROUPS) {
 160                 err = -EIO;
 161                 goto end;
 162         }
 163         efw->phys_in = hwinfo->phys_in;
 164         efw->phys_out = hwinfo->phys_out;
 165         efw->phys_in_grp_count = hwinfo->phys_in_grp_count;
 166         efw->phys_out_grp_count = hwinfo->phys_out_grp_count;
 167         memcpy(&efw->phys_in_grps, hwinfo->phys_in_grps,
 168                sizeof(struct snd_efw_phys_grp) * hwinfo->phys_in_grp_count);
 169         memcpy(&efw->phys_out_grps, hwinfo->phys_out_grps,
 170                sizeof(struct snd_efw_phys_grp) * hwinfo->phys_out_grp_count);
 171
 172         /* AudioFire8 (since 2009) and AudioFirePre8 */
 173         if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_9)
 174                 efw->is_af9 = true;
 175         /* These models uses the same firmware. */
 176         if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_2 ||
 177             hwinfo->type == MODEL_ECHO_AUDIOFIRE_4 ||
 178             hwinfo->type == MODEL_ECHO_AUDIOFIRE_9 ||
 179             hwinfo->type == MODEL_GIBSON_RIP ||
 180             hwinfo->type == MODEL_GIBSON_GOLDTOP)
 181                 efw->is_fireworks3 = true;
 182 end:
 183         kfree(hwinfo);
 184         return err;
 185 }
 186
 187 static void efw_free(struct snd_efw *efw)
 188 {
 189         snd_efw_stream_destroy_duplex(efw);
 190         snd_efw_transaction_remove_instance(efw);
 191         fw_unit_put(efw->unit);
 192
 193         kfree(efw->resp_buf);
 194
 195         mutex_destroy(&efw->mutex);
 196         kfree(efw);
 197 }
 198
 199 /*
 200  * This module releases the FireWire unit data after all ALSA character devices
 201  * are released by applications. This is for releasing stream data or finishing
 202  * transactions safely. Thus at returning from .remove(), this module still keep
 203  * references for the unit.
 204  */
 205 static void
 206 efw_card_free(struct snd_card *card)
 207 {
 208         struct snd_efw *efw = card->private_data;
 209
 210         if (efw->card_index >= 0) {
 211                 mutex_lock(&devices_mutex);
 212                 clear_bit(efw->card_index, devices_used);
 213                 mutex_unlock(&devices_mutex);
 214         }
 215
 216         efw_free(card->private_data);
 217 }
 218
 219 static void
 220 do_registration(struct work_struct *work)
 221 {
 222         struct snd_efw *efw = container_of(work, struct snd_efw, dwork.work);
 223         unsigned int card_index;
 224         int err;
 225
 226         if (efw->registered)
 227                 return;
 228
 229         mutex_lock(&devices_mutex);
 230
 231         /* check registered cards */
 232         for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) {
 233                 if (!test_bit(card_index, devices_used) && enable[card_index])
 234                         break;
 235         }
 236         if (card_index >= SNDRV_CARDS) {
 237                 mutex_unlock(&devices_mutex);
 238                 return;
 239         }
 240
 241         err = snd_card_new(&efw->unit->device, index[card_index],
 242                            id[card_index], THIS_MODULE, 0, &efw->card);
 243         if (err < 0) {
 244                 mutex_unlock(&devices_mutex);
 245                 return;
 246         }
 247
 248         /* prepare response buffer */
 249         snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size,
 250                                       SND_EFW_RESPONSE_MAXIMUM_BYTES, 4096U);
 251         efw->resp_buf = kzalloc(snd_efw_resp_buf_size, GFP_KERNEL);
 252         if (efw->resp_buf == NULL) {
 253                 err = -ENOMEM;
 254                 goto error;
 255         }
 256         efw->pull_ptr = efw->push_ptr = efw->resp_buf;
 257         snd_efw_transaction_add_instance(efw);
 258
 259         err = get_hardware_info(efw);
 260         if (err < 0)
 261                 goto error;
 262
 263         err = snd_efw_stream_init_duplex(efw);
 264         if (err < 0)
 265                 goto error;
 266
 267         snd_efw_proc_init(efw);
 268
 269         if (efw->midi_out_ports || efw->midi_in_ports) {
 270                 err = snd_efw_create_midi_devices(efw);
 271                 if (err < 0)
 272                         goto error;
 273         }
 274
 275         err = snd_efw_create_pcm_devices(efw);
 276         if (err < 0)
 277                 goto error;
 278
 279         err = snd_efw_create_hwdep_device(efw);
 280         if (err < 0)
 281                 goto error;
 282
 283         err = snd_card_register(efw->card);
 284         if (err < 0)
 285                 goto error;
 286
 287         set_bit(card_index, devices_used);
 288         mutex_unlock(&devices_mutex);
 289
 290         /*
 291          * After registered, efw instance can be released corresponding to
 292          * releasing the sound card instance.
 293          */
 294         efw->card->private_free = efw_card_free;
 295         efw->card->private_data = efw;
 296         efw->registered = true;
 297
 298         return;
 299 error:
 300         mutex_unlock(&devices_mutex);
 301         snd_efw_transaction_remove_instance(efw);
 302         snd_efw_stream_destroy_duplex(efw);
 303         snd_card_free(efw->card);
 304         dev_info(&efw->unit->device,
 305                  "Sound card registration failed: %d\n", err);
 306 }
 307
 308 static int
 309 efw_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry)
 310 {
 311         struct snd_efw *efw;
 312
 313         efw = kzalloc(sizeof(struct snd_efw), GFP_KERNEL);
 314         if (efw == NULL)
 315                 return -ENOMEM;
 316
 317         efw->unit = fw_unit_get(unit);
 318         dev_set_drvdata(&unit->device, efw);
 319
 320         mutex_init(&efw->mutex);
 321         spin_lock_init(&efw->lock);
 322         init_waitqueue_head(&efw->hwdep_wait);
 323
 324         /* Allocate and register this sound card later. */
 325         INIT_DEFERRABLE_WORK(&efw->dwork, do_registration);
 326         snd_fw_schedule_registration(unit, &efw->dwork);
 327
 328         return 0;
 329 }
 330
 331 static void efw_update(struct fw_unit *unit)
 332 {
 333         struct snd_efw *efw = dev_get_drvdata(&unit->device);
 334
 335         /* Postpone a workqueue for deferred registration. */
 336         if (!efw->registered)
 337                 snd_fw_schedule_registration(unit, &efw->dwork);
 338
 339         snd_efw_transaction_bus_reset(efw->unit);
 340
 341         /*
 342          * After registration, userspace can start packet streaming, then this
 343          * code block works fine.
 344          */
 345         if (efw->registered) {
 346                 mutex_lock(&efw->mutex);
 347                 snd_efw_stream_update_duplex(efw);
 348                 mutex_unlock(&efw->mutex);
 349         }
 350 }
 351
 352 static void efw_remove(struct fw_unit *unit)
 353 {
 354         struct snd_efw *efw = dev_get_drvdata(&unit->device);
 355
 356         /*
 357          * Confirm to stop the work for registration before the sound card is
 358          * going to be released. The work is not scheduled again because bus
 359          * reset handler is not called anymore.
 360          */
 361         cancel_delayed_work_sync(&efw->dwork);
 362
 363         if (efw->registered) {
 364                 /* No need to wait for releasing card object in this context. */
 365                 snd_card_free_when_closed(efw->card);
 366         } else {
 367                 /* Don't forget this case. */
 368                 efw_free(efw);
 369         }
 370 }
 371
 372 static const struct ieee1394_device_id efw_id_table[] = {
 373         SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F),
 374         SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F),
 375         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8),
 376         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12),
 377         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD),
 378         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE),
 379         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2),
 380         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4),
 381         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9),
 382         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8),
 383         SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI),
 384         SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP),
 385         SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP),
 386         {}
 387 };
 388 MODULE_DEVICE_TABLE(ieee1394, efw_id_table);
 389
 390 static struct fw_driver efw_driver = {
 391         .driver = {
 392                 .owner = THIS_MODULE,
 393                 .name = "snd-fireworks",
 394                 .bus = &fw_bus_type,
 395         },
 396         .probe    = efw_probe,
 397         .update   = efw_update,
 398         .remove   = efw_remove,
 399         .id_table = efw_id_table,
 400 };
 401
 402 static int __init snd_efw_init(void)
 403 {
 404         int err;
 405
 406         err = snd_efw_transaction_register();
 407         if (err < 0)
 408                 goto end;
 409
 410         err = driver_register(&efw_driver.driver);
 411         if (err < 0)
 412                 snd_efw_transaction_unregister();
 413
 414 end:
 415         return err;
 416 }
 417
 418 static void __exit snd_efw_exit(void)
 419 {
 420         snd_efw_transaction_unregister();
 421         driver_unregister(&efw_driver.driver);
 422 }
 423
 424 module_init(snd_efw_init);
 425 module_exit(snd_efw_exit);