[linux.git] / sound / usb / proc.c

/*
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <linux/init.h>
#include <linux/usb.h>

#include <sound/core.h>
#include <sound/info.h>
#include <sound/pcm.h>

#include "usbaudio.h"
#include "helper.h"
#include "card.h"
#include "endpoint.h"
#include "proc.h"

/* convert our full speed USB rate into sampling rate in Hz */
static inline unsigned get_full_speed_hz(unsigned int usb_rate)
{
	return (usb_rate * 125 + (1 << 12)) >> 13;
}

/* convert our high speed USB rate into sampling rate in Hz */
static inline unsigned get_high_speed_hz(unsigned int usb_rate)
{
	return (usb_rate * 125 + (1 << 9)) >> 10;
}

/*
 * common proc files to show the usb device info
 */
static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
{
	struct snd_usb_audio *chip = entry->private_data;
	if (!atomic_read(&chip->shutdown))
		snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
}

static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
{
	struct snd_usb_audio *chip = entry->private_data;
	if (!atomic_read(&chip->shutdown))
		snd_iprintf(buffer, "%04x:%04x\n", 
			    USB_ID_VENDOR(chip->usb_id),
			    USB_ID_PRODUCT(chip->usb_id));
}

void snd_usb_audio_create_proc(struct snd_usb_audio *chip)
{
	struct snd_info_entry *entry;
	if (!snd_card_proc_new(chip->card, "usbbus", &entry))
		snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
	if (!snd_card_proc_new(chip->card, "usbid", &entry))
		snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
}

/*
 * proc interface for list the supported pcm formats
 */
static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
{
	struct audioformat *fp;
	static char *sync_types[4] = {
		"NONE", "ASYNC", "ADAPTIVE", "SYNC"
	};

	list_for_each_entry(fp, &subs->fmt_list, list) {
		snd_pcm_format_t fmt;

		snd_iprintf(buffer, "  Interface %d\n", fp->iface);
		snd_iprintf(buffer, "    Altset %d\n", fp->altsetting);
		snd_iprintf(buffer, "    Format:");
		for (fmt = 0; fmt <= SNDRV_PCM_FORMAT_LAST; ++fmt)
			if (fp->formats & pcm_format_to_bits(fmt))
				snd_iprintf(buffer, " %s",
					    snd_pcm_format_name(fmt));
		snd_iprintf(buffer, "\n");
		snd_iprintf(buffer, "    Channels: %d\n", fp->channels);
		snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
			    fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
			    fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
			    sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
		if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
			snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
				    fp->rate_min, fp->rate_max);
		} else {
			unsigned int i;
			snd_iprintf(buffer, "    Rates: ");
			for (i = 0; i < fp->nr_rates; i++) {
				if (i > 0)
					snd_iprintf(buffer, ", ");
				snd_iprintf(buffer, "%d", fp->rate_table[i]);
			}
			snd_iprintf(buffer, "\n");
		}
		if (subs->speed != USB_SPEED_FULL)
			snd_iprintf(buffer, "    Data packet interval: %d us\n",
				    125 * (1 << fp->datainterval));
		// snd_iprintf(buffer, "    Max Packet Size = %d\n", fp->maxpacksize);
		// snd_iprintf(buffer, "    EP Attribute = %#x\n", fp->attributes);
	}
}

static void proc_dump_ep_status(struct snd_usb_substream *subs,
				struct snd_usb_endpoint *data_ep,
				struct snd_usb_endpoint *sync_ep,
				struct snd_info_buffer *buffer)
{
	if (!data_ep)
		return;
	snd_iprintf(buffer, "    Packet Size = %d\n", data_ep->curpacksize);
	snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
		    subs->speed == USB_SPEED_FULL
		    ? get_full_speed_hz(data_ep->freqm)
		    : get_high_speed_hz(data_ep->freqm),
		    data_ep->freqm >> 16, data_ep->freqm & 0xffff);
	if (sync_ep && data_ep->freqshift != INT_MIN) {
		int res = 16 - data_ep->freqshift;
		snd_iprintf(buffer, "    Feedback Format = %d.%d\n",
			    (sync_ep->syncmaxsize > 3 ? 32 : 24) - res, res);
	}
}

static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
{
	if (subs->running) {
		snd_iprintf(buffer, "  Status: Running\n");
		snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
		snd_iprintf(buffer, "    Altset = %d\n", subs->altset_idx);
		proc_dump_ep_status(subs, subs->data_endpoint, subs->sync_endpoint, buffer);
	} else {
		snd_iprintf(buffer, "  Status: Stop\n");
	}
}

static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
{
	struct snd_usb_stream *stream = entry->private_data;

	snd_iprintf(buffer, "%s : %s\n", stream->chip->card->longname, stream->pcm->name);

	if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) {
		snd_iprintf(buffer, "\nPlayback:\n");
		proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
		proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer);
	}
	if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) {
		snd_iprintf(buffer, "\nCapture:\n");
		proc_dump_substream_status(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
		proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer);
	}
}

void snd_usb_proc_pcm_format_add(struct snd_usb_stream *stream)
{
	struct snd_info_entry *entry;
	char name[32];
	struct snd_card *card = stream->chip->card;

	sprintf(name, "stream%d", stream->pcm_index);
	if (!snd_card_proc_new(card, name, &entry))
		snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
}
Commit	Line	Data
e5779998 DM	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"
c89a5d9c	28	#include "endpoint.h"
e5779998 DM	29	#include "proc.h"
	30
	31	/* convert our full speed USB rate into sampling rate in Hz */
	32	static 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 */
	38	static 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	*/
	46	static 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;
47ab1545	49	if (!atomic_read(&chip->shutdown))
e5779998 DM	50	snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum);
	51	}
	52
	53	static 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;
47ab1545	56	if (!atomic_read(&chip->shutdown))
e5779998 DM	57	snd_iprintf(buffer, "%04x:%04x\n",
	58	USB_ID_VENDOR(chip->usb_id),
	59	USB_ID_PRODUCT(chip->usb_id));
	60	}
	61
	62	void 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	*/
	74	static void proc_dump_substream_formats(struct snd_usb_substream subs, struct snd_info_buffer buffer)
	75	{
88766f04	76	struct audioformat *fp;
e5779998 DM	77	static char *sync_types[4] = {
	78	"NONE", "ASYNC", "ADAPTIVE", "SYNC"
	79	};
	80
88766f04	81	list_for_each_entry(fp, &subs->fmt_list, list) {
015eb0b0	82	snd_pcm_format_t fmt;
88766f04	83
e5779998 DM	84	snd_iprintf(buffer, " Interface %d\n", fp->iface);
e5779998 DM	85	snd_iprintf(buffer, " Altset %d\n", fp->altsetting);
015eb0b0 CL	86	snd_iprintf(buffer, " Format:");
015eb0b0 CL	87	for (fmt = 0; fmt <= SNDRV_PCM_FORMAT_LAST; ++fmt)
74c34ca1	88	if (fp->formats & pcm_format_to_bits(fmt))
015eb0b0 CL	89	snd_iprintf(buffer, " %s",
	90	snd_pcm_format_name(fmt));
	91	snd_iprintf(buffer, "\n");
e5779998 DM	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	}
978520b7	110	if (subs->speed != USB_SPEED_FULL)
e5779998 DM	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
22026c1a	118	static void proc_dump_ep_status(struct snd_usb_substream *subs,
e6135fe9 TH	119	struct snd_usb_endpoint *data_ep,
e6135fe9 TH	120	struct snd_usb_endpoint *sync_ep,
22026c1a TI	121	struct snd_info_buffer *buffer)
22026c1a TI	122	{
e6135fe9	123	if (!data_ep)
22026c1a	124	return;
e6135fe9	125	snd_iprintf(buffer, " Packet Size = %d\n", data_ep->curpacksize);
22026c1a	126	snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n",
978520b7	127	subs->speed == USB_SPEED_FULL
e6135fe9 TH	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;
22026c1a	133	snd_iprintf(buffer, " Feedback Format = %d.%d\n",
e6135fe9	134	(sync_ep->syncmaxsize > 3 ? 32 : 24) - res, res);
22026c1a TI	135	}
	136	}
	137
e5779998 DM	138	static void proc_dump_substream_status(struct snd_usb_substream subs, struct snd_info_buffer buffer)
	139	{
	140	if (subs->running) {
e5779998 DM	141	snd_iprintf(buffer, " Status: Running\n");
e5779998 DM	142	snd_iprintf(buffer, " Interface = %d\n", subs->interface);
e11b4e0e	143	snd_iprintf(buffer, " Altset = %d\n", subs->altset_idx);
e6135fe9	144	proc_dump_ep_status(subs, subs->data_endpoint, subs->sync_endpoint, buffer);
e5779998 DM	145	} else {
	146	snd_iprintf(buffer, " Status: Stop\n");
	147	}
	148	}
	149
	150	static 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
	168	void 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