1 /* 2 * motu.c - a part of driver for MOTU FireWire series 3 * 4 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp> 5 * 6 * Licensed under the terms of the GNU General Public License, version 2. 7 */ 8 9 #include "motu.h" 10 11 #define OUI_MOTU 0x0001f2 12 13 MODULE_DESCRIPTION("MOTU FireWire driver"); 14 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>"); 15 MODULE_LICENSE("GPL v2"); 16 17 const unsigned int snd_motu_clock_rates[SND_MOTU_CLOCK_RATE_COUNT] = { 18 /* mode 0 */ 19 [0] = 44100, 20 [1] = 48000, 21 /* mode 1 */ 22 [2] = 88200, 23 [3] = 96000, 24 /* mode 2 */ 25 [4] = 176400, 26 [5] = 192000, 27 }; 28 29 static void name_card(struct snd_motu *motu) 30 { 31 struct fw_device *fw_dev = fw_parent_device(motu->unit); 32 struct fw_csr_iterator it; 33 int key, val; 34 u32 version = 0; 35 36 fw_csr_iterator_init(&it, motu->unit->directory); 37 while (fw_csr_iterator_next(&it, &key, &val)) { 38 switch (key) { 39 case CSR_VERSION: 40 version = val; 41 break; 42 } 43 } 44 45 strcpy(motu->card->driver, "FW-MOTU"); 46 strcpy(motu->card->shortname, motu->spec->name); 47 strcpy(motu->card->mixername, motu->spec->name); 48 snprintf(motu->card->longname, sizeof(motu->card->longname), 49 "MOTU %s (version:%d), GUID %08x%08x at %s, S%d", 50 motu->spec->name, version, 51 fw_dev->config_rom[3], fw_dev->config_rom[4], 52 dev_name(&motu->unit->device), 100 << fw_dev->max_speed); 53 } 54 55 static void motu_free(struct snd_motu *motu) 56 { 57 snd_motu_transaction_unregister(motu); 58 59 snd_motu_stream_destroy_duplex(motu); 60 fw_unit_put(motu->unit); 61 62 mutex_destroy(&motu->mutex); 63 kfree(motu); 64 } 65 66 /* 67 * This module releases the FireWire unit data after all ALSA character devices 68 * are released by applications. This is for releasing stream data or finishing 69 * transactions safely. Thus at returning from .remove(), this module still keep 70 * references for the unit. 71 */ 72 static void motu_card_free(struct snd_card *card) 73 { 74 motu_free(card->private_data); 75 } 76 77 static void do_registration(struct work_struct *work) 78 { 79 struct snd_motu *motu = container_of(work, struct snd_motu, dwork.work); 80 int err; 81 82 if (motu->registered) 83 return; 84 85 err = snd_card_new(&motu->unit->device, -1, NULL, THIS_MODULE, 0, 86 &motu->card); 87 if (err < 0) 88 return; 89 90 name_card(motu); 91 92 err = snd_motu_transaction_register(motu); 93 if (err < 0) 94 goto error; 95 96 err = snd_motu_stream_init_duplex(motu); 97 if (err < 0) 98 goto error; 99 100 snd_motu_proc_init(motu); 101 102 err = snd_motu_create_pcm_devices(motu); 103 if (err < 0) 104 goto error; 105 106 if (motu->spec->flags & SND_MOTU_SPEC_HAS_MIDI) { 107 err = snd_motu_create_midi_devices(motu); 108 if (err < 0) 109 goto error; 110 } 111 112 err = snd_motu_create_hwdep_device(motu); 113 if (err < 0) 114 goto error; 115 116 err = snd_card_register(motu->card); 117 if (err < 0) 118 goto error; 119 120 /* 121 * After registered, motu instance can be released corresponding to 122 * releasing the sound card instance. 123 */ 124 motu->card->private_free = motu_card_free; 125 motu->card->private_data = motu; 126 motu->registered = true; 127 128 return; 129 error: 130 snd_motu_transaction_unregister(motu); 131 snd_motu_stream_destroy_duplex(motu); 132 snd_card_free(motu->card); 133 dev_info(&motu->unit->device, 134 "Sound card registration failed: %d\n", err); 135 } 136 137 static int motu_probe(struct fw_unit *unit, 138 const struct ieee1394_device_id *entry) 139 { 140 struct snd_motu *motu; 141 142 /* Allocate this independently of sound card instance. */ 143 motu = kzalloc(sizeof(struct snd_motu), GFP_KERNEL); 144 if (motu == NULL) 145 return -ENOMEM; 146 147 motu->spec = (const struct snd_motu_spec *)entry->driver_data; 148 motu->unit = fw_unit_get(unit); 149 dev_set_drvdata(&unit->device, motu); 150 151 mutex_init(&motu->mutex); 152 spin_lock_init(&motu->lock); 153 init_waitqueue_head(&motu->hwdep_wait); 154 155 /* Allocate and register this sound card later. */ 156 INIT_DEFERRABLE_WORK(&motu->dwork, do_registration); 157 snd_fw_schedule_registration(unit, &motu->dwork); 158 159 return 0; 160 } 161 162 static void motu_remove(struct fw_unit *unit) 163 { 164 struct snd_motu *motu = dev_get_drvdata(&unit->device); 165 166 /* 167 * Confirm to stop the work for registration before the sound card is 168 * going to be released. The work is not scheduled again because bus 169 * reset handler is not called anymore. 170 */ 171 cancel_delayed_work_sync(&motu->dwork); 172 173 if (motu->registered) { 174 /* No need to wait for releasing card object in this context. */ 175 snd_card_free_when_closed(motu->card); 176 } else { 177 /* Don't forget this case. */ 178 motu_free(motu); 179 } 180 } 181 182 static void motu_bus_update(struct fw_unit *unit) 183 { 184 struct snd_motu *motu = dev_get_drvdata(&unit->device); 185 186 /* Postpone a workqueue for deferred registration. */ 187 if (!motu->registered) 188 snd_fw_schedule_registration(unit, &motu->dwork); 189 190 /* The handler address register becomes initialized. */ 191 snd_motu_transaction_reregister(motu); 192 } 193 194 static struct snd_motu_spec motu_828mk2 = { 195 .name = "828mk2", 196 .protocol = &snd_motu_protocol_v2, 197 .flags = SND_MOTU_SPEC_SUPPORT_CLOCK_X2 | 198 SND_MOTU_SPEC_TX_MICINST_CHUNK | 199 SND_MOTU_SPEC_TX_RETURN_CHUNK | 200 SND_MOTU_SPEC_HAS_OPT_IFACE_A | 201 SND_MOTU_SPEC_HAS_MIDI, 202 203 .analog_in_ports = 8, 204 .analog_out_ports = 8, 205 }; 206 207 static struct snd_motu_spec motu_828mk3 = { 208 .name = "828mk3", 209 .protocol = &snd_motu_protocol_v3, 210 .flags = SND_MOTU_SPEC_SUPPORT_CLOCK_X2 | 211 SND_MOTU_SPEC_SUPPORT_CLOCK_X4 | 212 SND_MOTU_SPEC_TX_MICINST_CHUNK | 213 SND_MOTU_SPEC_TX_RETURN_CHUNK | 214 SND_MOTU_SPEC_TX_REVERB_CHUNK | 215 SND_MOTU_SPEC_HAS_OPT_IFACE_A | 216 SND_MOTU_SPEC_HAS_OPT_IFACE_B | 217 SND_MOTU_SPEC_HAS_MIDI, 218 219 .analog_in_ports = 8, 220 .analog_out_ports = 8, 221 }; 222 223 #define SND_MOTU_DEV_ENTRY(model, data) \ 224 { \ 225 .match_flags = IEEE1394_MATCH_VENDOR_ID | \ 226 IEEE1394_MATCH_MODEL_ID | \ 227 IEEE1394_MATCH_SPECIFIER_ID, \ 228 .vendor_id = OUI_MOTU, \ 229 .model_id = model, \ 230 .specifier_id = OUI_MOTU, \ 231 .driver_data = (kernel_ulong_t)data, \ 232 } 233 234 static const struct ieee1394_device_id motu_id_table[] = { 235 SND_MOTU_DEV_ENTRY(0x101800, &motu_828mk2), 236 SND_MOTU_DEV_ENTRY(0x106800, &motu_828mk3), /* FireWire only. */ 237 SND_MOTU_DEV_ENTRY(0x100800, &motu_828mk3), /* Hybrid. */ 238 { } 239 }; 240 MODULE_DEVICE_TABLE(ieee1394, motu_id_table); 241 242 static struct fw_driver motu_driver = { 243 .driver = { 244 .owner = THIS_MODULE, 245 .name = KBUILD_MODNAME, 246 .bus = &fw_bus_type, 247 }, 248 .probe = motu_probe, 249 .update = motu_bus_update, 250 .remove = motu_remove, 251 .id_table = motu_id_table, 252 }; 253 254 static int __init alsa_motu_init(void) 255 { 256 return driver_register(&motu_driver.driver); 257 } 258 259 static void __exit alsa_motu_exit(void) 260 { 261 driver_unregister(&motu_driver.driver); 262 } 263 264 module_init(alsa_motu_init); 265 module_exit(alsa_motu_exit); 266