~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/firewire/motu/motu.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * motu.c - a part of driver for MOTU FireWire series
  4  *
  5  * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
  6  */
  7 
  8 #include "motu.h"
  9 
 10 #define OUI_MOTU        0x0001f2
 11 
 12 MODULE_DESCRIPTION("MOTU FireWire driver");
 13 MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
 14 MODULE_LICENSE("GPL v2");
 15 
 16 const unsigned int snd_motu_clock_rates[SND_MOTU_CLOCK_RATE_COUNT] = {
 17         /* mode 0 */
 18         [0] =  44100,
 19         [1] =  48000,
 20         /* mode 1 */
 21         [2] =  88200,
 22         [3] =  96000,
 23         /* mode 2 */
 24         [4] = 176400,
 25         [5] = 192000,
 26 };
 27 
 28 static void name_card(struct snd_motu *motu)
 29 {
 30         struct fw_device *fw_dev = fw_parent_device(motu->unit);
 31         struct fw_csr_iterator it;
 32         int key, val;
 33         u32 version = 0;
 34 
 35         fw_csr_iterator_init(&it, motu->unit->directory);
 36         while (fw_csr_iterator_next(&it, &key, &val)) {
 37                 switch (key) {
 38                 case CSR_MODEL:
 39                         version = val;
 40                         break;
 41                 }
 42         }
 43 
 44         strcpy(motu->card->driver, "FW-MOTU");
 45         strcpy(motu->card->shortname, motu->spec->name);
 46         strcpy(motu->card->mixername, motu->spec->name);
 47         snprintf(motu->card->longname, sizeof(motu->card->longname),
 48                  "MOTU %s (version:%06x), GUID %08x%08x at %s, S%d",
 49                  motu->spec->name, version,
 50                  fw_dev->config_rom[3], fw_dev->config_rom[4],
 51                  dev_name(&motu->unit->device), 100 << fw_dev->max_speed);
 52 }
 53 
 54 static void motu_card_free(struct snd_card *card)
 55 {
 56         struct snd_motu *motu = card->private_data;
 57 
 58         snd_motu_transaction_unregister(motu);
 59         snd_motu_stream_destroy_duplex(motu);
 60 }
 61 
 62 static void do_registration(struct work_struct *work)
 63 {
 64         struct snd_motu *motu = container_of(work, struct snd_motu, dwork.work);
 65         int err;
 66 
 67         if (motu->registered)
 68                 return;
 69 
 70         err = snd_card_new(&motu->unit->device, -1, NULL, THIS_MODULE, 0,
 71                            &motu->card);
 72         if (err < 0)
 73                 return;
 74         motu->card->private_free = motu_card_free;
 75         motu->card->private_data = motu;
 76 
 77         name_card(motu);
 78 
 79         err = snd_motu_transaction_register(motu);
 80         if (err < 0)
 81                 goto error;
 82 
 83         err = snd_motu_stream_init_duplex(motu);
 84         if (err < 0)
 85                 goto error;
 86 
 87         snd_motu_proc_init(motu);
 88 
 89         err = snd_motu_create_pcm_devices(motu);
 90         if (err < 0)
 91                 goto error;
 92 
 93         if ((motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) ||
 94             (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) ||
 95             (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) ||
 96             (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q)) {
 97                 err = snd_motu_create_midi_devices(motu);
 98                 if (err < 0)
 99                         goto error;
100         }
101 
102         err = snd_motu_create_hwdep_device(motu);
103         if (err < 0)
104                 goto error;
105 
106         err = snd_card_register(motu->card);
107         if (err < 0)
108                 goto error;
109 
110         motu->registered = true;
111 
112         return;
113 error:
114         snd_card_free(motu->card);
115         dev_info(&motu->unit->device,
116                  "Sound card registration failed: %d\n", err);
117 }
118 
119 static int motu_probe(struct fw_unit *unit,
120                       const struct ieee1394_device_id *entry)
121 {
122         struct snd_motu *motu;
123 
124         /* Allocate this independently of sound card instance. */
125         motu = devm_kzalloc(&unit->device, sizeof(struct snd_motu), GFP_KERNEL);
126         if (!motu)
127                 return -ENOMEM;
128         motu->unit = fw_unit_get(unit);
129         dev_set_drvdata(&unit->device, motu);
130 
131         motu->spec = (const struct snd_motu_spec *)entry->driver_data;
132         mutex_init(&motu->mutex);
133         spin_lock_init(&motu->lock);
134         init_waitqueue_head(&motu->hwdep_wait);
135 
136         /* Allocate and register this sound card later. */
137         INIT_DEFERRABLE_WORK(&motu->dwork, do_registration);
138         snd_fw_schedule_registration(unit, &motu->dwork);
139 
140         return 0;
141 }
142 
143 static void motu_remove(struct fw_unit *unit)
144 {
145         struct snd_motu *motu = dev_get_drvdata(&unit->device);
146 
147         /*
148          * Confirm to stop the work for registration before the sound card is
149          * going to be released. The work is not scheduled again because bus
150          * reset handler is not called anymore.
151          */
152         cancel_delayed_work_sync(&motu->dwork);
153 
154         if (motu->registered) {
155                 // Block till all of ALSA character devices are released.
156                 snd_card_free(motu->card);
157         }
158 
159         mutex_destroy(&motu->mutex);
160         fw_unit_put(motu->unit);
161 }
162 
163 static void motu_bus_update(struct fw_unit *unit)
164 {
165         struct snd_motu *motu = dev_get_drvdata(&unit->device);
166 
167         /* Postpone a workqueue for deferred registration. */
168         if (!motu->registered)
169                 snd_fw_schedule_registration(unit, &motu->dwork);
170 
171         /* The handler address register becomes initialized. */
172         snd_motu_transaction_reregister(motu);
173 }
174 
175 #define SND_MOTU_DEV_ENTRY(model, data)                 \
176 {                                                       \
177         .match_flags    = IEEE1394_MATCH_VENDOR_ID |    \
178                           IEEE1394_MATCH_SPECIFIER_ID | \
179                           IEEE1394_MATCH_VERSION,       \
180         .vendor_id      = OUI_MOTU,                     \
181         .specifier_id   = OUI_MOTU,                     \
182         .version        = model,                        \
183         .driver_data    = (kernel_ulong_t)data,         \
184 }
185 
186 static const struct ieee1394_device_id motu_id_table[] = {
187         SND_MOTU_DEV_ENTRY(0x000003, &snd_motu_spec_828mk2),
188         SND_MOTU_DEV_ENTRY(0x000009, &snd_motu_spec_traveler),
189         SND_MOTU_DEV_ENTRY(0x00000d, &snd_motu_spec_ultralite),
190         SND_MOTU_DEV_ENTRY(0x00000f, &snd_motu_spec_8pre),
191         SND_MOTU_DEV_ENTRY(0x000015, &snd_motu_spec_828mk3), // FireWire only.
192         SND_MOTU_DEV_ENTRY(0x000019, &snd_motu_spec_ultralite_mk3), // FireWire only.
193         SND_MOTU_DEV_ENTRY(0x000035, &snd_motu_spec_828mk3), // Hybrid.
194         SND_MOTU_DEV_ENTRY(0x000033, &snd_motu_spec_audio_express),
195         SND_MOTU_DEV_ENTRY(0x000045, &snd_motu_spec_4pre),
196         { }
197 };
198 MODULE_DEVICE_TABLE(ieee1394, motu_id_table);
199 
200 static struct fw_driver motu_driver = {
201         .driver   = {
202                 .owner  = THIS_MODULE,
203                 .name   = KBUILD_MODNAME,
204                 .bus    = &fw_bus_type,
205         },
206         .probe    = motu_probe,
207         .update   = motu_bus_update,
208         .remove   = motu_remove,
209         .id_table = motu_id_table,
210 };
211 
212 static int __init alsa_motu_init(void)
213 {
214         return driver_register(&motu_driver.driver);
215 }
216 
217 static void __exit alsa_motu_exit(void)
218 {
219         driver_unregister(&motu_driver.driver);
220 }
221 
222 module_init(alsa_motu_init);
223 module_exit(alsa_motu_exit);
224 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp