projects/linux·blob master · refs

376 lines · 10.0 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * serial-generic.c
4 * Copyright (c) by Daniel Kaehn <[email protected]
5 * Based on serial-u16550.c by Jaroslav Kysela <[email protected]>,
6 * Isaku Yamahata <[email protected]>,
7 * George Hansper <[email protected]>,
8 * Hannu Savolainen
9 *
10 * Generic serial MIDI driver using the serdev serial bus API for hardware interaction
11 */
12
13#include <linux/err.h>
14#include <linux/init.h>
15#include <linux/interrupt.h>
16#include <linux/io.h>
17#include <linux/ioport.h>
18#include <linux/module.h>
19#include <linux/of.h>
20#include <linux/serdev.h>
21#include <linux/serial_reg.h>
22#include <linux/slab.h>
23#include <linux/dev_printk.h>
24
25#include <sound/core.h>
26#include <sound/rawmidi.h>
27#include <sound/initval.h>
28
29MODULE_DESCRIPTION("Generic serial MIDI driver");
30MODULE_LICENSE("GPL");
31
32#define SERIAL_MODE_INPUT_OPEN 1
33#define SERIAL_MODE_OUTPUT_OPEN 2
34#define SERIAL_MODE_INPUT_TRIGGERED 3
35#define SERIAL_MODE_OUTPUT_TRIGGERED 4
36
37#define SERIAL_TX_STATE_ACTIVE 1
38#define SERIAL_TX_STATE_WAKEUP 2
39
40#define INTERNAL_BUF_SIZE 256
41
42struct snd_serial_generic {
43 struct serdev_device *serdev;
44
45 struct snd_card *card;
46 struct snd_rawmidi *rmidi;
47 struct snd_rawmidi_substream *midi_output;
48 struct snd_rawmidi_substream *midi_input;
49
50 unsigned int baudrate;
51
52 unsigned long filemode; /* open status of file */
53 struct work_struct tx_work;
54 unsigned long tx_state;
55
56 char tx_buf[INTERNAL_BUF_SIZE];
57};
58
59static void snd_serial_generic_tx_wakeup(struct snd_serial_generic *drvdata)
60{
61 if (test_and_set_bit(SERIAL_TX_STATE_ACTIVE, &drvdata->tx_state))
62 set_bit(SERIAL_TX_STATE_WAKEUP, &drvdata->tx_state);
63
64 schedule_work(&drvdata->tx_work);
65}
66
67static void snd_serial_generic_tx_work(struct work_struct *work)
68{
69 int num_bytes;
70 struct snd_serial_generic *drvdata = container_of(work, struct snd_serial_generic,
71 tx_work);
72 struct snd_rawmidi_substream *substream = drvdata->midi_output;
73
74 clear_bit(SERIAL_TX_STATE_WAKEUP, &drvdata->tx_state);
75
76 while (!snd_rawmidi_transmit_empty(substream)) {
77
78 if (!test_bit(SERIAL_MODE_OUTPUT_OPEN, &drvdata->filemode))
79 break;
80
81 num_bytes = snd_rawmidi_transmit_peek(substream, drvdata->tx_buf,
82 INTERNAL_BUF_SIZE);
83 num_bytes = serdev_device_write_buf(drvdata->serdev, drvdata->tx_buf,
84 num_bytes);
85
86 if (!num_bytes)
87 break;
88
89 snd_rawmidi_transmit_ack(substream, num_bytes);
90
91 if (!test_bit(SERIAL_TX_STATE_WAKEUP, &drvdata->tx_state))
92 break;
93 }
94
95 clear_bit(SERIAL_TX_STATE_ACTIVE, &drvdata->tx_state);
96}
97
98static void snd_serial_generic_write_wakeup(struct serdev_device *serdev)
99{
100 struct snd_serial_generic *drvdata = serdev_device_get_drvdata(serdev);
101
102 snd_serial_generic_tx_wakeup(drvdata);
103}
104
105static size_t snd_serial_generic_receive_buf(struct serdev_device *serdev,
106 const u8 *buf, size_t count)
107{
108 int ret;
109 struct snd_serial_generic *drvdata = serdev_device_get_drvdata(serdev);
110
111 if (!test_bit(SERIAL_MODE_INPUT_OPEN, &drvdata->filemode))
112 return 0;
113
114 ret = snd_rawmidi_receive(drvdata->midi_input, buf, count);
115 return ret < 0 ? 0 : ret;
116}
117
118static const struct serdev_device_ops snd_serial_generic_serdev_device_ops = {
119 .receive_buf = snd_serial_generic_receive_buf,
120 .write_wakeup = snd_serial_generic_write_wakeup
121};
122
123static int snd_serial_generic_ensure_serdev_open(struct snd_serial_generic *drvdata)
124{
125 int err;
126 unsigned int actual_baud;
127
128 if (drvdata->filemode)
129 return 0;
130
131 dev_dbg(drvdata->card->dev, "Opening serial port for card %s\n",
132 drvdata->card->shortname);
133 err = serdev_device_open(drvdata->serdev);
134 if (err < 0)
135 return err;
136
137 actual_baud = serdev_device_set_baudrate(drvdata->serdev,
138 drvdata->baudrate);
139 if (actual_baud != drvdata->baudrate) {
140 dev_warn(drvdata->card->dev, "requested %d baud for card %s but it was actually set to %d\n",
141 drvdata->baudrate, drvdata->card->shortname, actual_baud);
142 }
143
144 return 0;
145}
146
147static int snd_serial_generic_input_open(struct snd_rawmidi_substream *substream)
148{
149 int err;
150 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
151
152 dev_dbg(drvdata->card->dev, "Opening input for card %s\n",
153 drvdata->card->shortname);
154
155 err = snd_serial_generic_ensure_serdev_open(drvdata);
156 if (err < 0)
157 return err;
158
159 set_bit(SERIAL_MODE_INPUT_OPEN, &drvdata->filemode);
160 drvdata->midi_input = substream;
161 return 0;
162}
163
164static int snd_serial_generic_input_close(struct snd_rawmidi_substream *substream)
165{
166 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
167
168 dev_dbg(drvdata->card->dev, "Closing input for card %s\n",
169 drvdata->card->shortname);
170
171 clear_bit(SERIAL_MODE_INPUT_OPEN, &drvdata->filemode);
172 clear_bit(SERIAL_MODE_INPUT_TRIGGERED, &drvdata->filemode);
173
174 drvdata->midi_input = NULL;
175
176 if (!drvdata->filemode)
177 serdev_device_close(drvdata->serdev);
178 return 0;
179}
180
181static void snd_serial_generic_input_trigger(struct snd_rawmidi_substream *substream,
182 int up)
183{
184 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
185
186 if (up)
187 set_bit(SERIAL_MODE_INPUT_TRIGGERED, &drvdata->filemode);
188 else
189 clear_bit(SERIAL_MODE_INPUT_TRIGGERED, &drvdata->filemode);
190}
191
192static int snd_serial_generic_output_open(struct snd_rawmidi_substream *substream)
193{
194 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
195 int err;
196
197 dev_dbg(drvdata->card->dev, "Opening output for card %s\n",
198 drvdata->card->shortname);
199
200 err = snd_serial_generic_ensure_serdev_open(drvdata);
201 if (err < 0)
202 return err;
203
204 set_bit(SERIAL_MODE_OUTPUT_OPEN, &drvdata->filemode);
205
206 drvdata->midi_output = substream;
207 return 0;
208};
209
210static int snd_serial_generic_output_close(struct snd_rawmidi_substream *substream)
211{
212 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
213
214 dev_dbg(drvdata->card->dev, "Closing output for card %s\n",
215 drvdata->card->shortname);
216
217 clear_bit(SERIAL_MODE_OUTPUT_OPEN, &drvdata->filemode);
218 clear_bit(SERIAL_MODE_OUTPUT_TRIGGERED, &drvdata->filemode);
219
220 if (!drvdata->filemode)
221 serdev_device_close(drvdata->serdev);
222
223 drvdata->midi_output = NULL;
224
225 return 0;
226};
227
228static void snd_serial_generic_output_trigger(struct snd_rawmidi_substream *substream,
229 int up)
230{
231 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
232
233 if (up)
234 set_bit(SERIAL_MODE_OUTPUT_TRIGGERED, &drvdata->filemode);
235 else
236 clear_bit(SERIAL_MODE_OUTPUT_TRIGGERED, &drvdata->filemode);
237
238 if (up)
239 snd_serial_generic_tx_wakeup(drvdata);
240}
241
242static void snd_serial_generic_output_drain(struct snd_rawmidi_substream *substream)
243{
244 struct snd_serial_generic *drvdata = substream->rmidi->card->private_data;
245
246 /* Flush any pending characters */
247 serdev_device_write_flush(drvdata->serdev);
248 cancel_work_sync(&drvdata->tx_work);
249}
250
251static const struct snd_rawmidi_ops snd_serial_generic_output = {
252 .open = snd_serial_generic_output_open,
253 .close = snd_serial_generic_output_close,
254 .trigger = snd_serial_generic_output_trigger,
255 .drain = snd_serial_generic_output_drain,
256};
257
258static const struct snd_rawmidi_ops snd_serial_generic_input = {
259 .open = snd_serial_generic_input_open,
260 .close = snd_serial_generic_input_close,
261 .trigger = snd_serial_generic_input_trigger,
262};
263
264static void snd_serial_generic_parse_dt(struct serdev_device *serdev,
265 struct snd_serial_generic *drvdata)
266{
267 int err;
268
269 err = of_property_read_u32(serdev->dev.of_node, "current-speed",
270 &drvdata->baudrate);
271 if (err < 0) {
272 dev_dbg(drvdata->card->dev,
273 "MIDI device reading of current-speed DT param failed with error %d, using default of 38400\n",
274 err);
275 drvdata->baudrate = 38400;
276 }
277
278}
279
280static void snd_serial_generic_substreams(struct snd_rawmidi_str *stream, int dev_num)
281{
282 struct snd_rawmidi_substream *substream;
283
284 list_for_each_entry(substream, &stream->substreams, list) {
285 sprintf(substream->name, "Serial MIDI %d-%d", dev_num, substream->number);
286 }
287}
288
289static int snd_serial_generic_rmidi(struct snd_serial_generic *drvdata,
290 int outs, int ins, struct snd_rawmidi **rmidi)
291{
292 struct snd_rawmidi *rrawmidi;
293 int err;
294
295 err = snd_rawmidi_new(drvdata->card, drvdata->card->driver, 0,
296 outs, ins, &rrawmidi);
297
298 if (err < 0)
299 return err;
300
301 snd_rawmidi_set_ops(rrawmidi, SNDRV_RAWMIDI_STREAM_INPUT,
302 &snd_serial_generic_input);
303 snd_rawmidi_set_ops(rrawmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
304 &snd_serial_generic_output);
305 strscpy(rrawmidi->name, drvdata->card->shortname);
306
307 snd_serial_generic_substreams(&rrawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT],
308 drvdata->serdev->ctrl->nr);
309 snd_serial_generic_substreams(&rrawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT],
310 drvdata->serdev->ctrl->nr);
311
312 rrawmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
313 SNDRV_RAWMIDI_INFO_INPUT |
314 SNDRV_RAWMIDI_INFO_DUPLEX;
315
316 if (rmidi)
317 *rmidi = rrawmidi;
318 return 0;
319}
320
321static int snd_serial_generic_probe(struct serdev_device *serdev)
322{
323 struct snd_card *card;
324 struct snd_serial_generic *drvdata;
325 int err;
326
327 err = snd_devm_card_new(&serdev->dev, SNDRV_DEFAULT_IDX1,
328 SNDRV_DEFAULT_STR1, THIS_MODULE,
329 sizeof(struct snd_serial_generic), &card);
330
331 if (err < 0)
332 return err;
333
334 strscpy(card->driver, "SerialMIDI");
335 sprintf(card->shortname, "SerialMIDI-%d", serdev->ctrl->nr);
336 sprintf(card->longname, "Serial MIDI device at serial%d", serdev->ctrl->nr);
337
338 drvdata = card->private_data;
339
340 drvdata->serdev = serdev;
341 drvdata->card = card;
342
343 snd_serial_generic_parse_dt(serdev, drvdata);
344
345 INIT_WORK(&drvdata->tx_work, snd_serial_generic_tx_work);
346
347 err = snd_serial_generic_rmidi(drvdata, 1, 1, &drvdata->rmidi);
348 if (err < 0)
349 return err;
350
351 serdev_device_set_client_ops(serdev, &snd_serial_generic_serdev_device_ops);
352 serdev_device_set_drvdata(drvdata->serdev, drvdata);
353
354 err = snd_card_register(card);
355 if (err < 0)
356 return err;
357
358 return 0;
359}
360
361static const struct of_device_id snd_serial_generic_dt_ids[] = {
362 { .compatible = "serial-midi" },
363 {},
364};
365
366MODULE_DEVICE_TABLE(of, snd_serial_generic_dt_ids);
367
368static struct serdev_device_driver snd_serial_generic_driver = {
369 .driver = {
370 .name = "snd-serial-generic",
371 .of_match_table = snd_serial_generic_dt_ids,
372 },
373 .probe = snd_serial_generic_probe,
374};
375
376module_serdev_device_driver(snd_serial_generic_driver);