1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * ff.c - a part of driver for RME Fireface series 4 * 5 * Copyright (c) 2015-2017 Takashi Sakamoto 6 */ 7 8 #include "ff.h" 9 10 #define OUI_RME 0x000a35 11 12 MODULE_DESCRIPTION("RME Fireface series Driver"); 13 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>"); 14 MODULE_LICENSE("GPL v2"); 15 16 static void name_card(struct snd_ff *ff) 17 { 18 struct fw_device *fw_dev = fw_parent_device(ff->unit); 19 20 strcpy(ff->card->driver, "Fireface"); 21 strcpy(ff->card->shortname, ff->spec->name); 22 strcpy(ff->card->mixername, ff->spec->name); 23 snprintf(ff->card->longname, sizeof(ff->card->longname), 24 "RME %s, GUID %08x%08x at %s, S%d", ff->spec->name, 25 fw_dev->config_rom[3], fw_dev->config_rom[4], 26 dev_name(&ff->unit->device), 100 << fw_dev->max_speed); 27 } 28 29 static void ff_card_free(struct snd_card *card) 30 { 31 struct snd_ff *ff = card->private_data; 32 33 snd_ff_stream_destroy_duplex(ff); 34 snd_ff_transaction_unregister(ff); 35 } 36 37 static void do_registration(struct work_struct *work) 38 { 39 struct snd_ff *ff = container_of(work, struct snd_ff, dwork.work); 40 int err; 41 42 if (ff->registered) 43 return; 44 45 err = snd_card_new(&ff->unit->device, -1, NULL, THIS_MODULE, 0, 46 &ff->card); 47 if (err < 0) 48 return; 49 ff->card->private_free = ff_card_free; 50 ff->card->private_data = ff; 51 52 err = snd_ff_transaction_register(ff); 53 if (err < 0) 54 goto error; 55 56 name_card(ff); 57 58 err = snd_ff_stream_init_duplex(ff); 59 if (err < 0) 60 goto error; 61 62 snd_ff_proc_init(ff); 63 64 err = snd_ff_create_midi_devices(ff); 65 if (err < 0) 66 goto error; 67 68 err = snd_ff_create_pcm_devices(ff); 69 if (err < 0) 70 goto error; 71 72 err = snd_ff_create_hwdep_devices(ff); 73 if (err < 0) 74 goto error; 75 76 err = snd_card_register(ff->card); 77 if (err < 0) 78 goto error; 79 80 ff->registered = true; 81 82 return; 83 error: 84 snd_card_free(ff->card); 85 dev_info(&ff->unit->device, 86 "Sound card registration failed: %d\n", err); 87 } 88 89 static int snd_ff_probe(struct fw_unit *unit, 90 const struct ieee1394_device_id *entry) 91 { 92 struct snd_ff *ff; 93 94 ff = devm_kzalloc(&unit->device, sizeof(struct snd_ff), GFP_KERNEL); 95 if (!ff) 96 return -ENOMEM; 97 ff->unit = fw_unit_get(unit); 98 dev_set_drvdata(&unit->device, ff); 99 100 mutex_init(&ff->mutex); 101 spin_lock_init(&ff->lock); 102 init_waitqueue_head(&ff->hwdep_wait); 103 104 ff->spec = (const struct snd_ff_spec *)entry->driver_data; 105 106 /* Register this sound card later. */ 107 INIT_DEFERRABLE_WORK(&ff->dwork, do_registration); 108 snd_fw_schedule_registration(unit, &ff->dwork); 109 110 return 0; 111 } 112 113 static void snd_ff_update(struct fw_unit *unit) 114 { 115 struct snd_ff *ff = dev_get_drvdata(&unit->device); 116 117 /* Postpone a workqueue for deferred registration. */ 118 if (!ff->registered) 119 snd_fw_schedule_registration(unit, &ff->dwork); 120 121 snd_ff_transaction_reregister(ff); 122 123 if (ff->registered) 124 snd_ff_stream_update_duplex(ff); 125 } 126 127 static void snd_ff_remove(struct fw_unit *unit) 128 { 129 struct snd_ff *ff = dev_get_drvdata(&unit->device); 130 131 /* 132 * Confirm to stop the work for registration before the sound card is 133 * going to be released. The work is not scheduled again because bus 134 * reset handler is not called anymore. 135 */ 136 cancel_work_sync(&ff->dwork.work); 137 138 if (ff->registered) { 139 // Block till all of ALSA character devices are released. 140 snd_card_free(ff->card); 141 } 142 143 mutex_destroy(&ff->mutex); 144 fw_unit_put(ff->unit); 145 } 146 147 static const struct snd_ff_spec spec_ff800 = { 148 .name = "Fireface800", 149 .pcm_capture_channels = {28, 20, 12}, 150 .pcm_playback_channels = {28, 20, 12}, 151 .midi_in_ports = 1, 152 .midi_out_ports = 1, 153 .protocol = &snd_ff_protocol_ff800, 154 .midi_high_addr = 0x000200000320ull, 155 .midi_addr_range = 12, 156 .midi_rx_addrs = {0x000080180000ull, 0}, 157 }; 158 159 static const struct snd_ff_spec spec_ff400 = { 160 .name = "Fireface400", 161 .pcm_capture_channels = {18, 14, 10}, 162 .pcm_playback_channels = {18, 14, 10}, 163 .midi_in_ports = 2, 164 .midi_out_ports = 2, 165 .protocol = &snd_ff_protocol_ff400, 166 .midi_high_addr = 0x0000801003f4ull, 167 .midi_addr_range = SND_FF_MAXIMIM_MIDI_QUADS * 4, 168 .midi_rx_addrs = {0x000080180000ull, 0x000080190000ull}, 169 }; 170 171 static const struct snd_ff_spec spec_ucx = { 172 .name = "FirefaceUCX", 173 .pcm_capture_channels = {18, 14, 12}, 174 .pcm_playback_channels = {18, 14, 12}, 175 .midi_in_ports = 2, 176 .midi_out_ports = 2, 177 .protocol = &snd_ff_protocol_latter, 178 .midi_high_addr = 0xffff00000034ull, 179 .midi_addr_range = 0x80, 180 .midi_rx_addrs = {0xffff00000030ull, 0xffff00000030ull}, 181 }; 182 183 static const struct ieee1394_device_id snd_ff_id_table[] = { 184 /* Fireface 800 */ 185 { 186 .match_flags = IEEE1394_MATCH_VENDOR_ID | 187 IEEE1394_MATCH_SPECIFIER_ID | 188 IEEE1394_MATCH_VERSION | 189 IEEE1394_MATCH_MODEL_ID, 190 .vendor_id = OUI_RME, 191 .specifier_id = OUI_RME, 192 .version = 0x000001, 193 .model_id = 0x101800, 194 .driver_data = (kernel_ulong_t)&spec_ff800, 195 }, 196 /* Fireface 400 */ 197 { 198 .match_flags = IEEE1394_MATCH_VENDOR_ID | 199 IEEE1394_MATCH_SPECIFIER_ID | 200 IEEE1394_MATCH_VERSION | 201 IEEE1394_MATCH_MODEL_ID, 202 .vendor_id = OUI_RME, 203 .specifier_id = OUI_RME, 204 .version = 0x000002, 205 .model_id = 0x101800, 206 .driver_data = (kernel_ulong_t)&spec_ff400, 207 }, 208 // Fireface UCX. 209 { 210 .match_flags = IEEE1394_MATCH_VENDOR_ID | 211 IEEE1394_MATCH_SPECIFIER_ID | 212 IEEE1394_MATCH_VERSION | 213 IEEE1394_MATCH_MODEL_ID, 214 .vendor_id = OUI_RME, 215 .specifier_id = OUI_RME, 216 .version = 0x000004, 217 .model_id = 0x101800, 218 .driver_data = (kernel_ulong_t)&spec_ucx, 219 }, 220 {} 221 }; 222 MODULE_DEVICE_TABLE(ieee1394, snd_ff_id_table); 223 224 static struct fw_driver ff_driver = { 225 .driver = { 226 .owner = THIS_MODULE, 227 .name = KBUILD_MODNAME, 228 .bus = &fw_bus_type, 229 }, 230 .probe = snd_ff_probe, 231 .update = snd_ff_update, 232 .remove = snd_ff_remove, 233 .id_table = snd_ff_id_table, 234 }; 235 236 static int __init snd_ff_init(void) 237 { 238 return driver_register(&ff_driver.driver); 239 } 240 241 static void __exit snd_ff_exit(void) 242 { 243 driver_unregister(&ff_driver.driver); 244 } 245 246 module_init(snd_ff_init); 247 module_exit(snd_ff_exit); 248