hda_proc.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367
  1. /*
  2. * Universal Interface for Intel High Definition Audio Codec
  3. *
  4. * Generic proc interface
  5. *
  6. * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
  7. *
  8. *
  9. * This driver is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * (at your option) any later version.
  13. *
  14. * This driver is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22. */
  23. #include <sound/driver.h>
  24. #include <linux/init.h>
  25. #include <linux/pci.h>
  26. #include <sound/core.h>
  27. #include "hda_codec.h"
  28. #include "hda_local.h"
  29. static const char *get_wid_type_name(unsigned int wid_value)
  30. {
  31. static char *names[16] = {
  32. [AC_WID_AUD_OUT] = "Audio Output",
  33. [AC_WID_AUD_IN] = "Audio Input",
  34. [AC_WID_AUD_MIX] = "Audio Mixer",
  35. [AC_WID_AUD_SEL] = "Audio Selector",
  36. [AC_WID_PIN] = "Pin Complex",
  37. [AC_WID_POWER] = "Power Widget",
  38. [AC_WID_VOL_KNB] = "Volume Knob Widget",
  39. [AC_WID_BEEP] = "Beep Generator Widget",
  40. [AC_WID_VENDOR] = "Vendor Defined Widget",
  41. };
  42. wid_value &= 0xf;
  43. if (names[wid_value])
  44. return names[wid_value];
  45. else
  46. return "UNKNOWN Widget";
  47. }
  48. static void print_amp_caps(struct snd_info_buffer *buffer,
  49. struct hda_codec *codec, hda_nid_t nid, int dir)
  50. {
  51. unsigned int caps;
  52. caps = snd_hda_param_read(codec, nid,
  53. dir == HDA_OUTPUT ?
  54. AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP);
  55. if (caps == -1 || caps == 0) {
  56. snd_iprintf(buffer, "N/A\n");
  57. return;
  58. }
  59. snd_iprintf(buffer, "ofs=0x%02x, nsteps=0x%02x, stepsize=0x%02x, mute=%x\n",
  60. caps & AC_AMPCAP_OFFSET,
  61. (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT,
  62. (caps & AC_AMPCAP_STEP_SIZE) >> AC_AMPCAP_STEP_SIZE_SHIFT,
  63. (caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT);
  64. }
  65. static void print_amp_vals(struct snd_info_buffer *buffer,
  66. struct hda_codec *codec, hda_nid_t nid,
  67. int dir, int stereo, int indices)
  68. {
  69. unsigned int val;
  70. int i;
  71. dir = dir == HDA_OUTPUT ? AC_AMP_GET_OUTPUT : AC_AMP_GET_INPUT;
  72. for (i = 0; i < indices; i++) {
  73. snd_iprintf(buffer, " [");
  74. if (stereo) {
  75. val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_AMP_GAIN_MUTE,
  76. AC_AMP_GET_LEFT | dir | i);
  77. snd_iprintf(buffer, "0x%02x ", val);
  78. }
  79. val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_AMP_GAIN_MUTE,
  80. AC_AMP_GET_RIGHT | dir | i);
  81. snd_iprintf(buffer, "0x%02x]", val);
  82. }
  83. snd_iprintf(buffer, "\n");
  84. }
  85. static void print_pcm_rates(struct snd_info_buffer *buffer, unsigned int pcm)
  86. {
  87. static unsigned int rates[] = {
  88. 8000, 11025, 16000, 22050, 32000, 44100, 48000, 88200,
  89. 96000, 176400, 192000, 384000
  90. };
  91. int i;
  92. pcm &= AC_SUPPCM_RATES;
  93. snd_iprintf(buffer, " rates [0x%x]:", pcm);
  94. for (i = 0; i < ARRAY_SIZE(rates); i++)
  95. if (pcm & (1 << i))
  96. snd_iprintf(buffer, " %d", rates[i]);
  97. snd_iprintf(buffer, "\n");
  98. }
  99. static void print_pcm_bits(struct snd_info_buffer *buffer, unsigned int pcm)
  100. {
  101. static unsigned int bits[] = { 8, 16, 20, 24, 32 };
  102. int i;
  103. pcm = (pcm >> 16) & 0xff;
  104. snd_iprintf(buffer, " bits [0x%x]:", pcm);
  105. for (i = 0; i < ARRAY_SIZE(bits); i++)
  106. if (pcm & (1 << i))
  107. snd_iprintf(buffer, " %d", bits[i]);
  108. snd_iprintf(buffer, "\n");
  109. }
  110. static void print_pcm_formats(struct snd_info_buffer *buffer,
  111. unsigned int streams)
  112. {
  113. snd_iprintf(buffer, " formats [0x%x]:", streams & 0xf);
  114. if (streams & AC_SUPFMT_PCM)
  115. snd_iprintf(buffer, " PCM");
  116. if (streams & AC_SUPFMT_FLOAT32)
  117. snd_iprintf(buffer, " FLOAT");
  118. if (streams & AC_SUPFMT_AC3)
  119. snd_iprintf(buffer, " AC3");
  120. snd_iprintf(buffer, "\n");
  121. }
  122. static void print_pcm_caps(struct snd_info_buffer *buffer,
  123. struct hda_codec *codec, hda_nid_t nid)
  124. {
  125. unsigned int pcm = snd_hda_param_read(codec, nid, AC_PAR_PCM);
  126. unsigned int stream = snd_hda_param_read(codec, nid, AC_PAR_STREAM);
  127. if (pcm == -1 || stream == -1) {
  128. snd_iprintf(buffer, "N/A\n");
  129. return;
  130. }
  131. print_pcm_rates(buffer, pcm);
  132. print_pcm_bits(buffer, pcm);
  133. print_pcm_formats(buffer, stream);
  134. }
  135. static const char *get_jack_location(u32 cfg)
  136. {
  137. static char *bases[7] = {
  138. "N/A", "Rear", "Front", "Left", "Right", "Top", "Bottom",
  139. };
  140. static unsigned char specials_idx[] = {
  141. 0x07, 0x08,
  142. 0x17, 0x18, 0x19,
  143. 0x37, 0x38
  144. };
  145. static char *specials[] = {
  146. "Rear Panel", "Drive Bar",
  147. "Riser", "HDMI", "ATAPI",
  148. "Mobile-In", "Mobile-Out"
  149. };
  150. int i;
  151. cfg = (cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT;
  152. if ((cfg & 0x0f) < 7)
  153. return bases[cfg & 0x0f];
  154. for (i = 0; i < ARRAY_SIZE(specials_idx); i++) {
  155. if (cfg == specials_idx[i])
  156. return specials[i];
  157. }
  158. return "UNKNOWN";
  159. }
  160. static const char *get_jack_connection(u32 cfg)
  161. {
  162. static char *names[16] = {
  163. "Unknown", "1/8", "1/4", "ATAPI",
  164. "RCA", "Optical","Digital", "Analog",
  165. "DIN", "XLR", "RJ11", "Comb",
  166. NULL, NULL, NULL, "Other"
  167. };
  168. cfg = (cfg & AC_DEFCFG_CONN_TYPE) >> AC_DEFCFG_CONN_TYPE_SHIFT;
  169. if (names[cfg])
  170. return names[cfg];
  171. else
  172. return "UNKNOWN";
  173. }
  174. static const char *get_jack_color(u32 cfg)
  175. {
  176. static char *names[16] = {
  177. "Unknown", "Black", "Grey", "Blue",
  178. "Green", "Red", "Orange", "Yellow",
  179. "Purple", "Pink", NULL, NULL,
  180. NULL, NULL, "White", "Other",
  181. };
  182. cfg = (cfg & AC_DEFCFG_COLOR) >> AC_DEFCFG_COLOR_SHIFT;
  183. if (names[cfg])
  184. return names[cfg];
  185. else
  186. return "UNKNOWN";
  187. }
  188. static void print_pin_caps(struct snd_info_buffer *buffer,
  189. struct hda_codec *codec, hda_nid_t nid)
  190. {
  191. static char *jack_conns[4] = { "Jack", "N/A", "Fixed", "Both" };
  192. static char *jack_types[16] = {
  193. "Line Out", "Speaker", "HP Out", "CD",
  194. "SPDIF Out", "Digital Out", "Modem Line", "Modem Hand",
  195. "Line In", "Aux", "Mic", "Telephony",
  196. "SPDIF In", "Digitial In", "Reserved", "Other"
  197. };
  198. static char *jack_locations[4] = { "Ext", "Int", "Sep", "Oth" };
  199. unsigned int caps;
  200. caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
  201. snd_iprintf(buffer, " Pincap 0x08%x:", caps);
  202. if (caps & AC_PINCAP_IN)
  203. snd_iprintf(buffer, " IN");
  204. if (caps & AC_PINCAP_OUT)
  205. snd_iprintf(buffer, " OUT");
  206. if (caps & AC_PINCAP_HP_DRV)
  207. snd_iprintf(buffer, " HP");
  208. if (caps & AC_PINCAP_EAPD)
  209. snd_iprintf(buffer, " EAPD");
  210. if (caps & AC_PINCAP_PRES_DETECT)
  211. snd_iprintf(buffer, " Detect");
  212. snd_iprintf(buffer, "\n");
  213. caps = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
  214. snd_iprintf(buffer, " Pin Default 0x%08x: [%s] %s at %s %s\n", caps,
  215. jack_conns[(caps & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT],
  216. jack_types[(caps & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT],
  217. jack_locations[(caps >> (AC_DEFCFG_LOCATION_SHIFT + 4)) & 3],
  218. get_jack_location(caps));
  219. snd_iprintf(buffer, " Conn = %s, Color = %s\n",
  220. get_jack_connection(caps),
  221. get_jack_color(caps));
  222. }
  223. static void print_codec_info(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  224. {
  225. struct hda_codec *codec = entry->private_data;
  226. char buf[32];
  227. hda_nid_t nid;
  228. int i, nodes;
  229. snd_hda_get_codec_name(codec, buf, sizeof(buf));
  230. snd_iprintf(buffer, "Codec: %s\n", buf);
  231. snd_iprintf(buffer, "Address: %d\n", codec->addr);
  232. snd_iprintf(buffer, "Vendor Id: 0x%x\n", codec->vendor_id);
  233. snd_iprintf(buffer, "Subsystem Id: 0x%x\n", codec->subsystem_id);
  234. snd_iprintf(buffer, "Revision Id: 0x%x\n", codec->revision_id);
  235. if (! codec->afg)
  236. return;
  237. snd_iprintf(buffer, "Default PCM:\n");
  238. print_pcm_caps(buffer, codec, codec->afg);
  239. snd_iprintf(buffer, "Default Amp-In caps: ");
  240. print_amp_caps(buffer, codec, codec->afg, HDA_INPUT);
  241. snd_iprintf(buffer, "Default Amp-Out caps: ");
  242. print_amp_caps(buffer, codec, codec->afg, HDA_OUTPUT);
  243. nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
  244. if (! nid || nodes < 0) {
  245. snd_iprintf(buffer, "Invalid AFG subtree\n");
  246. return;
  247. }
  248. for (i = 0; i < nodes; i++, nid++) {
  249. unsigned int wid_caps = snd_hda_param_read(codec, nid,
  250. AC_PAR_AUDIO_WIDGET_CAP);
  251. unsigned int wid_type = (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
  252. int conn_len = 0;
  253. hda_nid_t conn[HDA_MAX_CONNECTIONS];
  254. snd_iprintf(buffer, "Node 0x%02x [%s] wcaps 0x%x:", nid,
  255. get_wid_type_name(wid_type), wid_caps);
  256. if (wid_caps & AC_WCAP_STEREO)
  257. snd_iprintf(buffer, " Stereo");
  258. else
  259. snd_iprintf(buffer, " Mono");
  260. if (wid_caps & AC_WCAP_DIGITAL)
  261. snd_iprintf(buffer, " Digital");
  262. if (wid_caps & AC_WCAP_IN_AMP)
  263. snd_iprintf(buffer, " Amp-In");
  264. if (wid_caps & AC_WCAP_OUT_AMP)
  265. snd_iprintf(buffer, " Amp-Out");
  266. snd_iprintf(buffer, "\n");
  267. if (wid_caps & AC_WCAP_CONN_LIST)
  268. conn_len = snd_hda_get_connections(codec, nid, conn,
  269. HDA_MAX_CONNECTIONS);
  270. if (wid_caps & AC_WCAP_IN_AMP) {
  271. snd_iprintf(buffer, " Amp-In caps: ");
  272. print_amp_caps(buffer, codec, nid, HDA_INPUT);
  273. snd_iprintf(buffer, " Amp-In vals: ");
  274. print_amp_vals(buffer, codec, nid, HDA_INPUT,
  275. wid_caps & AC_WCAP_STEREO, conn_len);
  276. }
  277. if (wid_caps & AC_WCAP_OUT_AMP) {
  278. snd_iprintf(buffer, " Amp-Out caps: ");
  279. print_amp_caps(buffer, codec, nid, HDA_OUTPUT);
  280. snd_iprintf(buffer, " Amp-Out vals: ");
  281. print_amp_vals(buffer, codec, nid, HDA_OUTPUT,
  282. wid_caps & AC_WCAP_STEREO, 1);
  283. }
  284. if (wid_type == AC_WID_PIN) {
  285. unsigned int pinctls;
  286. print_pin_caps(buffer, codec, nid);
  287. pinctls = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  288. snd_iprintf(buffer, " Pin-ctls: 0x%02x:", pinctls);
  289. if (pinctls & AC_PINCTL_IN_EN)
  290. snd_iprintf(buffer, " IN");
  291. if (pinctls & AC_PINCTL_OUT_EN)
  292. snd_iprintf(buffer, " OUT");
  293. if (pinctls & AC_PINCTL_HP_EN)
  294. snd_iprintf(buffer, " HP");
  295. snd_iprintf(buffer, "\n");
  296. }
  297. if ((wid_type == AC_WID_AUD_OUT || wid_type == AC_WID_AUD_IN) &&
  298. (wid_caps & AC_WCAP_FORMAT_OVRD)) {
  299. snd_iprintf(buffer, " PCM:\n");
  300. print_pcm_caps(buffer, codec, nid);
  301. }
  302. if (wid_caps & AC_WCAP_POWER)
  303. snd_iprintf(buffer, " Power: 0x%x\n",
  304. snd_hda_codec_read(codec, nid, 0,
  305. AC_VERB_GET_POWER_STATE, 0));
  306. if (wid_caps & AC_WCAP_CONN_LIST) {
  307. int c, curr = -1;
  308. if (conn_len > 1 && wid_type != AC_WID_AUD_MIX)
  309. curr = snd_hda_codec_read(codec, nid, 0,
  310. AC_VERB_GET_CONNECT_SEL, 0);
  311. snd_iprintf(buffer, " Connection: %d\n", conn_len);
  312. snd_iprintf(buffer, " ");
  313. for (c = 0; c < conn_len; c++) {
  314. snd_iprintf(buffer, " 0x%02x", conn[c]);
  315. if (c == curr)
  316. snd_iprintf(buffer, "*");
  317. }
  318. snd_iprintf(buffer, "\n");
  319. }
  320. }
  321. }
  322. /*
  323. * create a proc read
  324. */
  325. int snd_hda_codec_proc_new(struct hda_codec *codec)
  326. {
  327. char name[32];
  328. struct snd_info_entry *entry;
  329. int err;
  330. snprintf(name, sizeof(name), "codec#%d", codec->addr);
  331. err = snd_card_proc_new(codec->bus->card, name, &entry);
  332. if (err < 0)
  333. return err;
  334. snd_info_set_text_ops(entry, codec, print_codec_info);
  335. return 0;
  336. }