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 > AMDTP_MAX_CHANNELS_FOR_PCM || 142 hwinfo->amdtp_tx_pcm_channels_2x > AMDTP_MAX_CHANNELS_FOR_PCM || 143 hwinfo->amdtp_tx_pcm_channels_4x > AMDTP_MAX_CHANNELS_FOR_PCM || 144 hwinfo->amdtp_rx_pcm_channels > AMDTP_MAX_CHANNELS_FOR_PCM || 145 hwinfo->amdtp_rx_pcm_channels_2x > AMDTP_MAX_CHANNELS_FOR_PCM || 146 hwinfo->amdtp_rx_pcm_channels_4x > AMDTP_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 end: 172 kfree(hwinfo); 173 return err; 174 } 175 176 /* 177 * This module releases the FireWire unit data after all ALSA character devices 178 * are released by applications. This is for releasing stream data or finishing 179 * transactions safely. Thus at returning from .remove(), this module still keep 180 * references for the unit. 181 */ 182 static void 183 efw_card_free(struct snd_card *card) 184 { 185 struct snd_efw *efw = card->private_data; 186 187 snd_efw_stream_destroy_duplex(efw); 188 snd_efw_transaction_remove_instance(efw); 189 fw_unit_put(efw->unit); 190 191 kfree(efw->resp_buf); 192 193 if (efw->card_index >= 0) { 194 mutex_lock(&devices_mutex); 195 clear_bit(efw->card_index, devices_used); 196 mutex_unlock(&devices_mutex); 197 } 198 199 mutex_destroy(&efw->mutex); 200 } 201 202 static int 203 efw_probe(struct fw_unit *unit, 204 const struct ieee1394_device_id *entry) 205 { 206 struct snd_card *card; 207 struct snd_efw *efw; 208 int card_index, err; 209 210 mutex_lock(&devices_mutex); 211 212 /* check registered cards */ 213 for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) { 214 if (!test_bit(card_index, devices_used) && enable[card_index]) 215 break; 216 } 217 if (card_index >= SNDRV_CARDS) { 218 err = -ENOENT; 219 goto end; 220 } 221 222 err = snd_card_new(&unit->device, index[card_index], id[card_index], 223 THIS_MODULE, sizeof(struct snd_efw), &card); 224 if (err < 0) 225 goto end; 226 efw = card->private_data; 227 efw->card_index = card_index; 228 set_bit(card_index, devices_used); 229 card->private_free = efw_card_free; 230 231 efw->card = card; 232 efw->unit = fw_unit_get(unit); 233 mutex_init(&efw->mutex); 234 spin_lock_init(&efw->lock); 235 init_waitqueue_head(&efw->hwdep_wait); 236 237 /* prepare response buffer */ 238 snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size, 239 SND_EFW_RESPONSE_MAXIMUM_BYTES, 4096U); 240 efw->resp_buf = kzalloc(snd_efw_resp_buf_size, GFP_KERNEL); 241 if (efw->resp_buf == NULL) { 242 err = -ENOMEM; 243 goto error; 244 } 245 efw->pull_ptr = efw->push_ptr = efw->resp_buf; 246 snd_efw_transaction_add_instance(efw); 247 248 err = get_hardware_info(efw); 249 if (err < 0) 250 goto error; 251 if (entry->model_id == MODEL_ECHO_AUDIOFIRE_9) 252 efw->is_af9 = true; 253 254 snd_efw_proc_init(efw); 255 256 if (efw->midi_out_ports || efw->midi_in_ports) { 257 err = snd_efw_create_midi_devices(efw); 258 if (err < 0) 259 goto error; 260 } 261 262 err = snd_efw_create_pcm_devices(efw); 263 if (err < 0) 264 goto error; 265 266 err = snd_efw_create_hwdep_device(efw); 267 if (err < 0) 268 goto error; 269 270 err = snd_efw_stream_init_duplex(efw); 271 if (err < 0) 272 goto error; 273 274 err = snd_card_register(card); 275 if (err < 0) { 276 snd_efw_stream_destroy_duplex(efw); 277 goto error; 278 } 279 280 dev_set_drvdata(&unit->device, efw); 281 end: 282 mutex_unlock(&devices_mutex); 283 return err; 284 error: 285 snd_efw_transaction_remove_instance(efw); 286 mutex_unlock(&devices_mutex); 287 snd_card_free(card); 288 return err; 289 } 290 291 static void efw_update(struct fw_unit *unit) 292 { 293 struct snd_efw *efw = dev_get_drvdata(&unit->device); 294 295 snd_efw_transaction_bus_reset(efw->unit); 296 snd_efw_stream_update_duplex(efw); 297 } 298 299 static void efw_remove(struct fw_unit *unit) 300 { 301 struct snd_efw *efw = dev_get_drvdata(&unit->device); 302 303 /* No need to wait for releasing card object in this context. */ 304 snd_card_free_when_closed(efw->card); 305 } 306 307 static const struct ieee1394_device_id efw_id_table[] = { 308 SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F), 309 SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F), 310 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8), 311 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12), 312 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD), 313 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE), 314 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2), 315 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4), 316 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9), 317 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8), 318 SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI), 319 SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP), 320 SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP), 321 {} 322 }; 323 MODULE_DEVICE_TABLE(ieee1394, efw_id_table); 324 325 static struct fw_driver efw_driver = { 326 .driver = { 327 .owner = THIS_MODULE, 328 .name = "snd-fireworks", 329 .bus = &fw_bus_type, 330 }, 331 .probe = efw_probe, 332 .update = efw_update, 333 .remove = efw_remove, 334 .id_table = efw_id_table, 335 }; 336 337 static int __init snd_efw_init(void) 338 { 339 int err; 340 341 err = snd_efw_transaction_register(); 342 if (err < 0) 343 goto end; 344 345 err = driver_register(&efw_driver.driver); 346 if (err < 0) 347 snd_efw_transaction_unregister(); 348 349 end: 350 return err; 351 } 352 353 static void __exit snd_efw_exit(void) 354 { 355 snd_efw_transaction_unregister(); 356 driver_unregister(&efw_driver.driver); 357 } 358 359 module_init(snd_efw_init); 360 module_exit(snd_efw_exit); 361