firewire/fireworks/fireworks.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * fireworks.c - a part of driver for Fireworks based devices
0004  *
0005  * Copyright (c) 2009-2010 Clemens Ladisch
0006  * Copyright (c) 2013-2014 Takashi Sakamoto
0007  */
0008
0009 /*
0010  * Fireworks is a board module which Echo Audio produced. This module consists
0011  * of three chipsets:
0012  *  - Communication chipset for IEEE1394 PHY/Link and IEC 61883-1/6
0013  *  - DSP or/and FPGA for signal processing
0014  *  - Flash Memory to store firmwares
0015  */
0016
0017 #include "fireworks.h"
0018
0019 MODULE_DESCRIPTION("Echo Fireworks driver");
0020 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
0021 MODULE_LICENSE("GPL v2");
0022
0023 static int index[SNDRV_CARDS]   = SNDRV_DEFAULT_IDX;
0024 static char *id[SNDRV_CARDS]    = SNDRV_DEFAULT_STR;
0025 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
0026 unsigned int snd_efw_resp_buf_size  = 1024;
0027 bool snd_efw_resp_buf_debug     = false;
0028
0029 module_param_array(index, int, NULL, 0444);
0030 MODULE_PARM_DESC(index, "card index");
0031 module_param_array(id, charp, NULL, 0444);
0032 MODULE_PARM_DESC(id, "ID string");
0033 module_param_array(enable, bool, NULL, 0444);
0034 MODULE_PARM_DESC(enable, "enable Fireworks sound card");
0035 module_param_named(resp_buf_size, snd_efw_resp_buf_size, uint, 0444);
0036 MODULE_PARM_DESC(resp_buf_size,
0037          "response buffer size (max 4096, default 1024)");
0038 module_param_named(resp_buf_debug, snd_efw_resp_buf_debug, bool, 0444);
0039 MODULE_PARM_DESC(resp_buf_debug, "store all responses to buffer");
0040
0041 static DEFINE_MUTEX(devices_mutex);
0042 static DECLARE_BITMAP(devices_used, SNDRV_CARDS);
0043
0044 #define VENDOR_LOUD         0x000ff2
0045 #define  MODEL_MACKIE_400F      0x00400f
0046 #define  MODEL_MACKIE_1200F     0x01200f
0047
0048 #define VENDOR_ECHO         0x001486
0049 #define  MODEL_ECHO_AUDIOFIRE_12    0x00af12
0050 #define  MODEL_ECHO_AUDIOFIRE_12HD  0x0af12d
0051 #define  MODEL_ECHO_AUDIOFIRE_12_APPLE  0x0af12a
0052 /* This is applied for AudioFire8 (until 2009 July) */
0053 #define  MODEL_ECHO_AUDIOFIRE_8     0x000af8
0054 #define  MODEL_ECHO_AUDIOFIRE_2     0x000af2
0055 #define  MODEL_ECHO_AUDIOFIRE_4     0x000af4
0056 /* AudioFire9 is applied for AudioFire8(since 2009 July) and AudioFirePre8 */
0057 #define  MODEL_ECHO_AUDIOFIRE_9     0x000af9
0058 /* unknown as product */
0059 #define  MODEL_ECHO_FIREWORKS_8     0x0000f8
0060 #define  MODEL_ECHO_FIREWORKS_HDMI  0x00afd1
0061
0062 #define VENDOR_GIBSON           0x00075b
0063 /* for Robot Interface Pack of Dark Fire, Dusk Tiger, Les Paul Standard 2010 */
0064 #define  MODEL_GIBSON_RIP       0x00afb2
0065 /* unknown as product */
0066 #define  MODEL_GIBSON_GOLDTOP       0x00afb9
0067
0068 /* part of hardware capability flags */
0069 #define FLAG_RESP_ADDR_CHANGABLE    0
0070
0071 static int
0072 get_hardware_info(struct snd_efw *efw)
0073 {
0074     struct fw_device *fw_dev = fw_parent_device(efw->unit);
0075     struct snd_efw_hwinfo *hwinfo;
0076     char version[12] = {0};
0077     int err;
0078
0079     hwinfo = kzalloc(sizeof(struct snd_efw_hwinfo), GFP_KERNEL);
0080     if (hwinfo == NULL)
0081         return -ENOMEM;
0082
0083     err = snd_efw_command_get_hwinfo(efw, hwinfo);
0084     if (err < 0)
0085         goto end;
0086
0087     /* firmware version for communication chipset */
0088     snprintf(version, sizeof(version), "%u.%u",
0089          (hwinfo->arm_version >> 24) & 0xff,
0090          (hwinfo->arm_version >> 16) & 0xff);
0091     efw->firmware_version = hwinfo->arm_version;
0092
0093     strcpy(efw->card->driver, "Fireworks");
0094     strcpy(efw->card->shortname, hwinfo->model_name);
0095     strcpy(efw->card->mixername, hwinfo->model_name);
0096     snprintf(efw->card->longname, sizeof(efw->card->longname),
0097          "%s %s v%s, GUID %08x%08x at %s, S%d",
0098          hwinfo->vendor_name, hwinfo->model_name, version,
0099          hwinfo->guid_hi, hwinfo->guid_lo,
0100          dev_name(&efw->unit->device), 100 << fw_dev->max_speed);
0101
0102     if (hwinfo->flags & BIT(FLAG_RESP_ADDR_CHANGABLE))
0103         efw->resp_addr_changable = true;
0104
0105     efw->supported_sampling_rate = 0;
0106     if ((hwinfo->min_sample_rate <= 22050)
0107      && (22050 <= hwinfo->max_sample_rate))
0108         efw->supported_sampling_rate |= SNDRV_PCM_RATE_22050;
0109     if ((hwinfo->min_sample_rate <= 32000)
0110      && (32000 <= hwinfo->max_sample_rate))
0111         efw->supported_sampling_rate |= SNDRV_PCM_RATE_32000;
0112     if ((hwinfo->min_sample_rate <= 44100)
0113      && (44100 <= hwinfo->max_sample_rate))
0114         efw->supported_sampling_rate |= SNDRV_PCM_RATE_44100;
0115     if ((hwinfo->min_sample_rate <= 48000)
0116      && (48000 <= hwinfo->max_sample_rate))
0117         efw->supported_sampling_rate |= SNDRV_PCM_RATE_48000;
0118     if ((hwinfo->min_sample_rate <= 88200)
0119      && (88200 <= hwinfo->max_sample_rate))
0120         efw->supported_sampling_rate |= SNDRV_PCM_RATE_88200;
0121     if ((hwinfo->min_sample_rate <= 96000)
0122      && (96000 <= hwinfo->max_sample_rate))
0123         efw->supported_sampling_rate |= SNDRV_PCM_RATE_96000;
0124     if ((hwinfo->min_sample_rate <= 176400)
0125      && (176400 <= hwinfo->max_sample_rate))
0126         efw->supported_sampling_rate |= SNDRV_PCM_RATE_176400;
0127     if ((hwinfo->min_sample_rate <= 192000)
0128      && (192000 <= hwinfo->max_sample_rate))
0129         efw->supported_sampling_rate |= SNDRV_PCM_RATE_192000;
0130
0131     /* the number of MIDI ports, not of MIDI conformant data channels */
0132     if (hwinfo->midi_out_ports > SND_EFW_MAX_MIDI_OUT_PORTS ||
0133         hwinfo->midi_in_ports > SND_EFW_MAX_MIDI_IN_PORTS) {
0134         err = -EIO;
0135         goto end;
0136     }
0137     efw->midi_out_ports = hwinfo->midi_out_ports;
0138     efw->midi_in_ports = hwinfo->midi_in_ports;
0139
0140     if (hwinfo->amdtp_tx_pcm_channels    > AM824_MAX_CHANNELS_FOR_PCM ||
0141         hwinfo->amdtp_tx_pcm_channels_2x > AM824_MAX_CHANNELS_FOR_PCM ||
0142         hwinfo->amdtp_tx_pcm_channels_4x > AM824_MAX_CHANNELS_FOR_PCM ||
0143         hwinfo->amdtp_rx_pcm_channels    > AM824_MAX_CHANNELS_FOR_PCM ||
0144         hwinfo->amdtp_rx_pcm_channels_2x > AM824_MAX_CHANNELS_FOR_PCM ||
0145         hwinfo->amdtp_rx_pcm_channels_4x > AM824_MAX_CHANNELS_FOR_PCM) {
0146         err = -ENOSYS;
0147         goto end;
0148     }
0149     efw->pcm_capture_channels[0] = hwinfo->amdtp_tx_pcm_channels;
0150     efw->pcm_capture_channels[1] = hwinfo->amdtp_tx_pcm_channels_2x;
0151     efw->pcm_capture_channels[2] = hwinfo->amdtp_tx_pcm_channels_4x;
0152     efw->pcm_playback_channels[0] = hwinfo->amdtp_rx_pcm_channels;
0153     efw->pcm_playback_channels[1] = hwinfo->amdtp_rx_pcm_channels_2x;
0154     efw->pcm_playback_channels[2] = hwinfo->amdtp_rx_pcm_channels_4x;
0155
0156     /* Hardware metering. */
0157     if (hwinfo->phys_in_grp_count  > HWINFO_MAX_CAPS_GROUPS ||
0158         hwinfo->phys_out_grp_count > HWINFO_MAX_CAPS_GROUPS) {
0159         err = -EIO;
0160         goto end;
0161     }
0162     efw->phys_in = hwinfo->phys_in;
0163     efw->phys_out = hwinfo->phys_out;
0164     efw->phys_in_grp_count = hwinfo->phys_in_grp_count;
0165     efw->phys_out_grp_count = hwinfo->phys_out_grp_count;
0166     memcpy(&efw->phys_in_grps, hwinfo->phys_in_grps,
0167            sizeof(struct snd_efw_phys_grp) * hwinfo->phys_in_grp_count);
0168     memcpy(&efw->phys_out_grps, hwinfo->phys_out_grps,
0169            sizeof(struct snd_efw_phys_grp) * hwinfo->phys_out_grp_count);
0170
0171     /* AudioFire8 (since 2009) and AudioFirePre8 */
0172     if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_9)
0173         efw->is_af9 = true;
0174     /* These models uses the same firmware. */
0175     if (hwinfo->type == MODEL_ECHO_AUDIOFIRE_2 ||
0176         hwinfo->type == MODEL_ECHO_AUDIOFIRE_4 ||
0177         hwinfo->type == MODEL_ECHO_AUDIOFIRE_9 ||
0178         hwinfo->type == MODEL_GIBSON_RIP ||
0179         hwinfo->type == MODEL_GIBSON_GOLDTOP)
0180         efw->is_fireworks3 = true;
0181 end:
0182     kfree(hwinfo);
0183     return err;
0184 }
0185
0186 static void
0187 efw_card_free(struct snd_card *card)
0188 {
0189     struct snd_efw *efw = card->private_data;
0190
0191     mutex_lock(&devices_mutex);
0192     clear_bit(efw->card_index, devices_used);
0193     mutex_unlock(&devices_mutex);
0194
0195     snd_efw_stream_destroy_duplex(efw);
0196     snd_efw_transaction_remove_instance(efw);
0197
0198     mutex_destroy(&efw->mutex);
0199     fw_unit_put(efw->unit);
0200 }
0201
0202 static int efw_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry)
0203 {
0204     unsigned int card_index;
0205     struct snd_card *card;
0206     struct snd_efw *efw;
0207     int err;
0208
0209     // check registered cards.
0210     mutex_lock(&devices_mutex);
0211     for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) {
0212         if (!test_bit(card_index, devices_used) && enable[card_index])
0213             break;
0214     }
0215     if (card_index >= SNDRV_CARDS) {
0216         mutex_unlock(&devices_mutex);
0217         return -ENOENT;
0218     }
0219
0220     err = snd_card_new(&unit->device, index[card_index], id[card_index], THIS_MODULE,
0221                sizeof(*efw), &card);
0222     if (err < 0) {
0223         mutex_unlock(&devices_mutex);
0224         return err;
0225     }
0226     card->private_free = efw_card_free;
0227     set_bit(card_index, devices_used);
0228     mutex_unlock(&devices_mutex);
0229
0230     efw = card->private_data;
0231     efw->unit = fw_unit_get(unit);
0232     dev_set_drvdata(&unit->device, efw);
0233     efw->card = card;
0234     efw->card_index = card_index;
0235
0236     mutex_init(&efw->mutex);
0237     spin_lock_init(&efw->lock);
0238     init_waitqueue_head(&efw->hwdep_wait);
0239
0240     // prepare response buffer.
0241     snd_efw_resp_buf_size = clamp(snd_efw_resp_buf_size, SND_EFW_RESPONSE_MAXIMUM_BYTES, 4096U);
0242     efw->resp_buf = devm_kzalloc(&card->card_dev, snd_efw_resp_buf_size, GFP_KERNEL);
0243     if (!efw->resp_buf) {
0244         err = -ENOMEM;
0245         goto error;
0246     }
0247     efw->pull_ptr = efw->push_ptr = efw->resp_buf;
0248     snd_efw_transaction_add_instance(efw);
0249
0250     err = get_hardware_info(efw);
0251     if (err < 0)
0252         goto error;
0253
0254     err = snd_efw_stream_init_duplex(efw);
0255     if (err < 0)
0256         goto error;
0257
0258     snd_efw_proc_init(efw);
0259
0260     if (efw->midi_out_ports || efw->midi_in_ports) {
0261         err = snd_efw_create_midi_devices(efw);
0262         if (err < 0)
0263             goto error;
0264     }
0265
0266     err = snd_efw_create_pcm_devices(efw);
0267     if (err < 0)
0268         goto error;
0269
0270     err = snd_efw_create_hwdep_device(efw);
0271     if (err < 0)
0272         goto error;
0273
0274     err = snd_card_register(card);
0275     if (err < 0)
0276         goto error;
0277
0278     return 0;
0279 error:
0280     snd_card_free(card);
0281     return err;
0282 }
0283
0284 static void efw_update(struct fw_unit *unit)
0285 {
0286     struct snd_efw *efw = dev_get_drvdata(&unit->device);
0287
0288     snd_efw_transaction_bus_reset(efw->unit);
0289
0290     mutex_lock(&efw->mutex);
0291     snd_efw_stream_update_duplex(efw);
0292     mutex_unlock(&efw->mutex);
0293 }
0294
0295 static void efw_remove(struct fw_unit *unit)
0296 {
0297     struct snd_efw *efw = dev_get_drvdata(&unit->device);
0298
0299     // Block till all of ALSA character devices are released.
0300     snd_card_free(efw->card);
0301 }
0302
0303 #define SPECIFIER_1394TA    0x00a02d
0304 #define VERSION_EFW     0x010000
0305
0306 #define SND_EFW_DEV_ENTRY(vendor, model) \
0307 { \
0308     .match_flags    = IEEE1394_MATCH_VENDOR_ID | \
0309               IEEE1394_MATCH_MODEL_ID | \
0310               IEEE1394_MATCH_SPECIFIER_ID | \
0311               IEEE1394_MATCH_VERSION, \
0312     .vendor_id  = vendor,\
0313     .model_id   = model, \
0314     .specifier_id   = SPECIFIER_1394TA, \
0315     .version    = VERSION_EFW, \
0316 }
0317
0318 static const struct ieee1394_device_id efw_id_table[] = {
0319     SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_400F),
0320     SND_EFW_DEV_ENTRY(VENDOR_LOUD, MODEL_MACKIE_1200F),
0321     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_8),
0322     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12),
0323     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12HD),
0324     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_12_APPLE),
0325     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_2),
0326     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_4),
0327     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_AUDIOFIRE_9),
0328     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_8),
0329     SND_EFW_DEV_ENTRY(VENDOR_ECHO, MODEL_ECHO_FIREWORKS_HDMI),
0330     SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_RIP),
0331     SND_EFW_DEV_ENTRY(VENDOR_GIBSON, MODEL_GIBSON_GOLDTOP),
0332     {}
0333 };
0334 MODULE_DEVICE_TABLE(ieee1394, efw_id_table);
0335
0336 static struct fw_driver efw_driver = {
0337     .driver = {
0338         .owner = THIS_MODULE,
0339         .name = KBUILD_MODNAME,
0340         .bus = &fw_bus_type,
0341     },
0342     .probe    = efw_probe,
0343     .update   = efw_update,
0344     .remove   = efw_remove,
0345     .id_table = efw_id_table,
0346 };
0347
0348 static int __init snd_efw_init(void)
0349 {
0350     int err;
0351
0352     err = snd_efw_transaction_register();
0353     if (err < 0)
0354         goto end;
0355
0356     err = driver_register(&efw_driver.driver);
0357     if (err < 0)
0358         snd_efw_transaction_unregister();
0359
0360 end:
0361     return err;
0362 }
0363
0364 static void __exit snd_efw_exit(void)
0365 {
0366     snd_efw_transaction_unregister();
0367     driver_unregister(&efw_driver.driver);
0368 }
0369
0370 module_init(snd_efw_init);
0371 module_exit(snd_efw_exit);