Linux Audio

Check our new training course

Loading...
v5.9
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  3 */
  4
  5#include <linux/init.h>
  6#include <linux/usb.h>
  7
  8#include <sound/core.h>
  9#include <sound/info.h>
 10#include <sound/pcm.h>
 11
 12#include "usbaudio.h"
 13#include "helper.h"
 14#include "card.h"
 15#include "endpoint.h"
 16#include "proc.h"
 17
 18/* convert our full speed USB rate into sampling rate in Hz */
 19static inline unsigned get_full_speed_hz(unsigned int usb_rate)
 20{
 21	return (usb_rate * 125 + (1 << 12)) >> 13;
 22}
 23
 24/* convert our high speed USB rate into sampling rate in Hz */
 25static inline unsigned get_high_speed_hz(unsigned int usb_rate)
 26{
 27	return (usb_rate * 125 + (1 << 9)) >> 10;
 28}
 29
 30/*
 31 * common proc files to show the usb device info
 32 */
 33static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 34{
 35	struct snd_usb_audio *chip = entry->private_data;
 36	if (!atomic_read(&chip->shutdown))
 37		snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
 38}
 39
 40static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 41{
 42	struct snd_usb_audio *chip = entry->private_data;
 43	if (!atomic_read(&chip->shutdown))
 44		snd_iprintf(buffer, "%04x:%04x\n", 
 45			    USB_ID_VENDOR(chip->usb_id),
 46			    USB_ID_PRODUCT(chip->usb_id));
 47}
 48
 49void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
 50{
 51	snd_card_ro_proc_new(chip->card, "usbbus", chip,
 52			     proc_audio_usbbus_read);
 53	snd_card_ro_proc_new(chip->card, "usbid", chip,
 54			     proc_audio_usbid_read);
 55}
 56
 57static const char * const channel_labels[] = {
 58	[SNDRV_CHMAP_NA]	= "N/A",
 59	[SNDRV_CHMAP_MONO]	= "MONO",
 60	[SNDRV_CHMAP_FL]	= "FL",
 61	[SNDRV_CHMAP_FR]	= "FR",
 62	[SNDRV_CHMAP_FC]	= "FC",
 63	[SNDRV_CHMAP_LFE]	= "LFE",
 64	[SNDRV_CHMAP_RL]	= "RL",
 65	[SNDRV_CHMAP_RR]	= "RR",
 66	[SNDRV_CHMAP_FLC]	= "FLC",
 67	[SNDRV_CHMAP_FRC]	= "FRC",
 68	[SNDRV_CHMAP_RC]	= "RC",
 69	[SNDRV_CHMAP_SL]	= "SL",
 70	[SNDRV_CHMAP_SR]	= "SR",
 71	[SNDRV_CHMAP_TC]	= "TC",
 72	[SNDRV_CHMAP_TFL]	= "TFL",
 73	[SNDRV_CHMAP_TFC]	= "TFC",
 74	[SNDRV_CHMAP_TFR]	= "TFR",
 75	[SNDRV_CHMAP_TRL]	= "TRL",
 76	[SNDRV_CHMAP_TRC]	= "TRC",
 77	[SNDRV_CHMAP_TRR]	= "TRR",
 78	[SNDRV_CHMAP_TFLC]	= "TFLC",
 79	[SNDRV_CHMAP_TFRC]	= "TFRC",
 80	[SNDRV_CHMAP_LLFE]	= "LLFE",
 81	[SNDRV_CHMAP_RLFE]	= "RLFE",
 82	[SNDRV_CHMAP_TSL]	= "TSL",
 83	[SNDRV_CHMAP_TSR]	= "TSR",
 84	[SNDRV_CHMAP_BC]	= "BC",
 85	[SNDRV_CHMAP_RLC]	= "RLC",
 86	[SNDRV_CHMAP_RRC]	= "RRC",
 87};
 88
 89/*
 90 * proc interface for list the supported pcm formats
 91 */
 92static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
 93{
 94	struct audioformat *fp;
 95	static const char * const sync_types[4] = {
 96		"NONE", "ASYNC", "ADAPTIVE", "SYNC"
 97	};
 98
 99	list_for_each_entry(fp, &subs->fmt_list, list) {
100		snd_pcm_format_t fmt;
101
102		snd_iprintf(buffer, "  Interface %d\n", fp->iface);
103		snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
104		snd_iprintf(buffer, "    Format:");
105		pcm_for_each_format(fmt)
106			if (fp->formats & pcm_format_to_bits(fmt))
107				snd_iprintf(buffer, " %s",
108					    snd_pcm_format_name(fmt));
109		snd_iprintf(buffer, "\n");
110		snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
111		snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
112			    fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
113			    fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
114			    sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
115		if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
116			snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
117				    fp->rate_min, fp->rate_max);
118		} else {
119			unsigned int i;
120			snd_iprintf(buffer, "    Rates: ");
121			for (i = 0; i < fp->nr_rates; i++) {
122				if (i > 0)
123					snd_iprintf(buffer, ", ");
124				snd_iprintf(buffer, "%d", fp->rate_table[i]);
125			}
126			snd_iprintf(buffer, "\n");
127		}
128		if (subs->speed != USB_SPEED_FULL)
129			snd_iprintf(buffer, "    Data packet interval: %d us\n",
130				    125 * (1 << fp->datainterval));
131		snd_iprintf(buffer, "    Bits: %d\n", fp->fmt_bits);
132
133		if (fp->dsd_raw)
134			snd_iprintf(buffer, "    DSD raw: DOP=%d, bitrev=%d\n",
135				    fp->dsd_dop, fp->dsd_bitrev);
136
137		if (fp->chmap) {
138			const struct snd_pcm_chmap_elem *map = fp->chmap;
139			int c;
140
141			snd_iprintf(buffer, "    Channel map:");
142			for (c = 0; c < map->channels; c++) {
143				if (map->map[c] >= ARRAY_SIZE(channel_labels) ||
144				    !channel_labels[map->map[c]])
145					snd_iprintf(buffer, " --");
146				else
147					snd_iprintf(buffer, " %s",
148						    channel_labels[map->map[c]]);
149			}
150			snd_iprintf(buffer, "\n");
151		}
152
153		// snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
154		// snd_iprintf(buffer, "    EP Attribute = %#x\n", fp->attributes);
155	}
156}
157
158static void proc_dump_ep_status(struct snd_usb_substream *subs,
159				struct snd_usb_endpoint *data_ep,
160				struct snd_usb_endpoint *sync_ep,
161				struct snd_info_buffer *buffer)
162{
163	if (!data_ep)
164		return;
165	snd_iprintf(buffer, "    Packet Size = %d\n", data_ep->curpacksize);
166	snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
167		    subs->speed == USB_SPEED_FULL
168		    ? get_full_speed_hz(data_ep->freqm)
169		    : get_high_speed_hz(data_ep->freqm),
170		    data_ep->freqm >> 16, data_ep->freqm & 0xffff);
171	if (sync_ep && data_ep->freqshift != INT_MIN) {
172		int res = 16 - data_ep->freqshift;
173		snd_iprintf(buffer, "    Feedback Format = %d.%d\n",
174			    (sync_ep->syncmaxsize > 3 ? 32 : 24) - res, res);
175	}
176}
177
178static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
179{
180	if (subs->running) {
181		snd_iprintf(buffer, "  Status: Running\n");
182		snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
183		snd_iprintf(buffer, "    Altset = %d\n", subs->altset_idx);
184		proc_dump_ep_status(subs, subs->data_endpoint, subs->sync_endpoint, buffer);
185	} else {
186		snd_iprintf(buffer, "  Status: Stop\n");
187	}
188}
189
190static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
191{
192	struct snd_usb_stream *stream = entry->private_data;
193
194	snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
195
196	if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
197		snd_iprintf(buffer, "\nPlayback:\n");
198		proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
199		proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
200	}
201	if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
202		snd_iprintf(buffer, "\nCapture:\n");
203		proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
204		proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
205	}
206}
207
208void snd_usb_proc_pcm_format_add(struct snd_usb_stream *stream)
209{
 
210	char name[32];
211	struct snd_card *card = stream->chip->card;
212
213	sprintf(name, "stream%d", stream->pcm_index);
214	snd_card_ro_proc_new(card, name, stream, proc_pcm_format_read);
 
215}
216
v3.15
 
  1/*
  2 *   This program is free software; you can redistribute it and/or modify
  3 *   it under the terms of the GNU General Public License as published by
  4 *   the Free Software Foundation; either version 2 of the License, or
  5 *   (at your option) any later version.
  6 *
  7 *   This program is distributed in the hope that it will be useful,
  8 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  9 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 10 *   GNU General Public License for more details.
 11 *
 12 *   You should have received a copy of the GNU General Public License
 13 *   along with this program; if not, write to the Free Software
 14 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 15 *
 16 */
 17
 18#include <linux/init.h>
 19#include <linux/usb.h>
 20
 21#include <sound/core.h>
 22#include <sound/info.h>
 23#include <sound/pcm.h>
 24
 25#include "usbaudio.h"
 26#include "helper.h"
 27#include "card.h"
 28#include "endpoint.h"
 29#include "proc.h"
 30
 31/* convert our full speed USB rate into sampling rate in Hz */
 32static inline unsigned get_full_speed_hz(unsigned int usb_rate)
 33{
 34	return (usb_rate * 125 + (1 << 12)) >> 13;
 35}
 36
 37/* convert our high speed USB rate into sampling rate in Hz */
 38static inline unsigned get_high_speed_hz(unsigned int usb_rate)
 39{
 40	return (usb_rate * 125 + (1 << 9)) >> 10;
 41}
 42
 43/*
 44 * common proc files to show the usb device info
 45 */
 46static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 47{
 48	struct snd_usb_audio *chip = entry->private_data;
 49	if (!chip->shutdown)
 50		snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
 51}
 52
 53static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 54{
 55	struct snd_usb_audio *chip = entry->private_data;
 56	if (!chip->shutdown)
 57		snd_iprintf(buffer, "%04x:%04x\n", 
 58			    USB_ID_VENDOR(chip->usb_id),
 59			    USB_ID_PRODUCT(chip->usb_id));
 60}
 61
 62void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
 63{
 64	struct snd_info_entry *entry;
 65	if (!snd_card_proc_new(chip->card, "usbbus", &entry))
 66		snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
 67	if (!snd_card_proc_new(chip->card, "usbid", &entry))
 68		snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
 69}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 70
 71/*
 72 * proc interface for list the supported pcm formats
 73 */
 74static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
 75{
 76	struct audioformat *fp;
 77	static char *sync_types[4] = {
 78		"NONE", "ASYNC", "ADAPTIVE", "SYNC"
 79	};
 80
 81	list_for_each_entry(fp, &subs->fmt_list, list) {
 82		snd_pcm_format_t fmt;
 83
 84		snd_iprintf(buffer, "  Interface %d\n", fp->iface);
 85		snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
 86		snd_iprintf(buffer, "    Format:");
 87		for (fmt = 0; fmt <= SNDRV_PCM_FORMAT_LAST; ++fmt)
 88			if (fp->formats & pcm_format_to_bits(fmt))
 89				snd_iprintf(buffer, " %s",
 90					    snd_pcm_format_name(fmt));
 91		snd_iprintf(buffer, "\n");
 92		snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
 93		snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
 94			    fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
 95			    fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
 96			    sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
 97		if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
 98			snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
 99				    fp->rate_min, fp->rate_max);
100		} else {
101			unsigned int i;
102			snd_iprintf(buffer, "    Rates: ");
103			for (i = 0; i < fp->nr_rates; i++) {
104				if (i > 0)
105					snd_iprintf(buffer, ", ");
106				snd_iprintf(buffer, "%d", fp->rate_table[i]);
107			}
108			snd_iprintf(buffer, "\n");
109		}
110		if (subs->speed != USB_SPEED_FULL)
111			snd_iprintf(buffer, "    Data packet interval: %d us\n",
112				    125 * (1 << fp->datainterval));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
113		// snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
114		// snd_iprintf(buffer, "    EP Attribute = %#x\n", fp->attributes);
115	}
116}
117
118static void proc_dump_ep_status(struct snd_usb_substream *subs,
119				struct snd_usb_endpoint *data_ep,
120				struct snd_usb_endpoint *sync_ep,
121				struct snd_info_buffer *buffer)
122{
123	if (!data_ep)
124		return;
125	snd_iprintf(buffer, "    Packet Size = %d\n", data_ep->curpacksize);
126	snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
127		    subs->speed == USB_SPEED_FULL
128		    ? get_full_speed_hz(data_ep->freqm)
129		    : get_high_speed_hz(data_ep->freqm),
130		    data_ep->freqm >> 16, data_ep->freqm & 0xffff);
131	if (sync_ep && data_ep->freqshift != INT_MIN) {
132		int res = 16 - data_ep->freqshift;
133		snd_iprintf(buffer, "    Feedback Format = %d.%d\n",
134			    (sync_ep->syncmaxsize > 3 ? 32 : 24) - res, res);
135	}
136}
137
138static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
139{
140	if (subs->running) {
141		snd_iprintf(buffer, "  Status: Running\n");
142		snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
143		snd_iprintf(buffer, "    Altset = %d\n", subs->altset_idx);
144		proc_dump_ep_status(subs, subs->data_endpoint, subs->sync_endpoint, buffer);
145	} else {
146		snd_iprintf(buffer, "  Status: Stop\n");
147	}
148}
149
150static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
151{
152	struct snd_usb_stream *stream = entry->private_data;
153
154	snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);
155
156	if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
157		snd_iprintf(buffer, "\nPlayback:\n");
158		proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
159		proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
160	}
161	if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
162		snd_iprintf(buffer, "\nCapture:\n");
163		proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
164		proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
165	}
166}
167
168void snd_usb_proc_pcm_format_add(struct snd_usb_stream *stream)
169{
170	struct snd_info_entry *entry;
171	char name[32];
172	struct snd_card *card = stream->chip->card;
173
174	sprintf(name, "stream%d", stream->pcm_index);
175	if (!snd_card_proc_new(card, name, &entry))
176		snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
177}
178