[deliverable/linux.git] / sound / firewire / bebob / bebob_proc.c

/*
 * bebob_proc.c - a part of driver for BeBoB based devices
 *
 * Copyright (c) 2013-2014 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include "./bebob.h"

/* contents of information register */
struct hw_info {
	u64 manufacturer;
	u32 protocol_ver;
	u32 bld_ver;
	u32 guid[2];
	u32 model_id;
	u32 model_rev;
	u64 fw_date;
	u64 fw_time;
	u32 fw_id;
	u32 fw_ver;
	u32 base_addr;
	u32 max_size;
	u64 bld_date;
	u64 bld_time;
/* may not used in product
	u64 dbg_date;
	u64 dbg_time;
	u32 dbg_id;
	u32 dbg_version;
*/
} __packed;

static void
proc_read_hw_info(struct snd_info_entry *entry,
		  struct snd_info_buffer *buffer)
{
	struct snd_bebob *bebob = entry->private_data;
	struct hw_info *info;

	info = kzalloc(sizeof(struct hw_info), GFP_KERNEL);
	if (info == NULL)
		return;

	if (snd_bebob_read_block(bebob->unit, 0,
				   info, sizeof(struct hw_info)) < 0)
		goto end;

	snd_iprintf(buffer, "Manufacturer:\t%.8s\n",
		    (char *)&info->manufacturer);
	snd_iprintf(buffer, "Protocol Ver:\t%d\n", info->protocol_ver);
	snd_iprintf(buffer, "Build Ver:\t%d\n", info->bld_ver);
	snd_iprintf(buffer, "GUID:\t\t0x%.8X%.8X\n",
		    info->guid[0], info->guid[1]);
	snd_iprintf(buffer, "Model ID:\t0x%02X\n", info->model_id);
	snd_iprintf(buffer, "Model Rev:\t%d\n", info->model_rev);
	snd_iprintf(buffer, "Firmware Date:\t%.8s\n", (char *)&info->fw_date);
	snd_iprintf(buffer, "Firmware Time:\t%.8s\n", (char *)&info->fw_time);
	snd_iprintf(buffer, "Firmware ID:\t0x%X\n", info->fw_id);
	snd_iprintf(buffer, "Firmware Ver:\t%d\n", info->fw_ver);
	snd_iprintf(buffer, "Base Addr:\t0x%X\n", info->base_addr);
	snd_iprintf(buffer, "Max Size:\t%d\n", info->max_size);
	snd_iprintf(buffer, "Loader Date:\t%.8s\n", (char *)&info->bld_date);
	snd_iprintf(buffer, "Loader Time:\t%.8s\n", (char *)&info->bld_time);

end:
	kfree(info);
}

static void
proc_read_meters(struct snd_info_entry *entry,
		 struct snd_info_buffer *buffer)
{
	struct snd_bebob *bebob = entry->private_data;
	const struct snd_bebob_meter_spec *spec = bebob->spec->meter;
	u32 *buf;
	unsigned int i, c, channels, size;

	if (spec == NULL)
		return;

	channels = spec->num * 2;
	size = channels * sizeof(u32);
	buf = kmalloc(size, GFP_KERNEL);
	if (buf == NULL)
		return;

	if (spec->get(bebob, buf, size) < 0)
		goto end;

	for (i = 0, c = 1; i < channels; i++) {
		snd_iprintf(buffer, "%s %d:\t%d\n",
			    spec->labels[i / 2], c++, buf[i]);
		if ((i + 1 < channels - 1) &&
		    (strcmp(spec->labels[i / 2],
			    spec->labels[(i + 1) / 2]) != 0))
			c = 1;
	}
end:
	kfree(buf);
}

static void
proc_read_formation(struct snd_info_entry *entry,
		struct snd_info_buffer *buffer)
{
	struct snd_bebob *bebob = entry->private_data;
	struct snd_bebob_stream_formation *formation;
	unsigned int i;

	snd_iprintf(buffer, "Output Stream from device:\n");
	snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n");
	formation = bebob->tx_stream_formations;
	for (i = 0; i < SND_BEBOB_STRM_FMT_ENTRIES; i++) {
		snd_iprintf(buffer,
			    "\t%d\t%d\t%d\n", snd_bebob_rate_table[i],
			    formation[i].pcm, formation[i].midi);
	}

	snd_iprintf(buffer, "Input Stream to device:\n");
	snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n");
	formation = bebob->rx_stream_formations;
	for (i = 0; i < SND_BEBOB_STRM_FMT_ENTRIES; i++) {
		snd_iprintf(buffer,
			    "\t%d\t%d\t%d\n", snd_bebob_rate_table[i],
			    formation[i].pcm, formation[i].midi);
	}
}

static void
proc_read_clock(struct snd_info_entry *entry,
		struct snd_info_buffer *buffer)
{
	static const char *const clk_labels[] = {
		"Internal",
		"External",
		"SYT-Match",
	};
	struct snd_bebob *bebob = entry->private_data;
	const struct snd_bebob_rate_spec *rate_spec = bebob->spec->rate;
	const struct snd_bebob_clock_spec *clk_spec = bebob->spec->clock;
	enum snd_bebob_clock_type src;
	unsigned int rate;

	if (rate_spec->get(bebob, &rate) >= 0)
		snd_iprintf(buffer, "Sampling rate: %d\n", rate);

	if (snd_bebob_stream_get_clock_src(bebob, &src) >= 0) {
		if (clk_spec)
			snd_iprintf(buffer, "Clock Source: %s\n",
				    clk_labels[src]);
		else
			snd_iprintf(buffer, "Clock Source: %s (MSU-dest: %d)\n",
				    clk_labels[src], bebob->sync_input_plug);
	}
}

static void
add_node(struct snd_bebob *bebob, struct snd_info_entry *root, const char *name,
	 void (*op)(struct snd_info_entry *e, struct snd_info_buffer *b))
{
	struct snd_info_entry *entry;

	entry = snd_info_create_card_entry(bebob->card, name, root);
	if (entry == NULL)
		return;

	snd_info_set_text_ops(entry, bebob, op);
	if (snd_info_register(entry) < 0)
		snd_info_free_entry(entry);
}

void snd_bebob_proc_init(struct snd_bebob *bebob)
{
	struct snd_info_entry *root;

	/*
	 * All nodes are automatically removed at snd_card_disconnect(),
	 * by following to link list.
	 */
	root = snd_info_create_card_entry(bebob->card, "firewire",
					  bebob->card->proc_root);
	if (root == NULL)
		return;
	root->mode = S_IFDIR | S_IRUGO | S_IXUGO;
	if (snd_info_register(root) < 0) {
		snd_info_free_entry(root);
		return;
	}

	add_node(bebob, root, "clock", proc_read_clock);
	add_node(bebob, root, "firmware", proc_read_hw_info);
	add_node(bebob, root, "formation", proc_read_formation);

	if (bebob->spec->meter != NULL)
		add_node(bebob, root, "meter", proc_read_meters);
}
Commit	Line	Data
ad9697ba TS	1	/*
	2	* bebob_proc.c - a part of driver for BeBoB based devices
	3	*
	4	* Copyright (c) 2013-2014 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	#include "./bebob.h"
	10
	11	/* contents of information register */
	12	struct hw_info {
	13	u64 manufacturer;
	14	u32 protocol_ver;
	15	u32 bld_ver;
	16	u32 guid[2];
	17	u32 model_id;
	18	u32 model_rev;
	19	u64 fw_date;
	20	u64 fw_time;
	21	u32 fw_id;
	22	u32 fw_ver;
	23	u32 base_addr;
	24	u32 max_size;
	25	u64 bld_date;
	26	u64 bld_time;
	27	/* may not used in product
	28	u64 dbg_date;
	29	u64 dbg_time;
	30	u32 dbg_id;
	31	u32 dbg_version;
	32	*/
	33	} __packed;
	34
	35	static void
	36	proc_read_hw_info(struct snd_info_entry *entry,
	37	struct snd_info_buffer *buffer)
	38	{
	39	struct snd_bebob *bebob = entry->private_data;
	40	struct hw_info *info;
	41
	42	info = kzalloc(sizeof(struct hw_info), GFP_KERNEL);
	43	if (info == NULL)
	44	return;
	45
	46	if (snd_bebob_read_block(bebob->unit, 0,
	47	info, sizeof(struct hw_info)) < 0)
	48	goto end;
	49
	50	snd_iprintf(buffer, "Manufacturer:\t%.8s\n",
	51	(char *)&info->manufacturer);
	52	snd_iprintf(buffer, "Protocol Ver:\t%d\n", info->protocol_ver);
	53	snd_iprintf(buffer, "Build Ver:\t%d\n", info->bld_ver);
	54	snd_iprintf(buffer, "GUID:\t\t0x%.8X%.8X\n",
	55	info->guid[0], info->guid[1]);
	56	snd_iprintf(buffer, "Model ID:\t0x%02X\n", info->model_id);
	57	snd_iprintf(buffer, "Model Rev:\t%d\n", info->model_rev);
	58	snd_iprintf(buffer, "Firmware Date:\t%.8s\n", (char *)&info->fw_date);
	59	snd_iprintf(buffer, "Firmware Time:\t%.8s\n", (char *)&info->fw_time);
	60	snd_iprintf(buffer, "Firmware ID:\t0x%X\n", info->fw_id);
	61	snd_iprintf(buffer, "Firmware Ver:\t%d\n", info->fw_ver);
	62	snd_iprintf(buffer, "Base Addr:\t0x%X\n", info->base_addr);
	63	snd_iprintf(buffer, "Max Size:\t%d\n", info->max_size);
	64	snd_iprintf(buffer, "Loader Date:\t%.8s\n", (char *)&info->bld_date);
65	snd_iprintf(buffer, "Loader Time:\t%.8s\n", (char *)&info->bld_time);
66
67	end:
68	kfree(info);
69	}
70
1fc9522a TS	71	static void
	72	proc_read_meters(struct snd_info_entry *entry,
	73	struct snd_info_buffer *buffer)
	74	{
	75	struct snd_bebob *bebob = entry->private_data;
6b9866c8	76	const struct snd_bebob_meter_spec *spec = bebob->spec->meter;
1fc9522a TS	77	u32 *buf;
	78	unsigned int i, c, channels, size;
	79
	80	if (spec == NULL)
	81	return;
	82
	83	channels = spec->num * 2;
	84	size = channels * sizeof(u32);
	85	buf = kmalloc(size, GFP_KERNEL);
	86	if (buf == NULL)
	87	return;
	88
	89	if (spec->get(bebob, buf, size) < 0)
	90	goto end;
	91
	92	for (i = 0, c = 1; i < channels; i++) {
	93	snd_iprintf(buffer, "%s %d:\t%d\n",
	94	spec->labels[i / 2], c++, buf[i]);
	95	if ((i + 1 < channels - 1) &&
	96	(strcmp(spec->labels[i / 2],
	97	spec->labels[(i + 1) / 2]) != 0))
	98	c = 1;
	99	}
	100	end:
	101	kfree(buf);
	102	}
	103
ad9697ba TS	104	static void
	105	proc_read_formation(struct snd_info_entry *entry,
	106	struct snd_info_buffer *buffer)
	107	{
	108	struct snd_bebob *bebob = entry->private_data;
	109	struct snd_bebob_stream_formation *formation;
	110	unsigned int i;
	111
	112	snd_iprintf(buffer, "Output Stream from device:\n");
	113	snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n");
	114	formation = bebob->tx_stream_formations;
	115	for (i = 0; i < SND_BEBOB_STRM_FMT_ENTRIES; i++) {
	116	snd_iprintf(buffer,
	117	"\t%d\t%d\t%d\n", snd_bebob_rate_table[i],
	118	formation[i].pcm, formation[i].midi);
	119	}
	120
	121	snd_iprintf(buffer, "Input Stream to device:\n");
	122	snd_iprintf(buffer, "\tRate\tPCM\tMIDI\n");
	123	formation = bebob->rx_stream_formations;
	124	for (i = 0; i < SND_BEBOB_STRM_FMT_ENTRIES; i++) {
	125	snd_iprintf(buffer,
	126	"\t%d\t%d\t%d\n", snd_bebob_rate_table[i],
	127	formation[i].pcm, formation[i].midi);
	128	}
	129	}
	130
	131	static void
	132	proc_read_clock(struct snd_info_entry *entry,
	133	struct snd_info_buffer *buffer)
	134	{
3e254b16 TS	135	static const char *const clk_labels[] = {
	136	"Internal",
	137	"External",
	138	"SYT-Match",
	139	};
ad9697ba	140	struct snd_bebob *bebob = entry->private_data;
6b9866c8 JL	141	const struct snd_bebob_rate_spec *rate_spec = bebob->spec->rate;
6b9866c8 JL	142	const struct snd_bebob_clock_spec *clk_spec = bebob->spec->clock;
3e254b16 TS	143	enum snd_bebob_clock_type src;
3e254b16 TS	144	unsigned int rate;
ad9697ba	145
1fc9522a	146	if (rate_spec->get(bebob, &rate) >= 0)
ad9697ba TS	147	snd_iprintf(buffer, "Sampling rate: %d\n", rate);
ad9697ba TS	148
3e254b16 TS	149	if (snd_bebob_stream_get_clock_src(bebob, &src) >= 0) {
3e254b16 TS	150	if (clk_spec)
1fc9522a	151	snd_iprintf(buffer, "Clock Source: %s\n",
3e254b16 TS	152	clk_labels[src]);
3e254b16 TS	153	else
1fc9522a	154	snd_iprintf(buffer, "Clock Source: %s (MSU-dest: %d)\n",
3e254b16	155	clk_labels[src], bebob->sync_input_plug);
1fc9522a	156	}
ad9697ba TS	157	}
	158
	159	static void
	160	add_node(struct snd_bebob bebob, struct snd_info_entry root, const char *name,
	161	void (op)(struct snd_info_entry e, struct snd_info_buffer *b))
	162	{
	163	struct snd_info_entry *entry;
	164
	165	entry = snd_info_create_card_entry(bebob->card, name, root);
	166	if (entry == NULL)
	167	return;
	168
	169	snd_info_set_text_ops(entry, bebob, op);
	170	if (snd_info_register(entry) < 0)
	171	snd_info_free_entry(entry);
	172	}
	173
	174	void snd_bebob_proc_init(struct snd_bebob *bebob)
	175	{
	176	struct snd_info_entry *root;
	177
	178	/*
	179	* All nodes are automatically removed at snd_card_disconnect(),
	180	* by following to link list.
	181	*/
	182	root = snd_info_create_card_entry(bebob->card, "firewire",
	183	bebob->card->proc_root);
	184	if (root == NULL)
	185	return;
	186	root->mode = S_IFDIR \| S_IRUGO \| S_IXUGO;
	187	if (snd_info_register(root) < 0) {
	188	snd_info_free_entry(root);
	189	return;
	190	}
	191
	192	add_node(bebob, root, "clock", proc_read_clock);
	193	add_node(bebob, root, "firmware", proc_read_hw_info);
	194	add_node(bebob, root, "formation", proc_read_formation);
1fc9522a TS	195
	196	if (bebob->spec->meter != NULL)
	197	add_node(bebob, root, "meter", proc_read_meters);
ad9697ba	198	}