firewire/motu/motu.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * motu.c - a part of driver for MOTU FireWire series
0004  *
0005  * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
0006  */
0007
0008 #include "motu.h"
0009
0010 #define OUI_MOTU    0x0001f2
0011
0012 MODULE_DESCRIPTION("MOTU FireWire driver");
0013 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
0014 MODULE_LICENSE("GPL v2");
0015
0016 const unsigned int snd_motu_clock_rates[SND_MOTU_CLOCK_RATE_COUNT] = {
0017     /* mode 0 */
0018     [0] =  44100,
0019     [1] =  48000,
0020     /* mode 1 */
0021     [2] =  88200,
0022     [3] =  96000,
0023     /* mode 2 */
0024     [4] = 176400,
0025     [5] = 192000,
0026 };
0027
0028 static void name_card(struct snd_motu *motu)
0029 {
0030     struct fw_device *fw_dev = fw_parent_device(motu->unit);
0031     struct fw_csr_iterator it;
0032     int key, val;
0033     u32 version = 0;
0034
0035     fw_csr_iterator_init(&it, motu->unit->directory);
0036     while (fw_csr_iterator_next(&it, &key, &val)) {
0037         switch (key) {
0038         case CSR_MODEL:
0039             version = val;
0040             break;
0041         }
0042     }
0043
0044     strcpy(motu->card->driver, "FW-MOTU");
0045     strcpy(motu->card->shortname, motu->spec->name);
0046     strcpy(motu->card->mixername, motu->spec->name);
0047     snprintf(motu->card->longname, sizeof(motu->card->longname),
0048          "MOTU %s (version:%06x), GUID %08x%08x at %s, S%d",
0049          motu->spec->name, version,
0050          fw_dev->config_rom[3], fw_dev->config_rom[4],
0051          dev_name(&motu->unit->device), 100 << fw_dev->max_speed);
0052 }
0053
0054 static void motu_card_free(struct snd_card *card)
0055 {
0056     struct snd_motu *motu = card->private_data;
0057
0058     snd_motu_transaction_unregister(motu);
0059     snd_motu_stream_destroy_duplex(motu);
0060
0061     mutex_destroy(&motu->mutex);
0062     fw_unit_put(motu->unit);
0063 }
0064
0065 static int motu_probe(struct fw_unit *unit, const struct ieee1394_device_id *entry)
0066 {
0067     struct snd_card *card;
0068     struct snd_motu *motu;
0069     int err;
0070
0071     err = snd_card_new(&unit->device, -1, NULL, THIS_MODULE, sizeof(*motu), &card);
0072     if (err < 0)
0073         return err;
0074     card->private_free = motu_card_free;
0075
0076     motu = card->private_data;
0077     motu->unit = fw_unit_get(unit);
0078     dev_set_drvdata(&unit->device, motu);
0079     motu->card = card;
0080
0081     motu->spec = (const struct snd_motu_spec *)entry->driver_data;
0082     mutex_init(&motu->mutex);
0083     spin_lock_init(&motu->lock);
0084     init_waitqueue_head(&motu->hwdep_wait);
0085
0086     name_card(motu);
0087
0088     err = snd_motu_transaction_register(motu);
0089     if (err < 0)
0090         goto error;
0091
0092     err = snd_motu_stream_init_duplex(motu);
0093     if (err < 0)
0094         goto error;
0095
0096     snd_motu_proc_init(motu);
0097
0098     err = snd_motu_create_pcm_devices(motu);
0099     if (err < 0)
0100         goto error;
0101
0102     if ((motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) ||
0103         (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) ||
0104         (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) ||
0105         (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q)) {
0106         err = snd_motu_create_midi_devices(motu);
0107         if (err < 0)
0108             goto error;
0109     }
0110
0111     err = snd_motu_create_hwdep_device(motu);
0112     if (err < 0)
0113         goto error;
0114
0115     if (motu->spec->flags & SND_MOTU_SPEC_REGISTER_DSP) {
0116         err = snd_motu_register_dsp_message_parser_new(motu);
0117         if (err < 0)
0118             goto error;
0119     } else if (motu->spec->flags & SND_MOTU_SPEC_COMMAND_DSP) {
0120         err = snd_motu_command_dsp_message_parser_new(motu);
0121         if (err < 0)
0122             goto error;
0123     }
0124
0125     err = snd_card_register(card);
0126     if (err < 0)
0127         goto error;
0128
0129     return 0;
0130 error:
0131     snd_card_free(card);
0132     return err;
0133 }
0134
0135 static void motu_remove(struct fw_unit *unit)
0136 {
0137     struct snd_motu *motu = dev_get_drvdata(&unit->device);
0138
0139     // Block till all of ALSA character devices are released.
0140     snd_card_free(motu->card);
0141 }
0142
0143 static void motu_bus_update(struct fw_unit *unit)
0144 {
0145     struct snd_motu *motu = dev_get_drvdata(&unit->device);
0146
0147     /* The handler address register becomes initialized. */
0148     snd_motu_transaction_reregister(motu);
0149 }
0150
0151 #define SND_MOTU_DEV_ENTRY(model, data)         \
0152 {                           \
0153     .match_flags    = IEEE1394_MATCH_VENDOR_ID |    \
0154               IEEE1394_MATCH_SPECIFIER_ID | \
0155               IEEE1394_MATCH_VERSION,   \
0156     .vendor_id  = OUI_MOTU,         \
0157     .specifier_id   = OUI_MOTU,         \
0158     .version    = model,            \
0159     .driver_data    = (kernel_ulong_t)data,     \
0160 }
0161
0162 static const struct ieee1394_device_id motu_id_table[] = {
0163     SND_MOTU_DEV_ENTRY(0x000001, &snd_motu_spec_828),
0164     SND_MOTU_DEV_ENTRY(0x000002, &snd_motu_spec_896),
0165     SND_MOTU_DEV_ENTRY(0x000003, &snd_motu_spec_828mk2),
0166     SND_MOTU_DEV_ENTRY(0x000005, &snd_motu_spec_896hd),
0167     SND_MOTU_DEV_ENTRY(0x000009, &snd_motu_spec_traveler),
0168     SND_MOTU_DEV_ENTRY(0x00000d, &snd_motu_spec_ultralite),
0169     SND_MOTU_DEV_ENTRY(0x00000f, &snd_motu_spec_8pre),
0170     SND_MOTU_DEV_ENTRY(0x000015, &snd_motu_spec_828mk3_fw), // FireWire only.
0171     SND_MOTU_DEV_ENTRY(0x000019, &snd_motu_spec_ultralite_mk3), // FireWire only.
0172     SND_MOTU_DEV_ENTRY(0x00001b, &snd_motu_spec_traveler_mk3),
0173     SND_MOTU_DEV_ENTRY(0x000030, &snd_motu_spec_ultralite_mk3), // Hybrid.
0174     SND_MOTU_DEV_ENTRY(0x000035, &snd_motu_spec_828mk3_hybrid), // Hybrid.
0175     SND_MOTU_DEV_ENTRY(0x000033, &snd_motu_spec_audio_express),
0176     SND_MOTU_DEV_ENTRY(0x000039, &snd_motu_spec_track16),
0177     SND_MOTU_DEV_ENTRY(0x000045, &snd_motu_spec_4pre),
0178     { }
0179 };
0180 MODULE_DEVICE_TABLE(ieee1394, motu_id_table);
0181
0182 static struct fw_driver motu_driver = {
0183     .driver   = {
0184         .owner  = THIS_MODULE,
0185         .name   = KBUILD_MODNAME,
0186         .bus    = &fw_bus_type,
0187     },
0188     .probe    = motu_probe,
0189     .update   = motu_bus_update,
0190     .remove   = motu_remove,
0191     .id_table = motu_id_table,
0192 };
0193
0194 static int __init alsa_motu_init(void)
0195 {
0196     return driver_register(&motu_driver.driver);
0197 }
0198
0199 static void __exit alsa_motu_exit(void)
0200 {
0201     driver_unregister(&motu_driver.driver);
0202 }
0203
0204 module_init(alsa_motu_init);
0205 module_exit(alsa_motu_exit);