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

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

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

~ [ 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