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); 426