Lines Matching refs:substream
106 static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
111 spin_lock_irqsave(&substream->lock, flags);
112 ready = __snd_rawmidi_ready(substream->runtime);
113 spin_unlock_irqrestore(&substream->lock, flags);
117 static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream *substream,
120 struct snd_rawmidi_runtime *runtime = substream->runtime;
123 (!substream->append || runtime->avail >= count);
132 runtime->event(runtime->substream);
135 /* buffer refcount management: call with substream->lock held */
146 static void snd_rawmidi_buffer_ref_sync(struct snd_rawmidi_substream *substream)
150 spin_lock_irq(&substream->lock);
151 while (substream->runtime->buffer_ref) {
152 spin_unlock_irq(&substream->lock);
154 rmidi_err(substream->rmidi, "Buffer ref sync timeout\n");
158 spin_lock_irq(&substream->lock);
160 spin_unlock_irq(&substream->lock);
163 static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream *substream)
170 runtime->substream = substream;
176 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
186 substream->runtime = runtime;
187 if (rawmidi_is_ump(substream->rmidi))
204 static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream *substream)
206 struct snd_rawmidi_runtime *runtime = substream->runtime;
210 substream->runtime = NULL;
214 static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream, int up)
216 if (!substream->opened)
218 substream->ops->trigger(substream, up);
221 static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
223 if (!substream->opened)
225 substream->ops->trigger(substream, up);
227 cancel_work_sync(&substream->runtime->event_work);
238 static void reset_runtime_ptrs(struct snd_rawmidi_substream *substream,
243 spin_lock_irqsave(&substream->lock, flags);
244 if (substream->opened && substream->runtime)
245 __reset_runtime_ptrs(substream->runtime, is_input);
246 spin_unlock_irqrestore(&substream->lock, flags);
249 int snd_rawmidi_drop_output(struct snd_rawmidi_substream *substream)
251 snd_rawmidi_output_trigger(substream, 0);
252 reset_runtime_ptrs(substream, false);
257 int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
263 spin_lock_irq(&substream->lock);
264 runtime = substream->runtime;
265 if (!substream->opened || !runtime || !runtime->buffer) {
271 spin_unlock_irq(&substream->lock);
279 spin_lock_irq(&substream->lock);
283 rmidi_warn(substream->rmidi,
289 spin_unlock_irq(&substream->lock);
293 if (substream->ops->drain)
294 substream->ops->drain(substream);
297 snd_rawmidi_drop_output(substream);
300 spin_lock_irq(&substream->lock);
302 spin_unlock_irq(&substream->lock);
308 int snd_rawmidi_drain_input(struct snd_rawmidi_substream *substream)
310 snd_rawmidi_input_trigger(substream, 0);
311 reset_runtime_ptrs(substream, true);
316 /* look for an available substream for the given stream direction;
323 struct snd_rawmidi_substream *substream;
335 list_for_each_entry(substream, &s->substreams, list) {
336 if (substream->opened) {
339 !substream->append)
342 if (subdevice < 0 || subdevice == substream->number) {
343 *sub_ret = substream;
350 /* open and do ref-counting for the given substream */
352 struct snd_rawmidi_substream *substream,
357 if (substream->use_count == 0) {
358 err = snd_rawmidi_runtime_create(substream);
361 err = substream->ops->open(substream);
363 snd_rawmidi_runtime_free(substream);
366 spin_lock_irq(&substream->lock);
367 substream->opened = 1;
368 substream->active_sensing = 0;
370 substream->append = 1;
371 substream->pid = get_pid(task_pid(current));
372 rmidi->streams[substream->stream].substream_opened++;
373 spin_unlock_irq(&substream->lock);
375 substream->use_count++;
380 struct snd_rawmidi_substream *substream,
549 struct snd_rawmidi_substream *substream,
552 if (--substream->use_count)
556 if (substream->stream == SNDRV_RAWMIDI_STREAM_INPUT)
557 snd_rawmidi_input_trigger(substream, 0);
559 if (substream->active_sensing) {
564 snd_rawmidi_kernel_write(substream, &buf, 1);
566 if (snd_rawmidi_drain_output(substream) == -ERESTARTSYS)
567 snd_rawmidi_output_trigger(substream, 0);
569 snd_rawmidi_buffer_ref_sync(substream);
571 spin_lock_irq(&substream->lock);
572 substream->opened = 0;
573 substream->append = 0;
574 spin_unlock_irq(&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(substream->pid);
580 substream->pid = NULL;
581 rmidi->streams[substream->stream].substream_opened--;
634 static int snd_rawmidi_info(struct snd_rawmidi_substream *substream,
639 if (substream == NULL)
641 rmidi = substream->rmidi;
645 info->subdevice = substream->number;
646 info->stream = substream->stream;
650 strcpy(info->subname, substream->name);
651 info->subdevices_count = substream->pstr->substream_count;
652 info->subdevices_avail = (substream->pstr->substream_count -
653 substream->pstr->substream_opened);
657 static int snd_rawmidi_info_user(struct snd_rawmidi_substream *substream,
663 err = snd_rawmidi_info(substream, &info);
676 struct snd_rawmidi_substream *substream;
689 list_for_each_entry(substream, &pstr->substreams, list) {
690 if ((unsigned int)substream->number == info->subdevice)
691 return snd_rawmidi_info(substream, info);
727 static int resize_runtime_buffer(struct snd_rawmidi_substream *substream,
731 struct snd_rawmidi_runtime *runtime = substream->runtime;
747 spin_lock_irq(&substream->lock);
749 spin_unlock_irq(&substream->lock);
757 spin_unlock_irq(&substream->lock);
764 int snd_rawmidi_output_params(struct snd_rawmidi_substream *substream,
769 snd_rawmidi_drain_output(substream);
770 mutex_lock(&substream->rmidi->open_mutex);
771 if (substream->append && substream->use_count > 1)
774 err = resize_runtime_buffer(substream, params, false);
777 substream->active_sensing = !params->no_active_sensing;
778 mutex_unlock(&substream->rmidi->open_mutex);
783 int snd_rawmidi_input_params(struct snd_rawmidi_substream *substream,
790 snd_rawmidi_drain_input(substream);
791 mutex_lock(&substream->rmidi->open_mutex);
799 err = resize_runtime_buffer(substream, params, true);
802 substream->framing = framing;
803 substream->clock_type = clock_type;
805 mutex_unlock(&substream->rmidi->open_mutex);
810 static int snd_rawmidi_output_status(struct snd_rawmidi_substream *substream,
813 struct snd_rawmidi_runtime *runtime = substream->runtime;
817 spin_lock_irq(&substream->lock);
819 spin_unlock_irq(&substream->lock);
823 static int snd_rawmidi_input_status(struct snd_rawmidi_substream *substream,
826 struct snd_rawmidi_runtime *runtime = substream->runtime;
830 spin_lock_irq(&substream->lock);
834 spin_unlock_irq(&substream->lock);
1101 static int receive_with_tstamp_framing(struct snd_rawmidi_substream *substream,
1104 struct snd_rawmidi_runtime *runtime = substream->runtime;
1140 static struct timespec64 get_framing_tstamp(struct snd_rawmidi_substream *substream)
1144 switch (substream->clock_type) {
1160 * @substream: the rawmidi substream
1168 int snd_rawmidi_receive(struct snd_rawmidi_substream *substream,
1172 struct timespec64 ts64 = get_framing_tstamp(substream);
1176 spin_lock_irqsave(&substream->lock, flags);
1177 if (!substream->opened) {
1181 runtime = substream->runtime;
1183 rmidi_dbg(substream->rmidi,
1193 if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) {
1194 result = receive_with_tstamp_framing(substream, buffer, count, &ts64);
1196 substream->bytes++;
1206 substream->bytes += count;
1243 spin_unlock_irqrestore(&substream->lock, flags);
1248 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream *substream,
1254 struct snd_rawmidi_runtime *runtime = substream->runtime;
1258 spin_lock_irqsave(&substream->lock, flags);
1276 spin_unlock_irqrestore(&substream->lock, flags);
1280 spin_lock_irqsave(&substream->lock, flags);
1289 spin_unlock_irqrestore(&substream->lock, flags);
1293 long snd_rawmidi_kernel_read(struct snd_rawmidi_substream *substream,
1296 snd_rawmidi_input_trigger(substream, 1);
1297 return snd_rawmidi_kernel_read1(substream, NULL/*userbuf*/, buf, count);
1307 struct snd_rawmidi_substream *substream;
1311 substream = rfile->input;
1312 if (substream == NULL)
1314 runtime = substream->runtime;
1315 snd_rawmidi_input_trigger(substream, 1);
1318 spin_lock_irq(&substream->lock);
1323 spin_unlock_irq(&substream->lock);
1329 spin_unlock_irq(&substream->lock);
1336 spin_lock_irq(&substream->lock);
1338 spin_unlock_irq(&substream->lock);
1342 spin_unlock_irq(&substream->lock);
1343 count1 = snd_rawmidi_kernel_read1(substream,
1358 * @substream: the rawmidi substream
1362 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)
1368 spin_lock_irqsave(&substream->lock, flags);
1369 runtime = substream->runtime;
1370 if (!substream->opened || !runtime || !runtime->buffer) {
1371 rmidi_dbg(substream->rmidi,
1377 spin_unlock_irqrestore(&substream->lock, flags);
1384 * @substream: the rawmidi substream
1390 static int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
1394 struct snd_rawmidi_runtime *runtime = substream->runtime;
1397 rmidi_dbg(substream->rmidi,
1437 * @substream: the rawmidi substream
1449 int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
1455 spin_lock_irqsave(&substream->lock, flags);
1456 if (!substream->opened || !substream->runtime)
1459 result = __snd_rawmidi_transmit_peek(substream, buffer, count);
1460 spin_unlock_irqrestore(&substream->lock, flags);
1467 * @substream: the rawmidi substream
1472 static int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream,
1475 struct snd_rawmidi_runtime *runtime = substream->runtime;
1478 rmidi_dbg(substream->rmidi,
1487 substream->bytes += count;
1497 * @substream: the rawmidi substream
1506 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
1511 spin_lock_irqsave(&substream->lock, flags);
1512 if (!substream->opened || !substream->runtime)
1515 result = __snd_rawmidi_transmit_ack(substream, count);
1516 spin_unlock_irqrestore(&substream->lock, flags);
1523 * @substream: the rawmidi substream
1531 int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
1537 spin_lock_irqsave(&substream->lock, flags);
1538 if (!substream->opened)
1541 count = __snd_rawmidi_transmit_peek(substream, buffer, count);
1545 result = __snd_rawmidi_transmit_ack(substream, count);
1547 spin_unlock_irqrestore(&substream->lock, flags);
1554 * @substream: rawmidi substream
1558 int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream)
1564 spin_lock_irqsave(&substream->lock, flags);
1565 runtime = substream->runtime;
1566 if (substream->opened && runtime &&
1569 __snd_rawmidi_transmit_ack(substream, count);
1571 spin_unlock_irqrestore(&substream->lock, flags);
1576 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream *substream,
1583 struct snd_rawmidi_runtime *runtime = substream->runtime;
1592 spin_lock_irqsave(&substream->lock, flags);
1593 if (substream->append) {
1595 spin_unlock_irqrestore(&substream->lock, flags);
1617 spin_unlock_irqrestore(&substream->lock, flags);
1620 spin_lock_irqsave(&substream->lock, flags);
1624 spin_lock_irqsave(&substream->lock, flags);
1632 spin_unlock_irqrestore(&substream->lock, flags);
1634 snd_rawmidi_output_trigger(substream, 1);
1638 long snd_rawmidi_kernel_write(struct snd_rawmidi_substream *substream,
1641 return snd_rawmidi_kernel_write1(substream, NULL, buf, count);
1652 struct snd_rawmidi_substream *substream;
1655 substream = rfile->output;
1656 runtime = substream->runtime;
1658 if (substream->append && count > runtime->buffer_size)
1662 spin_lock_irq(&substream->lock);
1663 while (!snd_rawmidi_ready_append(substream, count)) {
1667 spin_unlock_irq(&substream->lock);
1673 spin_unlock_irq(&substream->lock);
1680 spin_lock_irq(&substream->lock);
1682 spin_unlock_irq(&substream->lock);
1686 spin_unlock_irq(&substream->lock);
1687 count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count);
1697 spin_lock_irq(&substream->lock);
1705 spin_unlock_irq(&substream->lock);
1712 spin_lock_irq(&substream->lock);
1714 spin_unlock_irq(&substream->lock);
1762 struct snd_rawmidi_substream *substream;
1777 list_for_each_entry(substream,
1783 substream->number,
1784 (unsigned long) substream->bytes);
1785 if (substream->opened) {
1788 pid_vnr(substream->pid));
1789 runtime = substream->runtime;
1790 spin_lock_irq(&substream->lock);
1793 spin_unlock_irq(&substream->lock);
1804 list_for_each_entry(substream,
1810 substream->number,
1811 (unsigned long) substream->bytes);
1812 if (substream->opened) {
1815 pid_vnr(substream->pid));
1816 runtime = substream->runtime;
1817 spin_lock_irq(&substream->lock);
1821 spin_unlock_irq(&substream->lock);
1827 if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) {
1828 clock_type = substream->clock_type >> SNDRV_RAWMIDI_MODE_CLOCK_SHIFT;
1862 struct snd_rawmidi_substream *substream;
1866 substream = kzalloc(sizeof(*substream), GFP_KERNEL);
1867 if (!substream)
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(&substream->list, &stream->substreams);
1971 struct snd_rawmidi_substream *substream;
1974 substream = list_entry(stream->substreams.next, struct snd_rawmidi_substream, list);
1975 list_del(&substream->list);
1976 kfree(substream);
2159 struct snd_rawmidi_substream *substream;
2161 list_for_each_entry(substream, &rmidi->streams[stream].substreams, list)
2162 substream->ops = ops;