xref: /openbmc/linux/sound/pci/emu10k1/emuproc.c (revision bd7bf042e89941d4e693a0ec68c5093a2bb2adb3)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
31da177e4SLinus Torvalds  *                   Creative Labs, Inc.
41da177e4SLinus Torvalds  *  Routines for control of EMU10K1 chips / proc interface routines
51da177e4SLinus Torvalds  *
61da177e4SLinus Torvalds  *  BUGS:
71da177e4SLinus Torvalds  *    --
81da177e4SLinus Torvalds  *
91da177e4SLinus Torvalds  *  TODO:
101da177e4SLinus Torvalds  *    --
111da177e4SLinus Torvalds  *
121da177e4SLinus Torvalds  *   This program is free software; you can redistribute it and/or modify
131da177e4SLinus Torvalds  *   it under the terms of the GNU General Public License as published by
141da177e4SLinus Torvalds  *   the Free Software Foundation; either version 2 of the License, or
151da177e4SLinus Torvalds  *   (at your option) any later version.
161da177e4SLinus Torvalds  *
171da177e4SLinus Torvalds  *   This program is distributed in the hope that it will be useful,
181da177e4SLinus Torvalds  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
191da177e4SLinus Torvalds  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
201da177e4SLinus Torvalds  *   GNU General Public License for more details.
211da177e4SLinus Torvalds  *
221da177e4SLinus Torvalds  *   You should have received a copy of the GNU General Public License
231da177e4SLinus Torvalds  *   along with this program; if not, write to the Free Software
241da177e4SLinus Torvalds  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
251da177e4SLinus Torvalds  *
261da177e4SLinus Torvalds  */
271da177e4SLinus Torvalds 
281da177e4SLinus Torvalds #include <sound/driver.h>
291da177e4SLinus Torvalds #include <linux/slab.h>
301da177e4SLinus Torvalds #include <linux/init.h>
311da177e4SLinus Torvalds #include <sound/core.h>
321da177e4SLinus Torvalds #include <sound/emu10k1.h>
33001f7589SJames Courtier-Dutton #include "p16v.h"
341da177e4SLinus Torvalds 
351da177e4SLinus Torvalds static void snd_emu10k1_proc_spdif_status(emu10k1_t * emu,
361da177e4SLinus Torvalds 					  snd_info_buffer_t * buffer,
371da177e4SLinus Torvalds 					  char *title,
381da177e4SLinus Torvalds 					  int status_reg,
391da177e4SLinus Torvalds 					  int rate_reg)
401da177e4SLinus Torvalds {
411da177e4SLinus Torvalds 	static char *clkaccy[4] = { "1000ppm", "50ppm", "variable", "unknown" };
421da177e4SLinus Torvalds 	static int samplerate[16] = { 44100, 1, 48000, 32000, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
431da177e4SLinus Torvalds 	static char *channel[16] = { "unspec", "left", "right", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15" };
441da177e4SLinus Torvalds 	static char *emphasis[8] = { "none", "50/15 usec 2 channel", "2", "3", "4", "5", "6", "7" };
451da177e4SLinus Torvalds 	unsigned int status, rate = 0;
461da177e4SLinus Torvalds 
471da177e4SLinus Torvalds 	status = snd_emu10k1_ptr_read(emu, status_reg, 0);
481da177e4SLinus Torvalds 
491da177e4SLinus Torvalds 	snd_iprintf(buffer, "\n%s\n", title);
501da177e4SLinus Torvalds 
51df34140aSJames Courtier-Dutton 	if (status != 0xffffffff) {
521da177e4SLinus Torvalds 		snd_iprintf(buffer, "Professional Mode     : %s\n", (status & SPCS_PROFESSIONAL) ? "yes" : "no");
531da177e4SLinus Torvalds 		snd_iprintf(buffer, "Not Audio Data        : %s\n", (status & SPCS_NOTAUDIODATA) ? "yes" : "no");
541da177e4SLinus Torvalds 		snd_iprintf(buffer, "Copyright             : %s\n", (status & SPCS_COPYRIGHT) ? "yes" : "no");
551da177e4SLinus Torvalds 		snd_iprintf(buffer, "Emphasis              : %s\n", emphasis[(status & SPCS_EMPHASISMASK) >> 3]);
561da177e4SLinus Torvalds 		snd_iprintf(buffer, "Mode                  : %i\n", (status & SPCS_MODEMASK) >> 6);
571da177e4SLinus Torvalds 		snd_iprintf(buffer, "Category Code         : 0x%x\n", (status & SPCS_CATEGORYCODEMASK) >> 8);
581da177e4SLinus Torvalds 		snd_iprintf(buffer, "Generation Status     : %s\n", status & SPCS_GENERATIONSTATUS ? "original" : "copy");
591da177e4SLinus Torvalds 		snd_iprintf(buffer, "Source Mask           : %i\n", (status & SPCS_SOURCENUMMASK) >> 16);
601da177e4SLinus Torvalds 		snd_iprintf(buffer, "Channel Number        : %s\n", channel[(status & SPCS_CHANNELNUMMASK) >> 20]);
611da177e4SLinus Torvalds 		snd_iprintf(buffer, "Sample Rate           : %iHz\n", samplerate[(status & SPCS_SAMPLERATEMASK) >> 24]);
621da177e4SLinus Torvalds 		snd_iprintf(buffer, "Clock Accuracy        : %s\n", clkaccy[(status & SPCS_CLKACCYMASK) >> 28]);
631da177e4SLinus Torvalds 
641da177e4SLinus Torvalds 		if (rate_reg > 0) {
65df34140aSJames Courtier-Dutton 			rate = snd_emu10k1_ptr_read(emu, rate_reg, 0);
66001f7589SJames Courtier-Dutton 			snd_iprintf(buffer, "S/PDIF Valid          : %s\n", rate & SRCS_SPDIFVALID ? "on" : "off");
671da177e4SLinus Torvalds 			snd_iprintf(buffer, "S/PDIF Locked         : %s\n", rate & SRCS_SPDIFLOCKED ? "on" : "off");
681da177e4SLinus Torvalds 			snd_iprintf(buffer, "Rate Locked           : %s\n", rate & SRCS_RATELOCKED ? "on" : "off");
69df34140aSJames Courtier-Dutton 			/* From ((Rate * 48000 ) / 262144); */
70df34140aSJames Courtier-Dutton 			snd_iprintf(buffer, "Estimated Sample Rate : %d\n", ((rate & 0xFFFFF ) * 375) >> 11);
711da177e4SLinus Torvalds 		}
72df34140aSJames Courtier-Dutton 	} else {
73df34140aSJames Courtier-Dutton 		snd_iprintf(buffer, "No signal detected.\n");
74df34140aSJames Courtier-Dutton 	}
75df34140aSJames Courtier-Dutton 
761da177e4SLinus Torvalds }
771da177e4SLinus Torvalds 
781da177e4SLinus Torvalds static void snd_emu10k1_proc_read(snd_info_entry_t *entry,
791da177e4SLinus Torvalds 				  snd_info_buffer_t * buffer)
801da177e4SLinus Torvalds {
811da177e4SLinus Torvalds 	/* FIXME - output names are in emufx.c too */
821da177e4SLinus Torvalds 	static char *creative_outs[32] = {
831da177e4SLinus Torvalds 		/* 00 */ "AC97 Left",
841da177e4SLinus Torvalds 		/* 01 */ "AC97 Right",
851da177e4SLinus Torvalds 		/* 02 */ "Optical IEC958 Left",
861da177e4SLinus Torvalds 		/* 03 */ "Optical IEC958 Right",
871da177e4SLinus Torvalds 		/* 04 */ "Center",
881da177e4SLinus Torvalds 		/* 05 */ "LFE",
891da177e4SLinus Torvalds 		/* 06 */ "Headphone Left",
901da177e4SLinus Torvalds 		/* 07 */ "Headphone Right",
911da177e4SLinus Torvalds 		/* 08 */ "Surround Left",
921da177e4SLinus Torvalds 		/* 09 */ "Surround Right",
931da177e4SLinus Torvalds 		/* 10 */ "PCM Capture Left",
941da177e4SLinus Torvalds 		/* 11 */ "PCM Capture Right",
951da177e4SLinus Torvalds 		/* 12 */ "MIC Capture",
961da177e4SLinus Torvalds 		/* 13 */ "AC97 Surround Left",
971da177e4SLinus Torvalds 		/* 14 */ "AC97 Surround Right",
981da177e4SLinus Torvalds 		/* 15 */ "???",
991da177e4SLinus Torvalds 		/* 16 */ "???",
1001da177e4SLinus Torvalds 		/* 17 */ "Analog Center",
1011da177e4SLinus Torvalds 		/* 18 */ "Analog LFE",
1021da177e4SLinus Torvalds 		/* 19 */ "???",
1031da177e4SLinus Torvalds 		/* 20 */ "???",
1041da177e4SLinus Torvalds 		/* 21 */ "???",
1051da177e4SLinus Torvalds 		/* 22 */ "???",
1061da177e4SLinus Torvalds 		/* 23 */ "???",
1071da177e4SLinus Torvalds 		/* 24 */ "???",
1081da177e4SLinus Torvalds 		/* 25 */ "???",
1091da177e4SLinus Torvalds 		/* 26 */ "???",
1101da177e4SLinus Torvalds 		/* 27 */ "???",
1111da177e4SLinus Torvalds 		/* 28 */ "???",
1121da177e4SLinus Torvalds 		/* 29 */ "???",
1131da177e4SLinus Torvalds 		/* 30 */ "???",
1141da177e4SLinus Torvalds 		/* 31 */ "???"
1151da177e4SLinus Torvalds 	};
1161da177e4SLinus Torvalds 
1171da177e4SLinus Torvalds 	static char *audigy_outs[64] = {
1181da177e4SLinus Torvalds 		/* 00 */ "Digital Front Left",
1191da177e4SLinus Torvalds 		/* 01 */ "Digital Front Right",
1201da177e4SLinus Torvalds 		/* 02 */ "Digital Center",
1211da177e4SLinus Torvalds 		/* 03 */ "Digital LEF",
1221da177e4SLinus Torvalds 		/* 04 */ "Headphone Left",
1231da177e4SLinus Torvalds 		/* 05 */ "Headphone Right",
1241da177e4SLinus Torvalds 		/* 06 */ "Digital Rear Left",
1251da177e4SLinus Torvalds 		/* 07 */ "Digital Rear Right",
1261da177e4SLinus Torvalds 		/* 08 */ "Front Left",
1271da177e4SLinus Torvalds 		/* 09 */ "Front Right",
1281da177e4SLinus Torvalds 		/* 10 */ "Center",
1291da177e4SLinus Torvalds 		/* 11 */ "LFE",
1301da177e4SLinus Torvalds 		/* 12 */ "???",
1311da177e4SLinus Torvalds 		/* 13 */ "???",
1321da177e4SLinus Torvalds 		/* 14 */ "Rear Left",
1331da177e4SLinus Torvalds 		/* 15 */ "Rear Right",
1341da177e4SLinus Torvalds 		/* 16 */ "AC97 Front Left",
1351da177e4SLinus Torvalds 		/* 17 */ "AC97 Front Right",
1361da177e4SLinus Torvalds 		/* 18 */ "ADC Caputre Left",
1371da177e4SLinus Torvalds 		/* 19 */ "ADC Capture Right",
1381da177e4SLinus Torvalds 		/* 20 */ "???",
1391da177e4SLinus Torvalds 		/* 21 */ "???",
1401da177e4SLinus Torvalds 		/* 22 */ "???",
1411da177e4SLinus Torvalds 		/* 23 */ "???",
1421da177e4SLinus Torvalds 		/* 24 */ "???",
1431da177e4SLinus Torvalds 		/* 25 */ "???",
1441da177e4SLinus Torvalds 		/* 26 */ "???",
1451da177e4SLinus Torvalds 		/* 27 */ "???",
1461da177e4SLinus Torvalds 		/* 28 */ "???",
1471da177e4SLinus Torvalds 		/* 29 */ "???",
1481da177e4SLinus Torvalds 		/* 30 */ "???",
1491da177e4SLinus Torvalds 		/* 31 */ "???",
1501da177e4SLinus Torvalds 		/* 32 */ "FXBUS2_0",
1511da177e4SLinus Torvalds 		/* 33 */ "FXBUS2_1",
1521da177e4SLinus Torvalds 		/* 34 */ "FXBUS2_2",
1531da177e4SLinus Torvalds 		/* 35 */ "FXBUS2_3",
1541da177e4SLinus Torvalds 		/* 36 */ "FXBUS2_4",
1551da177e4SLinus Torvalds 		/* 37 */ "FXBUS2_5",
1561da177e4SLinus Torvalds 		/* 38 */ "FXBUS2_6",
1571da177e4SLinus Torvalds 		/* 39 */ "FXBUS2_7",
1581da177e4SLinus Torvalds 		/* 40 */ "FXBUS2_8",
1591da177e4SLinus Torvalds 		/* 41 */ "FXBUS2_9",
1601da177e4SLinus Torvalds 		/* 42 */ "FXBUS2_10",
1611da177e4SLinus Torvalds 		/* 43 */ "FXBUS2_11",
1621da177e4SLinus Torvalds 		/* 44 */ "FXBUS2_12",
1631da177e4SLinus Torvalds 		/* 45 */ "FXBUS2_13",
1641da177e4SLinus Torvalds 		/* 46 */ "FXBUS2_14",
1651da177e4SLinus Torvalds 		/* 47 */ "FXBUS2_15",
1661da177e4SLinus Torvalds 		/* 48 */ "FXBUS2_16",
1671da177e4SLinus Torvalds 		/* 49 */ "FXBUS2_17",
1681da177e4SLinus Torvalds 		/* 50 */ "FXBUS2_18",
1691da177e4SLinus Torvalds 		/* 51 */ "FXBUS2_19",
1701da177e4SLinus Torvalds 		/* 52 */ "FXBUS2_20",
1711da177e4SLinus Torvalds 		/* 53 */ "FXBUS2_21",
1721da177e4SLinus Torvalds 		/* 54 */ "FXBUS2_22",
1731da177e4SLinus Torvalds 		/* 55 */ "FXBUS2_23",
1741da177e4SLinus Torvalds 		/* 56 */ "FXBUS2_24",
1751da177e4SLinus Torvalds 		/* 57 */ "FXBUS2_25",
1761da177e4SLinus Torvalds 		/* 58 */ "FXBUS2_26",
1771da177e4SLinus Torvalds 		/* 59 */ "FXBUS2_27",
1781da177e4SLinus Torvalds 		/* 60 */ "FXBUS2_28",
1791da177e4SLinus Torvalds 		/* 61 */ "FXBUS2_29",
1801da177e4SLinus Torvalds 		/* 62 */ "FXBUS2_30",
1811da177e4SLinus Torvalds 		/* 63 */ "FXBUS2_31"
1821da177e4SLinus Torvalds 	};
1831da177e4SLinus Torvalds 
1841da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
1851da177e4SLinus Torvalds 	unsigned int val, val1;
1861da177e4SLinus Torvalds 	int nefx = emu->audigy ? 64 : 32;
1871da177e4SLinus Torvalds 	char **outputs = emu->audigy ? audigy_outs : creative_outs;
1881da177e4SLinus Torvalds 	int idx;
1891da177e4SLinus Torvalds 
1901da177e4SLinus Torvalds 	snd_iprintf(buffer, "EMU10K1\n\n");
1911da177e4SLinus Torvalds 	snd_iprintf(buffer, "Card                  : %s\n",
1922b637da5SLee Revell 		    emu->audigy ? "Audigy" : (emu->card_capabilities->ecard ? "EMU APS" : "Creative"));
1931da177e4SLinus Torvalds 	snd_iprintf(buffer, "Internal TRAM (words) : 0x%x\n", emu->fx8010.itram_size);
1941da177e4SLinus Torvalds 	snd_iprintf(buffer, "External TRAM (words) : 0x%x\n", (int)emu->fx8010.etram_pages.bytes / 2);
1951da177e4SLinus Torvalds 	snd_iprintf(buffer, "\n");
1961da177e4SLinus Torvalds 	snd_iprintf(buffer, "Effect Send Routing   :\n");
1971da177e4SLinus Torvalds 	for (idx = 0; idx < NUM_G; idx++) {
1981da177e4SLinus Torvalds 		val = emu->audigy ?
1991da177e4SLinus Torvalds 			snd_emu10k1_ptr_read(emu, A_FXRT1, idx) :
2001da177e4SLinus Torvalds 			snd_emu10k1_ptr_read(emu, FXRT, idx);
2011da177e4SLinus Torvalds 		val1 = emu->audigy ?
2021da177e4SLinus Torvalds 			snd_emu10k1_ptr_read(emu, A_FXRT2, idx) :
2031da177e4SLinus Torvalds 			0;
2041da177e4SLinus Torvalds 		if (emu->audigy) {
2051da177e4SLinus Torvalds 			snd_iprintf(buffer, "Ch%i: A=%i, B=%i, C=%i, D=%i, ",
2061da177e4SLinus Torvalds 				idx,
2071da177e4SLinus Torvalds 				val & 0x3f,
2081da177e4SLinus Torvalds 				(val >> 8) & 0x3f,
2091da177e4SLinus Torvalds 				(val >> 16) & 0x3f,
2101da177e4SLinus Torvalds 				(val >> 24) & 0x3f);
2111da177e4SLinus Torvalds 			snd_iprintf(buffer, "E=%i, F=%i, G=%i, H=%i\n",
2121da177e4SLinus Torvalds 				val1 & 0x3f,
2131da177e4SLinus Torvalds 				(val1 >> 8) & 0x3f,
2141da177e4SLinus Torvalds 				(val1 >> 16) & 0x3f,
2151da177e4SLinus Torvalds 				(val1 >> 24) & 0x3f);
2161da177e4SLinus Torvalds 		} else {
2171da177e4SLinus Torvalds 			snd_iprintf(buffer, "Ch%i: A=%i, B=%i, C=%i, D=%i\n",
2181da177e4SLinus Torvalds 				idx,
2191da177e4SLinus Torvalds 				(val >> 16) & 0x0f,
2201da177e4SLinus Torvalds 				(val >> 20) & 0x0f,
2211da177e4SLinus Torvalds 				(val >> 24) & 0x0f,
2221da177e4SLinus Torvalds 				(val >> 28) & 0x0f);
2231da177e4SLinus Torvalds 		}
2241da177e4SLinus Torvalds 	}
2251da177e4SLinus Torvalds 	snd_iprintf(buffer, "\nCaptured FX Outputs   :\n");
2261da177e4SLinus Torvalds 	for (idx = 0; idx < nefx; idx++) {
2271da177e4SLinus Torvalds 		if (emu->efx_voices_mask[idx/32] & (1 << (idx%32)))
2281da177e4SLinus Torvalds 			snd_iprintf(buffer, "  Output %02i [%s]\n", idx, outputs[idx]);
2291da177e4SLinus Torvalds 	}
2301da177e4SLinus Torvalds 	snd_iprintf(buffer, "\nAll FX Outputs        :\n");
2311da177e4SLinus Torvalds 	for (idx = 0; idx < (emu->audigy ? 64 : 32); idx++)
2321da177e4SLinus Torvalds 		snd_iprintf(buffer, "  Output %02i [%s]\n", idx, outputs[idx]);
233df34140aSJames Courtier-Dutton }
234df34140aSJames Courtier-Dutton 
235df34140aSJames Courtier-Dutton static void snd_emu10k1_proc_spdif_read(snd_info_entry_t *entry,
236df34140aSJames Courtier-Dutton 				  snd_info_buffer_t * buffer)
237df34140aSJames Courtier-Dutton {
238df34140aSJames Courtier-Dutton 	emu10k1_t *emu = entry->private_data;
239df34140aSJames Courtier-Dutton 	snd_emu10k1_proc_spdif_status(emu, buffer, "CD-ROM S/PDIF In", CDCS, CDSRCS);
240df34140aSJames Courtier-Dutton 	snd_emu10k1_proc_spdif_status(emu, buffer, "Optical or Coax S/PDIF In", GPSCS, GPSRCS);
241df34140aSJames Courtier-Dutton #if 0
2421da177e4SLinus Torvalds 	val = snd_emu10k1_ptr_read(emu, ZVSRCS, 0);
2431da177e4SLinus Torvalds 	snd_iprintf(buffer, "\nZoomed Video\n");
2441da177e4SLinus Torvalds 	snd_iprintf(buffer, "Rate Locked           : %s\n", val & SRCS_RATELOCKED ? "on" : "off");
2451da177e4SLinus Torvalds 	snd_iprintf(buffer, "Estimated Sample Rate : 0x%x\n", val & SRCS_ESTSAMPLERATE);
246df34140aSJames Courtier-Dutton #endif
2471da177e4SLinus Torvalds }
2481da177e4SLinus Torvalds 
249001f7589SJames Courtier-Dutton static void snd_emu10k1_proc_rates_read(snd_info_entry_t *entry,
250001f7589SJames Courtier-Dutton 				  snd_info_buffer_t * buffer)
251001f7589SJames Courtier-Dutton {
252001f7589SJames Courtier-Dutton 	static int samplerate[8] = { 44100, 48000, 96000, 192000, 4, 5, 6, 7 };
253001f7589SJames Courtier-Dutton 	emu10k1_t *emu = entry->private_data;
254001f7589SJames Courtier-Dutton 	unsigned int val, tmp, n;
255001f7589SJames Courtier-Dutton 	val = snd_emu10k1_ptr20_read(emu, CAPTURE_RATE_STATUS, 0);
256001f7589SJames Courtier-Dutton 	tmp = (val >> 16) & 0x8;
257001f7589SJames Courtier-Dutton 	for (n=0;n<4;n++) {
258001f7589SJames Courtier-Dutton 		tmp = val >> (16 + (n*4));
259001f7589SJames Courtier-Dutton 		if (tmp & 0x8) snd_iprintf(buffer, "Channel %d: Rate=%d\n", n, samplerate[tmp & 0x7]);
260001f7589SJames Courtier-Dutton 		else snd_iprintf(buffer, "Channel %d: No input\n", n);
261001f7589SJames Courtier-Dutton 	}
262001f7589SJames Courtier-Dutton }
263001f7589SJames Courtier-Dutton 
2641da177e4SLinus Torvalds static void snd_emu10k1_proc_acode_read(snd_info_entry_t *entry,
2651da177e4SLinus Torvalds 				        snd_info_buffer_t * buffer)
2661da177e4SLinus Torvalds {
2671da177e4SLinus Torvalds 	u32 pc;
2681da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
2691da177e4SLinus Torvalds 
2701da177e4SLinus Torvalds 	snd_iprintf(buffer, "FX8010 Instruction List '%s'\n", emu->fx8010.name);
2711da177e4SLinus Torvalds 	snd_iprintf(buffer, "  Code dump      :\n");
2721da177e4SLinus Torvalds 	for (pc = 0; pc < (emu->audigy ? 1024 : 512); pc++) {
2731da177e4SLinus Torvalds 		u32 low, high;
2741da177e4SLinus Torvalds 
2751da177e4SLinus Torvalds 		low = snd_emu10k1_efx_read(emu, pc * 2);
2761da177e4SLinus Torvalds 		high = snd_emu10k1_efx_read(emu, pc * 2 + 1);
2771da177e4SLinus Torvalds 		if (emu->audigy)
2781da177e4SLinus Torvalds 			snd_iprintf(buffer, "    OP(0x%02x, 0x%03x, 0x%03x, 0x%03x, 0x%03x) /* 0x%04x: 0x%08x%08x */\n",
2791da177e4SLinus Torvalds 				    (high >> 24) & 0x0f,
2801da177e4SLinus Torvalds 				    (high >> 12) & 0x7ff,
2811da177e4SLinus Torvalds 				    (high >> 0) & 0x7ff,
2821da177e4SLinus Torvalds 				    (low >> 12) & 0x7ff,
2831da177e4SLinus Torvalds 				    (low >> 0) & 0x7ff,
2841da177e4SLinus Torvalds 				    pc,
2851da177e4SLinus Torvalds 				    high, low);
2861da177e4SLinus Torvalds 		else
2871da177e4SLinus Torvalds 			snd_iprintf(buffer, "    OP(0x%02x, 0x%03x, 0x%03x, 0x%03x, 0x%03x) /* 0x%04x: 0x%08x%08x */\n",
2881da177e4SLinus Torvalds 				    (high >> 20) & 0x0f,
2891da177e4SLinus Torvalds 				    (high >> 10) & 0x3ff,
2901da177e4SLinus Torvalds 				    (high >> 0) & 0x3ff,
2911da177e4SLinus Torvalds 				    (low >> 10) & 0x3ff,
2921da177e4SLinus Torvalds 				    (low >> 0) & 0x3ff,
2931da177e4SLinus Torvalds 				    pc,
2941da177e4SLinus Torvalds 				    high, low);
2951da177e4SLinus Torvalds 	}
2961da177e4SLinus Torvalds }
2971da177e4SLinus Torvalds 
2981da177e4SLinus Torvalds #define TOTAL_SIZE_GPR		(0x100*4)
2991da177e4SLinus Torvalds #define A_TOTAL_SIZE_GPR	(0x200*4)
3001da177e4SLinus Torvalds #define TOTAL_SIZE_TANKMEM_DATA	(0xa0*4)
3011da177e4SLinus Torvalds #define TOTAL_SIZE_TANKMEM_ADDR (0xa0*4)
3021da177e4SLinus Torvalds #define A_TOTAL_SIZE_TANKMEM_DATA (0x100*4)
3031da177e4SLinus Torvalds #define A_TOTAL_SIZE_TANKMEM_ADDR (0x100*4)
3041da177e4SLinus Torvalds #define TOTAL_SIZE_CODE		(0x200*8)
3051da177e4SLinus Torvalds #define A_TOTAL_SIZE_CODE	(0x400*8)
3061da177e4SLinus Torvalds 
3071da177e4SLinus Torvalds static long snd_emu10k1_fx8010_read(snd_info_entry_t *entry, void *file_private_data,
3081da177e4SLinus Torvalds 				    struct file *file, char __user *buf,
3091da177e4SLinus Torvalds 				    unsigned long count, unsigned long pos)
3101da177e4SLinus Torvalds {
3111da177e4SLinus Torvalds 	long size;
3121da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
3131da177e4SLinus Torvalds 	unsigned int offset;
3141da177e4SLinus Torvalds 	int tram_addr = 0;
3151da177e4SLinus Torvalds 
3161da177e4SLinus Torvalds 	if (!strcmp(entry->name, "fx8010_tram_addr")) {
3171da177e4SLinus Torvalds 		offset = TANKMEMADDRREGBASE;
3181da177e4SLinus Torvalds 		tram_addr = 1;
3191da177e4SLinus Torvalds 	} else if (!strcmp(entry->name, "fx8010_tram_data")) {
3201da177e4SLinus Torvalds 		offset = TANKMEMDATAREGBASE;
3211da177e4SLinus Torvalds 	} else if (!strcmp(entry->name, "fx8010_code")) {
3221da177e4SLinus Torvalds 		offset = emu->audigy ? A_MICROCODEBASE : MICROCODEBASE;
3231da177e4SLinus Torvalds 	} else {
3241da177e4SLinus Torvalds 		offset = emu->audigy ? A_FXGPREGBASE : FXGPREGBASE;
3251da177e4SLinus Torvalds 	}
3261da177e4SLinus Torvalds 	size = count;
3271da177e4SLinus Torvalds 	if (pos + size > entry->size)
3281da177e4SLinus Torvalds 		size = (long)entry->size - pos;
3291da177e4SLinus Torvalds 	if (size > 0) {
3301da177e4SLinus Torvalds 		unsigned int *tmp;
3311da177e4SLinus Torvalds 		long res;
3321da177e4SLinus Torvalds 		unsigned int idx;
3331da177e4SLinus Torvalds 		if ((tmp = kmalloc(size + 8, GFP_KERNEL)) == NULL)
3341da177e4SLinus Torvalds 			return -ENOMEM;
3351da177e4SLinus Torvalds 		for (idx = 0; idx < ((pos & 3) + size + 3) >> 2; idx++)
3361da177e4SLinus Torvalds 			if (tram_addr && emu->audigy) {
3371da177e4SLinus Torvalds 				tmp[idx] = snd_emu10k1_ptr_read(emu, offset + idx + (pos >> 2), 0) >> 11;
3381da177e4SLinus Torvalds 				tmp[idx] |= snd_emu10k1_ptr_read(emu, 0x100 + idx + (pos >> 2), 0) << 20;
3391da177e4SLinus Torvalds 			} else
3401da177e4SLinus Torvalds 				tmp[idx] = snd_emu10k1_ptr_read(emu, offset + idx + (pos >> 2), 0);
3411da177e4SLinus Torvalds 		if (copy_to_user(buf, ((char *)tmp) + (pos & 3), size))
3421da177e4SLinus Torvalds 			res = -EFAULT;
3431da177e4SLinus Torvalds 		else {
3441da177e4SLinus Torvalds 			res = size;
3451da177e4SLinus Torvalds 		}
3461da177e4SLinus Torvalds 		kfree(tmp);
3471da177e4SLinus Torvalds 		return res;
3481da177e4SLinus Torvalds 	}
3491da177e4SLinus Torvalds 	return 0;
3501da177e4SLinus Torvalds }
3511da177e4SLinus Torvalds 
3521da177e4SLinus Torvalds static void snd_emu10k1_proc_voices_read(snd_info_entry_t *entry,
3531da177e4SLinus Torvalds 				  snd_info_buffer_t * buffer)
3541da177e4SLinus Torvalds {
3551da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
3561da177e4SLinus Torvalds 	emu10k1_voice_t *voice;
3571da177e4SLinus Torvalds 	int idx;
3581da177e4SLinus Torvalds 
3591da177e4SLinus Torvalds 	snd_iprintf(buffer, "ch\tuse\tpcm\tefx\tsynth\tmidi\n");
3601da177e4SLinus Torvalds 	for (idx = 0; idx < NUM_G; idx++) {
3611da177e4SLinus Torvalds 		voice = &emu->voices[idx];
3621da177e4SLinus Torvalds 		snd_iprintf(buffer, "%i\t%i\t%i\t%i\t%i\t%i\n",
3631da177e4SLinus Torvalds 			idx,
3641da177e4SLinus Torvalds 			voice->use,
3651da177e4SLinus Torvalds 			voice->pcm,
3661da177e4SLinus Torvalds 			voice->efx,
3671da177e4SLinus Torvalds 			voice->synth,
3681da177e4SLinus Torvalds 			voice->midi);
3691da177e4SLinus Torvalds 	}
3701da177e4SLinus Torvalds }
3711da177e4SLinus Torvalds 
3721da177e4SLinus Torvalds #ifdef CONFIG_SND_DEBUG
3731da177e4SLinus Torvalds static void snd_emu_proc_io_reg_read(snd_info_entry_t *entry,
3741da177e4SLinus Torvalds 				     snd_info_buffer_t * buffer)
3751da177e4SLinus Torvalds {
3761da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
3771da177e4SLinus Torvalds 	unsigned long value;
3781da177e4SLinus Torvalds 	unsigned long flags;
3791da177e4SLinus Torvalds 	int i;
3801da177e4SLinus Torvalds 	snd_iprintf(buffer, "IO Registers:\n\n");
3811da177e4SLinus Torvalds 	for(i = 0; i < 0x40; i+=4) {
3821da177e4SLinus Torvalds 		spin_lock_irqsave(&emu->emu_lock, flags);
3831da177e4SLinus Torvalds 		value = inl(emu->port + i);
3841da177e4SLinus Torvalds 		spin_unlock_irqrestore(&emu->emu_lock, flags);
3851da177e4SLinus Torvalds 		snd_iprintf(buffer, "%02X: %08lX\n", i, value);
3861da177e4SLinus Torvalds 	}
3871da177e4SLinus Torvalds }
3881da177e4SLinus Torvalds 
3891da177e4SLinus Torvalds static void snd_emu_proc_io_reg_write(snd_info_entry_t *entry,
3901da177e4SLinus Torvalds                                       snd_info_buffer_t * buffer)
3911da177e4SLinus Torvalds {
3921da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
3931da177e4SLinus Torvalds 	unsigned long flags;
3941da177e4SLinus Torvalds 	char line[64];
3951da177e4SLinus Torvalds 	u32 reg, val;
3961da177e4SLinus Torvalds 	while (!snd_info_get_line(buffer, line, sizeof(line))) {
3971da177e4SLinus Torvalds 		if (sscanf(line, "%x %x", &reg, &val) != 2)
3981da177e4SLinus Torvalds 			continue;
3991da177e4SLinus Torvalds 		if ((reg < 0x40) && (reg >=0) && (val <= 0xffffffff) ) {
4001da177e4SLinus Torvalds 			spin_lock_irqsave(&emu->emu_lock, flags);
4011da177e4SLinus Torvalds 			outl(val, emu->port + (reg & 0xfffffffc));
4021da177e4SLinus Torvalds 			spin_unlock_irqrestore(&emu->emu_lock, flags);
4031da177e4SLinus Torvalds 		}
4041da177e4SLinus Torvalds 	}
4051da177e4SLinus Torvalds }
4061da177e4SLinus Torvalds 
4071da177e4SLinus Torvalds static unsigned int snd_ptr_read(emu10k1_t * emu,
4081da177e4SLinus Torvalds 				 unsigned int iobase,
4091da177e4SLinus Torvalds 				 unsigned int reg,
4101da177e4SLinus Torvalds 				 unsigned int chn)
4111da177e4SLinus Torvalds {
4121da177e4SLinus Torvalds 	unsigned long flags;
4131da177e4SLinus Torvalds 	unsigned int regptr, val;
4141da177e4SLinus Torvalds 
4151da177e4SLinus Torvalds 	regptr = (reg << 16) | chn;
4161da177e4SLinus Torvalds 
4171da177e4SLinus Torvalds 	spin_lock_irqsave(&emu->emu_lock, flags);
4181da177e4SLinus Torvalds 	outl(regptr, emu->port + iobase + PTR);
4191da177e4SLinus Torvalds 	val = inl(emu->port + iobase + DATA);
4201da177e4SLinus Torvalds 	spin_unlock_irqrestore(&emu->emu_lock, flags);
4211da177e4SLinus Torvalds 	return val;
4221da177e4SLinus Torvalds }
4231da177e4SLinus Torvalds 
4241da177e4SLinus Torvalds static void snd_ptr_write(emu10k1_t *emu,
4251da177e4SLinus Torvalds 			  unsigned int iobase,
4261da177e4SLinus Torvalds 			  unsigned int reg,
4271da177e4SLinus Torvalds 			  unsigned int chn,
4281da177e4SLinus Torvalds 			  unsigned int data)
4291da177e4SLinus Torvalds {
4301da177e4SLinus Torvalds 	unsigned int regptr;
4311da177e4SLinus Torvalds 	unsigned long flags;
4321da177e4SLinus Torvalds 
4331da177e4SLinus Torvalds 	regptr = (reg << 16) | chn;
4341da177e4SLinus Torvalds 
4351da177e4SLinus Torvalds 	spin_lock_irqsave(&emu->emu_lock, flags);
4361da177e4SLinus Torvalds 	outl(regptr, emu->port + iobase + PTR);
4371da177e4SLinus Torvalds 	outl(data, emu->port + iobase + DATA);
4381da177e4SLinus Torvalds 	spin_unlock_irqrestore(&emu->emu_lock, flags);
4391da177e4SLinus Torvalds }
4401da177e4SLinus Torvalds 
4411da177e4SLinus Torvalds 
4421da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_read(snd_info_entry_t *entry,
4431da177e4SLinus Torvalds 				      snd_info_buffer_t * buffer, int iobase, int offset, int length, int voices)
4441da177e4SLinus Torvalds {
4451da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
4461da177e4SLinus Torvalds 	unsigned long value;
4471da177e4SLinus Torvalds 	int i,j;
4481da177e4SLinus Torvalds 	if (offset+length > 0x80) {
4491da177e4SLinus Torvalds 		snd_iprintf(buffer, "Input values out of range\n");
4501da177e4SLinus Torvalds 		return;
4511da177e4SLinus Torvalds 	}
4521da177e4SLinus Torvalds 	snd_iprintf(buffer, "Registers 0x%x\n", iobase);
4531da177e4SLinus Torvalds 	for(i = offset; i < offset+length; i++) {
4541da177e4SLinus Torvalds 		snd_iprintf(buffer, "%02X: ",i);
4551da177e4SLinus Torvalds 		for (j = 0; j < voices; j++) {
4561da177e4SLinus Torvalds 			if(iobase == 0)
4571da177e4SLinus Torvalds                 		value = snd_ptr_read(emu, 0, i, j);
4581da177e4SLinus Torvalds 			else
4591da177e4SLinus Torvalds                 		value = snd_ptr_read(emu, 0x20, i, j);
4601da177e4SLinus Torvalds 			snd_iprintf(buffer, "%08lX ", value);
4611da177e4SLinus Torvalds 		}
4621da177e4SLinus Torvalds 		snd_iprintf(buffer, "\n");
4631da177e4SLinus Torvalds 	}
4641da177e4SLinus Torvalds }
4651da177e4SLinus Torvalds 
4661da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_write(snd_info_entry_t *entry,
4671da177e4SLinus Torvalds 				       snd_info_buffer_t * buffer, int iobase)
4681da177e4SLinus Torvalds {
4691da177e4SLinus Torvalds 	emu10k1_t *emu = entry->private_data;
4701da177e4SLinus Torvalds 	char line[64];
4711da177e4SLinus Torvalds 	unsigned int reg, channel_id , val;
4721da177e4SLinus Torvalds 	while (!snd_info_get_line(buffer, line, sizeof(line))) {
4731da177e4SLinus Torvalds 		if (sscanf(line, "%x %x %x", &reg, &channel_id, &val) != 3)
4741da177e4SLinus Torvalds 			continue;
4751da177e4SLinus Torvalds 		if ((reg < 0x80) && (reg >=0) && (val <= 0xffffffff) && (channel_id >=0) && (channel_id <= 3) )
4761da177e4SLinus Torvalds 			snd_ptr_write(emu, iobase, reg, channel_id, val);
4771da177e4SLinus Torvalds 	}
4781da177e4SLinus Torvalds }
4791da177e4SLinus Torvalds 
4801da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_write00(snd_info_entry_t *entry,
4811da177e4SLinus Torvalds 					 snd_info_buffer_t * buffer)
4821da177e4SLinus Torvalds {
4831da177e4SLinus Torvalds 	snd_emu_proc_ptr_reg_write(entry, buffer, 0);
4841da177e4SLinus Torvalds }
4851da177e4SLinus Torvalds 
4861da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_write20(snd_info_entry_t *entry,
4871da177e4SLinus Torvalds 					 snd_info_buffer_t * buffer)
4881da177e4SLinus Torvalds {
4891da177e4SLinus Torvalds 	snd_emu_proc_ptr_reg_write(entry, buffer, 0x20);
4901da177e4SLinus Torvalds }
4911da177e4SLinus Torvalds 
4921da177e4SLinus Torvalds 
4931da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_read00a(snd_info_entry_t *entry,
4941da177e4SLinus Torvalds 					 snd_info_buffer_t * buffer)
4951da177e4SLinus Torvalds {
4961da177e4SLinus Torvalds 	snd_emu_proc_ptr_reg_read(entry, buffer, 0, 0, 0x40, 64);
4971da177e4SLinus Torvalds }
4981da177e4SLinus Torvalds 
4991da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_read00b(snd_info_entry_t *entry,
5001da177e4SLinus Torvalds 					 snd_info_buffer_t * buffer)
5011da177e4SLinus Torvalds {
5021da177e4SLinus Torvalds 	snd_emu_proc_ptr_reg_read(entry, buffer, 0, 0x40, 0x40, 64);
5031da177e4SLinus Torvalds }
5041da177e4SLinus Torvalds 
5051da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_read20a(snd_info_entry_t *entry,
5061da177e4SLinus Torvalds 					 snd_info_buffer_t * buffer)
5071da177e4SLinus Torvalds {
5081da177e4SLinus Torvalds 	snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0, 0x40, 4);
5091da177e4SLinus Torvalds }
5101da177e4SLinus Torvalds 
5111da177e4SLinus Torvalds static void snd_emu_proc_ptr_reg_read20b(snd_info_entry_t *entry,
5121da177e4SLinus Torvalds 					 snd_info_buffer_t * buffer)
5131da177e4SLinus Torvalds {
5141da177e4SLinus Torvalds 	snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0x40, 0x40, 4);
5151da177e4SLinus Torvalds }
5161da177e4SLinus Torvalds #endif
5171da177e4SLinus Torvalds 
5181da177e4SLinus Torvalds static struct snd_info_entry_ops snd_emu10k1_proc_ops_fx8010 = {
5191da177e4SLinus Torvalds 	.read = snd_emu10k1_fx8010_read,
5201da177e4SLinus Torvalds };
5211da177e4SLinus Torvalds 
5221da177e4SLinus Torvalds int __devinit snd_emu10k1_proc_init(emu10k1_t * emu)
5231da177e4SLinus Torvalds {
5241da177e4SLinus Torvalds 	snd_info_entry_t *entry;
5251da177e4SLinus Torvalds #ifdef CONFIG_SND_DEBUG
5261da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "io_regs", &entry)) {
5271da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 1024, snd_emu_proc_io_reg_read);
5281da177e4SLinus Torvalds 		entry->c.text.write_size = 64;
5291da177e4SLinus Torvalds 		entry->c.text.write = snd_emu_proc_io_reg_write;
530*bd7bf042STakashi Iwai 		entry->mode |= S_IWUSR;
5311da177e4SLinus Torvalds 	}
5321da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "ptr_regs00a", &entry)) {
5331da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read00a);
5341da177e4SLinus Torvalds 		entry->c.text.write_size = 64;
5351da177e4SLinus Torvalds 		entry->c.text.write = snd_emu_proc_ptr_reg_write00;
536*bd7bf042STakashi Iwai 		entry->mode |= S_IWUSR;
5371da177e4SLinus Torvalds 	}
5381da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "ptr_regs00b", &entry)) {
5391da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read00b);
5401da177e4SLinus Torvalds 		entry->c.text.write_size = 64;
5411da177e4SLinus Torvalds 		entry->c.text.write = snd_emu_proc_ptr_reg_write00;
542*bd7bf042STakashi Iwai 		entry->mode |= S_IWUSR;
5431da177e4SLinus Torvalds 	}
5441da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "ptr_regs20a", &entry)) {
5451da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read20a);
5461da177e4SLinus Torvalds 		entry->c.text.write_size = 64;
5471da177e4SLinus Torvalds 		entry->c.text.write = snd_emu_proc_ptr_reg_write20;
548*bd7bf042STakashi Iwai 		entry->mode |= S_IWUSR;
5491da177e4SLinus Torvalds 	}
5501da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "ptr_regs20b", &entry)) {
5511da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 65536, snd_emu_proc_ptr_reg_read20b);
5521da177e4SLinus Torvalds 		entry->c.text.write_size = 64;
5531da177e4SLinus Torvalds 		entry->c.text.write = snd_emu_proc_ptr_reg_write20;
554*bd7bf042STakashi Iwai 		entry->mode |= S_IWUSR;
5551da177e4SLinus Torvalds 	}
5561da177e4SLinus Torvalds #endif
5571da177e4SLinus Torvalds 
5581da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "emu10k1", &entry))
5591da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_read);
5601da177e4SLinus Torvalds 
561df34140aSJames Courtier-Dutton 	if (emu->card_capabilities->emu10k2_chip) {
562df34140aSJames Courtier-Dutton 		if (! snd_card_proc_new(emu->card, "spdif-in", &entry))
563df34140aSJames Courtier-Dutton 			snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_spdif_read);
564df34140aSJames Courtier-Dutton 	}
565001f7589SJames Courtier-Dutton 	if (emu->card_capabilities->ca0151_chip) {
566001f7589SJames Courtier-Dutton 		if (! snd_card_proc_new(emu->card, "capture-rates", &entry))
567001f7589SJames Courtier-Dutton 			snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_rates_read);
568001f7589SJames Courtier-Dutton 	}
569df34140aSJames Courtier-Dutton 
5701da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "voices", &entry))
5711da177e4SLinus Torvalds 		snd_info_set_text_ops(entry, emu, 2048, snd_emu10k1_proc_voices_read);
5721da177e4SLinus Torvalds 
5731da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "fx8010_gpr", &entry)) {
5741da177e4SLinus Torvalds 		entry->content = SNDRV_INFO_CONTENT_DATA;
5751da177e4SLinus Torvalds 		entry->private_data = emu;
5761da177e4SLinus Torvalds 		entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
5771da177e4SLinus Torvalds 		entry->size = emu->audigy ? A_TOTAL_SIZE_GPR : TOTAL_SIZE_GPR;
5781da177e4SLinus Torvalds 		entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
5791da177e4SLinus Torvalds 	}
5801da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "fx8010_tram_data", &entry)) {
5811da177e4SLinus Torvalds 		entry->content = SNDRV_INFO_CONTENT_DATA;
5821da177e4SLinus Torvalds 		entry->private_data = emu;
5831da177e4SLinus Torvalds 		entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
5841da177e4SLinus Torvalds 		entry->size = emu->audigy ? A_TOTAL_SIZE_TANKMEM_DATA : TOTAL_SIZE_TANKMEM_DATA ;
5851da177e4SLinus Torvalds 		entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
5861da177e4SLinus Torvalds 	}
5871da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "fx8010_tram_addr", &entry)) {
5881da177e4SLinus Torvalds 		entry->content = SNDRV_INFO_CONTENT_DATA;
5891da177e4SLinus Torvalds 		entry->private_data = emu;
5901da177e4SLinus Torvalds 		entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
5911da177e4SLinus Torvalds 		entry->size = emu->audigy ? A_TOTAL_SIZE_TANKMEM_ADDR : TOTAL_SIZE_TANKMEM_ADDR ;
5921da177e4SLinus Torvalds 		entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
5931da177e4SLinus Torvalds 	}
5941da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "fx8010_code", &entry)) {
5951da177e4SLinus Torvalds 		entry->content = SNDRV_INFO_CONTENT_DATA;
5961da177e4SLinus Torvalds 		entry->private_data = emu;
5971da177e4SLinus Torvalds 		entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
5981da177e4SLinus Torvalds 		entry->size = emu->audigy ? A_TOTAL_SIZE_CODE : TOTAL_SIZE_CODE;
5991da177e4SLinus Torvalds 		entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
6001da177e4SLinus Torvalds 	}
6011da177e4SLinus Torvalds 	if (! snd_card_proc_new(emu->card, "fx8010_acode", &entry)) {
6021da177e4SLinus Torvalds 		entry->content = SNDRV_INFO_CONTENT_TEXT;
6031da177e4SLinus Torvalds 		entry->private_data = emu;
6041da177e4SLinus Torvalds 		entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
6051da177e4SLinus Torvalds 		entry->c.text.read_size = 128*1024;
6061da177e4SLinus Torvalds 		entry->c.text.read = snd_emu10k1_proc_acode_read;
6071da177e4SLinus Torvalds 	}
6081da177e4SLinus Torvalds 	return 0;
6091da177e4SLinus Torvalds }
610