1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Abstract layer for MIDI v1.0 stream
4	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
5	*/
6
7	#include <sound/core.h>
8	#include <linux/major.h>
9	#include <linux/init.h>
10	#include <linux/sched/signal.h>
11	#include <linux/slab.h>
12	#include <linux/time.h>
13	#include <linux/wait.h>
14	#include <linux/mutex.h>
15	#include <linux/module.h>
16	#include <linux/delay.h>
17	#include <linux/mm.h>
18	#include <linux/nospec.h>
19	#include <sound/rawmidi.h>
20	#include <sound/info.h>
21	#include <sound/control.h>
22	#include <sound/minors.h>
23	#include <sound/initval.h>
24	#include <sound/ump.h>
25
26	MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
27	MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA.");
28	MODULE_LICENSE("GPL");
29
30	#ifdef CONFIG_SND_OSSEMUL
31	static int midi_map[SNDRV_CARDS];
32	static int amidi_map[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 1};
33	module_param_array(midi_map, int, NULL, 0444);
34	MODULE_PARM_DESC(midi_map, "Raw MIDI device number assigned to 1st OSS device.");
35	module_param_array(amidi_map, int, NULL, 0444);
36	MODULE_PARM_DESC(amidi_map, "Raw MIDI device number assigned to 2nd OSS device.");
37	#endif /* CONFIG_SND_OSSEMUL */
38
39	static int snd_rawmidi_dev_free(struct snd_device *device);
40	static int snd_rawmidi_dev_register(struct snd_device *device);
41	static int snd_rawmidi_dev_disconnect(struct snd_device *device);
42
43	static LIST_HEAD(snd_rawmidi_devices);
44	static DEFINE_MUTEX(register_mutex);
45
46	#define rmidi_err(rmidi, fmt, args...) \
47	dev_err((rmidi)->dev, fmt, ##args)
48	#define rmidi_warn(rmidi, fmt, args...) \
49	dev_warn((rmidi)->dev, fmt, ##args)
50	#define rmidi_dbg(rmidi, fmt, args...) \
51	dev_dbg((rmidi)->dev, fmt, ##args)
52
53	struct snd_rawmidi_status32 {
54	s32 stream;
55	s32 tstamp_sec; /* Timestamp */
56	s32 tstamp_nsec;
57	u32 avail; /* available bytes */
58	u32 xruns; /* count of overruns since last status (in bytes) */
59	unsigned char reserved[16]; /* reserved for future use */
60	};
61
62	#define SNDRV_RAWMIDI_IOCTL_STATUS32 _IOWR('W', 0x20, struct snd_rawmidi_status32)
63
64	struct snd_rawmidi_status64 {
65	int stream;
66	u8 rsvd[4]; /* alignment */
67	s64 tstamp_sec; /* Timestamp */
68	s64 tstamp_nsec;
69	size_t avail; /* available bytes */
70	size_t xruns; /* count of overruns since last status (in bytes) */
71	unsigned char reserved[16]; /* reserved for future use */
72	};
73
74	#define SNDRV_RAWMIDI_IOCTL_STATUS64 _IOWR('W', 0x20, struct snd_rawmidi_status64)
75
76	#define rawmidi_is_ump(rmidi) \
77	(IS_ENABLED(CONFIG_SND_UMP) && ((rmidi)->info_flags & SNDRV_RAWMIDI_INFO_UMP))
78
79	static struct snd_rawmidi *snd_rawmidi_search(struct snd_card *card, int device)
80	{
81	struct snd_rawmidi *rawmidi;
82
83	list_for_each_entry(rawmidi, &snd_rawmidi_devices, list)
84	if (rawmidi->card == card && rawmidi->device == device)
85	return rawmidi;
86	return NULL;
87	}
88
89	static inline unsigned short snd_rawmidi_file_flags(struct file *file)
90	{
91	switch (file->f_mode & (FMODE_READ | FMODE_WRITE)) {
92	case FMODE_WRITE:
93	return SNDRV_RAWMIDI_LFLG_OUTPUT;
94	case FMODE_READ:
95	return SNDRV_RAWMIDI_LFLG_INPUT;
96	default:
97	return SNDRV_RAWMIDI_LFLG_OPEN;
98	}
99	}
100
101	static inline bool __snd_rawmidi_ready(struct snd_rawmidi_runtime *runtime)
102	{
103	return runtime->avail >= runtime->avail_min;
104	}
105
106	static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
107	{
108	unsigned long flags;
109	bool ready;
110
111	spin_lock_irqsave(&substream->lock, flags);
112	ready = __snd_rawmidi_ready(runtime: substream->runtime);
113	spin_unlock_irqrestore(lock: &substream->lock, flags);
114	return ready;
115	}
116
117	static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream,
118	size_t count)
119	{
120	struct snd_rawmidi_runtime *runtime = substream->runtime;
121
122	return runtime->avail >= runtime->avail_min &&
123	(!substream->append || runtime->avail >= count);
124	}
125
126	static void snd_rawmidi_input_event_work(struct work_struct *work)
127	{
128	struct snd_rawmidi_runtime *runtime =
129	container_of(work, struct snd_rawmidi_runtime, event_work);
130
131	if (runtime->event)
132	runtime->event(runtime->substream);
133	}
134
135	/* buffer refcount management: call with substream->lock held */
136	static inline void snd_rawmidi_buffer_ref(struct snd_rawmidi_runtime *runtime)
137	{
138	runtime->buffer_ref++;
139	}
140
141	static inline void snd_rawmidi_buffer_unref(struct snd_rawmidi_runtime *runtime)
142	{
143	runtime->buffer_ref--;
144	}
145
146	static void snd_rawmidi_buffer_ref_sync(struct snd_rawmidi_substream *substream)
147	{
148	int loop = HZ;
149
150	spin_lock_irq(lock: &substream->lock);
151	while (substream->runtime->buffer_ref) {
152	spin_unlock_irq(lock: &substream->lock);
153	if (!--loop) {
154	rmidi_err(substream->rmidi, "Buffer ref sync timeout\n");
155	return;
156	}
157	schedule_timeout_uninterruptible(timeout: 1);
158	spin_lock_irq(lock: &substream->lock);
159	}
160	spin_unlock_irq(lock: &substream->lock);
161	}
162
163	static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream)
164	{
165	struct snd_rawmidi_runtime *runtime;
166
167	runtime = kzalloc(size: sizeof(*runtime), GFP_KERNEL);
168	if (!runtime)
169	return -ENOMEM;
170	runtime->substream = substream;
171	init_waitqueue_head(&runtime->sleep);
172	INIT_WORK(&runtime->event_work, snd_rawmidi_input_event_work);
173	runtime->event = NULL;
174	runtime->buffer_size = PAGE_SIZE;
175	runtime->avail_min = 1;
176	if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
177	runtime->avail = 0;
178	else
179	runtime->avail = runtime->buffer_size;
180	runtime->buffer = kvzalloc(size: runtime->buffer_size, GFP_KERNEL);
181	if (!runtime->buffer) {
182	kfree(objp: runtime);
183	return -ENOMEM;
184	}
185	runtime->appl_ptr = runtime->hw_ptr = 0;
186	substream->runtime = runtime;
187	if (rawmidi_is_ump(substream->rmidi))
188	runtime->align = 3;
189	return 0;
190	}
191
192	/* get the current alignment (either 0 or 3) */
193	static inline int get_align(struct snd_rawmidi_runtime *runtime)
194	{
195	if (IS_ENABLED(CONFIG_SND_UMP))
196	return runtime->align;
197	else
198	return 0;
199	}
200
201	/* get the trimmed size with the current alignment */
202	#define get_aligned_size(runtime, size) ((size) & ~get_align(runtime))
203
204	static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream)
205	{
206	struct snd_rawmidi_runtime *runtime = substream->runtime;
207
208	kvfree(addr: runtime->buffer);
209	kfree(objp: runtime);
210	substream->runtime = NULL;
211	return 0;
212	}
213
214	static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream, int up)
215	{
216	if (!substream->opened)
217	return;
218	substream->ops->trigger(substream, up);
219	}
220
221	static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
222	{
223	if (!substream->opened)
224	return;
225	substream->ops->trigger(substream, up);
226	if (!up)
227	cancel_work_sync(work: &substream->runtime->event_work);
228	}
229
230	static void __reset_runtime_ptrs(struct snd_rawmidi_runtime *runtime,
231	bool is_input)
232	{
233	runtime->drain = 0;
234	runtime->appl_ptr = runtime->hw_ptr = 0;
235	runtime->avail = is_input ? 0 : runtime->buffer_size;
236	}
237
238	static void reset_runtime_ptrs(struct snd_rawmidi_substream *substream,
239	bool is_input)
240	{
241	unsigned long flags;
242
243	spin_lock_irqsave(&substream->lock, flags);
244	if (substream->opened && substream->runtime)
245	__reset_runtime_ptrs(runtime: substream->runtime, is_input);
246	spin_unlock_irqrestore(lock: &substream->lock, flags);
247	}
248
249	int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream)
250	{
251	snd_rawmidi_output_trigger(substream, up: 0);
252	reset_runtime_ptrs(substream, is_input: false);
253	return 0;
254	}
255	EXPORT_SYMBOL(snd_rawmidi_drop_output);
256
257	int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
258	{
259	int err = 0;
260	long timeout;
261	struct snd_rawmidi_runtime *runtime;
262
263	spin_lock_irq(lock: &substream->lock);
264	runtime = substream->runtime;
265	if (!substream->opened || !runtime || !runtime->buffer) {
266	err = -EINVAL;
267	} else {
268	snd_rawmidi_buffer_ref(runtime);
269	runtime->drain = 1;
270	}
271	spin_unlock_irq(lock: &substream->lock);
272	if (err < 0)
273	return err;
274
275	timeout = wait_event_interruptible_timeout(runtime->sleep,
276	(runtime->avail >= runtime->buffer_size),
277	10*HZ);
278
279	spin_lock_irq(lock: &substream->lock);
280	if (signal_pending(current))
281	err = -ERESTARTSYS;
282	if (runtime->avail < runtime->buffer_size && !timeout) {
283	rmidi_warn(substream->rmidi,
284	"rawmidi drain error (avail = %li, buffer_size = %li)\n",
285	(long)runtime->avail, (long)runtime->buffer_size);
286	err = -EIO;
287	}
288	runtime->drain = 0;
289	spin_unlock_irq(lock: &substream->lock);
290
291	if (err != -ERESTARTSYS) {
292	/* we need wait a while to make sure that Tx FIFOs are empty */
293	if (substream->ops->drain)
294	substream->ops->drain(substream);
295	else
296	msleep(msecs: 50);
297	snd_rawmidi_drop_output(substream);
298	}
299
300	spin_lock_irq(lock: &substream->lock);
301	snd_rawmidi_buffer_unref(runtime);
302	spin_unlock_irq(lock: &substream->lock);
303
304	return err;
305	}
306	EXPORT_SYMBOL(snd_rawmidi_drain_output);
307
308	int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream)
309	{
310	snd_rawmidi_input_trigger(substream, up: 0);
311	reset_runtime_ptrs(substream, is_input: true);
312	return 0;
313	}
314	EXPORT_SYMBOL(snd_rawmidi_drain_input);
315
316	/* look for an available substream for the given stream direction;
317	* if a specific subdevice is given, try to assign it
318	*/
319	static int assign_substream(struct snd_rawmidi *rmidi, int subdevice,
320	int stream, int mode,
321	struct snd_rawmidi_substream **sub_ret)
322	{
323	struct snd_rawmidi_substream *substream;
324	struct snd_rawmidi_str *s = &rmidi->streams[stream];
325	static const unsigned int info_flags[2] = {
326	[SNDRV_RAWMIDI_STREAM_OUTPUT] = SNDRV_RAWMIDI_INFO_OUTPUT,
327	[SNDRV_RAWMIDI_STREAM_INPUT] = SNDRV_RAWMIDI_INFO_INPUT,
328	};
329
330	if (!(rmidi->info_flags & info_flags[stream]))
331	return -ENXIO;
332	if (subdevice >= 0 && subdevice >= s->substream_count)
333	return -ENODEV;
334
335	list_for_each_entry(substream, &s->substreams, list) {
336	if (substream->opened) {
337	if (stream == SNDRV_RAWMIDI_STREAM_INPUT ||
338	!(mode & SNDRV_RAWMIDI_LFLG_APPEND) ||
339	!substream->append)
340	continue;
341	}
342	if (subdevice < 0 || subdevice == substream->number) {
343	*sub_ret = substream;
344	return 0;
345	}
346	}
347	return -EAGAIN;
348	}
349
350	/* open and do ref-counting for the given substream */
351	static int open_substream(struct snd_rawmidi *rmidi,
352	struct snd_rawmidi_substream *substream,
353	int mode)
354	{
355	int err;
356
357	if (substream->use_count == 0) {
358	err = snd_rawmidi_runtime_create(substream);
359	if (err < 0)
360	return err;
361	err = substream->ops->open(substream);
362	if (err < 0) {
363	snd_rawmidi_runtime_free(substream);
364	return err;
365	}
366	spin_lock_irq(lock: &substream->lock);
367	substream->opened = 1;
368	substream->active_sensing = 0;
369	if (mode & SNDRV_RAWMIDI_LFLG_APPEND)
370	substream->append = 1;
371	substream->pid = get_pid(pid: task_pid(current));
372	rmidi->streams[substream->stream].substream_opened++;
373	spin_unlock_irq(lock: &substream->lock);
374	}
375	substream->use_count++;
376	return 0;
377	}
378
379	static void close_substream(struct snd_rawmidi *rmidi,
380	struct snd_rawmidi_substream *substream,
381	int cleanup);
382
383	static int rawmidi_open_priv(struct snd_rawmidi *rmidi, int subdevice, int mode,
384	struct snd_rawmidi_file *rfile)
385	{
386	struct snd_rawmidi_substream *sinput = NULL, *soutput = NULL;
387	int err;
388
389	rfile->input = rfile->output = NULL;
390	if (mode & SNDRV_RAWMIDI_LFLG_INPUT) {
391	err = assign_substream(rmidi, subdevice,
392	stream: SNDRV_RAWMIDI_STREAM_INPUT,
393	mode, sub_ret: &sinput);
394	if (err < 0)
395	return err;
396	}
397	if (mode & SNDRV_RAWMIDI_LFLG_OUTPUT) {
398	err = assign_substream(rmidi, subdevice,
399	stream: SNDRV_RAWMIDI_STREAM_OUTPUT,
400	mode, sub_ret: &soutput);
401	if (err < 0)
402	return err;
403	}
404
405	if (sinput) {
406	err = open_substream(rmidi, substream: sinput, mode);
407	if (err < 0)
408	return err;
409	}
410	if (soutput) {
411	err = open_substream(rmidi, substream: soutput, mode);
412	if (err < 0) {
413	if (sinput)
414	close_substream(rmidi, substream: sinput, cleanup: 0);
415	return err;
416	}
417	}
418
419	rfile->rmidi = rmidi;
420	rfile->input = sinput;
421	rfile->output = soutput;
422	return 0;
423	}
424
425	/* called from sound/core/seq/seq_midi.c */
426	int snd_rawmidi_kernel_open(struct snd_rawmidi *rmidi, int subdevice,
427	int mode, struct snd_rawmidi_file *rfile)
428	{
429	int err;
430
431	if (snd_BUG_ON(!rfile))
432	return -EINVAL;
433	if (!try_module_get(module: rmidi->card->module))
434	return -ENXIO;
435
436	mutex_lock(&rmidi->open_mutex);
437	err = rawmidi_open_priv(rmidi, subdevice, mode, rfile);
438	mutex_unlock(lock: &rmidi->open_mutex);
439	if (err < 0)
440	module_put(module: rmidi->card->module);
441	return err;
442	}
443	EXPORT_SYMBOL(snd_rawmidi_kernel_open);
444
445	static int snd_rawmidi_open(struct inode *inode, struct file *file)
446	{
447	int maj = imajor(inode);
448	struct snd_card *card;
449	int subdevice;
450	unsigned short fflags;
451	int err;
452	struct snd_rawmidi *rmidi;
453	struct snd_rawmidi_file *rawmidi_file = NULL;
454	wait_queue_entry_t wait;
455
456	if ((file->f_flags & O_APPEND) && !(file->f_flags & O_NONBLOCK))
457	return -EINVAL; /* invalid combination */
458
459	err = stream_open(inode, filp: file);
460	if (err < 0)
461	return err;
462
463	if (maj == snd_major) {
464	rmidi = snd_lookup_minor_data(minor: iminor(inode),
465	type: SNDRV_DEVICE_TYPE_RAWMIDI);
466	#ifdef CONFIG_SND_OSSEMUL
467	} else if (maj == SOUND_MAJOR) {
468	rmidi = snd_lookup_oss_minor_data(minor: iminor(inode),
469	SNDRV_OSS_DEVICE_TYPE_MIDI);
470	#endif
471	} else
472	return -ENXIO;
473
474	if (rmidi == NULL)
475	return -ENODEV;
476
477	if (!try_module_get(module: rmidi->card->module)) {
478	snd_card_unref(card: rmidi->card);
479	return -ENXIO;
480	}
481
482	mutex_lock(&rmidi->open_mutex);
483	card = rmidi->card;
484	err = snd_card_file_add(card, file);
485	if (err < 0)
486	goto __error_card;
487	fflags = snd_rawmidi_file_flags(file);
488	if ((file->f_flags & O_APPEND) || maj == SOUND_MAJOR) /* OSS emul? */
489	fflags |= SNDRV_RAWMIDI_LFLG_APPEND;
490	rawmidi_file = kmalloc(size: sizeof(*rawmidi_file), GFP_KERNEL);
491	if (rawmidi_file == NULL) {
492	err = -ENOMEM;
493	goto __error;
494	}
495	rawmidi_file->user_pversion = 0;
496	init_waitqueue_entry(wq_entry: &wait, current);
497	add_wait_queue(wq_head: &rmidi->open_wait, wq_entry: &wait);
498	while (1) {
499	subdevice = snd_ctl_get_preferred_subdevice(card, type: SND_CTL_SUBDEV_RAWMIDI);
500	err = rawmidi_open_priv(rmidi, subdevice, mode: fflags, rfile: rawmidi_file);
501	if (err >= 0)
502	break;
503	if (err == -EAGAIN) {
504	if (file->f_flags & O_NONBLOCK) {
505	err = -EBUSY;
506	break;
507	}
508	} else
509	break;
510	set_current_state(TASK_INTERRUPTIBLE);
511	mutex_unlock(lock: &rmidi->open_mutex);
512	schedule();
513	mutex_lock(&rmidi->open_mutex);
514	if (rmidi->card->shutdown) {
515	err = -ENODEV;
516	break;
517	}
518	if (signal_pending(current)) {
519	err = -ERESTARTSYS;
520	break;
521	}
522	}
523	remove_wait_queue(wq_head: &rmidi->open_wait, wq_entry: &wait);
524	if (err < 0) {
525	kfree(objp: rawmidi_file);
526	goto __error;
527	}
528	#ifdef CONFIG_SND_OSSEMUL
529	if (rawmidi_file->input && rawmidi_file->input->runtime)
530	rawmidi_file->input->runtime->oss = (maj == SOUND_MAJOR);
531	if (rawmidi_file->output && rawmidi_file->output->runtime)
532	rawmidi_file->output->runtime->oss = (maj == SOUND_MAJOR);
533	#endif
534	file->private_data = rawmidi_file;
535	mutex_unlock(lock: &rmidi->open_mutex);
536	snd_card_unref(card: rmidi->card);
537	return 0;
538
539	__error:
540	snd_card_file_remove(card, file);
541	__error_card:
542	mutex_unlock(lock: &rmidi->open_mutex);
543	module_put(module: rmidi->card->module);
544	snd_card_unref(card: rmidi->card);
545	return err;
546	}
547
548	static void close_substream(struct snd_rawmidi *rmidi,
549	struct snd_rawmidi_substream *substream,
550	int cleanup)
551	{
552	if (--substream->use_count)
553	return;
554
555	if (cleanup) {
556	if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
557	snd_rawmidi_input_trigger(substream, up: 0);
558	else {
559	if (substream->active_sensing) {
560	unsigned char buf = 0xfe;
561	/* sending single active sensing message
562	* to shut the device up
563	*/
564	snd_rawmidi_kernel_write(substream, buf: &buf, count: 1);
565	}
566	if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS)
567	snd_rawmidi_output_trigger(substream, up: 0);
568	}
569	snd_rawmidi_buffer_ref_sync(substream);
570	}
571	spin_lock_irq(lock: &substream->lock);
572	substream->opened = 0;
573	substream->append = 0;
574	spin_unlock_irq(lock: &substream->lock);
575	substream->ops->close(substream);
576	if (substream->runtime->private_free)
577	substream->runtime->private_free(substream);
578	snd_rawmidi_runtime_free(substream);
579	put_pid(pid: substream->pid);
580	substream->pid = NULL;
581	rmidi->streams[substream->stream].substream_opened--;
582	}
583
584	static void rawmidi_release_priv(struct snd_rawmidi_file *rfile)
585	{
586	struct snd_rawmidi *rmidi;
587
588	rmidi = rfile->rmidi;
589	mutex_lock(&rmidi->open_mutex);
590	if (rfile->input) {
591	close_substream(rmidi, substream: rfile->input, cleanup: 1);
592	rfile->input = NULL;
593	}
594	if (rfile->output) {
595	close_substream(rmidi, substream: rfile->output, cleanup: 1);
596	rfile->output = NULL;
597	}
598	rfile->rmidi = NULL;
599	mutex_unlock(lock: &rmidi->open_mutex);
600	wake_up(&rmidi->open_wait);
601	}
602
603	/* called from sound/core/seq/seq_midi.c */
604	int snd_rawmidi_kernel_release(struct snd_rawmidi_file *rfile)
605	{
606	struct snd_rawmidi *rmidi;
607
608	if (snd_BUG_ON(!rfile))
609	return -ENXIO;
610
611	rmidi = rfile->rmidi;
612	rawmidi_release_priv(rfile);
613	module_put(module: rmidi->card->module);
614	return 0;
615	}
616	EXPORT_SYMBOL(snd_rawmidi_kernel_release);
617
618	static int snd_rawmidi_release(struct inode *inode, struct file *file)
619	{
620	struct snd_rawmidi_file *rfile;
621	struct snd_rawmidi *rmidi;
622	struct module *module;
623
624	rfile = file->private_data;
625	rmidi = rfile->rmidi;
626	rawmidi_release_priv(rfile);
627	kfree(objp: rfile);
628	module = rmidi->card->module;
629	snd_card_file_remove(card: rmidi->card, file);
630	module_put(module);
631	return 0;
632	}
633
634	static int snd_rawmidi_info(struct snd_rawmidi_substream *substream,
635	struct snd_rawmidi_info *info)
636	{
637	struct snd_rawmidi *rmidi;
638
639	if (substream == NULL)
640	return -ENODEV;
641	rmidi = substream->rmidi;
642	memset(info, 0, sizeof(*info));
643	info->card = rmidi->card->number;
644	info->device = rmidi->device;
645	info->subdevice = substream->number;
646	info->stream = substream->stream;
647	info->flags = rmidi->info_flags;
648	strcpy(p: info->id, q: rmidi->id);
649	strcpy(p: info->name, q: rmidi->name);
650	strcpy(p: info->subname, q: substream->name);
651	info->subdevices_count = substream->pstr->substream_count;
652	info->subdevices_avail = (substream->pstr->substream_count -
653	substream->pstr->substream_opened);
654	return 0;
655	}
656
657	static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream,
658	struct snd_rawmidi_info __user *_info)
659	{
660	struct snd_rawmidi_info info;
661	int err;
662
663	err = snd_rawmidi_info(substream, info: &info);
664	if (err < 0)
665	return err;
666	if (copy_to_user(to: _info, from: &info, n: sizeof(struct snd_rawmidi_info)))
667	return -EFAULT;
668	return 0;
669	}
670
671	static int __snd_rawmidi_info_select(struct snd_card *card,
672	struct snd_rawmidi_info *info)
673	{
674	struct snd_rawmidi *rmidi;
675	struct snd_rawmidi_str *pstr;
676	struct snd_rawmidi_substream *substream;
677
678	rmidi = snd_rawmidi_search(card, device: info->device);
679	if (!rmidi)
680	return -ENXIO;
681	if (info->stream < 0 || info->stream > 1)
682	return -EINVAL;
683	info->stream = array_index_nospec(info->stream, 2);
684	pstr = &rmidi->streams[info->stream];
685	if (pstr->substream_count == 0)
686	return -ENOENT;
687	if (info->subdevice >= pstr->substream_count)
688	return -ENXIO;
689	list_for_each_entry(substream, &pstr->substreams, list) {
690	if ((unsigned int)substream->number == info->subdevice)
691	return snd_rawmidi_info(substream, info);
692	}
693	return -ENXIO;
694	}
695
696	int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info)
697	{
698	int ret;
699
700	mutex_lock(&register_mutex);
701	ret = __snd_rawmidi_info_select(card, info);
702	mutex_unlock(lock: &register_mutex);
703	return ret;
704	}
705	EXPORT_SYMBOL(snd_rawmidi_info_select);
706
707	static int snd_rawmidi_info_select_user(struct snd_card *card,
708	struct snd_rawmidi_info __user *_info)
709	{
710	int err;
711	struct snd_rawmidi_info info;
712
713	if (get_user(info.device, &_info->device))
714	return -EFAULT;
715	if (get_user(info.stream, &_info->stream))
716	return -EFAULT;
717	if (get_user(info.subdevice, &_info->subdevice))
718	return -EFAULT;
719	err = snd_rawmidi_info_select(card, &info);
720	if (err < 0)
721	return err;
722	if (copy_to_user(to: _info, from: &info, n: sizeof(struct snd_rawmidi_info)))
723	return -EFAULT;
724	return 0;
725	}
726
727	static int resize_runtime_buffer(struct snd_rawmidi_substream *substream,
728	struct snd_rawmidi_params *params,
729	bool is_input)
730	{
731	struct snd_rawmidi_runtime *runtime = substream->runtime;
732	char *newbuf, *oldbuf;
733	unsigned int framing = params->mode & SNDRV_RAWMIDI_MODE_FRAMING_MASK;
734
735	if (params->buffer_size < 32 || params->buffer_size > 1024L * 1024L)
736	return -EINVAL;
737	if (framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP && (params->buffer_size & 0x1f) != 0)
738	return -EINVAL;
739	if (params->avail_min < 1 || params->avail_min > params->buffer_size)
740	return -EINVAL;
741	if (params->buffer_size & get_align(runtime))
742	return -EINVAL;
743	if (params->buffer_size != runtime->buffer_size) {
744	newbuf = kvzalloc(size: params->buffer_size, GFP_KERNEL);
745	if (!newbuf)
746	return -ENOMEM;
747	spin_lock_irq(lock: &substream->lock);
748	if (runtime->buffer_ref) {
749	spin_unlock_irq(lock: &substream->lock);
750	kvfree(addr: newbuf);
751	return -EBUSY;
752	}
753	oldbuf = runtime->buffer;
754	runtime->buffer = newbuf;
755	runtime->buffer_size = params->buffer_size;
756	__reset_runtime_ptrs(runtime, is_input);
757	spin_unlock_irq(lock: &substream->lock);
758	kvfree(addr: oldbuf);
759	}
760	runtime->avail_min = params->avail_min;
761	return 0;
762	}
763
764	int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream,
765	struct snd_rawmidi_params *params)
766	{
767	int err;
768
769	snd_rawmidi_drain_output(substream);
770	mutex_lock(&substream->rmidi->open_mutex);
771	if (substream->append && substream->use_count > 1)
772	err = -EBUSY;
773	else
774	err = resize_runtime_buffer(substream, params, is_input: false);
775
776	if (!err)
777	substream->active_sensing = !params->no_active_sensing;
778	mutex_unlock(lock: &substream->rmidi->open_mutex);
779	return err;
780	}
781	EXPORT_SYMBOL(snd_rawmidi_output_params);
782
783	int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream,
784	struct snd_rawmidi_params *params)
785	{
786	unsigned int framing = params->mode & SNDRV_RAWMIDI_MODE_FRAMING_MASK;
787	unsigned int clock_type = params->mode & SNDRV_RAWMIDI_MODE_CLOCK_MASK;
788	int err;
789
790	snd_rawmidi_drain_input(substream);
791	mutex_lock(&substream->rmidi->open_mutex);
792	if (framing == SNDRV_RAWMIDI_MODE_FRAMING_NONE && clock_type != SNDRV_RAWMIDI_MODE_CLOCK_NONE)
793	err = -EINVAL;
794	else if (clock_type > SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW)
795	err = -EINVAL;
796	else if (framing > SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP)
797	err = -EINVAL;
798	else
799	err = resize_runtime_buffer(substream, params, is_input: true);
800
801	if (!err) {
802	substream->framing = framing;
803	substream->clock_type = clock_type;
804	}
805	mutex_unlock(lock: &substream->rmidi->open_mutex);
806	return 0;
807	}
808	EXPORT_SYMBOL(snd_rawmidi_input_params);
809
810	static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream,
811	struct snd_rawmidi_status64 *status)
812	{
813	struct snd_rawmidi_runtime *runtime = substream->runtime;
814
815	memset(status, 0, sizeof(*status));
816	status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT;
817	spin_lock_irq(lock: &substream->lock);
818	status->avail = runtime->avail;
819	spin_unlock_irq(lock: &substream->lock);
820	return 0;
821	}
822
823	static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream,
824	struct snd_rawmidi_status64 *status)
825	{
826	struct snd_rawmidi_runtime *runtime = substream->runtime;
827
828	memset(status, 0, sizeof(*status));
829	status->stream = SNDRV_RAWMIDI_STREAM_INPUT;
830	spin_lock_irq(lock: &substream->lock);
831	status->avail = runtime->avail;
832	status->xruns = runtime->xruns;
833	runtime->xruns = 0;
834	spin_unlock_irq(lock: &substream->lock);
835	return 0;
836	}
837
838	static int snd_rawmidi_ioctl_status32(struct snd_rawmidi_file *rfile,
839	struct snd_rawmidi_status32 __user *argp)
840	{
841	int err = 0;
842	struct snd_rawmidi_status32 __user *status = argp;
843	struct snd_rawmidi_status32 status32;
844	struct snd_rawmidi_status64 status64;
845
846	if (copy_from_user(to: &status32, from: argp,
847	n: sizeof(struct snd_rawmidi_status32)))
848	return -EFAULT;
849
850	switch (status32.stream) {
851	case SNDRV_RAWMIDI_STREAM_OUTPUT:
852	if (rfile->output == NULL)
853	return -EINVAL;
854	err = snd_rawmidi_output_status(substream: rfile->output, status: &status64);
855	break;
856	case SNDRV_RAWMIDI_STREAM_INPUT:
857	if (rfile->input == NULL)
858	return -EINVAL;
859	err = snd_rawmidi_input_status(substream: rfile->input, status: &status64);
860	break;
861	default:
862	return -EINVAL;
863	}
864	if (err < 0)
865	return err;
866
867	status32 = (struct snd_rawmidi_status32) {
868	.stream = status64.stream,
869	.tstamp_sec = status64.tstamp_sec,
870	.tstamp_nsec = status64.tstamp_nsec,
871	.avail = status64.avail,
872	.xruns = status64.xruns,
873	};
874
875	if (copy_to_user(to: status, from: &status32, n: sizeof(*status)))
876	return -EFAULT;
877
878	return 0;
879	}
880
881	static int snd_rawmidi_ioctl_status64(struct snd_rawmidi_file *rfile,
882	struct snd_rawmidi_status64 __user *argp)
883	{
884	int err = 0;
885	struct snd_rawmidi_status64 status;
886
887	if (copy_from_user(to: &status, from: argp, n: sizeof(struct snd_rawmidi_status64)))
888	return -EFAULT;
889
890	switch (status.stream) {
891	case SNDRV_RAWMIDI_STREAM_OUTPUT:
892	if (rfile->output == NULL)
893	return -EINVAL;
894	err = snd_rawmidi_output_status(substream: rfile->output, status: &status);
895	break;
896	case SNDRV_RAWMIDI_STREAM_INPUT:
897	if (rfile->input == NULL)
898	return -EINVAL;
899	err = snd_rawmidi_input_status(substream: rfile->input, status: &status);
900	break;
901	default:
902	return -EINVAL;
903	}
904	if (err < 0)
905	return err;
906	if (copy_to_user(to: argp, from: &status,
907	n: sizeof(struct snd_rawmidi_status64)))
908	return -EFAULT;
909	return 0;
910	}
911
912	static long snd_rawmidi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
913	{
914	struct snd_rawmidi_file *rfile;
915	struct snd_rawmidi *rmidi;
916	void __user *argp = (void __user *)arg;
917
918	rfile = file->private_data;
919	if (((cmd >> 8) & 0xff) != 'W')
920	return -ENOTTY;
921	switch (cmd) {
922	case SNDRV_RAWMIDI_IOCTL_PVERSION:
923	return put_user(SNDRV_RAWMIDI_VERSION, (int __user *)argp) ? -EFAULT : 0;
924	case SNDRV_RAWMIDI_IOCTL_INFO:
925	{
926	int stream;
927	struct snd_rawmidi_info __user *info = argp;
928
929	if (get_user(stream, &info->stream))
930	return -EFAULT;
931	switch (stream) {
932	case SNDRV_RAWMIDI_STREAM_INPUT:
933	return snd_rawmidi_info_user(substream: rfile->input, info: info);
934	case SNDRV_RAWMIDI_STREAM_OUTPUT:
935	return snd_rawmidi_info_user(substream: rfile->output, info: info);
936	default:
937	return -EINVAL;
938	}
939	}
940	case SNDRV_RAWMIDI_IOCTL_USER_PVERSION:
941	if (get_user(rfile->user_pversion, (unsigned int __user *)arg))
942	return -EFAULT;
943	return 0;
944
945	case SNDRV_RAWMIDI_IOCTL_PARAMS:
946	{
947	struct snd_rawmidi_params params;
948
949	if (copy_from_user(to: &params, from: argp, n: sizeof(struct snd_rawmidi_params)))
950	return -EFAULT;
951	if (rfile->user_pversion < SNDRV_PROTOCOL_VERSION(2, 0, 2)) {
952	params.mode = 0;
953	memset(params.reserved, 0, sizeof(params.reserved));
954	}
955	switch (params.stream) {
956	case SNDRV_RAWMIDI_STREAM_OUTPUT:
957	if (rfile->output == NULL)
958	return -EINVAL;
959	return snd_rawmidi_output_params(rfile->output, &params);
960	case SNDRV_RAWMIDI_STREAM_INPUT:
961	if (rfile->input == NULL)
962	return -EINVAL;
963	return snd_rawmidi_input_params(rfile->input, &params);
964	default:
965	return -EINVAL;
966	}
967	}
968	case SNDRV_RAWMIDI_IOCTL_STATUS32:
969	return snd_rawmidi_ioctl_status32(rfile, argp);
970	case SNDRV_RAWMIDI_IOCTL_STATUS64:
971	return snd_rawmidi_ioctl_status64(rfile, argp);
972	case SNDRV_RAWMIDI_IOCTL_DROP:
973	{
974	int val;
975
976	if (get_user(val, (int __user *) argp))
977	return -EFAULT;
978	switch (val) {
979	case SNDRV_RAWMIDI_STREAM_OUTPUT:
980	if (rfile->output == NULL)
981	return -EINVAL;
982	return snd_rawmidi_drop_output(rfile->output);
983	default:
984	return -EINVAL;
985	}
986	}
987	case SNDRV_RAWMIDI_IOCTL_DRAIN:
988	{
989	int val;
990
991	if (get_user(val, (int __user *) argp))
992	return -EFAULT;
993	switch (val) {
994	case SNDRV_RAWMIDI_STREAM_OUTPUT:
995	if (rfile->output == NULL)
996	return -EINVAL;
997	return snd_rawmidi_drain_output(rfile->output);
998	case SNDRV_RAWMIDI_STREAM_INPUT:
999	if (rfile->input == NULL)
1000	return -EINVAL;
1001	return snd_rawmidi_drain_input(rfile->input);
1002	default:
1003	return -EINVAL;
1004	}
1005	}
1006	default:
1007	rmidi = rfile->rmidi;
1008	if (rmidi->ops && rmidi->ops->ioctl)
1009	return rmidi->ops->ioctl(rmidi, cmd, argp);
1010	rmidi_dbg(rmidi, "rawmidi: unknown command = 0x%x\n", cmd);
1011	}
1012	return -ENOTTY;
1013	}
1014
1015	/* ioctl to find the next device; either legacy or UMP depending on @find_ump */
1016	static int snd_rawmidi_next_device(struct snd_card *card, int __user *argp,
1017	bool find_ump)
1018
1019	{
1020	struct snd_rawmidi *rmidi;
1021	int device;
1022	bool is_ump;
1023
1024	if (get_user(device, argp))
1025	return -EFAULT;
1026	if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */
1027	device = SNDRV_RAWMIDI_DEVICES - 1;
1028	mutex_lock(&register_mutex);
1029	device = device < 0 ? 0 : device + 1;
1030	for (; device < SNDRV_RAWMIDI_DEVICES; device++) {
1031	rmidi = snd_rawmidi_search(card, device);
1032	if (!rmidi)
1033	continue;
1034	is_ump = rawmidi_is_ump(rmidi);
1035	if (find_ump == is_ump)
1036	break;
1037	}
1038	if (device == SNDRV_RAWMIDI_DEVICES)
1039	device = -1;
1040	mutex_unlock(lock: &register_mutex);
1041	if (put_user(device, argp))
1042	return -EFAULT;
1043	return 0;
1044	}
1045
1046	#if IS_ENABLED(CONFIG_SND_UMP)
1047	/* inquiry of UMP endpoint and block info via control API */
1048	static int snd_rawmidi_call_ump_ioctl(struct snd_card *card, int cmd,
1049	void __user *argp)
1050	{
1051	struct snd_ump_endpoint_info __user *info = argp;
1052	struct snd_rawmidi *rmidi;
1053	int device, ret;
1054
1055	if (get_user(device, &info->device))
1056	return -EFAULT;
1057	mutex_lock(&register_mutex);
1058	rmidi = snd_rawmidi_search(card, device);
1059	if (rmidi && rmidi->ops && rmidi->ops->ioctl)
1060	ret = rmidi->ops->ioctl(rmidi, cmd, argp);
1061	else
1062	ret = -ENXIO;
1063	mutex_unlock(lock: &register_mutex);
1064	return ret;
1065	}
1066	#endif
1067
1068	static int snd_rawmidi_control_ioctl(struct snd_card *card,
1069	struct snd_ctl_file *control,
1070	unsigned int cmd,
1071	unsigned long arg)
1072	{
1073	void __user *argp = (void __user *)arg;
1074
1075	switch (cmd) {
1076	case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
1077	return snd_rawmidi_next_device(card, argp, find_ump: false);
1078	#if IS_ENABLED(CONFIG_SND_UMP)
1079	case SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE:
1080	return snd_rawmidi_next_device(card, argp, find_ump: true);
1081	case SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO:
1082	return snd_rawmidi_call_ump_ioctl(card, SNDRV_UMP_IOCTL_ENDPOINT_INFO, argp);
1083	case SNDRV_CTL_IOCTL_UMP_BLOCK_INFO:
1084	return snd_rawmidi_call_ump_ioctl(card, SNDRV_UMP_IOCTL_BLOCK_INFO, argp);
1085	#endif
1086	case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
1087	{
1088	int val;
1089
1090	if (get_user(val, (int __user *)argp))
1091	return -EFAULT;
1092	control->preferred_subdevice[SND_CTL_SUBDEV_RAWMIDI] = val;
1093	return 0;
1094	}
1095	case SNDRV_CTL_IOCTL_RAWMIDI_INFO:
1096	return snd_rawmidi_info_select_user(card, info: argp);
1097	}
1098	return -ENOIOCTLCMD;
1099	}
1100
1101	static int receive_with_tstamp_framing(struct snd_rawmidi_substream *substream,
1102	const unsigned char *buffer, int src_count, const struct timespec64 *tstamp)
1103	{
1104	struct snd_rawmidi_runtime *runtime = substream->runtime;
1105	struct snd_rawmidi_framing_tstamp *dest_ptr;
1106	struct snd_rawmidi_framing_tstamp frame = { .tv_sec = tstamp->tv_sec, .tv_nsec = tstamp->tv_nsec };
1107	int orig_count = src_count;
1108	int frame_size = sizeof(struct snd_rawmidi_framing_tstamp);
1109	int align = get_align(runtime);
1110
1111	BUILD_BUG_ON(frame_size != 0x20);
1112	if (snd_BUG_ON((runtime->hw_ptr & 0x1f) != 0))
1113	return -EINVAL;
1114
1115	while (src_count > align) {
1116	if ((int)(runtime->buffer_size - runtime->avail) < frame_size) {
1117	runtime->xruns += src_count;
1118	break;
1119	}
1120	if (src_count >= SNDRV_RAWMIDI_FRAMING_DATA_LENGTH)
1121	frame.length = SNDRV_RAWMIDI_FRAMING_DATA_LENGTH;
1122	else {
1123	frame.length = get_aligned_size(runtime, src_count);
1124	if (!frame.length)
1125	break;
1126	memset(frame.data, 0, SNDRV_RAWMIDI_FRAMING_DATA_LENGTH);
1127	}
1128	memcpy(frame.data, buffer, frame.length);
1129	buffer += frame.length;
1130	src_count -= frame.length;
1131	dest_ptr = (struct snd_rawmidi_framing_tstamp *) (runtime->buffer + runtime->hw_ptr);
1132	*dest_ptr = frame;
1133	runtime->avail += frame_size;
1134	runtime->hw_ptr += frame_size;
1135	runtime->hw_ptr %= runtime->buffer_size;
1136	}
1137	return orig_count - src_count;
1138	}
1139
1140	static struct timespec64 get_framing_tstamp(struct snd_rawmidi_substream *substream)
1141	{
1142	struct timespec64 ts64 = {0, 0};
1143
1144	switch (substream->clock_type) {
1145	case SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW:
1146	ktime_get_raw_ts64(ts: &ts64);
1147	break;
1148	case SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC:
1149	ktime_get_ts64(ts: &ts64);
1150	break;
1151	case SNDRV_RAWMIDI_MODE_CLOCK_REALTIME:
1152	ktime_get_real_ts64(tv: &ts64);
1153	break;
1154	}
1155	return ts64;
1156	}
1157
1158	/**
1159	* snd_rawmidi_receive - receive the input data from the device
1160	* @substream: the rawmidi substream
1161	* @buffer: the buffer pointer
1162	* @count: the data size to read
1163	*
1164	* Reads the data from the internal buffer.
1165	*
1166	* Return: The size of read data, or a negative error code on failure.
1167	*/
1168	int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
1169	const unsigned char *buffer, int count)
1170	{
1171	unsigned long flags;
1172	struct timespec64 ts64 = get_framing_tstamp(substream);
1173	int result = 0, count1;
1174	struct snd_rawmidi_runtime *runtime;
1175
1176	spin_lock_irqsave(&substream->lock, flags);
1177	if (!substream->opened) {
1178	result = -EBADFD;
1179	goto unlock;
1180	}
1181	runtime = substream->runtime;
1182	if (!runtime || !runtime->buffer) {
1183	rmidi_dbg(substream->rmidi,
1184	"snd_rawmidi_receive: input is not active!!!\n");
1185	result = -EINVAL;
1186	goto unlock;
1187	}
1188
1189	count = get_aligned_size(runtime, count);
1190	if (!count)
1191	goto unlock;
1192
1193	if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) {
1194	result = receive_with_tstamp_framing(substream, buffer, src_count: count, tstamp: &ts64);
1195	} else if (count == 1) { /* special case, faster code */
1196	substream->bytes++;
1197	if (runtime->avail < runtime->buffer_size) {
1198	runtime->buffer[runtime->hw_ptr++] = buffer[0];
1199	runtime->hw_ptr %= runtime->buffer_size;
1200	runtime->avail++;
1201	result++;
1202	} else {
1203	runtime->xruns++;
1204	}
1205	} else {
1206	substream->bytes += count;
1207	count1 = runtime->buffer_size - runtime->hw_ptr;
1208	if (count1 > count)
1209	count1 = count;
1210	if (count1 > (int)(runtime->buffer_size - runtime->avail))
1211	count1 = runtime->buffer_size - runtime->avail;
1212	count1 = get_aligned_size(runtime, count1);
1213	if (!count1)
1214	goto unlock;
1215	memcpy(runtime->buffer + runtime->hw_ptr, buffer, count1);
1216	runtime->hw_ptr += count1;
1217	runtime->hw_ptr %= runtime->buffer_size;
1218	runtime->avail += count1;
1219	count -= count1;
1220	result += count1;
1221	if (count > 0) {
1222	buffer += count1;
1223	count1 = count;
1224	if (count1 > (int)(runtime->buffer_size - runtime->avail)) {
1225	count1 = runtime->buffer_size - runtime->avail;
1226	runtime->xruns += count - count1;
1227	}
1228	if (count1 > 0) {
1229	memcpy(runtime->buffer, buffer, count1);
1230	runtime->hw_ptr = count1;
1231	runtime->avail += count1;
1232	result += count1;
1233	}
1234	}
1235	}
1236	if (result > 0) {
1237	if (runtime->event)
1238	schedule_work(work: &runtime->event_work);
1239	else if (__snd_rawmidi_ready(runtime))
1240	wake_up(&runtime->sleep);
1241	}
1242	unlock:
1243	spin_unlock_irqrestore(lock: &substream->lock, flags);
1244	return result;
1245	}
1246	EXPORT_SYMBOL(snd_rawmidi_receive);
1247
1248	static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream,
1249	unsigned char __user *userbuf,
1250	unsigned char *kernelbuf, long count)
1251	{
1252	unsigned long flags;
1253	long result = 0, count1;
1254	struct snd_rawmidi_runtime *runtime = substream->runtime;
1255	unsigned long appl_ptr;
1256	int err = 0;
1257
1258	spin_lock_irqsave(&substream->lock, flags);
1259	snd_rawmidi_buffer_ref(runtime);
1260	while (count > 0 && runtime->avail) {
1261	count1 = runtime->buffer_size - runtime->appl_ptr;
1262	if (count1 > count)
1263	count1 = count;
1264	if (count1 > (int)runtime->avail)
1265	count1 = runtime->avail;
1266
1267	/* update runtime->appl_ptr before unlocking for userbuf */
1268	appl_ptr = runtime->appl_ptr;
1269	runtime->appl_ptr += count1;
1270	runtime->appl_ptr %= runtime->buffer_size;
1271	runtime->avail -= count1;
1272
1273	if (kernelbuf)
1274	memcpy(kernelbuf + result, runtime->buffer + appl_ptr, count1);
1275	if (userbuf) {
1276	spin_unlock_irqrestore(lock: &substream->lock, flags);
1277	if (copy_to_user(to: userbuf + result,
1278	from: runtime->buffer + appl_ptr, n: count1))
1279	err = -EFAULT;
1280	spin_lock_irqsave(&substream->lock, flags);
1281	if (err)
1282	goto out;
1283	}
1284	result += count1;
1285	count -= count1;
1286	}
1287	out:
1288	snd_rawmidi_buffer_unref(runtime);
1289	spin_unlock_irqrestore(lock: &substream->lock, flags);
1290	return result > 0 ? result : err;
1291	}
1292
1293	long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream,
1294	unsigned char *buf, long count)
1295	{
1296	snd_rawmidi_input_trigger(substream, up: 1);
1297	return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, kernelbuf: buf, count);
1298	}
1299	EXPORT_SYMBOL(snd_rawmidi_kernel_read);
1300
1301	static ssize_t snd_rawmidi_read(struct file *file, char __user *buf, size_t count,
1302	loff_t *offset)
1303	{
1304	long result;
1305	int count1;
1306	struct snd_rawmidi_file *rfile;
1307	struct snd_rawmidi_substream *substream;
1308	struct snd_rawmidi_runtime *runtime;
1309
1310	rfile = file->private_data;
1311	substream = rfile->input;
1312	if (substream == NULL)
1313	return -EIO;
1314	runtime = substream->runtime;
1315	snd_rawmidi_input_trigger(substream, up: 1);
1316	result = 0;
1317	while (count > 0) {
1318	spin_lock_irq(lock: &substream->lock);
1319	while (!__snd_rawmidi_ready(runtime)) {
1320	wait_queue_entry_t wait;
1321
1322	if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1323	spin_unlock_irq(lock: &substream->lock);
1324	return result > 0 ? result : -EAGAIN;
1325	}
1326	init_waitqueue_entry(wq_entry: &wait, current);
1327	add_wait_queue(wq_head: &runtime->sleep, wq_entry: &wait);
1328	set_current_state(TASK_INTERRUPTIBLE);
1329	spin_unlock_irq(lock: &substream->lock);
1330	schedule();
1331	remove_wait_queue(wq_head: &runtime->sleep, wq_entry: &wait);
1332	if (rfile->rmidi->card->shutdown)
1333	return -ENODEV;
1334	if (signal_pending(current))
1335	return result > 0 ? result : -ERESTARTSYS;
1336	spin_lock_irq(lock: &substream->lock);
1337	if (!runtime->avail) {
1338	spin_unlock_irq(lock: &substream->lock);
1339	return result > 0 ? result : -EIO;
1340	}
1341	}
1342	spin_unlock_irq(lock: &substream->lock);
1343	count1 = snd_rawmidi_kernel_read1(substream,
1344	userbuf: (unsigned char __user *)buf,
1345	NULL/*kernelbuf*/,
1346	count);
1347	if (count1 < 0)
1348	return result > 0 ? result : count1;
1349	result += count1;
1350	buf += count1;
1351	count -= count1;
1352	}
1353	return result;
1354	}
1355
1356	/**
1357	* snd_rawmidi_transmit_empty - check whether the output buffer is empty
1358	* @substream: the rawmidi substream
1359	*
1360	* Return: 1 if the internal output buffer is empty, 0 if not.
1361	*/
1362	int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)
1363	{
1364	struct snd_rawmidi_runtime *runtime;
1365	int result;
1366	unsigned long flags;
1367
1368	spin_lock_irqsave(&substream->lock, flags);
1369	runtime = substream->runtime;
1370	if (!substream->opened || !runtime || !runtime->buffer) {
1371	rmidi_dbg(substream->rmidi,
1372	"snd_rawmidi_transmit_empty: output is not active!!!\n");
1373	result = 1;
1374	} else {
1375	result = runtime->avail >= runtime->buffer_size;
1376	}
1377	spin_unlock_irqrestore(lock: &substream->lock, flags);
1378	return result;
1379	}
1380	EXPORT_SYMBOL(snd_rawmidi_transmit_empty);
1381
1382	/*
1383	* __snd_rawmidi_transmit_peek - copy data from the internal buffer
1384	* @substream: the rawmidi substream
1385	* @buffer: the buffer pointer
1386	* @count: data size to transfer
1387	*
1388	* This is a variant of snd_rawmidi_transmit_peek() without spinlock.
1389	*/
1390	static int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
1391	unsigned char *buffer, int count)
1392	{
1393	int result, count1;
1394	struct snd_rawmidi_runtime *runtime = substream->runtime;
1395
1396	if (runtime->buffer == NULL) {
1397	rmidi_dbg(substream->rmidi,
1398	"snd_rawmidi_transmit_peek: output is not active!!!\n");
1399	return -EINVAL;
1400	}
1401	result = 0;
1402	if (runtime->avail >= runtime->buffer_size) {
1403	/* warning: lowlevel layer MUST trigger down the hardware */
1404	goto __skip;
1405	}
1406	if (count == 1) { /* special case, faster code */
1407	*buffer = runtime->buffer[runtime->hw_ptr];
1408	result++;
1409	} else {
1410	count1 = runtime->buffer_size - runtime->hw_ptr;
1411	if (count1 > count)
1412	count1 = count;
1413	if (count1 > (int)(runtime->buffer_size - runtime->avail))
1414	count1 = runtime->buffer_size - runtime->avail;
1415	count1 = get_aligned_size(runtime, count1);
1416	if (!count1)
1417	goto __skip;
1418	memcpy(buffer, runtime->buffer + runtime->hw_ptr, count1);
1419	count -= count1;
1420	result += count1;
1421	if (count > 0) {
1422	if (count > (int)(runtime->buffer_size - runtime->avail - count1))
1423	count = runtime->buffer_size - runtime->avail - count1;
1424	count = get_aligned_size(runtime, count);
1425	if (!count)
1426	goto __skip;
1427	memcpy(buffer + count1, runtime->buffer, count);
1428	result += count;
1429	}
1430	}
1431	__skip:
1432	return result;
1433	}
1434
1435	/**
1436	* snd_rawmidi_transmit_peek - copy data from the internal buffer
1437	* @substream: the rawmidi substream
1438	* @buffer: the buffer pointer
1439	* @count: data size to transfer
1440	*
1441	* Copies data from the internal output buffer to the given buffer.
1442	*
1443	* Call this in the interrupt handler when the midi output is ready,
1444	* and call snd_rawmidi_transmit_ack() after the transmission is
1445	* finished.
1446	*
1447	* Return: The size of copied data, or a negative error code on failure.
1448	*/
1449	int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
1450	unsigned char *buffer, int count)
1451	{
1452	int result;
1453	unsigned long flags;
1454
1455	spin_lock_irqsave(&substream->lock, flags);
1456	if (!substream->opened || !substream->runtime)
1457	result = -EBADFD;
1458	else
1459	result = __snd_rawmidi_transmit_peek(substream, buffer, count);
1460	spin_unlock_irqrestore(lock: &substream->lock, flags);
1461	return result;
1462	}
1463	EXPORT_SYMBOL(snd_rawmidi_transmit_peek);
1464
1465	/*
1466	* __snd_rawmidi_transmit_ack - acknowledge the transmission
1467	* @substream: the rawmidi substream
1468	* @count: the transferred count
1469	*
1470	* This is a variant of __snd_rawmidi_transmit_ack() without spinlock.
1471	*/
1472	static int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream,
1473	int count)
1474	{
1475	struct snd_rawmidi_runtime *runtime = substream->runtime;
1476
1477	if (runtime->buffer == NULL) {
1478	rmidi_dbg(substream->rmidi,
1479	"snd_rawmidi_transmit_ack: output is not active!!!\n");
1480	return -EINVAL;
1481	}
1482	snd_BUG_ON(runtime->avail + count > runtime->buffer_size);
1483	count = get_aligned_size(runtime, count);
1484	runtime->hw_ptr += count;
1485	runtime->hw_ptr %= runtime->buffer_size;
1486	runtime->avail += count;
1487	substream->bytes += count;
1488	if (count > 0) {
1489	if (runtime->drain || __snd_rawmidi_ready(runtime))
1490	wake_up(&runtime->sleep);
1491	}
1492	return count;
1493	}
1494
1495	/**
1496	* snd_rawmidi_transmit_ack - acknowledge the transmission
1497	* @substream: the rawmidi substream
1498	* @count: the transferred count
1499	*
1500	* Advances the hardware pointer for the internal output buffer with
1501	* the given size and updates the condition.
1502	* Call after the transmission is finished.
1503	*
1504	* Return: The advanced size if successful, or a negative error code on failure.
1505	*/
1506	int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
1507	{
1508	int result;
1509	unsigned long flags;
1510
1511	spin_lock_irqsave(&substream->lock, flags);
1512	if (!substream->opened || !substream->runtime)
1513	result = -EBADFD;
1514	else
1515	result = __snd_rawmidi_transmit_ack(substream, count);
1516	spin_unlock_irqrestore(lock: &substream->lock, flags);
1517	return result;
1518	}
1519	EXPORT_SYMBOL(snd_rawmidi_transmit_ack);
1520
1521	/**
1522	* snd_rawmidi_transmit - copy from the buffer to the device
1523	* @substream: the rawmidi substream
1524	* @buffer: the buffer pointer
1525	* @count: the data size to transfer
1526	*
1527	* Copies data from the buffer to the device and advances the pointer.
1528	*
1529	* Return: The copied size if successful, or a negative error code on failure.
1530	*/
1531	int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
1532	unsigned char *buffer, int count)
1533	{
1534	int result;
1535	unsigned long flags;
1536
1537	spin_lock_irqsave(&substream->lock, flags);
1538	if (!substream->opened)
1539	result = -EBADFD;
1540	else {
1541	count = __snd_rawmidi_transmit_peek(substream, buffer, count);
1542	if (count <= 0)
1543	result = count;
1544	else
1545	result = __snd_rawmidi_transmit_ack(substream, count);
1546	}
1547	spin_unlock_irqrestore(lock: &substream->lock, flags);
1548	return result;
1549	}
1550	EXPORT_SYMBOL(snd_rawmidi_transmit);
1551
1552	/**
1553	* snd_rawmidi_proceed - Discard the all pending bytes and proceed
1554	* @substream: rawmidi substream
1555	*
1556	* Return: the number of discarded bytes
1557	*/
1558	int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream)
1559	{
1560	struct snd_rawmidi_runtime *runtime;
1561	unsigned long flags;
1562	int count = 0;
1563
1564	spin_lock_irqsave(&substream->lock, flags);
1565	runtime = substream->runtime;
1566	if (substream->opened && runtime &&
1567	runtime->avail < runtime->buffer_size) {
1568	count = runtime->buffer_size - runtime->avail;
1569	__snd_rawmidi_transmit_ack(substream, count);
1570	}
1571	spin_unlock_irqrestore(lock: &substream->lock, flags);
1572	return count;
1573	}
1574	EXPORT_SYMBOL(snd_rawmidi_proceed);
1575
1576	static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
1577	const unsigned char __user *userbuf,
1578	const unsigned char *kernelbuf,
1579	long count)
1580	{
1581	unsigned long flags;
1582	long count1, result;
1583	struct snd_rawmidi_runtime *runtime = substream->runtime;
1584	unsigned long appl_ptr;
1585
1586	if (!kernelbuf && !userbuf)
1587	return -EINVAL;
1588	if (snd_BUG_ON(!runtime->buffer))
1589	return -EINVAL;
1590
1591	result = 0;
1592	spin_lock_irqsave(&substream->lock, flags);
1593	if (substream->append) {
1594	if ((long)runtime->avail < count) {
1595	spin_unlock_irqrestore(lock: &substream->lock, flags);
1596	return -EAGAIN;
1597	}
1598	}
1599	snd_rawmidi_buffer_ref(runtime);
1600	while (count > 0 && runtime->avail > 0) {
1601	count1 = runtime->buffer_size - runtime->appl_ptr;
1602	if (count1 > count)
1603	count1 = count;
1604	if (count1 > (long)runtime->avail)
1605	count1 = runtime->avail;
1606
1607	/* update runtime->appl_ptr before unlocking for userbuf */
1608	appl_ptr = runtime->appl_ptr;
1609	runtime->appl_ptr += count1;
1610	runtime->appl_ptr %= runtime->buffer_size;
1611	runtime->avail -= count1;
1612
1613	if (kernelbuf)
1614	memcpy(runtime->buffer + appl_ptr,
1615	kernelbuf + result, count1);
1616	else if (userbuf) {
1617	spin_unlock_irqrestore(lock: &substream->lock, flags);
1618	if (copy_from_user(to: runtime->buffer + appl_ptr,
1619	from: userbuf + result, n: count1)) {
1620	spin_lock_irqsave(&substream->lock, flags);
1621	result = result > 0 ? result : -EFAULT;
1622	goto __end;
1623	}
1624	spin_lock_irqsave(&substream->lock, flags);
1625	}
1626	result += count1;
1627	count -= count1;
1628	}
1629	__end:
1630	count1 = runtime->avail < runtime->buffer_size;
1631	snd_rawmidi_buffer_unref(runtime);
1632	spin_unlock_irqrestore(lock: &substream->lock, flags);
1633	if (count1)
1634	snd_rawmidi_output_trigger(substream, up: 1);
1635	return result;
1636	}
1637
1638	long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream,
1639	const unsigned char *buf, long count)
1640	{
1641	return snd_rawmidi_kernel_write1(substream, NULL, kernelbuf: buf, count);
1642	}
1643	EXPORT_SYMBOL(snd_rawmidi_kernel_write);
1644
1645	static ssize_t snd_rawmidi_write(struct file *file, const char __user *buf,
1646	size_t count, loff_t *offset)
1647	{
1648	long result, timeout;
1649	int count1;
1650	struct snd_rawmidi_file *rfile;
1651	struct snd_rawmidi_runtime *runtime;
1652	struct snd_rawmidi_substream *substream;
1653
1654	rfile = file->private_data;
1655	substream = rfile->output;
1656	runtime = substream->runtime;
1657	/* we cannot put an atomic message to our buffer */
1658	if (substream->append && count > runtime->buffer_size)
1659	return -EIO;
1660	result = 0;
1661	while (count > 0) {
1662	spin_lock_irq(lock: &substream->lock);
1663	while (!snd_rawmidi_ready_append(substream, count)) {
1664	wait_queue_entry_t wait;
1665
1666	if (file->f_flags & O_NONBLOCK) {
1667	spin_unlock_irq(lock: &substream->lock);
1668	return result > 0 ? result : -EAGAIN;
1669	}
1670	init_waitqueue_entry(wq_entry: &wait, current);
1671	add_wait_queue(wq_head: &runtime->sleep, wq_entry: &wait);
1672	set_current_state(TASK_INTERRUPTIBLE);
1673	spin_unlock_irq(lock: &substream->lock);
1674	timeout = schedule_timeout(timeout: 30 * HZ);
1675	remove_wait_queue(wq_head: &runtime->sleep, wq_entry: &wait);
1676	if (rfile->rmidi->card->shutdown)
1677	return -ENODEV;
1678	if (signal_pending(current))
1679	return result > 0 ? result : -ERESTARTSYS;
1680	spin_lock_irq(lock: &substream->lock);
1681	if (!runtime->avail && !timeout) {
1682	spin_unlock_irq(lock: &substream->lock);
1683	return result > 0 ? result : -EIO;
1684	}
1685	}
1686	spin_unlock_irq(lock: &substream->lock);
1687	count1 = snd_rawmidi_kernel_write1(substream, userbuf: buf, NULL, count);
1688	if (count1 < 0)
1689	return result > 0 ? result : count1;
1690	result += count1;
1691	buf += count1;
1692	if ((size_t)count1 < count && (file->f_flags & O_NONBLOCK))
1693	break;
1694	count -= count1;
1695	}
1696	if (file->f_flags & O_DSYNC) {
1697	spin_lock_irq(lock: &substream->lock);
1698	while (runtime->avail != runtime->buffer_size) {
1699	wait_queue_entry_t wait;
1700	unsigned int last_avail = runtime->avail;
1701
1702	init_waitqueue_entry(wq_entry: &wait, current);
1703	add_wait_queue(wq_head: &runtime->sleep, wq_entry: &wait);
1704	set_current_state(TASK_INTERRUPTIBLE);
1705	spin_unlock_irq(lock: &substream->lock);
1706	timeout = schedule_timeout(timeout: 30 * HZ);
1707	remove_wait_queue(wq_head: &runtime->sleep, wq_entry: &wait);
1708	if (signal_pending(current))
1709	return result > 0 ? result : -ERESTARTSYS;
1710	if (runtime->avail == last_avail && !timeout)
1711	return result > 0 ? result : -EIO;
1712	spin_lock_irq(lock: &substream->lock);
1713	}
1714	spin_unlock_irq(lock: &substream->lock);
1715	}
1716	return result;
1717	}
1718
1719	static __poll_t snd_rawmidi_poll(struct file *file, poll_table *wait)
1720	{
1721	struct snd_rawmidi_file *rfile;
1722	struct snd_rawmidi_runtime *runtime;
1723	__poll_t mask;
1724
1725	rfile = file->private_data;
1726	if (rfile->input != NULL) {
1727	runtime = rfile->input->runtime;
1728	snd_rawmidi_input_trigger(substream: rfile->input, up: 1);
1729	poll_wait(filp: file, wait_address: &runtime->sleep, p: wait);
1730	}
1731	if (rfile->output != NULL) {
1732	runtime = rfile->output->runtime;
1733	poll_wait(filp: file, wait_address: &runtime->sleep, p: wait);
1734	}
1735	mask = 0;
1736	if (rfile->input != NULL) {
1737	if (snd_rawmidi_ready(substream: rfile->input))
1738	mask |= EPOLLIN | EPOLLRDNORM;
1739	}
1740	if (rfile->output != NULL) {
1741	if (snd_rawmidi_ready(substream: rfile->output))
1742	mask |= EPOLLOUT | EPOLLWRNORM;
1743	}
1744	return mask;
1745	}
1746
1747	/*
1748	*/
1749	#ifdef CONFIG_COMPAT
1750	#include "rawmidi_compat.c"
1751	#else
1752	#define snd_rawmidi_ioctl_compat NULL
1753	#endif
1754
1755	/*
1756	*/
1757
1758	static void snd_rawmidi_proc_info_read(struct snd_info_entry *entry,
1759	struct snd_info_buffer *buffer)
1760	{
1761	struct snd_rawmidi *rmidi;
1762	struct snd_rawmidi_substream *substream;
1763	struct snd_rawmidi_runtime *runtime;
1764	unsigned long buffer_size, avail, xruns;
1765	unsigned int clock_type;
1766	static const char *clock_names[4] = { "none", "realtime", "monotonic", "monotonic raw" };
1767
1768	rmidi = entry->private_data;
1769	snd_iprintf(buffer, "%s\n\n", rmidi->name);
1770	if (IS_ENABLED(CONFIG_SND_UMP))
1771	snd_iprintf(buffer, "Type: %s\n",
1772	rawmidi_is_ump(rmidi) ? "UMP" : "Legacy");
1773	if (rmidi->ops && rmidi->ops->proc_read)
1774	rmidi->ops->proc_read(entry, buffer);
1775	mutex_lock(&rmidi->open_mutex);
1776	if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) {
1777	list_for_each_entry(substream,
1778	&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams,
1779	list) {
1780	snd_iprintf(buffer,
1781	"Output %d\n"
1782	" Tx bytes : %lu\n",
1783	substream->number,
1784	(unsigned long) substream->bytes);
1785	if (substream->opened) {
1786	snd_iprintf(buffer,
1787	" Owner PID : %d\n",
1788	pid_vnr(substream->pid));
1789	runtime = substream->runtime;
1790	spin_lock_irq(lock: &substream->lock);
1791	buffer_size = runtime->buffer_size;
1792	avail = runtime->avail;
1793	spin_unlock_irq(lock: &substream->lock);
1794	snd_iprintf(buffer,
1795	" Mode : %s\n"
1796	" Buffer size : %lu\n"
1797	" Avail : %lu\n",
1798	runtime->oss ? "OSS compatible" : "native",
1799	buffer_size, avail);
1800	}
1801	}
1802	}
1803	if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_INPUT) {
1804	list_for_each_entry(substream,
1805	&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams,
1806	list) {
1807	snd_iprintf(buffer,
1808	"Input %d\n"
1809	" Rx bytes : %lu\n",
1810	substream->number,
1811	(unsigned long) substream->bytes);
1812	if (substream->opened) {
1813	snd_iprintf(buffer,
1814	" Owner PID : %d\n",
1815	pid_vnr(substream->pid));
1816	runtime = substream->runtime;
1817	spin_lock_irq(lock: &substream->lock);
1818	buffer_size = runtime->buffer_size;
1819	avail = runtime->avail;
1820	xruns = runtime->xruns;
1821	spin_unlock_irq(lock: &substream->lock);
1822	snd_iprintf(buffer,
1823	" Buffer size : %lu\n"
1824	" Avail : %lu\n"
1825	" Overruns : %lu\n",
1826	buffer_size, avail, xruns);
1827	if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) {
1828	clock_type = substream->clock_type >> SNDRV_RAWMIDI_MODE_CLOCK_SHIFT;
1829	if (!snd_BUG_ON(clock_type >= ARRAY_SIZE(clock_names)))
1830	snd_iprintf(buffer,
1831	" Framing : tstamp\n"
1832	" Clock type : %s\n",
1833	clock_names[clock_type]);
1834	}
1835	}
1836	}
1837	}
1838	mutex_unlock(lock: &rmidi->open_mutex);
1839	}
1840
1841	/*
1842	* Register functions
1843	*/
1844
1845	static const struct file_operations snd_rawmidi_f_ops = {
1846	.owner = THIS_MODULE,
1847	.read = snd_rawmidi_read,
1848	.write = snd_rawmidi_write,
1849	.open = snd_rawmidi_open,
1850	.release = snd_rawmidi_release,
1851	.llseek = no_llseek,
1852	.poll = snd_rawmidi_poll,
1853	.unlocked_ioctl = snd_rawmidi_ioctl,
1854	.compat_ioctl = snd_rawmidi_ioctl_compat,
1855	};
1856
1857	static int snd_rawmidi_alloc_substreams(struct snd_rawmidi *rmidi,
1858	struct snd_rawmidi_str *stream,
1859	int direction,
1860	int count)
1861	{
1862	struct snd_rawmidi_substream *substream;
1863	int idx;
1864
1865	for (idx = 0; idx < count; idx++) {
1866	substream = kzalloc(size: sizeof(*substream), GFP_KERNEL);
1867	if (!substream)
1868	return -ENOMEM;
1869	substream->stream = direction;
1870	substream->number = idx;
1871	substream->rmidi = rmidi;
1872	substream->pstr = stream;
1873	spin_lock_init(&substream->lock);
1874	list_add_tail(new: &substream->list, head: &stream->substreams);
1875	stream->substream_count++;
1876	}
1877	return 0;
1878	}
1879
1880	/* used for both rawmidi and ump */
1881	int snd_rawmidi_init(struct snd_rawmidi *rmidi,
1882	struct snd_card *card, char *id, int device,
1883	int output_count, int input_count,
1884	unsigned int info_flags)
1885	{
1886	int err;
1887	static const struct snd_device_ops ops = {
1888	.dev_free = snd_rawmidi_dev_free,
1889	.dev_register = snd_rawmidi_dev_register,
1890	.dev_disconnect = snd_rawmidi_dev_disconnect,
1891	};
1892
1893	rmidi->card = card;
1894	rmidi->device = device;
1895	mutex_init(&rmidi->open_mutex);
1896	init_waitqueue_head(&rmidi->open_wait);
1897	INIT_LIST_HEAD(list: &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams);
1898	INIT_LIST_HEAD(list: &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams);
1899	rmidi->info_flags = info_flags;
1900
1901	if (id != NULL)
1902	strscpy(p: rmidi->id, q: id, size: sizeof(rmidi->id));
1903
1904	err = snd_device_alloc(dev_p: &rmidi->dev, card);
1905	if (err < 0)
1906	return err;
1907	if (rawmidi_is_ump(rmidi))
1908	dev_set_name(dev: rmidi->dev, name: "umpC%iD%i", card->number, device);
1909	else
1910	dev_set_name(dev: rmidi->dev, name: "midiC%iD%i", card->number, device);
1911
1912	err = snd_rawmidi_alloc_substreams(rmidi,
1913	stream: &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT],
1914	direction: SNDRV_RAWMIDI_STREAM_INPUT,
1915	count: input_count);
1916	if (err < 0)
1917	return err;
1918	err = snd_rawmidi_alloc_substreams(rmidi,
1919	stream: &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT],
1920	direction: SNDRV_RAWMIDI_STREAM_OUTPUT,
1921	count: output_count);
1922	if (err < 0)
1923	return err;
1924	err = snd_device_new(card, type: SNDRV_DEV_RAWMIDI, device_data: rmidi, ops: &ops);
1925	if (err < 0)
1926	return err;
1927	return 0;
1928	}
1929	EXPORT_SYMBOL_GPL(snd_rawmidi_init);
1930
1931	/**
1932	* snd_rawmidi_new - create a rawmidi instance
1933	* @card: the card instance
1934	* @id: the id string
1935	* @device: the device index
1936	* @output_count: the number of output streams
1937	* @input_count: the number of input streams
1938	* @rrawmidi: the pointer to store the new rawmidi instance
1939	*
1940	* Creates a new rawmidi instance.
1941	* Use snd_rawmidi_set_ops() to set the operators to the new instance.
1942	*
1943	* Return: Zero if successful, or a negative error code on failure.
1944	*/
1945	int snd_rawmidi_new(struct snd_card *card, char *id, int device,
1946	int output_count, int input_count,
1947	struct snd_rawmidi **rrawmidi)
1948	{
1949	struct snd_rawmidi *rmidi;
1950	int err;
1951
1952	if (rrawmidi)
1953	*rrawmidi = NULL;
1954	rmidi = kzalloc(size: sizeof(*rmidi), GFP_KERNEL);
1955	if (!rmidi)
1956	return -ENOMEM;
1957	err = snd_rawmidi_init(rmidi, card, id, device,
1958	output_count, input_count, 0);
1959	if (err < 0) {
1960	snd_rawmidi_free(rmidi);
1961	return err;
1962	}
1963	if (rrawmidi)
1964	*rrawmidi = rmidi;
1965	return 0;
1966	}
1967	EXPORT_SYMBOL(snd_rawmidi_new);
1968
1969	static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream)
1970	{
1971	struct snd_rawmidi_substream *substream;
1972
1973	while (!list_empty(head: &stream->substreams)) {
1974	substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list);
1975	list_del(entry: &substream->list);
1976	kfree(objp: substream);
1977	}
1978	}
1979
1980	/* called from ump.c, too */
1981	int snd_rawmidi_free(struct snd_rawmidi *rmidi)
1982	{
1983	if (!rmidi)
1984	return 0;
1985
1986	snd_info_free_entry(entry: rmidi->proc_entry);
1987	rmidi->proc_entry = NULL;
1988	if (rmidi->ops && rmidi->ops->dev_unregister)
1989	rmidi->ops->dev_unregister(rmidi);
1990
1991	snd_rawmidi_free_substreams(stream: &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]);
1992	snd_rawmidi_free_substreams(stream: &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]);
1993	if (rmidi->private_free)
1994	rmidi->private_free(rmidi);
1995	put_device(dev: rmidi->dev);
1996	kfree(objp: rmidi);
1997	return 0;
1998	}
1999	EXPORT_SYMBOL_GPL(snd_rawmidi_free);
2000
2001	static int snd_rawmidi_dev_free(struct snd_device *device)
2002	{
2003	struct snd_rawmidi *rmidi = device->device_data;
2004
2005	return snd_rawmidi_free(rmidi);
2006	}
2007
2008	#if IS_ENABLED(CONFIG_SND_SEQUENCER)
2009	static void snd_rawmidi_dev_seq_free(struct snd_seq_device *device)
2010	{
2011	struct snd_rawmidi *rmidi = device->private_data;
2012
2013	rmidi->seq_dev = NULL;
2014	}
2015	#endif
2016
2017	static int snd_rawmidi_dev_register(struct snd_device *device)
2018	{
2019	int err;
2020	struct snd_info_entry *entry;
2021	char name[16];
2022	struct snd_rawmidi *rmidi = device->device_data;
2023
2024	if (rmidi->device >= SNDRV_RAWMIDI_DEVICES)
2025	return -ENOMEM;
2026	err = 0;
2027	mutex_lock(&register_mutex);
2028	if (snd_rawmidi_search(card: rmidi->card, device: rmidi->device))
2029	err = -EBUSY;
2030	else
2031	list_add_tail(new: &rmidi->list, head: &snd_rawmidi_devices);
2032	mutex_unlock(lock: &register_mutex);
2033	if (err < 0)
2034	return err;
2035
2036	err = snd_register_device(type: SNDRV_DEVICE_TYPE_RAWMIDI,
2037	card: rmidi->card, dev: rmidi->device,
2038	f_ops: &snd_rawmidi_f_ops, private_data: rmidi, device: rmidi->dev);
2039	if (err < 0) {
2040	rmidi_err(rmidi, "unable to register\n");
2041	goto error;
2042	}
2043	if (rmidi->ops && rmidi->ops->dev_register) {
2044	err = rmidi->ops->dev_register(rmidi);
2045	if (err < 0)
2046	goto error_unregister;
2047	}
2048	#ifdef CONFIG_SND_OSSEMUL
2049	rmidi->ossreg = 0;
2050	if (!rawmidi_is_ump(rmidi) &&
2051	(int)rmidi->device == midi_map[rmidi->card->number]) {
2052	if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI,
2053	card: rmidi->card, dev: 0, f_ops: &snd_rawmidi_f_ops,
2054	private_data: rmidi) < 0) {
2055	rmidi_err(rmidi,
2056	"unable to register OSS rawmidi device %i:%i\n",
2057	rmidi->card->number, 0);
2058	} else {
2059	rmidi->ossreg++;
2060	#ifdef SNDRV_OSS_INFO_DEV_MIDI
2061	snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI, num: rmidi->card->number, string: rmidi->name);
2062	#endif
2063	}
2064	}
2065	if (!rawmidi_is_ump(rmidi) &&
2066	(int)rmidi->device == amidi_map[rmidi->card->number]) {
2067	if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI,
2068	card: rmidi->card, dev: 1, f_ops: &snd_rawmidi_f_ops,
2069	private_data: rmidi) < 0) {
2070	rmidi_err(rmidi,
2071	"unable to register OSS rawmidi device %i:%i\n",
2072	rmidi->card->number, 1);
2073	} else {
2074	rmidi->ossreg++;
2075	}
2076	}
2077	#endif /* CONFIG_SND_OSSEMUL */
2078	sprintf(buf: name, fmt: "midi%d", rmidi->device);
2079	entry = snd_info_create_card_entry(card: rmidi->card, name, parent: rmidi->card->proc_root);
2080	if (entry) {
2081	entry->private_data = rmidi;
2082	entry->c.text.read = snd_rawmidi_proc_info_read;
2083	if (snd_info_register(entry) < 0) {
2084	snd_info_free_entry(entry);
2085	entry = NULL;
2086	}
2087	}
2088	rmidi->proc_entry = entry;
2089	#if IS_ENABLED(CONFIG_SND_SEQUENCER)
2090	/* no own registration mechanism? */
2091	if (!rmidi->ops || !rmidi->ops->dev_register) {
2092	if (snd_seq_device_new(card: rmidi->card, device: rmidi->device, SNDRV_SEQ_DEV_ID_MIDISYNTH, argsize: 0, result: &rmidi->seq_dev) >= 0) {
2093	rmidi->seq_dev->private_data = rmidi;
2094	rmidi->seq_dev->private_free = snd_rawmidi_dev_seq_free;
2095	sprintf(buf: rmidi->seq_dev->name, fmt: "MIDI %d-%d", rmidi->card->number, rmidi->device);
2096	snd_device_register(card: rmidi->card, device_data: rmidi->seq_dev);
2097	}
2098	}
2099	#endif
2100	return 0;
2101
2102	error_unregister:
2103	snd_unregister_device(dev: rmidi->dev);
2104	error:
2105	mutex_lock(&register_mutex);
2106	list_del(entry: &rmidi->list);
2107	mutex_unlock(lock: &register_mutex);
2108	return err;
2109	}
2110
2111	static int snd_rawmidi_dev_disconnect(struct snd_device *device)
2112	{
2113	struct snd_rawmidi *rmidi = device->device_data;
2114	int dir;
2115
2116	mutex_lock(&register_mutex);
2117	mutex_lock(&rmidi->open_mutex);
2118	wake_up(&rmidi->open_wait);
2119	list_del_init(entry: &rmidi->list);
2120	for (dir = 0; dir < 2; dir++) {
2121	struct snd_rawmidi_substream *s;
2122
2123	list_for_each_entry(s, &rmidi->streams[dir].substreams, list) {
2124	if (s->runtime)
2125	wake_up(&s->runtime->sleep);
2126	}
2127	}
2128
2129	#ifdef CONFIG_SND_OSSEMUL
2130	if (rmidi->ossreg) {
2131	if ((int)rmidi->device == midi_map[rmidi->card->number]) {
2132	snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, card: rmidi->card, dev: 0);
2133	#ifdef SNDRV_OSS_INFO_DEV_MIDI
2134	snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI, rmidi->card->number);
2135	#endif
2136	}
2137	if ((int)rmidi->device == amidi_map[rmidi->card->number])
2138	snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI, card: rmidi->card, dev: 1);
2139	rmidi->ossreg = 0;
2140	}
2141	#endif /* CONFIG_SND_OSSEMUL */
2142	snd_unregister_device(dev: rmidi->dev);
2143	mutex_unlock(lock: &rmidi->open_mutex);
2144	mutex_unlock(lock: &register_mutex);
2145	return 0;
2146	}
2147
2148	/**
2149	* snd_rawmidi_set_ops - set the rawmidi operators
2150	* @rmidi: the rawmidi instance
2151	* @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX
2152	* @ops: the operator table
2153	*
2154	* Sets the rawmidi operators for the given stream direction.
2155	*/
2156	void snd_rawmidi_set_ops(struct snd_rawmidi *rmidi, int stream,
2157	const struct snd_rawmidi_ops *ops)
2158	{
2159	struct snd_rawmidi_substream *substream;
2160
2161	list_for_each_entry(substream, &rmidi->streams[stream].substreams, list)
2162	substream->ops = ops;
2163	}
2164	EXPORT_SYMBOL(snd_rawmidi_set_ops);
2165
2166	/*
2167	* ENTRY functions
2168	*/
2169
2170	static int __init alsa_rawmidi_init(void)
2171	{
2172
2173	snd_ctl_register_ioctl(fcn: snd_rawmidi_control_ioctl);
2174	snd_ctl_register_ioctl_compat(fcn: snd_rawmidi_control_ioctl);
2175	#ifdef CONFIG_SND_OSSEMUL
2176	{ int i;
2177	/* check device map table */
2178	for (i = 0; i < SNDRV_CARDS; i++) {
2179	if (midi_map[i] < 0 || midi_map[i] >= SNDRV_RAWMIDI_DEVICES) {
2180	pr_err("ALSA: rawmidi: invalid midi_map[%d] = %d\n",
2181	i, midi_map[i]);
2182	midi_map[i] = 0;
2183	}
2184	if (amidi_map[i] < 0 || amidi_map[i] >= SNDRV_RAWMIDI_DEVICES) {
2185	pr_err("ALSA: rawmidi: invalid amidi_map[%d] = %d\n",
2186	i, amidi_map[i]);
2187	amidi_map[i] = 1;
2188	}
2189	}
2190	}
2191	#endif /* CONFIG_SND_OSSEMUL */
2192	return 0;
2193	}
2194
2195	static void __exit alsa_rawmidi_exit(void)
2196	{
2197	snd_ctl_unregister_ioctl(fcn: snd_rawmidi_control_ioctl);
2198	snd_ctl_unregister_ioctl_compat(fcn: snd_rawmidi_control_ioctl);
2199	}
2200
2201	module_init(alsa_rawmidi_init)
2202	module_exit(alsa_rawmidi_exit)
2203