Lines Matching +full:sub +full:- +full:device
1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * Copyright 2012-2013 (C) M2TECH S.r.l and Amarula Solutions B.V.
53 bool panic; /* if set driver won't do anymore pcm on device */
114 struct usb_device *device = rt->chip->dev;
147 dev_err(&device->dev, "Unsupported rate %d\n", rate);
148 return -EINVAL;
159 ret = usb_control_msg_send(device, 0,
164 dev_err(&device->dev, "Error setting samplerate %d.\n", rate);
173 struct device *device = &rt->chip->dev->dev;
175 if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
176 return &rt->playback;
178 dev_err(device, "Error getting pcm substream slot.\n");
187 if (rt->stream_state != STREAM_DISABLED) {
188 rt->stream_state = STREAM_STOPPING;
192 &rt->out_urbs[i].submitted, 100);
195 &rt->out_urbs[i].submitted);
196 usb_kill_urb(&rt->out_urbs[i].instance);
199 rt->stream_state = STREAM_DISABLED;
209 if (rt->stream_state == STREAM_DISABLED) {
212 rt->panic = false;
215 rt->stream_state = STREAM_STARTING;
217 memset(rt->out_urbs[i].buffer, 0, PCM_PACKET_SIZE);
218 usb_anchor_urb(&rt->out_urbs[i].instance,
219 &rt->out_urbs[i].submitted);
220 ret = usb_submit_urb(&rt->out_urbs[i].instance,
229 wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
231 if (rt->stream_wait_cond) {
232 struct device *device = &rt->chip->dev->dev;
233 dev_dbg(device, "%s: Stream is running wakeup event\n",
235 rt->stream_state = STREAM_RUNNING;
238 return -EIO;
244 /* The hardware wants word-swapped 32-bit values */
255 static bool hiface_pcm_playback(struct pcm_substream *sub, struct pcm_urb *urb)
257 struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
258 struct device *device = &urb->chip->dev->dev;
262 WARN_ON(alsa_rt->format != SNDRV_PCM_FORMAT_S32_LE);
264 pcm_buffer_size = snd_pcm_lib_buffer_bytes(sub->instance);
266 if (sub->dma_off + PCM_PACKET_SIZE <= pcm_buffer_size) {
267 dev_dbg(device, "%s: (1) buffer_size %#x dma_offset %#x\n", __func__,
269 (unsigned int) sub->dma_off);
271 source = alsa_rt->dma_area + sub->dma_off;
272 memcpy_swahw32(urb->buffer, source, PCM_PACKET_SIZE);
277 dev_dbg(device, "%s: (2) buffer_size %#x dma_offset %#x\n", __func__,
279 (unsigned int) sub->dma_off);
281 len = pcm_buffer_size - sub->dma_off;
283 source = alsa_rt->dma_area + sub->dma_off;
284 memcpy_swahw32(urb->buffer, source, len);
286 source = alsa_rt->dma_area;
287 memcpy_swahw32(urb->buffer + len, source,
288 PCM_PACKET_SIZE - len);
290 sub->dma_off += PCM_PACKET_SIZE;
291 if (sub->dma_off >= pcm_buffer_size)
292 sub->dma_off -= pcm_buffer_size;
294 sub->period_off += PCM_PACKET_SIZE;
295 if (sub->period_off >= alsa_rt->period_size) {
296 sub->period_off %= alsa_rt->period_size;
304 struct pcm_urb *out_urb = usb_urb->context;
305 struct pcm_runtime *rt = out_urb->chip->pcm;
306 struct pcm_substream *sub;
310 if (rt->panic || rt->stream_state == STREAM_STOPPING)
313 if (unlikely(usb_urb->status == -ENOENT || /* unlinked */
314 usb_urb->status == -ENODEV || /* device removed */
315 usb_urb->status == -ECONNRESET || /* unlinked */
316 usb_urb->status == -ESHUTDOWN)) { /* device disabled */
320 if (rt->stream_state == STREAM_STARTING) {
321 rt->stream_wait_cond = true;
322 wake_up(&rt->stream_wait_queue);
326 sub = &rt->playback;
327 scoped_guard(spinlock_irqsave, &sub->lock) {
328 if (sub->active)
329 do_period_elapsed = hiface_pcm_playback(sub, out_urb);
331 memset(out_urb->buffer, 0, PCM_PACKET_SIZE);
335 snd_pcm_period_elapsed(sub->instance);
337 ret = usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
344 rt->panic = true;
350 struct pcm_substream *sub = NULL;
351 struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
354 if (rt->panic)
355 return -EPIPE;
357 guard(mutex)(&rt->stream_mutex);
358 alsa_rt->hw = pcm_hw;
360 if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
361 sub = &rt->playback;
363 if (!sub) {
364 struct device *device = &rt->chip->dev->dev;
365 dev_err(device, "Invalid stream type\n");
366 return -EINVAL;
369 if (rt->extra_freq) {
370 alsa_rt->hw.rates |= SNDRV_PCM_RATE_KNOT;
371 alsa_rt->hw.rate_max = 384000;
374 ret = snd_pcm_hw_constraint_list(alsa_sub->runtime, 0,
381 sub->instance = alsa_sub;
382 sub->active = false;
389 struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
391 if (rt->panic)
394 guard(mutex)(&rt->stream_mutex);
395 if (sub) {
399 guard(spinlock_irqsave)(&sub->lock);
400 sub->instance = NULL;
401 sub->active = false;
409 struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
410 struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
413 if (rt->panic)
414 return -EPIPE;
415 if (!sub)
416 return -ENODEV;
418 guard(mutex)(&rt->stream_mutex);
422 sub->dma_off = 0;
423 sub->period_off = 0;
425 if (rt->stream_state == STREAM_DISABLED) {
427 ret = hiface_pcm_set_rate(rt, alsa_rt->rate);
439 struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
442 if (rt->panic)
443 return -EPIPE;
444 if (!sub)
445 return -ENODEV;
450 scoped_guard(spinlock_irq, &sub->lock) {
451 sub->active = true;
457 scoped_guard(spinlock_irq, &sub->lock) {
458 sub->active = false;
463 return -EINVAL;
469 struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub);
473 if (rt->panic || !sub)
476 guard(spinlock_irqsave)(&sub->lock);
477 dma_offset = sub->dma_off;
478 return bytes_to_frames(alsa_sub->runtime, dma_offset);
494 urb->chip = chip;
495 usb_init_urb(&urb->instance);
497 urb->buffer = kzalloc(PCM_PACKET_SIZE, GFP_KERNEL);
498 if (!urb->buffer)
499 return -ENOMEM;
501 usb_fill_bulk_urb(&urb->instance, chip->dev,
502 usb_sndbulkpipe(chip->dev, ep), (void *)urb->buffer,
504 if (usb_urb_ep_type_check(&urb->instance))
505 return -EINVAL;
506 init_usb_anchor(&urb->submitted);
513 struct pcm_runtime *rt = chip->pcm;
516 rt->panic = true;
518 guard(mutex)(&rt->stream_mutex);
525 struct pcm_runtime *rt = chip->pcm;
529 kfree(rt->out_urbs[i].buffer);
531 kfree(chip->pcm);
532 chip->pcm = NULL;
537 struct pcm_runtime *rt = pcm->private_data;
540 hiface_pcm_destroy(rt->chip);
552 return -ENOMEM;
554 rt->chip = chip;
555 rt->stream_state = STREAM_DISABLED;
557 rt->extra_freq = 1;
559 init_waitqueue_head(&rt->stream_wait_queue);
560 mutex_init(&rt->stream_mutex);
561 spin_lock_init(&rt->playback.lock);
564 ret = hiface_pcm_init_urb(&rt->out_urbs[i], chip, OUT_EP,
570 ret = snd_pcm_new(chip->card, "USB-SPDIF Audio", 0, 1, 0, &pcm);
572 dev_err(&chip->dev->dev, "Cannot create pcm instance\n");
576 pcm->private_data = rt;
577 pcm->private_free = hiface_pcm_free;
579 strscpy(pcm->name, "USB-SPDIF Audio", sizeof(pcm->name));
584 rt->instance = pcm;
586 chip->pcm = rt;
591 kfree(rt->out_urbs[i].buffer);