sound/firewire/fireface/ff.c

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