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 188 efw_card_free(struct snd_card *card) 189 { 190 struct snd_efw *efw = card->private_data; 191 192 mutex_lock(&devices_mutex); 193 clear_bit(efw->card_index, devices_used); 194 mutex_unlock(&devices_mutex); 195 196 snd_efw_stream_destroy_duplex(efw); 197 snd_efw_transaction_remove_instance(efw); 198 } 199 200 static void 201 do_registration(struct work_struct *work) 202 { 203 struct snd_efw *efw = container_of(work, struct snd_efw, dwork.work); 204 unsigned int card_index; 205 int err; 206 207 if (efw->registered) 208 return; 209 210 /* check registered cards */ 211 mutex_lock(&devices_mutex); 212 for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) { 213 if (!test_bit(card_index, devices_used) && enable[card_index]) 214 break; 215 } 216 if (card_index >= SNDRV_CARDS) { 217 mutex_unlock(&devices_mutex); 218 return; 219 } 220 221 err = snd_card_new(&efw->unit->device, index[card_index], 222 id[card_index], THIS_MODULE, 0, &efw->card); 223 if (err < 0) { 224 mutex_unlock(&devices_mutex); 225 return; 226 } 227 set_bit(card_index, devices_used); 228 mutex_unlock(&devices_mutex); 229 230 efw->card->private_free = efw_card_free; 231 efw->card->private_data = efw; 232 233 /* prepare response buffer */ 234 snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size, 235 SND_EFW_RESPONSE_MAXIMUM_BYTES, 4096U); 236 efw->resp_buf = devm_kzalloc(&efw->card->card_dev, 237 snd_efw_resp_buf_size, GFP_KERNEL); 238 if (!efw->resp_buf) { 239 err = -ENOMEM; 240 goto error; 241 } 242 efw->pull_ptr = efw->push_ptr = efw->resp_buf; 243 snd_efw_transaction_add_instance(efw); 244 245 err = get_hardware_info(efw); 246 if (err < 0) 247 goto error; 248 249 err = snd_efw_stream_init_duplex(efw); 250 if (err < 0) 251 goto error; 252 253 snd_efw_proc_init(efw); 254 255 if (efw->midi_out_ports || efw->midi_in_ports) { 256 err = snd_efw_create_midi_devices(efw); 257 if (err < 0) 258 goto error; 259 } 260 261 err = snd_efw_create_pcm_devices(efw); 262 if (err < 0) 263 goto error; 264 265 err = snd_efw_create_hwdep_device(efw); 266 if (err < 0) 267 goto error; 268 269 err = snd_card_register(efw->card); 270 if (err < 0) 271 goto error; 272 273 efw->registered = true; 274 275 return; 276 error: 277 snd_card_free(efw->card); 278 dev_info(&efw->unit->device, 279 "Sound card registration failed: %d\n", err); 280 } 281 282 static int 283 efw_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry) 284 { 285 struct snd_efw *efw; 286 287 efw = devm_kzalloc(&unit->device, sizeof(struct snd_efw), GFP_KERNEL); 288 if (efw == NULL) 289 return -ENOMEM; 290 efw->unit = fw_unit_get(unit); 291 dev_set_drvdata(&unit->device, efw); 292 293 mutex_init(&efw->mutex); 294 spin_lock_init(&efw->lock); 295 init_waitqueue_head(&efw->hwdep_wait); 296 297 /* Allocate and register this sound card later. */ 298 INIT_DEFERRABLE_WORK(&efw->dwork, do_registration); 299 snd_fw_schedule_registration(unit, &efw->dwork); 300 301 return 0; 302 } 303 304 static void efw_update(struct fw_unit *unit) 305 { 306 struct snd_efw *efw = dev_get_drvdata(&unit->device); 307 308 /* Postpone a workqueue for deferred registration. */ 309 if (!efw->registered) 310 snd_fw_schedule_registration(unit, &efw->dwork); 311 312 snd_efw_transaction_bus_reset(efw->unit); 313 314 /* 315 * After registration, userspace can start packet streaming, then this 316 * code block works fine. 317 */ 318 if (efw->registered) { 319 mutex_lock(&efw->mutex); 320 snd_efw_stream_update_duplex(efw); 321 mutex_unlock(&efw->mutex); 322 } 323 } 324 325 static void efw_remove(struct fw_unit *unit) 326 { 327 struct snd_efw *efw = dev_get_drvdata(&unit->device); 328 329 /* 330 * Confirm to stop the work for registration before the sound card is 331 * going to be released. The work is not scheduled again because bus 332 * reset handler is not called anymore. 333 */ 334 cancel_delayed_work_sync(&efw->dwork); 335 336 if (efw->registered) { 337 // Block till all of ALSA character devices are released. 338 snd_card_free(efw->card); 339 } 340 341 mutex_destroy(&efw->mutex); 342 fw_unit_put(efw->unit); 343 } 344 345 static const struct ieee1394_device_id efw_id_table[] = { 346 SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F), 347 SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F), 348 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8), 349 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12), 350 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD), 351 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE), 352 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2), 353 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4), 354 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9), 355 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8), 356 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI), 357 SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP), 358 SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP), 359 {} 360 }; 361 MODULE_DEVICE_TABLE(ieee1394, efw_id_table); 362 363 static struct fw_driver efw_driver = { 364 .driver = { 365 .owner = THIS_MODULE, 366 .name = "snd-fireworks", 367 .bus = &fw_bus_type, 368 }, 369 .probe = efw_probe, 370 .update = efw_update, 371 .remove = efw_remove, 372 .id_table = efw_id_table, 373 }; 374 375 static int __init snd_efw_init(void) 376 { 377 int err; 378 379 err = snd_efw_transaction_register(); 380 if (err < 0) 381 goto end; 382 383 err = driver_register(&efw_driver.driver); 384 if (err < 0) 385 snd_efw_transaction_unregister(); 386 387 end: 388 return err; 389 } 390 391 static void __exit snd_efw_exit(void) 392 { 393 snd_efw_transaction_unregister(); 394 driver_unregister(&efw_driver.driver); 395 } 396 397 module_init(snd_efw_init); 398 module_exit(snd_efw_exit); 399