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
12MODULE_DESCRIPTION("MOTU FireWire driver");
13MODULE_AUTHOR("Takashi Sakamoto <o-takashi@sakamocchi.jp>");
14MODULE_LICENSE("GPL v2");
15
16const 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
28static 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
54static 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
62static 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;
113error:
114	snd_card_free(motu->card);
115	dev_info(&motu->unit->device,
116		 "Sound card registration failed: %d\n", err);
117}
118
119static 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
143static 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
163static 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
186static 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};
198MODULE_DEVICE_TABLE(ieee1394, motu_id_table);
199
200static 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
212static int __init alsa_motu_init(void)
213{
214	return driver_register(&motu_driver.driver);
215}
216
217static void __exit alsa_motu_exit(void)
218{
219	driver_unregister(&motu_driver.driver);
220}
221
222module_init(alsa_motu_init);
223module_exit(alsa_motu_exit);
224