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_RX_MIDI_2ND_Q) || 107 (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) || 108 (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) || 109 (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q)) { 110 err = snd_motu_create_midi_devices(motu); 111 if (err < 0) 112 goto error; 113 } 114 115 err = snd_motu_create_hwdep_device(motu); 116 if (err < 0) 117 goto error; 118 119 err = snd_card_register(motu->card); 120 if (err < 0) 121 goto error; 122 123 /* 124 * After registered, motu instance can be released corresponding to 125 * releasing the sound card instance. 126 */ 127 motu->card->private_free = motu_card_free; 128 motu->card->private_data = motu; 129 motu->registered = true; 130 131 return; 132 error: 133 snd_motu_transaction_unregister(motu); 134 snd_motu_stream_destroy_duplex(motu); 135 snd_card_free(motu->card); 136 dev_info(&motu->unit->device, 137 "Sound card registration failed: %d\n", err); 138 } 139 140 static int motu_probe(struct fw_unit *unit, 141 const struct ieee1394_device_id *entry) 142 { 143 struct snd_motu *motu; 144 145 /* Allocate this independently of sound card instance. */ 146 motu = kzalloc(sizeof(struct snd_motu), GFP_KERNEL); 147 if (motu == NULL) 148 return -ENOMEM; 149 150 motu->spec = (const struct snd_motu_spec *)entry->driver_data; 151 motu->unit = fw_unit_get(unit); 152 dev_set_drvdata(&unit->device, motu); 153 154 mutex_init(&motu->mutex); 155 spin_lock_init(&motu->lock); 156 init_waitqueue_head(&motu->hwdep_wait); 157 158 /* Allocate and register this sound card later. */ 159 INIT_DEFERRABLE_WORK(&motu->dwork, do_registration); 160 snd_fw_schedule_registration(unit, &motu->dwork); 161 162 return 0; 163 } 164 165 static void motu_remove(struct fw_unit *unit) 166 { 167 struct snd_motu *motu = dev_get_drvdata(&unit->device); 168 169 /* 170 * Confirm to stop the work for registration before the sound card is 171 * going to be released. The work is not scheduled again because bus 172 * reset handler is not called anymore. 173 */ 174 cancel_delayed_work_sync(&motu->dwork); 175 176 if (motu->registered) { 177 /* No need to wait for releasing card object in this context. */ 178 snd_card_free_when_closed(motu->card); 179 } else { 180 /* Don't forget this case. */ 181 motu_free(motu); 182 } 183 } 184 185 static void motu_bus_update(struct fw_unit *unit) 186 { 187 struct snd_motu *motu = dev_get_drvdata(&unit->device); 188 189 /* Postpone a workqueue for deferred registration. */ 190 if (!motu->registered) 191 snd_fw_schedule_registration(unit, &motu->dwork); 192 193 /* The handler address register becomes initialized. */ 194 snd_motu_transaction_reregister(motu); 195 } 196 197 static const struct snd_motu_spec motu_828mk2 = { 198 .name = "828mk2", 199 .protocol = &snd_motu_protocol_v2, 200 .flags = SND_MOTU_SPEC_SUPPORT_CLOCK_X2 | 201 SND_MOTU_SPEC_TX_MICINST_CHUNK | 202 SND_MOTU_SPEC_TX_RETURN_CHUNK | 203 SND_MOTU_SPEC_RX_SEPARETED_MAIN | 204 SND_MOTU_SPEC_HAS_OPT_IFACE_A | 205 SND_MOTU_SPEC_RX_MIDI_2ND_Q | 206 SND_MOTU_SPEC_TX_MIDI_2ND_Q, 207 208 .analog_in_ports = 8, 209 .analog_out_ports = 8, 210 }; 211 212 const struct snd_motu_spec snd_motu_spec_traveler = { 213 .name = "Traveler", 214 .protocol = &snd_motu_protocol_v2, 215 .flags = SND_MOTU_SPEC_SUPPORT_CLOCK_X2 | 216 SND_MOTU_SPEC_SUPPORT_CLOCK_X4 | 217 SND_MOTU_SPEC_TX_RETURN_CHUNK | 218 SND_MOTU_SPEC_HAS_AESEBU_IFACE | 219 SND_MOTU_SPEC_HAS_OPT_IFACE_A | 220 SND_MOTU_SPEC_RX_MIDI_2ND_Q | 221 SND_MOTU_SPEC_TX_MIDI_2ND_Q, 222 223 .analog_in_ports = 8, 224 .analog_out_ports = 8, 225 }; 226 227 static const struct snd_motu_spec motu_828mk3 = { 228 .name = "828mk3", 229 .protocol = &snd_motu_protocol_v3, 230 .flags = SND_MOTU_SPEC_SUPPORT_CLOCK_X2 | 231 SND_MOTU_SPEC_SUPPORT_CLOCK_X4 | 232 SND_MOTU_SPEC_TX_MICINST_CHUNK | 233 SND_MOTU_SPEC_TX_RETURN_CHUNK | 234 SND_MOTU_SPEC_TX_REVERB_CHUNK | 235 SND_MOTU_SPEC_RX_SEPARETED_MAIN | 236 SND_MOTU_SPEC_HAS_OPT_IFACE_A | 237 SND_MOTU_SPEC_HAS_OPT_IFACE_B | 238 SND_MOTU_SPEC_RX_MIDI_3RD_Q | 239 SND_MOTU_SPEC_TX_MIDI_3RD_Q, 240 241 .analog_in_ports = 8, 242 .analog_out_ports = 8, 243 }; 244 245 static const struct snd_motu_spec motu_audio_express = { 246 .name = "AudioExpress", 247 .protocol = &snd_motu_protocol_v3, 248 .flags = SND_MOTU_SPEC_SUPPORT_CLOCK_X2 | 249 SND_MOTU_SPEC_TX_MICINST_CHUNK | 250 SND_MOTU_SPEC_TX_RETURN_CHUNK | 251 SND_MOTU_SPEC_RX_SEPARETED_MAIN | 252 SND_MOTU_SPEC_RX_MIDI_2ND_Q | 253 SND_MOTU_SPEC_TX_MIDI_3RD_Q, 254 .analog_in_ports = 2, 255 .analog_out_ports = 4, 256 }; 257 258 #define SND_MOTU_DEV_ENTRY(model, data) \ 259 { \ 260 .match_flags = IEEE1394_MATCH_VENDOR_ID | \ 261 IEEE1394_MATCH_MODEL_ID | \ 262 IEEE1394_MATCH_SPECIFIER_ID, \ 263 .vendor_id = OUI_MOTU, \ 264 .model_id = model, \ 265 .specifier_id = OUI_MOTU, \ 266 .driver_data = (kernel_ulong_t)data, \ 267 } 268 269 static const struct ieee1394_device_id motu_id_table[] = { 270 SND_MOTU_DEV_ENTRY(0x101800, &motu_828mk2), 271 SND_MOTU_DEV_ENTRY(0x107800, &snd_motu_spec_traveler), 272 SND_MOTU_DEV_ENTRY(0x106800, &motu_828mk3), /* FireWire only. */ 273 SND_MOTU_DEV_ENTRY(0x100800, &motu_828mk3), /* Hybrid. */ 274 SND_MOTU_DEV_ENTRY(0x104800, &motu_audio_express), 275 { } 276 }; 277 MODULE_DEVICE_TABLE(ieee1394, motu_id_table); 278 279 static struct fw_driver motu_driver = { 280 .driver = { 281 .owner = THIS_MODULE, 282 .name = KBUILD_MODNAME, 283 .bus = &fw_bus_type, 284 }, 285 .probe = motu_probe, 286 .update = motu_bus_update, 287 .remove = motu_remove, 288 .id_table = motu_id_table, 289 }; 290 291 static int __init alsa_motu_init(void) 292 { 293 return driver_register(&motu_driver.driver); 294 } 295 296 static void __exit alsa_motu_exit(void) 297 { 298 driver_unregister(&motu_driver.driver); 299 } 300 301 module_init(alsa_motu_init); 302 module_exit(alsa_motu_exit); 303