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