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