spacepaste

Paste details

reply | raw | toggle line wrapping

  1.  
  2. --- a/sound/pci/hda/patch_ca0132.c 2018-04-01 17:20:27.000000000 -0400
  3. +++ b/sound/pci/hda/patch_ca0132.c 2018-05-02 07:47:08.000000000 -0400
  4. @@ -29,6 +29,9 @@
  5. #include <linux/firmware.h>
  6. #include <linux/kernel.h>
  7. #include <sound/core.h>
  8. +#include <linux/types.h>
  9. +#include <linux/io.h>
  10. +#include <linux/pci.h>
  11. #include "hda_codec.h"
  12. #include "hda_local.h"
  13. #include "hda_auto_parser.h"
  14. @@ -42,6 +45,8 @@
  15. #define FLOAT_ZERO 0x00000000
  16. #define FLOAT_ONE 0x3f800000
  17. #define FLOAT_TWO 0x40000000
  18. +#define FLOAT_THREE 0x40400000
  19. +#define FLOAT_EIGHT 0x41000000
  20. #define FLOAT_MINUS_5 0xc0a00000
  22. #define UNSOL_TAG_DSP 0x16
  23. @@ -72,16 +77,22 @@
  24. #define SCP_GET 1
  26. #define EFX_FILE "ctefx.bin"
  27. +#define SBZ_EFX_FILE "ctefx-sbz.bin"
  28. +#define R3DI_EFX_FILE "ctefx-r3di.bin"
  30. #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
  31. MODULE_FIRMWARE(EFX_FILE);
  32. +MODULE_FIRMWARE(SBZ_EFX_FILE);
  33. +MODULE_FIRMWARE(R3DI_EFX_FILE);
  34. #endif
  36. -static char *dirstr[2] = { "Playback", "Capture" };
  37. +static const char *dirstr[2] = { "Playback", "Capture" };
  39. +#define NUM_OF_OUTPUTS 3
  40. enum {
  41. SPEAKER_OUT,
  42. - HEADPHONE_OUT
  43. + HEADPHONE_OUT,
  44. + SURROUND_OUT
  45. };
  47. enum {
  48. @@ -89,6 +100,15 @@
  49. LINE_MIC_IN
  50. };
  52. +/* Strings for Input Source Enum Control */
  53. +static const char *in_src_str[3] = {"Rear Mic", "Line", "Front Mic" };
  54. +#define IN_SRC_NUM_OF_INPUTS 3
  55. +enum {
  56. + REAR_MIC,
  57. + REAR_LINE_IN,
  58. + FRONT_MIC,
  59. +};
  60. +
  61. enum {
  62. #define VNODE_START_NID 0x80
  63. VNID_SPK = VNODE_START_NID, /* Speaker vnid */
  64. @@ -122,13 +142,26 @@
  65. VOICEFX = IN_EFFECT_END_NID,
  66. PLAY_ENHANCEMENT,
  67. CRYSTAL_VOICE,
  68. - EFFECT_END_NID
  69. + EFFECT_END_NID,
  70. + OUTPUT_SOURCE_ENUM,
  71. + INPUT_SOURCE_ENUM,
  72. + XBASS_XOVER,
  73. + EQ_PRESET_ENUM,
  74. + SMART_VOLUME_ENUM,
  75. + MIC_BOOST_ENUM
  76. #define EFFECTS_COUNT (EFFECT_END_NID - EFFECT_START_NID)
  77. };
  79. /* Effects values size*/
  80. #define EFFECT_VALS_MAX_COUNT 12
  82. +/* Amount of effect level sliders for ca0132_alt controls. */
  83. +#define EFFECT_LEVEL_SLIDERS 5
  84. +/* Default values for the effect slider controls, they are in order of their
  85. + * effect NID's. Surround, Crystalizer, Dialog Plus, Smart Volume, and then
  86. + * X-bass. */
  87. +static const unsigned int effect_slider_defaults[] = {67, 65, 50, 74, 50};
  88. +
  89. /* Latency introduced by DSP blocks in milliseconds. */
  90. #define DSP_CAPTURE_INIT_LATENCY 0
  91. #define DSP_CRYSTAL_VOICE_LATENCY 124
  92. @@ -472,6 +505,161 @@
  93. }
  94. };
  96. +/* ca0132 EQ presets, taken from Windows Sound Blaster Z Driver */
  97. +
  98. +#define EQ_PRESET_MAX_PARAM_COUNT 11
  99. +
  100. +struct ct_eq {
  101. + char *name;
  102. + hda_nid_t nid;
  103. + int mid;
  104. + int reqs[EQ_PRESET_MAX_PARAM_COUNT]; /*effect module request*/
  105. +};
  106. +
  107. +struct ct_eq_preset {
  108. + char *name; /*preset name*/
  109. + unsigned int vals[EQ_PRESET_MAX_PARAM_COUNT];
  110. +};
  111. +
  112. +static struct ct_eq ca0132_alt_eq_enum = {
  113. + .name = "FX: Equalizer Preset Switch",
  114. + .nid = EQ_PRESET_ENUM,
  115. + .mid = 0x96,
  116. + .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
  117. +};
  118. +
  119. +
  120. +static struct ct_eq_preset ca0132_alt_eq_presets[] = {
  121. + { .name = "Flat",
  122. + .vals = { 0x00000000, 0x00000000, 0x00000000,
  123. + 0x00000000, 0x00000000, 0x00000000,
  124. + 0x00000000, 0x00000000, 0x00000000,
  125. + 0x00000000, 0x00000000 }
  126. + },
  127. + { .name = "Acoustic",
  128. + .vals = { 0x00000000, 0x00000000, 0x3F8CCCCD,
  129. + 0x40000000, 0x00000000, 0x00000000,
  130. + 0x00000000, 0x00000000, 0x40000000,
  131. + 0x40000000, 0x40000000 }
  132. + },
  133. + { .name = "Classical",
  134. + .vals = { 0x00000000, 0x00000000, 0x40C00000,
  135. + 0x40C00000, 0x40466666, 0x00000000,
  136. + 0x00000000, 0x00000000, 0x00000000,
  137. + 0x40466666, 0x40466666 }
  138. + },
  139. + { .name = "Country",
  140. + .vals = { 0x00000000, 0xBF99999A, 0x00000000,
  141. + 0x3FA66666, 0x3FA66666, 0x3F8CCCCD,
  142. + 0x00000000, 0x00000000, 0x40000000,
  143. + 0x40466666, 0x40800000 }
  144. + },
  145. + { .name = "Dance",
  146. + .vals = { 0x00000000, 0xBF99999A, 0x40000000,
  147. + 0x40466666, 0x40866666, 0xBF99999A,
  148. + 0xBF99999A, 0x00000000, 0x00000000,
  149. + 0x40800000, 0x40800000 }
  150. + },
  151. + { .name = "Jazz",
  152. + .vals = { 0x00000000, 0x00000000, 0x00000000,
  153. + 0x3F8CCCCD, 0x40800000, 0x40800000,
  154. + 0x40800000, 0x00000000, 0x3F8CCCCD,
  155. + 0x40466666, 0x40466666 }
  156. + },
  157. + { .name = "New Age",
  158. + .vals = { 0x00000000, 0x00000000, 0x40000000,
  159. + 0x40000000, 0x00000000, 0x00000000,
  160. + 0x00000000, 0x3F8CCCCD, 0x40000000,
  161. + 0x40000000, 0x40000000 }
  162. + },
  163. + { .name = "Pop",
  164. + .vals = { 0x00000000, 0xBFCCCCCD, 0x00000000,
  165. + 0x40000000, 0x40000000, 0x00000000,
  166. + 0xBF99999A, 0xBF99999A, 0x00000000,
  167. + 0x40466666, 0x40C00000 }
  168. + },
  169. + { .name = "Rock",
  170. + .vals = { 0x00000000, 0xBF99999A, 0xBF99999A,
  171. + 0x3F8CCCCD, 0x40000000, 0xBF99999A,
  172. + 0xBF99999A, 0x00000000, 0x00000000,
  173. + 0x40800000, 0x40800000 }
  174. + },
  175. + { .name = "Vocal",
  176. + .vals = { 0x00000000, 0xC0000000, 0xBF99999A,
  177. + 0xBF99999A, 0x00000000, 0x40466666,
  178. + 0x40800000, 0x40466666, 0x00000000,
  179. + 0x00000000, 0x3F8CCCCD }
  180. + }
  181. +};
  182. +
  183. +/* DSP command sequences for ca0132_alt_select_out */
  184. +#define ALT_OUT_SET_MAX_COMMANDS 9 /* Max number of commands in sequence */
  185. +struct ca0132_alt_out_set {
  186. + char *name; /*preset name*/
  187. + unsigned char commands;
  188. + unsigned int mids[ALT_OUT_SET_MAX_COMMANDS];
  189. + unsigned int reqs[ALT_OUT_SET_MAX_COMMANDS];
  190. + unsigned int vals[ALT_OUT_SET_MAX_COMMANDS];
  191. +};
  192. +
  193. +static struct ca0132_alt_out_set alt_out_presets[] = {
  194. + { .name = "Line Out",
  195. + .commands = 7,
  196. + .mids = { 0x96, 0x96, 0x96, 0x8F,
  197. + 0x96, 0x96, 0x96 },
  198. + .reqs = { 0x19, 0x17, 0x18, 0x01,
  199. + 0x1F, 0x15, 0x3A },
  200. + .vals = { 0x3F000000, 0x42A00000, 0x00000000,
  201. + 0x00000000, 0x00000000, 0x00000000,
  202. + 0x00000000 }
  203. + },
  204. + { .name = "Headphone",
  205. + .commands = 7,
  206. + .mids = { 0x96, 0x96, 0x96, 0x8F,
  207. + 0x96, 0x96, 0x96 },
  208. + .reqs = { 0x19, 0x17, 0x18, 0x01,
  209. + 0x1F, 0x15, 0x3A },
  210. + .vals = { 0x3F000000, 0x42A00000, 0x00000000,
  211. + 0x00000000, 0x00000000, 0x00000000,
  212. + 0x00000000 }
  213. + },
  214. + { .name = "Surround",
  215. + .commands = 8,
  216. + .mids = { 0x96, 0x8F, 0x96, 0x96,
  217. + 0x96, 0x96, 0x96, 0x96 },
  218. + .reqs = { 0x18, 0x01, 0x1F, 0x15,
  219. + 0x3A, 0x1A, 0x1B, 0x1C },
  220. + .vals = { 0x00000000, 0x00000000, 0x00000000,
  221. + 0x00000000, 0x00000000, 0x00000000,
  222. + 0x00000000, 0x00000000 }
  223. + }
  224. +};
  225. +
  226. +/*
  227. + * DSP volume setting structs. Req 1 is left volume, req 2 is right volume,
  228. + * and I don't know what the third req is, but it's always zero. I assume it's
  229. + * some sort of update or set command to tell the DSP there's new volume info.
  230. + */
  231. +#define DSP_VOL_OUT 0
  232. +#define DSP_VOL_IN 1
  233. +
  234. +struct ct_dsp_volume_ctl {
  235. + hda_nid_t vnid;
  236. + int mid; /* module ID*/
  237. + unsigned int reqs[3]; /* scp req ID */
  238. +};
  239. +
  240. +static struct ct_dsp_volume_ctl ca0132_alt_vol_ctls[] = {
  241. + { .vnid = VNID_SPK,
  242. + .mid = 0x32,
  243. + .reqs = {3, 4, 2}
  244. + },
  245. + { .vnid = VNID_MIC,
  246. + .mid = 0x37,
  247. + .reqs = {2, 3, 1}
  248. + }
  249. +};
  250. +
  251. enum hda_cmd_vendor_io {
  252. /* for DspIO node */
  253. VENDOR_DSPIO_SCP_WRITE_DATA_LOW = 0x000,
  254. @@ -703,6 +891,7 @@
  255. const struct hda_verb *base_init_verbs;
  256. const struct hda_verb *base_exit_verbs;
  257. const struct hda_verb *chip_init_verbs;
  258. + const struct hda_verb *sbz_init_verbs;
  259. struct hda_verb *spec_init_verbs;
  260. struct auto_pin_cfg autocfg;
  262. @@ -719,6 +908,7 @@
  263. hda_nid_t shared_mic_nid;
  264. hda_nid_t shared_out_nid;
  265. hda_nid_t unsol_tag_hp;
  266. + hda_nid_t unsol_tag_front_hp; /* for desktop ca0132 codecs */
  267. hda_nid_t unsol_tag_amic1;
  269. /* chip access */
  270. @@ -734,6 +924,9 @@
  271. unsigned int scp_resp_header;
  272. unsigned int scp_resp_data[4];
  273. unsigned int scp_resp_count;
  274. + bool alt_firmware_present;
  275. + bool startup_check_entered;
  276. + bool dsp_reload;
  278. /* mixer and effects related */
  279. unsigned char dmic_ctl;
  280. @@ -746,6 +939,17 @@
  281. long effects_switch[EFFECTS_COUNT];
  282. long voicefx_val;
  283. long cur_mic_boost;
  284. + /* ca0132_alt control related values */
  285. + unsigned char in_enum_val;
  286. + unsigned char out_enum_val;
  287. + unsigned char mic_boost_enum_val;
  288. + unsigned char smart_volume_setting;
  289. + long fx_ctl_val[EFFECT_LEVEL_SLIDERS];
  290. + long xbass_xover_freq;
  291. + long eq_preset_val;
  292. + unsigned int tlv[4];
  293. + struct hda_vmaster_mute_hook vmaster_mute;
  294. +
  296. struct hda_codec *codec;
  297. struct delayed_work unsol_hp_work;
  298. @@ -754,6 +958,25 @@
  299. #ifdef ENABLE_TUNING_CONTROLS
  300. long cur_ctl_vals[TUNING_CTLS_COUNT];
  301. #endif
  302. + /*
  303. + * Sound Blaster Z PCI region 2 iomem, used for input and output
  304. + * switching, and other unknown commands.
  305. + */
  306. + void __iomem *mem_base;
  307. +
  308. + /*
  309. + * Whether or not to use the alt functions like alt_select_out,
  310. + * alt_select_in, etc. Only used on desktop codecs for now, because of
  311. + * surround sound support.
  312. + */
  313. + bool use_alt_functions;
  314. +
  315. + /*
  316. + * Whether or not to use alt controls: volume effect sliders, EQ
  317. + * presets, smart volume presets, and new control names with FX prefix.
  318. + * Renames PlayEnhancement and CrystalVoice too.
  319. + */
  320. + bool use_alt_controls;
  321. };
  323. /*
  324. @@ -762,6 +985,8 @@
  325. enum {
  326. QUIRK_NONE,
  327. QUIRK_ALIENWARE,
  328. + QUIRK_SBZ,
  329. + QUIRK_R3DI,
  330. };
  332. static const struct hda_pintbl alienware_pincfgs[] = {
  333. @@ -778,10 +1003,44 @@
  334. {}
  335. };
  337. +/* Sound Blaster Z pin configs taken from Windows Driver */
  338. +static const struct hda_pintbl sbz_pincfgs[] = {
  339. + { 0x0b, 0x01017010 }, /* Port G -- Lineout FRONT L/R */
  340. + { 0x0c, 0x014510f0 }, /* SPDIF Out 1 */
  341. + { 0x0d, 0x014510f0 }, /* Digital Out */
  342. + { 0x0e, 0x01c510f0 }, /* SPDIF In */
  343. + { 0x0f, 0x0221701f }, /* Port A -- BackPanel HP */
  344. + { 0x10, 0x01017012 }, /* Port D -- Center/LFE or FP Hp */
  345. + { 0x11, 0x01017014 }, /* Port B -- LineMicIn2 / Rear L/R */
  346. + { 0x12, 0x01a170f0 }, /* Port C -- LineIn1 */
  347. + { 0x13, 0x908700f0 }, /* What U Hear In*/
  348. + { 0x18, 0x50d000f0 }, /* N/A */
  349. + {}
  350. +};
  351. +
  352. +/* Recon3D integrated pin configs taken from Windows Driver */
  353. +static const struct hda_pintbl r3di_pincfgs[] = {
  354. + { 0x0b, 0x01014110 }, /* Port G -- Lineout FRONT L/R */
  355. + { 0x0c, 0x014510f0 }, /* SPDIF Out 1 */
  356. + { 0x0d, 0x014510f0 }, /* Digital Out */
  357. + { 0x0e, 0x41c520f0 }, /* SPDIF In */
  358. + { 0x0f, 0x0221401f }, /* Port A -- BackPanel HP */
  359. + { 0x10, 0x01016011 }, /* Port D -- Center/LFE or FP Hp */
  360. + { 0x11, 0x01011014 }, /* Port B -- LineMicIn2 / Rear L/R */
  361. + { 0x12, 0x02a090f0 }, /* Port C -- LineIn1 */
  362. + { 0x13, 0x908700f0 }, /* What U Hear In*/
  363. + { 0x18, 0x500000f0 }, /* N/A */
  364. + {}
  365. +};
  366. +
  367. static const struct snd_pci_quirk ca0132_quirks[] = {
  368. SND_PCI_QUIRK(0x1028, 0x0685, "Alienware 15 2015", QUIRK_ALIENWARE),
  369. SND_PCI_QUIRK(0x1028, 0x0688, "Alienware 17 2015", QUIRK_ALIENWARE),
  370. SND_PCI_QUIRK(0x1028, 0x0708, "Alienware 15 R2 2016", QUIRK_ALIENWARE),
  371. + SND_PCI_QUIRK(0x1102, 0x0010, "Sound Blaster Z", QUIRK_SBZ),
  372. + SND_PCI_QUIRK(0x1102, 0x0023, "Sound Blaster Z", QUIRK_SBZ),
  373. + SND_PCI_QUIRK(0x1458, 0xA016, "Recon3Di", QUIRK_R3DI),
  374. + SND_PCI_QUIRK(0x1458, 0xA036, "Recon3Di", QUIRK_R3DI),
  375. {}
  376. };
  378. @@ -965,6 +1224,29 @@
  379. }
  381. /*
  382. + * Write given value to the given address through the chip I/O widget.
  383. + * not protected by the Mutex
  384. + */
  385. +static int chipio_write_no_mutex(struct hda_codec *codec,
  386. + unsigned int chip_addx, const unsigned int data)
  387. +{
  388. + int err;
  389. +
  390. +
  391. + /* write the address, and if successful proceed to write data */
  392. + err = chipio_write_address(codec, chip_addx);
  393. + if (err < 0)
  394. + goto exit;
  395. +
  396. + err = chipio_write_data(codec, data);
  397. + if (err < 0)
  398. + goto exit;
  399. +
  400. +exit:
  401. + return err;
  402. +}
  403. +
  404. +/*
  405. * Write multiple values to the given address through the chip I/O widget.
  406. * protected by the Mutex
  407. */
  408. @@ -1058,6 +1340,80 @@
  409. }
  411. /*
  412. + * Set chip parameters through the chip I/O widget. NO MUTEX.
  413. + */
  414. +static void chipio_set_control_param_no_mutex(struct hda_codec *codec,
  415. + enum control_param_id param_id, int param_val)
  416. +{
  417. + int val;
  418. +
  419. + codec_dbg(codec, "chipio_param ID: %d val: 0x%02x \n", param_id, param_val);
  420. +
  421. + if ((param_id < 32) && (param_val < 8)) {
  422. + val = (param_val << 5) | (param_id);
  423. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  424. + VENDOR_CHIPIO_PARAM_SET, val);
  425. + } else {
  426. + if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) {
  427. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  428. + VENDOR_CHIPIO_PARAM_EX_ID_SET,
  429. + param_id);
  430. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  431. + VENDOR_CHIPIO_PARAM_EX_VALUE_SET,
  432. + param_val);
  433. + }
  434. + }
  435. +}
  436. +/*
  437. + * Connect stream to a source point, and then connect
  438. + * that source point to a destination point.
  439. + */
  440. +static void chipio_set_stream_source_dest(struct hda_codec *codec,
  441. + int streamid, int source_point, int dest_point)
  442. +{
  443. +
  444. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAM_ID, streamid);
  445. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAM_SOURCE_CONN_POINT,
  446. + source_point);
  447. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAM_DEST_CONN_POINT,
  448. + dest_point);
  449. +}
  450. +
  451. +/*
  452. + * Set number of channels in the selected stream.
  453. + */
  454. +static void chipio_set_stream_channels(struct hda_codec *codec,
  455. + int streamid, unsigned int channels)
  456. +{
  457. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAM_ID, streamid);
  458. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAMS_CHANNELS,
  459. + channels);
  460. +}
  461. +
  462. +/*
  463. + * Enable/Disable audio stream.
  464. + */
  465. +static void chipio_set_stream_control(struct hda_codec *codec,
  466. + int streamid, int enable)
  467. +{
  468. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAM_ID, streamid);
  469. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_STREAM_CONTROL,
  470. + enable);
  471. +}
  472. +
  473. +
  474. +/*
  475. + * Set sampling rate of the connection point. NO MUTEX.
  476. + */
  477. +static void chipio_set_conn_rate_no_mutex(struct hda_codec *codec,
  478. + int connid, enum ca0132_sample_rate rate)
  479. +{
  480. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_CONN_POINT_ID, connid);
  481. + chipio_set_control_param_no_mutex(codec, CONTROL_PARAM_CONN_POINT_SAMPLE_RATE,
  482. + rate);
  483. +}
  484. +
  485. +/*
  486. * Set sampling rate of the connection point.
  487. */
  488. static void chipio_set_conn_rate(struct hda_codec *codec,
  489. @@ -1420,8 +1776,8 @@
  490. * Returns zero or a negative error code.
  491. */
  492. static int dspio_scp(struct hda_codec *codec,
  493. - int mod_id, int req, int dir, void *data, unsigned int len,
  494. - void *reply, unsigned int *reply_len)
  495. + int mod_id, int src_id, int req, int dir, const void *data,
  496. + unsigned int len, void *reply, unsigned int *reply_len)
  497. {
  498. int status = 0;
  499. struct scp_msg scp_send, scp_reply;
  500. @@ -1445,7 +1801,7 @@
  501. return -EINVAL;
  502. }
  504. - scp_send.hdr = make_scp_header(mod_id, 0x20, (dir == SCP_GET), req,
  505. + scp_send.hdr = make_scp_header(mod_id, src_id, (dir == SCP_GET), req,
  506. 0, 0, 0, len/sizeof(unsigned int));
  507. if (data != NULL && len > 0) {
  508. len = min((unsigned int)(sizeof(scp_send.data)), len);
  509. @@ -1502,15 +1858,24 @@
  510. * Set DSP parameters
  511. */
  512. static int dspio_set_param(struct hda_codec *codec, int mod_id,
  513. - int req, void *data, unsigned int len)
  514. + int src_id, int req, const void *data, unsigned int len)
  515. {
  516. - return dspio_scp(codec, mod_id, req, SCP_SET, data, len, NULL, NULL);
  517. + return dspio_scp(codec, mod_id, src_id, req, SCP_SET, data, len, NULL,
  518. + NULL);
  519. }
  521. static int dspio_set_uint_param(struct hda_codec *codec, int mod_id,
  522. - int req, unsigned int data)
  523. + int req, const unsigned int data)
  524. +{
  525. + return dspio_set_param(codec, mod_id, 0x20, req, &data,
  526. + sizeof(unsigned int));
  527. +}
  528. +
  529. +static int dspio_set_uint_param_no_source(struct hda_codec *codec, int mod_id,
  530. + int req, const unsigned int data)
  531. {
  532. - return dspio_set_param(codec, mod_id, req, &data, sizeof(unsigned int));
  533. + return dspio_set_param(codec, mod_id, 0x00, req, &data,
  534. + sizeof(unsigned int));
  535. }
  537. /*
  538. @@ -1522,8 +1887,9 @@
  539. unsigned int size = sizeof(dma_chan);
  541. codec_dbg(codec, " dspio_alloc_dma_chan() -- begin\n");
  542. - status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN,
  543. - SCP_GET, NULL, 0, dma_chan, &size);
  544. + status = dspio_scp(codec, MASTERCONTROL, 0x20,
  545. + MASTERCONTROL_ALLOC_DMA_CHAN, SCP_GET, NULL, 0, dma_chan,
  546. + &size);
  548. if (status < 0) {
  549. codec_dbg(codec, "dspio_alloc_dma_chan: SCP Failed\n");
  550. @@ -1552,8 +1918,9 @@
  551. codec_dbg(codec, " dspio_free_dma_chan() -- begin\n");
  552. codec_dbg(codec, "dspio_free_dma_chan: chan=%d\n", dma_chan);
  554. - status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN,
  555. - SCP_SET, &dma_chan, sizeof(dma_chan), NULL, &dummy);
  556. + status = dspio_scp(codec, MASTERCONTROL, 0x20,
  557. + MASTERCONTROL_ALLOC_DMA_CHAN, SCP_SET, &dma_chan,
  558. + sizeof(dma_chan), NULL, &dummy);
  560. if (status < 0) {
  561. codec_dbg(codec, "dspio_free_dma_chan: SCP Failed\n");
  562. @@ -2575,14 +2942,16 @@
  563. */
  564. static void dspload_post_setup(struct hda_codec *codec)
  565. {
  566. + struct ca0132_spec *spec = codec->spec;
  567. codec_dbg(codec, "---- dspload_post_setup ------\n");
  568. + if (!spec->use_alt_functions) {
  569. + /*set DSP speaker to 2.0 configuration*/
  570. + chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x18), 0x08080080);
  571. + chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x19), 0x3f800000);
  573. - /*set DSP speaker to 2.0 configuration*/
  574. - chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x18), 0x08080080);
  575. - chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x19), 0x3f800000);
  576. -
  577. - /*update write pointer*/
  578. - chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x29), 0x00000002);
  579. + /*update write pointer*/
  580. + chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x29), 0x00000002);
  581. + }
  582. }
  584. /**
  585. @@ -2690,6 +3059,169 @@
  586. }
  588. /*
  589. + * Setup GPIO for the other variants of Core3D.
  590. + */
  591. +
  592. +/*
  593. + * Sets up the GPIO pins so that they are discoverable. If this isn't done,
  594. + * the card shows as having no GPIO pins.
  595. + */
  596. +static void ca0132_gpio_init(struct hda_codec *codec)
  597. +{
  598. + struct ca0132_spec *spec = codec->spec;
  599. + switch (spec->quirk) {
  600. + case QUIRK_SBZ:
  601. + codec_dbg(codec, "SBZ ca0132_gpio_init");
  602. + snd_hda_codec_write(codec, 0x01, 0, 0x793, 0x00);
  603. + snd_hda_codec_write(codec, 0x01, 0, 0x794, 0x53);
  604. + snd_hda_codec_write(codec, 0x01, 0, 0x790, 0x23);
  605. + break;
  606. + case QUIRK_R3DI:
  607. + codec_dbg(codec, "R3DI ca0132_gpio_init");
  608. + snd_hda_codec_write(codec, 0x01, 0, 0x793, 0x00);
  609. + snd_hda_codec_write(codec, 0x01, 0, 0x794, 0x5B);
  610. + break;
  611. + }
  612. +
  613. +}
  614. +
  615. +/* Sets the GPIO for audio output. */
  616. +static void ca0132_gpio_setup(struct hda_codec *codec)
  617. +{
  618. + struct ca0132_spec *spec = codec->spec;
  619. + switch (spec->quirk) {
  620. + case QUIRK_SBZ:
  621. + snd_hda_codec_write(codec, 0x01, 0,
  622. + AC_VERB_SET_GPIO_DIRECTION, 0x07);
  623. + snd_hda_codec_write(codec, 0x01, 0,
  624. + AC_VERB_SET_GPIO_MASK, 0x07);
  625. + snd_hda_codec_write(codec, 0x01, 0,
  626. + AC_VERB_SET_GPIO_DATA, 0x04);
  627. + snd_hda_codec_write(codec, 0x01, 0,
  628. + AC_VERB_SET_GPIO_DATA, 0x06);
  629. + break;
  630. + case QUIRK_R3DI:
  631. + snd_hda_codec_write(codec, 0x01, 0,
  632. + AC_VERB_SET_GPIO_DIRECTION, 0x1E);
  633. + snd_hda_codec_write(codec, 0x01, 0,
  634. + AC_VERB_SET_GPIO_MASK, 0x1F);
  635. + snd_hda_codec_write(codec, 0x01, 0,
  636. + AC_VERB_SET_GPIO_DATA, 0x0C);
  637. + break;
  638. + }
  639. +}
  640. +
  641. +/*
  642. + * GPIO control functions for the Recon3D integrated.
  643. + */
  644. +
  645. +enum r3di_gpio_bit{
  646. + /* Bit 1 - Switch between front/rear mic. 0 = rear, 1 = front */
  647. + R3DI_MIC_SELECT_BIT = 1,
  648. + /* Bit 2 - Switch between headphone/line out. 0 = Headphone, 1 = Line */
  649. + R3DI_OUT_SELECT_BIT = 2,
  650. + /*
  651. + * I dunno what this actually does, but it stays on until the dsp
  652. + * is downloaded.
  653. + */
  654. + R3DI_GPIO_DSP_DOWNLOADING = 3,
  655. + /*
  656. + * Same as above, no clue what it does, but it comes on after the dsp
  657. + * is downloaded.
  658. + */
  659. + R3DI_GPIO_DSP_DOWNLOADED = 4
  660. +};
  661. +
  662. +enum r3di_mic_select {
  663. + /* Set GPIO bit 1 to 0 for rear mic */
  664. + R3DI_REAR_MIC = 0,
  665. + /* Set GPIO bit 1 to 1 for front microphone*/
  666. + R3DI_FRONT_MIC = 1
  667. +};
  668. +
  669. +enum r3di_out_select {
  670. + /* Set GPIO bit 2 to 0 for headphone */
  671. + R3DI_HEADPHONE_OUT = 0,
  672. + /* Set GPIO bit 2 to 1 for speaker */
  673. + R3DI_LINE_OUT = 1
  674. +};
  675. +enum r3di_dsp_status {
  676. + /* Set GPIO bit 3 to 1 until DSP is downloaded */
  677. + R3DI_DSP_DOWNLOADING = 0,
  678. + /* Set GPIO bit 4 to 1 once DSP is downloaded */
  679. + R3DI_DSP_DOWNLOADED = 1
  680. +};
  681. +
  682. +static void r3di_gpio_mic_set(struct hda_codec *codec,
  683. + enum r3di_mic_select cur_mic)
  684. +{
  685. + unsigned int cur_gpio;
  686. +
  687. + /* Get the current GPIO Data setup */
  688. + cur_gpio = snd_hda_codec_read(codec, 0x01, 0, AC_VERB_GET_GPIO_DATA, 0);
  689. +
  690. + switch (cur_mic) {
  691. + case R3DI_REAR_MIC:
  692. + cur_gpio &= ~(1 << R3DI_MIC_SELECT_BIT);
  693. + break;
  694. + case R3DI_FRONT_MIC:
  695. + cur_gpio |= (1 << R3DI_MIC_SELECT_BIT);
  696. + break;
  697. + }
  698. + snd_hda_codec_write(codec, codec->core.afg, 0,
  699. + AC_VERB_SET_GPIO_DATA, cur_gpio);
  700. +}
  701. +
  702. +static void r3di_gpio_out_set(struct hda_codec *codec,
  703. + enum r3di_out_select cur_out)
  704. +{
  705. + unsigned int cur_gpio;
  706. +
  707. + /* Get the current GPIO Data setup */
  708. + cur_gpio = snd_hda_codec_read(codec, 0x01, 0, AC_VERB_GET_GPIO_DATA, 0);
  709. +
  710. + switch (cur_out) {
  711. + case R3DI_HEADPHONE_OUT:
  712. + cur_gpio &= ~(1 << R3DI_OUT_SELECT_BIT);
  713. + break;
  714. + case R3DI_LINE_OUT:
  715. + cur_gpio |= (1 << R3DI_OUT_SELECT_BIT);
  716. + break;
  717. + }
  718. + snd_hda_codec_write(codec, codec->core.afg, 0,
  719. + AC_VERB_SET_GPIO_DATA, cur_gpio);
  720. +}
  721. +
  722. +static void r3di_gpio_dsp_status_set(struct hda_codec *codec,
  723. + enum r3di_dsp_status dsp_status)
  724. +{
  725. + unsigned int cur_gpio;
  726. +
  727. + /* Get the current GPIO Data setup */
  728. + cur_gpio = snd_hda_codec_read(codec, 0x01, 0, AC_VERB_GET_GPIO_DATA, 0);
  729. +
  730. + switch (dsp_status) {
  731. + case R3DI_DSP_DOWNLOADING:
  732. + cur_gpio |= (1 << R3DI_GPIO_DSP_DOWNLOADING);
  733. + snd_hda_codec_write(codec, codec->core.afg, 0,
  734. + AC_VERB_SET_GPIO_DATA, cur_gpio);
  735. + break;
  736. + case R3DI_DSP_DOWNLOADED:
  737. + /* Set DOWNLOADING bit to 0. */
  738. + cur_gpio &= ~(1 << R3DI_GPIO_DSP_DOWNLOADING);
  739. +
  740. + snd_hda_codec_write(codec, codec->core.afg, 0,
  741. + AC_VERB_SET_GPIO_DATA, cur_gpio);
  742. +
  743. + cur_gpio |= (1 << R3DI_GPIO_DSP_DOWNLOADED);
  744. + break;
  745. + }
  746. +
  747. + snd_hda_codec_write(codec, codec->core.afg, 0,
  748. + AC_VERB_SET_GPIO_DATA, cur_gpio);
  749. +}
  750. +
  751. +/*
  752. * PCM callbacks
  753. */
  754. static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
  755. @@ -2852,6 +3384,19 @@
  756. .tlv = { .c = ca0132_volume_tlv }, \
  757. .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, 0, dir) }
  759. +#define CA0132_ALT_CODEC_VOL_MONO(xname, nid, channel, dir) \
  760. + { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
  761. + .name = xname, \
  762. + .subdevice = HDA_SUBDEV_AMP_FLAG, \
  763. + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
  764. + SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
  765. + SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
  766. + .info = snd_hda_mixer_amp_volume_info, \
  767. + .get = snd_hda_mixer_amp_volume_get, \
  768. + .put = ca0132_alt_volume_put, \
  769. + .tlv = { .c = snd_hda_mixer_amp_tlv }, \
  770. + .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, 0, dir) }
  771. +
  772. #define CA0132_CODEC_MUTE_MONO(xname, nid, channel, dir) \
  773. { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
  774. .name = xname, \
  775. @@ -2864,9 +3409,88 @@
  776. /* stereo */
  777. #define CA0132_CODEC_VOL(xname, nid, dir) \
  778. CA0132_CODEC_VOL_MONO(xname, nid, 3, dir)
  779. +#define CA0132_ALT_CODEC_VOL(xname, nid, dir) \
  780. + CA0132_ALT_CODEC_VOL_MONO(xname, nid, 3, dir)
  781. #define CA0132_CODEC_MUTE(xname, nid, dir) \
  782. CA0132_CODEC_MUTE_MONO(xname, nid, 3, dir)
  784. +/* lookup tables */
  785. +/*
  786. + * Lookup table with decibel values for the DSP. When volume is changed in
  787. + * Windows, the DSP is also sent the dB value in floating point. In Windows,
  788. + * these values have decimal points, probably because the Windows driver
  789. + * actually uses floating point. We can't here, so I made a lookup table of
  790. + * values -90 to 9. -90 is the lowest decibel value for both the ADC's and the
  791. + * DAC's, and 9 is the maximum.
  792. + */
  793. +static const unsigned int float_vol_db_lookup[] = {
  794. +0xC2B40000, 0xC2B20000, 0xC2B00000, 0xC2AE0000, 0xC2AC0000, 0xC2AA0000,
  795. +0xC2A80000, 0xC2A60000, 0xC2A40000, 0xC2A20000, 0xC2A00000, 0xC29E0000,
  796. +0xC29C0000, 0xC29A0000, 0xC2980000, 0xC2960000, 0xC2940000, 0xC2920000,
  797. +0xC2900000, 0xC28E0000, 0xC28C0000, 0xC28A0000, 0xC2880000, 0xC2860000,
  798. +0xC2840000, 0xC2820000, 0xC2800000, 0xC27C0000, 0xC2780000, 0xC2740000,
  799. +0xC2700000, 0xC26C0000, 0xC2680000, 0xC2640000, 0xC2600000, 0xC25C0000,
  800. +0xC2580000, 0xC2540000, 0xC2500000, 0xC24C0000, 0xC2480000, 0xC2440000,
  801. +0xC2400000, 0xC23C0000, 0xC2380000, 0xC2340000, 0xC2300000, 0xC22C0000,
  802. +0xC2280000, 0xC2240000, 0xC2200000, 0xC21C0000, 0xC2180000, 0xC2140000,
  803. +0xC2100000, 0xC20C0000, 0xC2080000, 0xC2040000, 0xC2000000, 0xC1F80000,
  804. +0xC1F00000, 0xC1E80000, 0xC1E00000, 0xC1D80000, 0xC1D00000, 0xC1C80000,
  805. +0xC1C00000, 0xC1B80000, 0xC1B00000, 0xC1A80000, 0xC1A00000, 0xC1980000,
  806. +0xC1900000, 0xC1880000, 0xC1800000, 0xC1700000, 0xC1600000, 0xC1500000,
  807. +0xC1400000, 0xC1300000, 0xC1200000, 0xC1100000, 0xC1000000, 0xC0E00000,
  808. +0xC0C00000, 0xC0A00000, 0xC0800000, 0xC0400000, 0xC0000000, 0xBF800000,
  809. +0x00000000, 0x3F800000, 0x40000000, 0x40400000, 0x40800000, 0x40A00000,
  810. +0x40C00000, 0x40E00000, 0x41000000, 0x41100000
  811. +};
  812. +
  813. +/*
  814. + * This table counts from float 0 to 1 in increments of .01, which is
  815. + * useful for a few different sliders.
  816. + */
  817. +static const unsigned int float_zero_to_one_lookup[] = {
  818. +0x00000000, 0x3C23D70A, 0x3CA3D70A, 0x3CF5C28F, 0x3D23D70A, 0x3D4CCCCD,
  819. +0x3D75C28F, 0x3D8F5C29, 0x3DA3D70A, 0x3DB851EC, 0x3DCCCCCD, 0x3DE147AE,
  820. +0x3DF5C28F, 0x3E051EB8, 0x3E0F5C29, 0x3E19999A, 0x3E23D70A, 0x3E2E147B,
  821. +0x3E3851EC, 0x3E428F5C, 0x3E4CCCCD, 0x3E570A3D, 0x3E6147AE, 0x3E6B851F,
  822. +0x3E75C28F, 0x3E800000, 0x3E851EB8, 0x3E8A3D71, 0x3E8F5C29, 0x3E947AE1,
  823. +0x3E99999A, 0x3E9EB852, 0x3EA3D70A, 0x3EA8F5C3, 0x3EAE147B, 0x3EB33333,
  824. +0x3EB851EC, 0x3EBD70A4, 0x3EC28F5C, 0x3EC7AE14, 0x3ECCCCCD, 0x3ED1EB85,
  825. +0x3ED70A3D, 0x3EDC28F6, 0x3EE147AE, 0x3EE66666, 0x3EEB851F, 0x3EF0A3D7,
  826. +0x3EF5C28F, 0x3EFAE148, 0x3F000000, 0x3F028F5C, 0x3F051EB8, 0x3F07AE14,
  827. +0x3F0A3D71, 0x3F0CCCCD, 0x3F0F5C29, 0x3F11EB85, 0x3F147AE1, 0x3F170A3D,
  828. +0x3F19999A, 0x3F1C28F6, 0x3F1EB852, 0x3F2147AE, 0x3F23D70A, 0x3F266666,
  829. +0x3F28F5C3, 0x3F2B851F, 0x3F2E147B, 0x3F30A3D7, 0x3F333333, 0x3F35C28F,
  830. +0x3F3851EC, 0x3F3AE148, 0x3F3D70A4, 0x3F400000, 0x3F428F5C, 0x3F451EB8,
  831. +0x3F47AE14, 0x3F4A3D71, 0x3F4CCCCD, 0x3F4F5C29, 0x3F51EB85, 0x3F547AE1,
  832. +0x3F570A3D, 0x3F59999A, 0x3F5C28F6, 0x3F5EB852, 0x3F6147AE, 0x3F63D70A,
  833. +0x3F666666, 0x3F68F5C3, 0x3F6B851F, 0x3F6E147B, 0x3F70A3D7, 0x3F733333,
  834. +0x3F75C28F, 0x3F7851EC, 0x3F7AE148, 0x3F7D70A4, 0x3F800000
  835. +};
  836. +
  837. +/*
  838. + * This table counts from float 10 to 1000, which is the range of the x-bass
  839. + * crossover slider in Windows.
  840. + */
  841. +static const unsigned int float_xbass_xover_lookup[] = {
  842. +0x41200000, 0x41A00000, 0x41F00000, 0x42200000, 0x42480000, 0x42700000,
  843. +0x428C0000, 0x42A00000, 0x42B40000, 0x42C80000, 0x42DC0000, 0x42F00000,
  844. +0x43020000, 0x430C0000, 0x43160000, 0x43200000, 0x432A0000, 0x43340000,
  845. +0x433E0000, 0x43480000, 0x43520000, 0x435C0000, 0x43660000, 0x43700000,
  846. +0x437A0000, 0x43820000, 0x43870000, 0x438C0000, 0x43910000, 0x43960000,
  847. +0x439B0000, 0x43A00000, 0x43A50000, 0x43AA0000, 0x43AF0000, 0x43B40000,
  848. +0x43B90000, 0x43BE0000, 0x43C30000, 0x43C80000, 0x43CD0000, 0x43D20000,
  849. +0x43D70000, 0x43DC0000, 0x43E10000, 0x43E60000, 0x43EB0000, 0x43F00000,
  850. +0x43F50000, 0x43FA0000, 0x43FF0000, 0x44020000, 0x44048000, 0x44070000,
  851. +0x44098000, 0x440C0000, 0x440E8000, 0x44110000, 0x44138000, 0x44160000,
  852. +0x44188000, 0x441B0000, 0x441D8000, 0x44200000, 0x44228000, 0x44250000,
  853. +0x44278000, 0x442A0000, 0x442C8000, 0x442F0000, 0x44318000, 0x44340000,
  854. +0x44368000, 0x44390000, 0x443B8000, 0x443E0000, 0x44408000, 0x44430000,
  855. +0x44458000, 0x44480000, 0x444A8000, 0x444D0000, 0x444F8000, 0x44520000,
  856. +0x44548000, 0x44570000, 0x44598000, 0x445C0000, 0x445E8000, 0x44610000,
  857. +0x44638000, 0x44660000, 0x44688000, 0x446B0000, 0x446D8000, 0x44700000,
  858. +0x44728000, 0x44750000, 0x44778000, 0x447A0000
  859. +};
  860. +
  861. /* The following are for tuning of products */
  862. #ifdef ENABLE_TUNING_CONTROLS
  864. @@ -2942,7 +3566,7 @@
  865. break;
  867. snd_hda_power_up(codec);
  868. - dspio_set_param(codec, ca0132_tuning_ctls[i].mid,
  869. + dspio_set_param(codec, ca0132_tuning_ctls[i].mid, 0x20,
  870. ca0132_tuning_ctls[i].req,
  871. &(lookup[idx]), sizeof(unsigned int));
  872. snd_hda_power_down(codec);
  873. @@ -3251,13 +3875,206 @@
  874. return err < 0 ? err : 0;
  875. }
  877. +/*
  878. + * This function behaves similarly to the ca0132_select_out funciton above,
  879. + * except with a few differences. It adds the ability to select the current
  880. + * output with an enumerated control "output source" if the auto detect
  881. + * mute switch is set to off. If the auto detect mute switch is enabled, it
  882. + * will detect either headphone or lineout(SPEAKER_OUT) from jack detection.
  883. + * It also adds the ability to auto-detect the front headphone port. The only
  884. + * way to select surround is to disable auto detect, and set Surround with the
  885. + * enumerated control.
  886. + */
  887. +static int ca0132_alt_select_out(struct hda_codec *codec)
  888. +{
  889. + struct ca0132_spec *spec = codec->spec;
  890. + unsigned int pin_ctl;
  891. + int jack_present;
  892. + int auto_jack;
  893. + unsigned int i;
  894. + unsigned int tmp;
  895. + int err;
  896. + /* Default Headphone is rear headphone */
  897. + hda_nid_t headphone_nid = spec->out_pins[1];
  898. +
  899. + codec_dbg(codec, "ca0132_alt_select_out\n");
  900. +
  901. + snd_hda_power_up_pm(codec);
  902. +
  903. + auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
  904. +
  905. + /* If headphone rear or front is plugged in, set to headphone.
  906. + * If neither is plugged in, set to rear line out. Only if
  907. + * hp/speaker auto detect is enabled. */
  908. + if (auto_jack) {
  909. + jack_present = snd_hda_jack_detect(codec, spec->unsol_tag_hp) ||
  910. + snd_hda_jack_detect(codec, spec->unsol_tag_front_hp);
  911. +
  912. + if (jack_present)
  913. + spec->cur_out_type = HEADPHONE_OUT;
  914. + else
  915. + spec->cur_out_type = SPEAKER_OUT;
  916. + } else
  917. + spec->cur_out_type = spec->out_enum_val;
  918. +
  919. + /* Begin DSP output switch */
  920. + tmp = FLOAT_ONE;
  921. + err = dspio_set_uint_param(codec, 0x96, 0x3A, tmp);
  922. + if (err < 0)
  923. + goto exit;
  924. +
  925. + switch (spec->cur_out_type) {
  926. + case SPEAKER_OUT:
  927. + codec_dbg(codec, "ca0132_alt_select_out speaker\n");
  928. + /*speaker out config*/
  929. + switch (spec->quirk) {
  930. + case QUIRK_SBZ:
  931. + writew(0x0007, spec->mem_base + 0x320);
  932. + writew(0x0104, spec->mem_base + 0x320);
  933. + writew(0x0101, spec->mem_base + 0x320);
  934. + chipio_set_control_param(codec, 0x0D, 0x18);
  935. + break;
  936. + case QUIRK_R3DI:
  937. + chipio_set_control_param(codec, 0x0D, 0x24);
  938. + r3di_gpio_out_set(codec, R3DI_LINE_OUT);
  939. + break;
  940. + }
  941. +
  942. + /* disable headphone node */
  943. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0,
  944. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  945. + snd_hda_set_pin_ctl(codec, spec->out_pins[1],
  946. + pin_ctl & ~PIN_HP);
  947. + /* enable line-out node */
  948. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,
  949. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  950. + snd_hda_set_pin_ctl(codec, spec->out_pins[0],
  951. + pin_ctl | PIN_OUT);
  952. + /* Enable EAPD */
  953. + snd_hda_codec_write(codec, spec->out_pins[0], 0,
  954. + AC_VERB_SET_EAPD_BTLENABLE, 0x01);
  955. +
  956. + /* If PlayEnhancement is enabled, set different source */
  957. + if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
  958. + dspio_set_uint_param(codec, 0x80, 0x04, FLOAT_ONE);
  959. + else
  960. + dspio_set_uint_param(codec, 0x80, 0x04, FLOAT_EIGHT);
  961. + break;
  962. + case HEADPHONE_OUT:
  963. + codec_dbg(codec, "ca0132_alt_select_out hp\n");
  964. + /* Headphone out config*/
  965. + switch (spec->quirk) {
  966. + case QUIRK_SBZ:
  967. + writew(0x0107, spec->mem_base + 0x320);
  968. + writew(0x0104, spec->mem_base + 0x320);
  969. + writew(0x0001, spec->mem_base + 0x320);
  970. + chipio_set_control_param(codec, 0x0D, 0x12);
  971. + break;
  972. + case QUIRK_R3DI:
  973. + chipio_set_control_param(codec, 0x0D, 0x21);
  974. + r3di_gpio_out_set(codec, R3DI_HEADPHONE_OUT);
  975. + break;
  976. + }
  977. +
  978. + snd_hda_codec_write(codec, spec->out_pins[0], 0,
  979. + AC_VERB_SET_EAPD_BTLENABLE, 0x00);
  980. +
  981. + /* disable speaker*/
  982. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,
  983. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  984. + snd_hda_set_pin_ctl(codec, spec->out_pins[0], pin_ctl & ~PIN_HP);
  985. +
  986. + /* enable headphone, either front or rear */
  987. +
  988. + if (snd_hda_jack_detect(codec, spec->unsol_tag_front_hp))
  989. + headphone_nid = spec->out_pins[2];
  990. + else if (snd_hda_jack_detect(codec, spec->unsol_tag_hp))
  991. + headphone_nid = spec->out_pins[1];
  992. +
  993. + pin_ctl = snd_hda_codec_read(codec, headphone_nid, 0,
  994. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  995. + snd_hda_set_pin_ctl(codec, headphone_nid,
  996. + pin_ctl | PIN_HP);
  997. +
  998. + if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
  999. + dspio_set_uint_param(codec, 0x80, 0x04, FLOAT_ONE);
  1000. + else
  1001. + dspio_set_uint_param(codec, 0x80, 0x04, FLOAT_ZERO);
  1002. + break;
  1003. + case SURROUND_OUT:
  1004. + codec_dbg(codec, "ca0132_alt_select_out Surround\n");
  1005. + /* Surround out config*/
  1006. + switch (spec->quirk) {
  1007. + case QUIRK_SBZ:
  1008. + writew(0x0007, spec->mem_base + 0x320);
  1009. + writew(0x0104, spec->mem_base + 0x320);
  1010. + writew(0x0101, spec->mem_base + 0x320);
  1011. + chipio_set_control_param(codec, 0x0D, 0x18);
  1012. + break;
  1013. + case QUIRK_R3DI:
  1014. + chipio_set_control_param(codec, 0x0D, 0x24);
  1015. + r3di_gpio_out_set(codec, R3DI_LINE_OUT);
  1016. + break;
  1017. + }
  1018. + /* enable line out node */
  1019. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0,
  1020. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  1021. + snd_hda_set_pin_ctl(codec, spec->out_pins[0],
  1022. + pin_ctl | PIN_OUT);
  1023. + /* Disable headphone out */
  1024. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0,
  1025. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  1026. + snd_hda_set_pin_ctl(codec, spec->out_pins[1],
  1027. + pin_ctl & ~PIN_HP);
  1028. + /* Enable EAPD on line out */
  1029. + snd_hda_codec_write(codec, spec->out_pins[0], 0,
  1030. + AC_VERB_SET_EAPD_BTLENABLE, 0x01);
  1031. + /* enable center/lfe out node */
  1032. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[2], 0,
  1033. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  1034. + snd_hda_set_pin_ctl(codec, spec->out_pins[2],
  1035. + pin_ctl | PIN_OUT);
  1036. + /* Now set rear surround node as out. */
  1037. + pin_ctl = snd_hda_codec_read(codec, spec->out_pins[3], 0,
  1038. + AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
  1039. + snd_hda_set_pin_ctl(codec, spec->out_pins[3],
  1040. + pin_ctl | PIN_OUT);
  1041. +
  1042. + if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID])
  1043. + dspio_set_uint_param(codec, 0x80, 0x04, FLOAT_ONE);
  1044. + else
  1045. + dspio_set_uint_param(codec, 0x80, 0x04, FLOAT_EIGHT);
  1046. + break;
  1047. + }
  1048. +
  1049. + /* run through the output dsp commands for line-out */
  1050. + for(i = 0; i < alt_out_presets[spec->cur_out_type].commands; i++) {
  1051. + err = dspio_set_uint_param(codec,
  1052. + alt_out_presets[spec->cur_out_type].mids[i],
  1053. + alt_out_presets[spec->cur_out_type].reqs[i],
  1054. + alt_out_presets[spec->cur_out_type].vals[i]);
  1055. +
  1056. + if (err < 0)
  1057. + goto exit;
  1058. + }
  1059. +
  1060. +exit:
  1061. + snd_hda_power_down_pm(codec);
  1062. +
  1063. + return err < 0 ? err : 0;
  1064. +}
  1065. +
  1066. static void ca0132_unsol_hp_delayed(struct work_struct *work)
  1067. {
  1068. struct ca0132_spec *spec = container_of(
  1069. to_delayed_work(work), struct ca0132_spec, unsol_hp_work);
  1070. struct hda_jack_tbl *jack;
  1072. - ca0132_select_out(spec->codec);
  1073. + if(spec->use_alt_functions)
  1074. + ca0132_alt_select_out(spec->codec);
  1075. + else
  1076. + ca0132_select_out(spec->codec);
  1077. +
  1078. jack = snd_hda_jack_tbl_get(spec->codec, spec->unsol_tag_hp);
  1079. if (jack) {
  1080. jack->block_report = 0;
  1081. @@ -3268,6 +4085,10 @@
  1082. static void ca0132_set_dmic(struct hda_codec *codec, int enable);
  1083. static int ca0132_mic_boost_set(struct hda_codec *codec, long val);
  1084. static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val);
  1085. +static void resume_mic1(struct hda_codec *codec, unsigned int oldval);
  1086. +static int stop_mic1(struct hda_codec *codec);
  1087. +static int ca0132_cvoice_switch_set(struct hda_codec *codec);
  1088. +static int ca0132_alt_mic_boost_set(struct hda_codec *codec, long val);
  1090. /*
  1091. * Select the active VIP source
  1092. @@ -3310,6 +4131,71 @@
  1093. return 1;
  1094. }
  1096. +static int ca0132_alt_set_vipsource(struct hda_codec *codec, int val)
  1097. +{
  1098. + struct ca0132_spec *spec = codec->spec;
  1099. + unsigned int tmp;
  1100. +
  1101. + if (spec->dsp_state != DSP_DOWNLOADED)
  1102. + return 0;
  1103. +
  1104. + codec_dbg(codec, "ca0132_alt_set_vipsource");
  1105. +
  1106. + chipio_set_stream_control(codec, 0x03, 0);
  1107. + chipio_set_stream_control(codec, 0x04, 0);
  1108. +
  1109. + /* if CrystalVoice is off, vipsource should be 0 */
  1110. + if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ||
  1111. + (val == 0) || spec->in_enum_val == REAR_LINE_IN) {
  1112. + codec_dbg(codec, "ca0132_alt_set_vipsource off.");
  1113. + chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, 0);
  1114. +
  1115. + tmp = FLOAT_ZERO;
  1116. + dspio_set_uint_param(codec, 0x80, 0x05, tmp);
  1117. +
  1118. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  1119. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  1120. + if (spec->quirk == QUIRK_R3DI)
  1121. + chipio_set_conn_rate(codec, 0x0F, SR_96_000);
  1122. +
  1123. +
  1124. + if (spec->in_enum_val == REAR_LINE_IN)
  1125. + tmp = FLOAT_ZERO;
  1126. + else {
  1127. + if (spec->quirk == QUIRK_SBZ)
  1128. + tmp = FLOAT_THREE;
  1129. + else
  1130. + tmp = FLOAT_ONE;
  1131. + }
  1132. +
  1133. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  1134. +
  1135. + } else {
  1136. + codec_dbg(codec, "ca0132_alt_set_vipsource on.");
  1137. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_16_000);
  1138. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_16_000);
  1139. + if (spec->quirk == QUIRK_R3DI)
  1140. + chipio_set_conn_rate(codec, 0x0F, SR_16_000);
  1141. +
  1142. + if (spec->effects_switch[VOICE_FOCUS - EFFECT_START_NID])
  1143. + tmp = FLOAT_TWO;
  1144. + else
  1145. + tmp = FLOAT_ONE;
  1146. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  1147. +
  1148. + tmp = FLOAT_ONE;
  1149. + dspio_set_uint_param(codec, 0x80, 0x05, tmp);
  1150. +
  1151. + msleep(20);
  1152. + chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, val);
  1153. + }
  1154. +
  1155. + chipio_set_stream_control(codec, 0x03, 1);
  1156. + chipio_set_stream_control(codec, 0x04, 1);
  1157. +
  1158. + return 1;
  1159. +}
  1160. +
  1161. /*
  1162. * Select the active microphone.
  1163. * If autodetect is enabled, mic will be selected based on jack detection.
  1164. @@ -3363,6 +4249,126 @@
  1165. }
  1167. /*
  1168. + * Select the active input.
  1169. + * Mic detection isn't used, because it's kind of pointless on the SBZ.
  1170. + * The front mic has no jack-detection, so the only way to switch to it
  1171. + * is to do it manually in alsamixer.
  1172. + */
  1173. +
  1174. +static int ca0132_alt_select_in(struct hda_codec *codec)
  1175. +{
  1176. + struct ca0132_spec *spec = codec->spec;
  1177. + unsigned int tmp;
  1178. +
  1179. + codec_dbg(codec, "ca0132_alt_select_in\n");
  1180. +
  1181. + snd_hda_power_up_pm(codec);
  1182. +
  1183. + chipio_set_stream_control(codec, 0x03, 0);
  1184. + chipio_set_stream_control(codec, 0x04, 0);
  1185. +
  1186. + spec->cur_mic_type = spec->in_enum_val;
  1187. +
  1188. + switch (spec->cur_mic_type) {
  1189. + case REAR_MIC:
  1190. + switch (spec->quirk) {
  1191. + case QUIRK_SBZ:
  1192. + writew(0x0000, spec->mem_base + 0x320);
  1193. + tmp = FLOAT_THREE;
  1194. + break;
  1195. + case QUIRK_R3DI:
  1196. + r3di_gpio_mic_set(codec, R3DI_REAR_MIC);
  1197. + tmp = FLOAT_ONE;
  1198. + break;
  1199. + default:
  1200. + tmp = FLOAT_ONE;
  1201. + break;
  1202. + }
  1203. +
  1204. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  1205. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  1206. + if (spec->quirk == QUIRK_R3DI)
  1207. + chipio_set_conn_rate(codec, 0x0F, SR_96_000);
  1208. +
  1209. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  1210. +
  1211. + chipio_set_stream_control(codec, 0x03, 1);
  1212. + chipio_set_stream_control(codec, 0x04, 1);
  1213. +
  1214. + if (spec->quirk == QUIRK_SBZ) {
  1215. + chipio_write(codec, 0x18B098, 0x0000000C);
  1216. + chipio_write(codec, 0x18B09C, 0x0000000C);
  1217. + }
  1218. + ca0132_alt_mic_boost_set(codec, spec->mic_boost_enum_val);
  1219. + break;
  1220. + case REAR_LINE_IN:
  1221. + ca0132_mic_boost_set(codec, 0);
  1222. + switch (spec->quirk) {
  1223. + case QUIRK_SBZ:
  1224. + writew(0x0000, spec->mem_base + 0x320);
  1225. + break;
  1226. + case QUIRK_R3DI:
  1227. + r3di_gpio_mic_set(codec, R3DI_REAR_MIC);
  1228. + break;
  1229. + }
  1230. +
  1231. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  1232. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  1233. + if (spec->quirk == QUIRK_R3DI)
  1234. + chipio_set_conn_rate(codec, 0x0F, SR_96_000);
  1235. +
  1236. + tmp = FLOAT_ZERO;
  1237. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  1238. +
  1239. + if (spec->quirk == QUIRK_SBZ) {
  1240. + chipio_write(codec, 0x18B098, 0x00000000);
  1241. + chipio_write(codec, 0x18B09C, 0x00000000);
  1242. + }
  1243. +
  1244. + chipio_set_stream_control(codec, 0x03, 1);
  1245. + chipio_set_stream_control(codec, 0x04, 1);
  1246. + break;
  1247. + case FRONT_MIC:
  1248. + switch (spec->quirk) {
  1249. + case QUIRK_SBZ:
  1250. + writew(0x0100, spec->mem_base + 0x320);
  1251. + writew(0x0005, spec->mem_base + 0x320);
  1252. + tmp = FLOAT_THREE;
  1253. + break;
  1254. + case QUIRK_R3DI:
  1255. + r3di_gpio_mic_set(codec, R3DI_FRONT_MIC);
  1256. + tmp = FLOAT_ONE;
  1257. + break;
  1258. + default:
  1259. + tmp = FLOAT_ONE;
  1260. + break;
  1261. + }
  1262. +
  1263. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  1264. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  1265. + if (spec->quirk == QUIRK_R3DI)
  1266. + chipio_set_conn_rate(codec, 0x0F, SR_96_000);
  1267. +
  1268. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  1269. +
  1270. + chipio_set_stream_control(codec, 0x03, 1);
  1271. + chipio_set_stream_control(codec, 0x04, 1);
  1272. +
  1273. + if (spec->quirk == QUIRK_SBZ) {
  1274. + chipio_write(codec, 0x18B098, 0x0000000C);
  1275. + chipio_write(codec, 0x18B09C, 0x000000CC);
  1276. + }
  1277. + ca0132_alt_mic_boost_set(codec, spec->mic_boost_enum_val);
  1278. + break;
  1279. + }
  1280. + ca0132_cvoice_switch_set(codec);
  1281. +
  1282. + snd_hda_power_down_pm(codec);
  1283. + return 0;
  1284. +
  1285. +}
  1286. +
  1287. +/*
  1288. * Check if VNODE settings take effect immediately.
  1289. */
  1290. static bool ca0132_is_vnode_effective(struct hda_codec *codec,
  1291. @@ -3418,7 +4424,7 @@
  1292. static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val)
  1293. {
  1294. struct ca0132_spec *spec = codec->spec;
  1295. - unsigned int on;
  1296. + unsigned int on, tmp;
  1297. int num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
  1298. int err = 0;
  1299. int idx = nid - EFFECT_START_NID;
  1300. @@ -3442,6 +4448,45 @@
  1301. /* Voice Focus applies to 2-ch Mic, Digital Mic */
  1302. if ((nid == VOICE_FOCUS) && (spec->cur_mic_type != DIGITAL_MIC))
  1303. val = 0;
  1304. +
  1305. + /* If Voice Focus on SBZ, set to two channel. */
  1306. + if ((nid == VOICE_FOCUS) && (spec->quirk == QUIRK_SBZ)
  1307. + && (spec->cur_mic_type != REAR_LINE_IN)) {
  1308. + if (spec->effects_switch[CRYSTAL_VOICE -
  1309. + EFFECT_START_NID]) {
  1310. +
  1311. + if (spec->effects_switch[VOICE_FOCUS -
  1312. + EFFECT_START_NID])
  1313. + tmp = FLOAT_TWO;
  1314. + else
  1315. + tmp = FLOAT_ONE;
  1316. +
  1317. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  1318. + }
  1319. + }
  1320. +
  1321. + /* For SBZ noise reduction, there's an extra command
  1322. + * to module ID 0x47. No clue why. */
  1323. + if ((nid == NOISE_REDUCTION) && (spec->quirk == QUIRK_SBZ)
  1324. + && (spec->cur_mic_type != REAR_LINE_IN)) {
  1325. + if (spec->effects_switch[CRYSTAL_VOICE -
  1326. + EFFECT_START_NID]) {
  1327. + if (spec->effects_switch[NOISE_REDUCTION -
  1328. + EFFECT_START_NID])
  1329. + tmp = FLOAT_ONE;
  1330. + else
  1331. + tmp = FLOAT_ZERO;
  1332. + }
  1333. + else
  1334. + tmp = FLOAT_ZERO;
  1335. +
  1336. + dspio_set_uint_param(codec, 0x47, 0x00, tmp);
  1337. + }
  1338. +
  1339. + /* If rear line in disable effects. */
  1340. + if (spec->use_alt_functions &&
  1341. + spec->in_enum_val == REAR_LINE_IN)
  1342. + val = 0;
  1343. }
  1345. codec_dbg(codec, "ca0132_effect_set: nid=0x%x, val=%ld\n",
  1346. @@ -3469,6 +4514,9 @@
  1347. codec_dbg(codec, "ca0132_pe_switch_set: val=%ld\n",
  1348. spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]);
  1350. + if (spec->use_alt_functions)
  1351. + ca0132_alt_select_out(codec);
  1352. +
  1353. i = OUT_EFFECT_START_NID - EFFECT_START_NID;
  1354. nid = OUT_EFFECT_START_NID;
  1355. /* PE affects all out effects */
  1356. @@ -3526,7 +4574,10 @@
  1358. /* set correct vipsource */
  1359. oldval = stop_mic1(codec);
  1360. - ret |= ca0132_set_vipsource(codec, 1);
  1361. + if (spec->use_alt_functions)
  1362. + ret |= ca0132_alt_set_vipsource(codec, 1);
  1363. + else
  1364. + ret |= ca0132_set_vipsource(codec, 1);
  1365. resume_mic1(codec, oldval);
  1366. return ret;
  1367. }
  1368. @@ -3546,6 +4597,16 @@
  1369. return ret;
  1370. }
  1372. +static int ca0132_alt_mic_boost_set(struct hda_codec *codec, long val)
  1373. +{
  1374. + struct ca0132_spec *spec = codec->spec;
  1375. + int ret = 0;
  1376. +
  1377. + ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0,
  1378. + HDA_INPUT, 0, HDA_AMP_VOLMASK, val);
  1379. + return ret;
  1380. +}
  1381. +
  1382. static int ca0132_vnode_switch_set(struct snd_kcontrol *kcontrol,
  1383. struct snd_ctl_elem_value *ucontrol)
  1384. {
  1385. @@ -3560,8 +4621,12 @@
  1386. if (nid == VNID_HP_SEL) {
  1387. auto_jack =
  1388. spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
  1389. - if (!auto_jack)
  1390. - ca0132_select_out(codec);
  1391. + if (!auto_jack) {
  1392. + if (spec->use_alt_functions)
  1393. + ca0132_alt_select_out(codec);
  1394. + else
  1395. + ca0132_select_out(codec);
  1396. + }
  1397. return 1;
  1398. }
  1400. @@ -3574,7 +4639,10 @@
  1401. }
  1403. if (nid == VNID_HP_ASEL) {
  1404. - ca0132_select_out(codec);
  1405. + if (spec->use_alt_functions)
  1406. + ca0132_alt_select_out(codec);
  1407. + else
  1408. + ca0132_select_out(codec);
  1409. return 1;
  1410. }
  1412. @@ -3602,6 +4670,428 @@
  1413. return ret;
  1414. }
  1415. /* End of control change helpers. */
  1416. +/*
  1417. + * Below I've added controls to mess with the effect levels, I've only enabled
  1418. + * them on the Sound Blaster Z, but they would probably also work on the
  1419. + * Chromebook. I figured they were probably tuned specifically for it, and left
  1420. + * out for a reason.
  1421. + */
  1422. +
  1423. +/* Sets DSP effect level from the sliders above the controls */
  1424. +static int ca0132_alt_slider_ctl_set(struct hda_codec *codec, hda_nid_t nid,
  1425. + const unsigned int *lookup, int idx)
  1426. +{
  1427. + int i = 0;
  1428. + unsigned int y;
  1429. + /* For X_BASS, req 2 is actually crossover freq instead of
  1430. + * effect level */
  1431. + if (nid == X_BASS)
  1432. + y = 2;
  1433. + else
  1434. + y = 1;
  1435. +
  1436. + snd_hda_power_up(codec);
  1437. + if (nid == XBASS_XOVER) {
  1438. + for(i = 0; i < OUT_EFFECTS_COUNT; i++)
  1439. + if (X_BASS == ca0132_effects[i].nid)
  1440. + break;
  1441. +
  1442. + dspio_set_param(codec, ca0132_effects[i].mid, 0x20,
  1443. + ca0132_effects[i].reqs[1],
  1444. + &(lookup[idx - 1]), sizeof(unsigned int));
  1445. + } else {
  1446. + /* Find the actual effect structure */
  1447. + for(i = 0; i < OUT_EFFECTS_COUNT; i++)
  1448. + if (nid == ca0132_effects[i].nid)
  1449. + break;
  1450. +
  1451. + dspio_set_param(codec, ca0132_effects[i].mid, 0x20,
  1452. + ca0132_effects[i].reqs[y],
  1453. + &(lookup[idx]), sizeof(unsigned int));
  1454. + }
  1455. +
  1456. + snd_hda_power_down(codec);
  1457. +
  1458. + return 0;
  1459. +}
  1460. +
  1461. +static int ca0132_alt_xbass_xover_slider_ctl_get(struct snd_kcontrol *kcontrol,
  1462. + struct snd_ctl_elem_value *ucontrol)
  1463. +{
  1464. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1465. + struct ca0132_spec *spec = codec->spec;
  1466. + long *valp = ucontrol->value.integer.value;
  1467. +
  1468. + *valp = spec->xbass_xover_freq;
  1469. + return 0;
  1470. +}
  1471. +
  1472. +static int ca0132_alt_slider_ctl_get(struct snd_kcontrol *kcontrol,
  1473. + struct snd_ctl_elem_value *ucontrol)
  1474. +{
  1475. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1476. + struct ca0132_spec *spec = codec->spec;
  1477. + hda_nid_t nid = get_amp_nid(kcontrol);
  1478. + long *valp = ucontrol->value.integer.value;
  1479. + int idx = nid - OUT_EFFECT_START_NID;
  1480. +
  1481. + *valp = spec->fx_ctl_val[idx];
  1482. + return 0;
  1483. +}
  1484. +
  1485. +/*
  1486. + * The X-bass crossover starts at 10hz, so the min is 1. The
  1487. + * frequency is set in multiples of 10.
  1488. + */
  1489. +static int ca0132_alt_xbass_xover_slider_info(struct snd_kcontrol *kcontrol,
  1490. + struct snd_ctl_elem_info *uinfo)
  1491. +{
  1492. + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  1493. + uinfo->count = 1;
  1494. + uinfo->value.integer.min = 1;
  1495. + uinfo->value.integer.max = 100;
  1496. + uinfo->value.integer.step = 1;
  1497. +
  1498. + return 0;
  1499. +}
  1500. +
  1501. +static int ca0132_alt_effect_slider_info(struct snd_kcontrol *kcontrol,
  1502. + struct snd_ctl_elem_info *uinfo)
  1503. +{
  1504. + int chs = get_amp_channels(kcontrol);
  1505. + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  1506. + uinfo->count = chs == 3 ? 2 : 1;
  1507. + uinfo->value.integer.min = 0;
  1508. + uinfo->value.integer.max = 100;
  1509. + uinfo->value.integer.step = 1;
  1510. +
  1511. + return 0;
  1512. +}
  1513. +
  1514. +static int ca0132_alt_xbass_xover_slider_put(struct snd_kcontrol *kcontrol,
  1515. + struct snd_ctl_elem_value *ucontrol)
  1516. +{
  1517. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1518. + struct ca0132_spec *spec = codec->spec;
  1519. + hda_nid_t nid = get_amp_nid(kcontrol);
  1520. + long *valp = ucontrol->value.integer.value;
  1521. + int idx;
  1522. +
  1523. + /* any change? */
  1524. + if (spec->xbass_xover_freq == *valp)
  1525. + return 0;
  1526. +
  1527. + spec->xbass_xover_freq = *valp;
  1528. +
  1529. + idx = *valp;
  1530. + ca0132_alt_slider_ctl_set(codec, nid, float_xbass_xover_lookup, idx);
  1531. +
  1532. + return 0;
  1533. +}
  1534. +
  1535. +static int ca0132_alt_effect_slider_put(struct snd_kcontrol *kcontrol,
  1536. + struct snd_ctl_elem_value *ucontrol)
  1537. +{
  1538. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1539. + struct ca0132_spec *spec = codec->spec;
  1540. + hda_nid_t nid = get_amp_nid(kcontrol);
  1541. + long *valp = ucontrol->value.integer.value;
  1542. + int idx;
  1543. +
  1544. + idx = nid - EFFECT_START_NID;
  1545. + /* any change? */
  1546. + if (spec->fx_ctl_val[idx] == *valp)
  1547. + return 0;
  1548. +
  1549. + spec->fx_ctl_val[idx] = *valp;
  1550. +
  1551. + idx = *valp;
  1552. + ca0132_alt_slider_ctl_set(codec, nid, float_zero_to_one_lookup, idx);
  1553. +
  1554. + return 0;
  1555. +}
  1556. +
  1557. +
  1558. +/* Mic Boost Enum for alternative ca0132 codecs. I didn't like that the original
  1559. + * only has off or full 30 dB, and didn't like making a volume slider that has
  1560. + * traditional 0-100 in alsamixer that goes in big steps. I like enum better. */
  1561. +#define MIC_BOOST_NUM_OF_STEPS 4
  1562. +#define MIC_BOOST_ENUM_MAX_STRLEN 10
  1563. +
  1564. +static int ca0132_alt_mic_boost_info(struct snd_kcontrol *kcontrol,
  1565. + struct snd_ctl_elem_info *uinfo)
  1566. +{
  1567. + char *sfx = "dB";
  1568. + char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
  1569. + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  1570. + uinfo->count = 1;
  1571. + uinfo->value.enumerated.items = MIC_BOOST_NUM_OF_STEPS;
  1572. + if (uinfo->value.enumerated.item >= MIC_BOOST_NUM_OF_STEPS)
  1573. + uinfo->value.enumerated.item = MIC_BOOST_NUM_OF_STEPS - 1;
  1574. + sprintf(namestr, "%d %s", (uinfo->value.enumerated.item * 10), sfx);
  1575. + strcpy(uinfo->value.enumerated.name, namestr);
  1576. + return 0;
  1577. +}
  1578. +
  1579. +static int ca0132_alt_mic_boost_get(struct snd_kcontrol *kcontrol,
  1580. + struct snd_ctl_elem_value *ucontrol)
  1581. +{
  1582. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1583. + struct ca0132_spec *spec = codec->spec;
  1584. +
  1585. + ucontrol->value.enumerated.item[0] = spec->mic_boost_enum_val;
  1586. + return 0;
  1587. +}
  1588. +
  1589. +static int ca0132_alt_mic_boost_put(struct snd_kcontrol *kcontrol,
  1590. + struct snd_ctl_elem_value *ucontrol)
  1591. +{
  1592. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1593. + struct ca0132_spec *spec = codec->spec;
  1594. + int sel = ucontrol->value.enumerated.item[0];
  1595. + unsigned int items = MIC_BOOST_NUM_OF_STEPS;
  1596. +
  1597. + if (sel >= items)
  1598. + return 0;
  1599. +
  1600. + codec_dbg(codec, "ca0132_alt_mic_boost: boost=%d\n",
  1601. + sel);
  1602. +
  1603. + spec->mic_boost_enum_val = sel;
  1604. +
  1605. + if (spec->in_enum_val != REAR_LINE_IN)
  1606. + ca0132_alt_mic_boost_set(codec, spec->mic_boost_enum_val);
  1607. +
  1608. + return 1;
  1609. +}
  1610. +
  1611. +
  1612. +/* Input Select Control for alternative ca0132 codecs. This exists because
  1613. + * front microphone has no auto-detect, and we need a way to set the rear
  1614. + * as line-in */
  1615. +
  1616. +static int ca0132_alt_input_source_info(struct snd_kcontrol *kcontrol,
  1617. + struct snd_ctl_elem_info *uinfo)
  1618. +{
  1619. + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  1620. + uinfo->count = 1;
  1621. + uinfo->value.enumerated.items = IN_SRC_NUM_OF_INPUTS;
  1622. + if (uinfo->value.enumerated.item >= IN_SRC_NUM_OF_INPUTS)
  1623. + uinfo->value.enumerated.item = IN_SRC_NUM_OF_INPUTS - 1;
  1624. + strcpy(uinfo->value.enumerated.name,
  1625. + in_src_str[uinfo->value.enumerated.item]);
  1626. + return 0;
  1627. +}
  1628. +
  1629. +static int ca0132_alt_input_source_get(struct snd_kcontrol *kcontrol,
  1630. + struct snd_ctl_elem_value *ucontrol)
  1631. +{
  1632. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1633. + struct ca0132_spec *spec = codec->spec;
  1634. +
  1635. + ucontrol->value.enumerated.item[0] = spec->in_enum_val;
  1636. + return 0;
  1637. +}
  1638. +
  1639. +static int ca0132_alt_input_source_put(struct snd_kcontrol *kcontrol,
  1640. + struct snd_ctl_elem_value *ucontrol)
  1641. +{
  1642. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1643. + struct ca0132_spec *spec = codec->spec;
  1644. + int sel = ucontrol->value.enumerated.item[0];
  1645. + unsigned int items = IN_SRC_NUM_OF_INPUTS;
  1646. +
  1647. + if (sel >= items)
  1648. + return 0;
  1649. +
  1650. + codec_dbg(codec, "ca0132_alt_input_select: sel=%d, preset=%s\n",
  1651. + sel, in_src_str[sel]);
  1652. +
  1653. + spec->in_enum_val = sel;
  1654. +
  1655. + ca0132_alt_select_in(codec);
  1656. +
  1657. + return 1;
  1658. +}
  1659. +
  1660. +/* Sound Blaster Z Output Select Control */
  1661. +static int ca0132_alt_output_select_get_info(struct snd_kcontrol *kcontrol,
  1662. + struct snd_ctl_elem_info *uinfo)
  1663. +{
  1664. + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  1665. + uinfo->count = 1;
  1666. + uinfo->value.enumerated.items = NUM_OF_OUTPUTS;
  1667. + if (uinfo->value.enumerated.item >= NUM_OF_OUTPUTS)
  1668. + uinfo->value.enumerated.item = NUM_OF_OUTPUTS - 1;
  1669. + strcpy(uinfo->value.enumerated.name,
  1670. + alt_out_presets[uinfo->value.enumerated.item].name);
  1671. + return 0;
  1672. +}
  1673. +
  1674. +static int ca0132_alt_output_select_get(struct snd_kcontrol *kcontrol,
  1675. + struct snd_ctl_elem_value *ucontrol)
  1676. +{
  1677. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1678. + struct ca0132_spec *spec = codec->spec;
  1679. +
  1680. + ucontrol->value.enumerated.item[0] = spec->out_enum_val;
  1681. + return 0;
  1682. +}
  1683. +
  1684. +static int ca0132_alt_output_select_put(struct snd_kcontrol *kcontrol,
  1685. + struct snd_ctl_elem_value *ucontrol)
  1686. +{
  1687. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1688. + struct ca0132_spec *spec = codec->spec;
  1689. + int sel = ucontrol->value.enumerated.item[0];
  1690. + unsigned int items = NUM_OF_OUTPUTS;
  1691. + unsigned int auto_jack;
  1692. +
  1693. + if (sel >= items)
  1694. + return 0;
  1695. +
  1696. + codec_dbg(codec, "ca0132_alt_output_select: sel=%d, preset=%s\n",
  1697. + sel, alt_out_presets[sel].name);
  1698. +
  1699. + spec->out_enum_val = sel;
  1700. +
  1701. + auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID];
  1702. +
  1703. + if (!auto_jack) {
  1704. + ca0132_alt_select_out(codec);
  1705. + }
  1706. +
  1707. + return 1;
  1708. +}
  1709. +
  1710. +/* Smart Volume output setting control. Three different settings, Normal,
  1711. + * which takes the value from the smart volume slider. The two others, loud
  1712. + * and night, disregard the slider value and have uneditable values. */
  1713. +#define NUM_OF_SVM_SETTINGS 3
  1714. +static const char *out_svm_set_enum_str[3] = {"Normal", "Loud", "Night" };
  1715. +
  1716. +static int ca0132_alt_svm_setting_info(struct snd_kcontrol *kcontrol,
  1717. + struct snd_ctl_elem_info *uinfo)
  1718. +{
  1719. + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  1720. + uinfo->count = 1;
  1721. + uinfo->value.enumerated.items = NUM_OF_SVM_SETTINGS;
  1722. + if (uinfo->value.enumerated.item >= NUM_OF_SVM_SETTINGS)
  1723. + uinfo->value.enumerated.item = NUM_OF_SVM_SETTINGS - 1;
  1724. + strcpy(uinfo->value.enumerated.name,
  1725. + out_svm_set_enum_str[uinfo->value.enumerated.item]);
  1726. + return 0;
  1727. +}
  1728. +
  1729. +static int ca0132_alt_svm_setting_get(struct snd_kcontrol *kcontrol,
  1730. + struct snd_ctl_elem_value *ucontrol)
  1731. +{
  1732. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1733. + struct ca0132_spec *spec = codec->spec;
  1734. +
  1735. + ucontrol->value.enumerated.item[0] = spec->smart_volume_setting;
  1736. + return 0;
  1737. +}
  1738. +
  1739. +static int ca0132_alt_svm_setting_put(struct snd_kcontrol *kcontrol,
  1740. + struct snd_ctl_elem_value *ucontrol)
  1741. +{
  1742. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1743. + struct ca0132_spec *spec = codec->spec;
  1744. + int sel = ucontrol->value.enumerated.item[0];
  1745. + unsigned int items = NUM_OF_SVM_SETTINGS;
  1746. + unsigned int idx = SMART_VOLUME - EFFECT_START_NID;
  1747. + unsigned int tmp;
  1748. +
  1749. + if (sel >= items)
  1750. + return 0;
  1751. +
  1752. + codec_dbg(codec, "ca0132_alt_svm_setting: sel=%d, preset=%s\n",
  1753. + sel, out_svm_set_enum_str[sel]);
  1754. +
  1755. + spec->smart_volume_setting = sel;
  1756. +
  1757. + switch (sel) {
  1758. + case 0:
  1759. + tmp = FLOAT_ZERO;
  1760. + break;
  1761. + case 1:
  1762. + tmp = FLOAT_ONE;
  1763. + break;
  1764. + case 2:
  1765. + tmp = FLOAT_TWO;
  1766. + break;
  1767. + default:
  1768. + tmp = FLOAT_ZERO;
  1769. + break;
  1770. + }
  1771. + /* Req 2 is the Smart Volume Setting req. */
  1772. + dspio_set_uint_param(codec, ca0132_effects[idx].mid,
  1773. + ca0132_effects[idx].reqs[2], tmp);
  1774. + return 1;
  1775. +}
  1776. +
  1777. +/* Sound Blaster Z EQ preset controls */
  1778. +static int ca0132_alt_eq_preset_info(struct snd_kcontrol *kcontrol,
  1779. + struct snd_ctl_elem_info *uinfo)
  1780. +{
  1781. + unsigned int items = sizeof(ca0132_alt_eq_presets)
  1782. + / sizeof(struct ct_eq_preset);
  1783. +
  1784. + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  1785. + uinfo->count = 1;
  1786. + uinfo->value.enumerated.items = items;
  1787. + if (uinfo->value.enumerated.item >= items)
  1788. + uinfo->value.enumerated.item = items - 1;
  1789. + strcpy(uinfo->value.enumerated.name,
  1790. + ca0132_alt_eq_presets[uinfo->value.enumerated.item].name);
  1791. + return 0;
  1792. +}
  1793. +
  1794. +static int ca0132_alt_eq_preset_get(struct snd_kcontrol *kcontrol,
  1795. + struct snd_ctl_elem_value *ucontrol)
  1796. +{
  1797. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1798. + struct ca0132_spec *spec = codec->spec;
  1799. +
  1800. + ucontrol->value.enumerated.item[0] = spec->eq_preset_val;
  1801. + return 0;
  1802. +}
  1803. +
  1804. +static int ca0132_alt_eq_preset_put(struct snd_kcontrol *kcontrol,
  1805. + struct snd_ctl_elem_value *ucontrol)
  1806. +{
  1807. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1808. + struct ca0132_spec *spec = codec->spec;
  1809. + int i, err = 0;
  1810. + int sel = ucontrol->value.enumerated.item[0];
  1811. + unsigned int items = sizeof(ca0132_alt_eq_presets)
  1812. + / sizeof(struct ct_eq_preset);
  1813. +
  1814. + if (sel >= items)
  1815. + return 0;
  1816. +
  1817. + codec_dbg(codec, "ca0132_alt_eq_preset_put: sel=%d, preset=%s\n",
  1818. + sel, ca0132_alt_eq_presets[sel].name);
  1819. +
  1820. + /*
  1821. + * Idx 0 is default.
  1822. + * Default needs to qualify with CrystalVoice state.
  1823. + */
  1824. + for (i = 0; i < EQ_PRESET_MAX_PARAM_COUNT; i++) {
  1825. + err = dspio_set_uint_param(codec, ca0132_alt_eq_enum.mid,
  1826. + ca0132_alt_eq_enum.reqs[i],
  1827. + ca0132_alt_eq_presets[sel].vals[i]);
  1828. + if (err < 0)
  1829. + break;
  1830. + }
  1831. +
  1832. + if (err >= 0) {
  1833. + spec->eq_preset_val = sel;
  1834. + }
  1835. +
  1836. + return 1;
  1837. +}
  1839. static int ca0132_voicefx_info(struct snd_kcontrol *kcontrol,
  1840. struct snd_ctl_elem_info *uinfo)
  1841. @@ -3753,10 +5243,15 @@
  1842. /* mic boost */
  1843. if (nid == spec->input_pins[0]) {
  1844. spec->cur_mic_boost = *valp;
  1845. + if (spec->use_alt_functions) {
  1846. + if (spec->in_enum_val != REAR_LINE_IN)
  1847. + changed = ca0132_mic_boost_set(codec, *valp);
  1848. + } else {
  1849. + /* Mic boost does not apply to Digital Mic */
  1850. + if (spec->cur_mic_type != DIGITAL_MIC)
  1851. + changed = ca0132_mic_boost_set(codec, *valp);
  1852. + }
  1854. - /* Mic boost does not apply to Digital Mic */
  1855. - if (spec->cur_mic_type != DIGITAL_MIC)
  1856. - changed = ca0132_mic_boost_set(codec, *valp);
  1857. goto exit;
  1858. }
  1860. @@ -3768,6 +5263,41 @@
  1861. /*
  1862. * Volume related
  1863. */
  1864. +/*
  1865. + * Sets the internal DSP decibel level to match the DAC for output, and the
  1866. + * ADC for input. Currently only the SBZ sets dsp capture volume level, and
  1867. + * all alternative codecs set DSP playback volume.
  1868. + */
  1869. +static void ca0132_alt_dsp_volume_put(struct hda_codec *codec, hda_nid_t nid)
  1870. +{
  1871. + struct ca0132_spec *spec = codec->spec;
  1872. + unsigned int dsp_dir;
  1873. + unsigned int lookup_val;
  1874. +
  1875. + if (nid == VNID_SPK)
  1876. + dsp_dir = DSP_VOL_OUT;
  1877. + else
  1878. + dsp_dir = DSP_VOL_IN;
  1879. +
  1880. + lookup_val = spec->vnode_lvol[nid - VNODE_START_NID];
  1881. +
  1882. + dspio_set_uint_param(codec,
  1883. + ca0132_alt_vol_ctls[dsp_dir].mid,
  1884. + ca0132_alt_vol_ctls[dsp_dir].reqs[0],
  1885. + float_vol_db_lookup[lookup_val]);
  1886. +
  1887. + lookup_val = spec->vnode_rvol[nid - VNODE_START_NID];
  1888. +
  1889. + dspio_set_uint_param(codec,
  1890. + ca0132_alt_vol_ctls[dsp_dir].mid,
  1891. + ca0132_alt_vol_ctls[dsp_dir].reqs[1],
  1892. + float_vol_db_lookup[lookup_val]);
  1893. +
  1894. + dspio_set_uint_param(codec,
  1895. + ca0132_alt_vol_ctls[dsp_dir].mid,
  1896. + ca0132_alt_vol_ctls[dsp_dir].reqs[2], FLOAT_ZERO);
  1897. +}
  1898. +
  1899. static int ca0132_volume_info(struct snd_kcontrol *kcontrol,
  1900. struct snd_ctl_elem_info *uinfo)
  1901. {
  1902. @@ -3869,6 +5399,51 @@
  1903. return changed;
  1904. }
  1906. +/*
  1907. + * This function is the same as the one above, because using an if statement
  1908. + * inside of the above volume control for the DSP volume would cause too much
  1909. + * lag. This is a lot more smooth.
  1910. + */
  1911. +static int ca0132_alt_volume_put(struct snd_kcontrol *kcontrol,
  1912. + struct snd_ctl_elem_value *ucontrol)
  1913. +{
  1914. + struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  1915. + struct ca0132_spec *spec = codec->spec;
  1916. + hda_nid_t nid = get_amp_nid(kcontrol);
  1917. + int ch = get_amp_channels(kcontrol);
  1918. + long *valp = ucontrol->value.integer.value;
  1919. + hda_nid_t vnid = 0;
  1920. + int changed = 1;
  1921. +
  1922. + switch (nid) {
  1923. + case 0x02:
  1924. + vnid = VNID_SPK;
  1925. + break;
  1926. + case 0x07:
  1927. + vnid = VNID_MIC;
  1928. + break;
  1929. + }
  1930. +
  1931. + /* store the left and right volume */
  1932. + if (ch & 1) {
  1933. + spec->vnode_lvol[vnid - VNODE_START_NID] = *valp;
  1934. + valp++;
  1935. + }
  1936. + if (ch & 2) {
  1937. + spec->vnode_rvol[vnid - VNODE_START_NID] = *valp;
  1938. + valp++;
  1939. + }
  1940. +
  1941. + snd_hda_power_up(codec);
  1942. + ca0132_alt_dsp_volume_put(codec, vnid);
  1943. + mutex_lock(&codec->control_mutex);
  1944. + changed = snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
  1945. + mutex_unlock(&codec->control_mutex);
  1946. + snd_hda_power_down(codec);
  1947. +
  1948. + return changed;
  1949. +}
  1950. +
  1951. static int ca0132_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag,
  1952. unsigned int size, unsigned int __user *tlv)
  1953. {
  1954. @@ -3907,14 +5482,61 @@
  1955. return err;
  1956. }
  1958. -static int add_fx_switch(struct hda_codec *codec, hda_nid_t nid,
  1959. +/* Add volume slider control for effect level */
  1960. +static int ca0132_alt_add_effect_slider(struct hda_codec *codec, hda_nid_t nid,
  1961. + const char *pfx, int dir)
  1962. +{
  1963. + char *fx = "FX:";
  1964. + char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
  1965. + int type = dir ? HDA_INPUT : HDA_OUTPUT;
  1966. + struct snd_kcontrol_new knew =
  1967. + HDA_CODEC_VOLUME_MONO(namestr, nid, 1, 0, type);
  1968. +
  1969. + sprintf(namestr, "%s %s %s Volume", fx, pfx, dirstr[dir]);
  1970. +
  1971. + knew.tlv.c = 0;
  1972. + knew.tlv.p = 0;
  1973. +
  1974. + switch (nid) {
  1975. + case XBASS_XOVER:
  1976. + knew.info = ca0132_alt_xbass_xover_slider_info;
  1977. + knew.get = ca0132_alt_xbass_xover_slider_ctl_get;
  1978. + knew.put = ca0132_alt_xbass_xover_slider_put;
  1979. + break;
  1980. + default:
  1981. + knew.info = ca0132_alt_effect_slider_info;
  1982. + knew.get = ca0132_alt_slider_ctl_get;
  1983. + knew.put = ca0132_alt_effect_slider_put;
  1984. + knew.private_value =
  1985. + HDA_COMPOSE_AMP_VAL(nid, 1, 0, type);
  1986. + break;
  1987. + }
  1988. +
  1989. + return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
  1990. +}
  1991. +
  1992. +/*
  1993. + * Added FX: prefix for the alternative codecs, because otherwise the surround
  1994. + * effect would conflict with the Surround sound volume control. Also seems more
  1995. + * clear as to what the switches do. Left alone for others.
  1996. + */
  1997. +static int add_fx_switch (struct hda_codec *codec, hda_nid_t nid,
  1998. const char *pfx, int dir)
  1999. {
  2000. + struct ca0132_spec *spec = codec->spec;
  2001. + char *fx = "FX:";
  2002. char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
  2003. int type = dir ? HDA_INPUT : HDA_OUTPUT;
  2004. struct snd_kcontrol_new knew =
  2005. CA0132_CODEC_MUTE_MONO(namestr, nid, 1, type);
  2006. - sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]);
  2007. + /* If using alt_controls, add FX: prefix. But, don't add FX:
  2008. + * prefix to OutFX or InFX enable controls.
  2009. + */
  2010. + if ((spec->use_alt_controls) && (nid <= IN_EFFECT_END_NID))
  2011. + sprintf(namestr, "%s %s %s Switch", fx, pfx, dirstr[dir]);
  2012. + else
  2013. + sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]);
  2014. +
  2015. return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
  2016. }
  2018. @@ -3929,6 +5551,111 @@
  2019. return snd_hda_ctl_add(codec, VOICEFX, snd_ctl_new1(&knew, codec));
  2020. }
  2022. +/* Create the EQ Preset control */
  2023. +static int add_ca0132_alt_eq_presets(struct hda_codec *codec)
  2024. +{
  2025. + struct snd_kcontrol_new knew =
  2026. + HDA_CODEC_MUTE_MONO(ca0132_alt_eq_enum.name,
  2027. + EQ_PRESET_ENUM, 1, 0, HDA_OUTPUT);
  2028. + knew.info = ca0132_alt_eq_preset_info;
  2029. + knew.get = ca0132_alt_eq_preset_get;
  2030. + knew.put = ca0132_alt_eq_preset_put;
  2031. + return snd_hda_ctl_add(codec, EQ_PRESET_ENUM,
  2032. + snd_ctl_new1(&knew, codec));
  2033. +}
  2034. +
  2035. +/* Add enumerated control for the three different settings of the smart volume
  2036. + * output effect. Normal just uses the slider value, and loud and night are
  2037. + * their own things that ignore that value. */
  2038. +static int ca0132_alt_add_svm_enum(struct hda_codec *codec)
  2039. +{
  2040. + struct snd_kcontrol_new knew =
  2041. + HDA_CODEC_MUTE_MONO("FX: Smart Volume Setting",
  2042. + SMART_VOLUME_ENUM, 1, 0, HDA_OUTPUT);
  2043. + knew.info = ca0132_alt_svm_setting_info;
  2044. + knew.get = ca0132_alt_svm_setting_get;
  2045. + knew.put = ca0132_alt_svm_setting_put;
  2046. + return snd_hda_ctl_add(codec, SMART_VOLUME_ENUM,
  2047. + snd_ctl_new1(&knew, codec));
  2048. +
  2049. +}
  2050. +
  2051. +/*
  2052. + * Create an Output Select enumerated control for codecs with surround
  2053. + * out capabilities.
  2054. + */
  2055. +static int ca0132_alt_add_output_enum(struct hda_codec *codec)
  2056. +{
  2057. + struct snd_kcontrol_new knew =
  2058. + HDA_CODEC_MUTE_MONO("Output Select",
  2059. + OUTPUT_SOURCE_ENUM, 1, 0, HDA_OUTPUT);
  2060. + knew.info = ca0132_alt_output_select_get_info;
  2061. + knew.get = ca0132_alt_output_select_get;
  2062. + knew.put = ca0132_alt_output_select_put;
  2063. + return snd_hda_ctl_add(codec, OUTPUT_SOURCE_ENUM,
  2064. + snd_ctl_new1(&knew, codec));
  2065. +}
  2066. +
  2067. +/*
  2068. + * Create an Input Source enumerated control for the alternate ca0132 codecs
  2069. + * because the front microphone has no auto-detect, and Line-in has to be set
  2070. + * somehow.
  2071. + */
  2072. +static int ca0132_alt_add_input_enum(struct hda_codec *codec)
  2073. +{
  2074. + struct snd_kcontrol_new knew =
  2075. + HDA_CODEC_MUTE_MONO("Input Source",
  2076. + INPUT_SOURCE_ENUM, 1, 0, HDA_INPUT);
  2077. + knew.info = ca0132_alt_input_source_info;
  2078. + knew.get = ca0132_alt_input_source_get;
  2079. + knew.put = ca0132_alt_input_source_put;
  2080. + return snd_hda_ctl_add(codec, INPUT_SOURCE_ENUM,
  2081. + snd_ctl_new1(&knew, codec));
  2082. +}
  2083. +
  2084. +/*
  2085. + * Add mic boost enumerated control. Switches through 0dB to 30dB. This adds
  2086. + * more control than the original mic boost, which is either full 30dB or off.
  2087. + */
  2088. +static int ca0132_alt_add_mic_boost_enum(struct hda_codec *codec)
  2089. +{
  2090. + struct snd_kcontrol_new knew =
  2091. + HDA_CODEC_MUTE_MONO("Mic Boost Capture Switch",
  2092. + MIC_BOOST_ENUM, 1, 0, HDA_INPUT);
  2093. + knew.info = ca0132_alt_mic_boost_info;
  2094. + knew.get = ca0132_alt_mic_boost_get;
  2095. + knew.put = ca0132_alt_mic_boost_put;
  2096. + return snd_hda_ctl_add(codec, MIC_BOOST_ENUM,
  2097. + snd_ctl_new1(&knew, codec));
  2098. +
  2099. +}
  2100. +
  2101. +/*
  2102. + * Need to create slave controls for the alternate codecs that have surround
  2103. + * capabilities.
  2104. + */
  2105. +static const char * const ca0132_alt_slave_pfxs[] = {
  2106. + "Front", "Surround", "Center", "LFE", NULL,
  2107. +};
  2108. +
  2109. +/*
  2110. + * Also need special channel map, because the default one is incorrect.
  2111. + * I think this has to do with the pin for rear surround being 0x11,
  2112. + * and the center/lfe being 0x10. Usually the pin order is the opposite.
  2113. + */
  2114. +const struct snd_pcm_chmap_elem ca0132_alt_chmaps[] = {
  2115. + { .channels = 2,
  2116. + .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
  2117. + { .channels = 4,
  2118. + .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
  2119. + SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
  2120. + { .channels = 6,
  2121. + .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
  2122. + SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE,
  2123. + SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
  2124. + { }
  2125. +};
  2126. +
  2127. /*
  2128. * When changing Node IDs for Mixer Controls below, make sure to update
  2129. * Node IDs in ca0132_config() as well.
  2130. @@ -3955,66 +5682,199 @@
  2131. { } /* end */
  2132. };
  2134. +/*
  2135. + * SBZ specific control mixer. Removes auto-detect for mic, and adds surround
  2136. + * controls. Also sets both the Front Playback and Capture Volume controls to
  2137. + * alt so they set the DSP's decibel level.
  2138. + */
  2139. +static struct snd_kcontrol_new sbz_mixer[] = {
  2140. + CA0132_ALT_CODEC_VOL("Front Playback Volume", 0x02, HDA_OUTPUT),
  2141. + CA0132_CODEC_MUTE("Front Playback Switch", VNID_SPK, HDA_OUTPUT),
  2142. + HDA_CODEC_VOLUME("Surround Playback Volume", 0x04, 0, HDA_OUTPUT),
  2143. + HDA_CODEC_MUTE("Surround Playback Switch", 0x04, 0, HDA_OUTPUT),
  2144. + HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x03, 1, 0, HDA_OUTPUT),
  2145. + HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x03, 1, 0, HDA_OUTPUT),
  2146. + HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x03, 2, 0, HDA_OUTPUT),
  2147. + HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x03, 2, 0, HDA_OUTPUT),
  2148. + CA0132_ALT_CODEC_VOL("Capture Volume", 0x07, HDA_INPUT),
  2149. + CA0132_CODEC_MUTE("Capture Switch", VNID_MIC, HDA_INPUT),
  2150. + HDA_CODEC_VOLUME("What U Hear Capture Volume", 0x0a, 0, HDA_INPUT),
  2151. + HDA_CODEC_MUTE("What U Hear Capture Switch", 0x0a, 0, HDA_INPUT),
  2152. + CA0132_CODEC_MUTE_MONO("HP/Speaker Auto Detect Playback Switch",
  2153. + VNID_HP_ASEL, 1, HDA_OUTPUT),
  2154. + { } /* end */
  2155. +};
  2156. +
  2157. +/*
  2158. + * Same as the Sound Blaster Z, except doesn't use the alt volume for capture
  2159. + * because it doesn't set decibel levels for the DSP for capture.
  2160. + */
  2161. +static struct snd_kcontrol_new r3di_mixer[] = {
  2162. + CA0132_ALT_CODEC_VOL("Front Playback Volume", 0x02, HDA_OUTPUT),
  2163. + CA0132_CODEC_MUTE("Front Playback Switch", VNID_SPK, HDA_OUTPUT),
  2164. + HDA_CODEC_VOLUME("Surround Playback Volume", 0x04, 0, HDA_OUTPUT),
  2165. + HDA_CODEC_MUTE("Surround Playback Switch", 0x04, 0, HDA_OUTPUT),
  2166. + HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x03, 1, 0, HDA_OUTPUT),
  2167. + HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x03, 1, 0, HDA_OUTPUT),
  2168. + HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x03, 2, 0, HDA_OUTPUT),
  2169. + HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x03, 2, 0, HDA_OUTPUT),
  2170. + CA0132_CODEC_VOL("Capture Volume", VNID_MIC, HDA_INPUT),
  2171. + CA0132_CODEC_MUTE("Capture Switch", VNID_MIC, HDA_INPUT),
  2172. + HDA_CODEC_VOLUME("What U Hear Capture Volume", 0x0a, 0, HDA_INPUT),
  2173. + HDA_CODEC_MUTE("What U Hear Capture Switch", 0x0a, 0, HDA_INPUT),
  2174. + CA0132_CODEC_MUTE_MONO("HP/Speaker Auto Detect Playback Switch",
  2175. + VNID_HP_ASEL, 1, HDA_OUTPUT),
  2176. + { } /* end */
  2177. +};
  2178. +
  2179. static int ca0132_build_controls(struct hda_codec *codec)
  2180. {
  2181. - struct ca0132_spec *spec = codec->spec;
  2182. - int i, num_fx;
  2183. - int err = 0;
  2184. + struct ca0132_spec *spec = codec->spec;
  2185. + struct hda_pcm *pcm;
  2186. + int i, num_fx, num_sliders;
  2187. + int err = 0;
  2188. +
  2189. + /* Add Mixer controls */
  2190. + for (i = 0; i < spec->num_mixers; i++) {
  2191. + err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
  2192. + if (err < 0)
  2193. + return err;
  2194. + }
  2195. + /* Setup vmaster with surround slaves for desktop ca0132 devices */
  2196. + if (spec->use_alt_functions) {
  2197. + snd_hda_set_vmaster_tlv(codec, spec->dacs[0], HDA_OUTPUT,
  2198. + spec->tlv);
  2199. + snd_hda_add_vmaster(codec, "Master Playback Volume",
  2200. + spec->tlv, ca0132_alt_slave_pfxs,
  2201. + "Playback Volume");
  2202. + err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
  2203. + NULL, ca0132_alt_slave_pfxs,
  2204. + "Playback Switch",
  2205. + true, &spec->vmaster_mute.sw_kctl);
  2206. +
  2207. + }
  2208. +
  2209. + /* Add in and out effects controls.
  2210. + * VoiceFX, PE and CrystalVoice are added separately.
  2211. + */
  2212. + num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
  2213. + for (i = 0; i < num_fx; i++) {
  2214. + /* SBZ breaks if Echo Cancellation is used */
  2215. + if (spec->quirk == QUIRK_SBZ) {
  2216. + if (i == (ECHO_CANCELLATION - IN_EFFECT_START_NID +
  2217. + OUT_EFFECTS_COUNT))
  2218. + continue;
  2219. + }
  2221. - /* Add Mixer controls */
  2222. - for (i = 0; i < spec->num_mixers; i++) {
  2223. - err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
  2224. + err = add_fx_switch (codec, ca0132_effects[i].nid,
  2225. + ca0132_effects[i].name,
  2226. + ca0132_effects[i].direct);
  2227. + if (err < 0)
  2228. + return err;
  2229. + }
  2230. + /*
  2231. + * If codec has use_alt_controls set to true, add effect level sliders,
  2232. + * EQ presets, and Smart Volume presets. Also, change names to add FX
  2233. + * prefix, and change PlayEnhancement and CrystalVoice to match.
  2234. + */
  2235. + if (spec->use_alt_controls) {
  2236. + ca0132_alt_add_svm_enum(codec);
  2237. + add_ca0132_alt_eq_presets(codec);
  2238. + err = add_fx_switch (codec, PLAY_ENHANCEMENT,
  2239. + "Enable OutFX", 0);
  2240. if (err < 0)
  2241. return err;
  2242. - }
  2244. - /* Add in and out effects controls.
  2245. - * VoiceFX, PE and CrystalVoice are added separately.
  2246. - */
  2247. - num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT;
  2248. - for (i = 0; i < num_fx; i++) {
  2249. - err = add_fx_switch(codec, ca0132_effects[i].nid,
  2250. - ca0132_effects[i].name,
  2251. - ca0132_effects[i].direct);
  2252. + err = add_fx_switch (codec, CRYSTAL_VOICE,
  2253. + "Enable InFX", 1);
  2254. if (err < 0)
  2255. return err;
  2256. - }
  2258. - err = add_fx_switch(codec, PLAY_ENHANCEMENT, "PlayEnhancement", 0);
  2259. - if (err < 0)
  2260. - return err;
  2261. + num_sliders = OUT_EFFECTS_COUNT - 1;
  2262. + for (i = 0; i < num_sliders; i++) {
  2263. + err = ca0132_alt_add_effect_slider(codec,
  2264. + ca0132_effects[i].nid,
  2265. + ca0132_effects[i].name,
  2266. + ca0132_effects[i].direct);
  2267. + if (err < 0)
  2268. + return err;
  2269. + }
  2271. - err = add_fx_switch(codec, CRYSTAL_VOICE, "CrystalVoice", 1);
  2272. - if (err < 0)
  2273. - return err;
  2274. + err = ca0132_alt_add_effect_slider(codec, XBASS_XOVER,
  2275. + "X-Bass Crossover", EFX_DIR_OUT);
  2277. - add_voicefx(codec);
  2278. + if (err < 0)
  2279. + return err;
  2280. + } else {
  2281. + err = add_fx_switch (codec, PLAY_ENHANCEMENT,
  2282. + "PlayEnhancement", 0);
  2283. + if (err < 0)
  2284. + return err;
  2285. +
  2286. + err = add_fx_switch (codec, CRYSTAL_VOICE,
  2287. + "CrystalVoice", 1);
  2288. + if (err < 0)
  2289. + return err;
  2290. + }
  2291. + add_voicefx(codec);
  2293. + /*
  2294. + * If the codec uses alt_functions, you need the enumerated controls
  2295. + * to select the new outputs and inputs, plus add the new mic boost
  2296. + * setting control.
  2297. + */
  2298. + if (spec->use_alt_functions) {
  2299. + ca0132_alt_add_output_enum(codec);
  2300. + ca0132_alt_add_input_enum(codec);
  2301. + ca0132_alt_add_mic_boost_enum(codec);
  2302. +
  2303. + }
  2304. #ifdef ENABLE_TUNING_CONTROLS
  2305. - add_tuning_ctls(codec);
  2306. + add_tuning_ctls(codec);
  2307. #endif
  2309. - err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
  2310. - if (err < 0)
  2311. - return err;
  2313. - if (spec->dig_out) {
  2314. - err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out,
  2315. - spec->dig_out);
  2316. - if (err < 0)
  2317. - return err;
  2318. - err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
  2319. - if (err < 0)
  2320. - return err;
  2321. - /* spec->multiout.share_spdif = 1; */
  2322. - }
  2323. + err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
  2324. + if (err < 0)
  2325. + return err;
  2326. +
  2327. + if (spec->dig_out) {
  2328. + err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out,
  2329. + spec->dig_out);
  2330. + if (err < 0)
  2331. + return err;
  2332. + err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
  2333. + if (err < 0)
  2334. + return err;
  2335. + /* spec->multiout.share_spdif = 1; */
  2336. + }
  2337. +
  2338. + if (spec->dig_in) {
  2339. + err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
  2340. + if (err < 0)
  2341. + return err;
  2342. + }
  2343. +
  2344. + /* if there is a possibility of having 6 channels, set up the proper
  2345. + * chmap. The ca0132 has a funky setup that needs FR,FL,FC,LFE,RR,RL
  2346. + * instead of the more common FR,FL,RR,RL,FC,LFE. Not sure why.
  2347. + */
  2348. + list_for_each_entry(pcm, &codec->pcm_list_head, list) {
  2349. + struct hda_pcm_stream *hinfo = &pcm->stream[SNDRV_PCM_STREAM_PLAYBACK];
  2350. + struct snd_pcm_chmap *chmap;
  2351. + const struct snd_pcm_chmap_elem *elem;
  2352. + elem = ca0132_alt_chmaps;
  2353. + codec_dbg(codec, "Name: %s Channels Max: %d ", pcm->name, hinfo->channels_max);
  2354. + if (hinfo->channels_max == 6) {
  2355. + err = snd_pcm_add_chmap_ctls(pcm->pcm,
  2356. + SNDRV_PCM_STREAM_PLAYBACK,
  2357. + elem, hinfo->channels_max, 0, &chmap);
  2358. + if (err < 0)
  2359. + codec_dbg(codec, "snd_pcm_add_chmap_ctls failed!");
  2360. + }
  2361. + }
  2363. - if (spec->dig_in) {
  2364. - err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
  2365. - if (err < 0)
  2366. - return err;
  2367. - }
  2368. - return 0;
  2369. + return 0;
  2370. }
  2372. /*
  2373. @@ -4068,6 +5928,11 @@
  2374. info = snd_hda_codec_pcm_new(codec, "CA0132 Analog");
  2375. if (!info)
  2376. return -ENOMEM;
  2377. + if (spec->use_alt_functions) {
  2378. + info->own_chmap = true;
  2379. + info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap
  2380. + = ca0132_alt_chmaps;
  2381. + }
  2382. info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback;
  2383. info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0];
  2384. info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
  2385. @@ -4076,12 +5941,15 @@
  2386. info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
  2387. info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0];
  2389. - info = snd_hda_codec_pcm_new(codec, "CA0132 Analog Mic-In2");
  2390. - if (!info)
  2391. - return -ENOMEM;
  2392. - info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
  2393. - info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
  2394. - info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1];
  2395. + /* With the DSP enabled, desktops don't use this ADC. */
  2396. + if (spec->use_alt_functions) {
  2397. + info = snd_hda_codec_pcm_new(codec, "CA0132 Analog Mic-In2");
  2398. + if (!info)
  2399. + return -ENOMEM;
  2400. + info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
  2401. + info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1;
  2402. + info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1];
  2403. + }
  2405. info = snd_hda_codec_pcm_new(codec, "CA0132 What U Hear");
  2406. if (!info)
  2407. @@ -4288,6 +6156,194 @@
  2408. }
  2410. /*
  2411. + * Recon3Di r3di_setup_defaults sub functions.
  2412. + */
  2413. +
  2414. +static void r3di_dsp_scp_startup(struct hda_codec *codec)
  2415. +{
  2416. + unsigned int tmp;
  2417. +
  2418. + tmp = 0x00000000;
  2419. + dspio_set_uint_param_no_source(codec, 0x80, 0x0A, tmp);
  2420. +
  2421. + tmp = 0x00000001;
  2422. + dspio_set_uint_param_no_source(codec, 0x80, 0x0B, tmp);
  2423. +
  2424. + tmp = 0x00000004;
  2425. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2426. +
  2427. + tmp = 0x00000005;
  2428. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2429. +
  2430. + tmp = 0x00000000;
  2431. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2432. +
  2433. +}
  2434. +
  2435. +static void r3di_dsp_initial_mic_setup(struct hda_codec *codec)
  2436. +{
  2437. + unsigned int tmp;
  2438. +
  2439. + /* Mic 1 Setup */
  2440. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  2441. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  2442. + /* This ConnPointID is unique to Recon3Di. Haven't seen it elsewhere */
  2443. + chipio_set_conn_rate(codec, 0x0F, SR_96_000);
  2444. + tmp = FLOAT_ONE;
  2445. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  2446. +
  2447. + /* Mic 2 Setup, even though it isn't connected on SBZ */
  2448. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN2, SR_96_000);
  2449. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT2, SR_96_000);
  2450. + chipio_set_conn_rate(codec, 0x0F, SR_96_000);
  2451. + tmp = FLOAT_ZERO;
  2452. + dspio_set_uint_param(codec, 0x80, 0x01, tmp);
  2453. +}
  2454. +
  2455. +/*
  2456. + * Initialize Sound Blaster Z analog microphones.
  2457. + */
  2458. +static void sbz_init_analog_mics(struct hda_codec *codec)
  2459. +{
  2460. + unsigned int tmp;
  2461. +
  2462. + /* Mic 1 Setup */
  2463. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  2464. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  2465. + tmp = FLOAT_THREE;
  2466. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  2467. +
  2468. + /* Mic 2 Setup, even though it isn't connected on SBZ */
  2469. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN2, SR_96_000);
  2470. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT2, SR_96_000);
  2471. + tmp = FLOAT_ZERO;
  2472. + dspio_set_uint_param(codec, 0x80, 0x01, tmp);
  2473. +
  2474. +}
  2475. +
  2476. +/*
  2477. + * Sets the source of stream 0x14 to connpointID 0x48, and the destination
  2478. + * connpointID to 0x91. If this isn't done, the destination is 0x71, and
  2479. + * you get no sound. I'm guessing this has to do with the Sound Blaster Z
  2480. + * having an updated DAC, which changes the destination to that DAC.
  2481. + */
  2482. +static void sbz_connect_streams(struct hda_codec *codec)
  2483. +{
  2484. + struct ca0132_spec *spec = codec->spec;
  2485. +
  2486. + mutex_lock(&spec->chipio_mutex);
  2487. +
  2488. + codec_dbg(codec, "Connect Streams entered, mutex locked and loaded.\n");
  2489. +
  2490. + chipio_set_stream_channels(codec, 0x0C, 6);
  2491. + chipio_set_stream_control(codec, 0x0C, 1);
  2492. +
  2493. + /* This value is 0x43 for 96khz, and 0x83 for 192khz. */
  2494. + chipio_write_no_mutex(codec, 0x18a020, 0x00000043);
  2495. +
  2496. + /* Setup stream 0x14 with it's source and destination points */
  2497. + chipio_set_stream_source_dest(codec, 0x14, 0x48, 0x91);
  2498. + chipio_set_conn_rate_no_mutex(codec, 0x48, SR_96_000);
  2499. + chipio_set_conn_rate_no_mutex(codec, 0x91, SR_96_000);
  2500. + chipio_set_stream_channels(codec, 0x14, 2);
  2501. + chipio_set_stream_control(codec, 0x14, 1);
  2502. +
  2503. + codec_dbg(codec, "Connect Streams exited, mutex released.\n");
  2504. +
  2505. + mutex_unlock(&spec->chipio_mutex);
  2506. +
  2507. +}
  2508. +
  2509. +/*
  2510. + * Write data through ChipIO to setup proper stream destinations.
  2511. + * Not sure how it exactly works, but it seems to direct data
  2512. + * to different destinations. Example is f8 to c0, e0 to c0.
  2513. + * All I know is, if you don't set these, you get no sound.
  2514. + */
  2515. +static void sbz_chipio_startup_data(struct hda_codec *codec)
  2516. +{
  2517. + struct ca0132_spec *spec = codec->spec;
  2518. + mutex_lock(&spec->chipio_mutex);
  2519. +
  2520. + codec_dbg(codec, "Startup Data entered, mutex locked and loaded.\n");
  2521. +
  2522. + /* These control audio output */
  2523. + chipio_write_no_mutex(codec, 0x190060, 0x0001f8c0);
  2524. + chipio_write_no_mutex(codec, 0x190064, 0x0001f9c1);
  2525. + chipio_write_no_mutex(codec, 0x190068, 0x0001fac6);
  2526. + chipio_write_no_mutex(codec, 0x19006c, 0x0001fbc7);
  2527. + /* Signal to update I think */
  2528. + chipio_write_no_mutex(codec, 0x19042c, 0x00000001);
  2529. +
  2530. + chipio_set_stream_channels(codec, 0x0C, 6);
  2531. + chipio_set_stream_control(codec, 0x0C, 1);
  2532. + /* No clue what these control */
  2533. + chipio_write_no_mutex(codec, 0x190030, 0x0001e0c0);
  2534. + chipio_write_no_mutex(codec, 0x190034, 0x0001e1c1);
  2535. + chipio_write_no_mutex(codec, 0x190038, 0x0001e4c2);
  2536. + chipio_write_no_mutex(codec, 0x19003c, 0x0001e5c3);
  2537. + chipio_write_no_mutex(codec, 0x190040, 0x0001e2c4);
  2538. + chipio_write_no_mutex(codec, 0x190044, 0x0001e3c5);
  2539. + chipio_write_no_mutex(codec, 0x190048, 0x0001e8c6);
  2540. + chipio_write_no_mutex(codec, 0x19004c, 0x0001e9c7);
  2541. + chipio_write_no_mutex(codec, 0x190050, 0x0001ecc8);
  2542. + chipio_write_no_mutex(codec, 0x190054, 0x0001edc9);
  2543. + chipio_write_no_mutex(codec, 0x190058, 0x0001eaca);
  2544. + chipio_write_no_mutex(codec, 0x19005c, 0x0001ebcb);
  2545. +
  2546. + chipio_write_no_mutex(codec, 0x19042c, 0x00000001);
  2547. +
  2548. + codec_dbg(codec, "Startup Data exited, mutex released.\n");
  2549. +
  2550. + mutex_unlock(&spec->chipio_mutex);
  2551. +}
  2552. +/* Sound Blaster Z uses these after DSP is loaded. Weird SCP commands
  2553. + * without a 0x20 source like normal. */
  2554. +static void sbz_dsp_scp_startup(struct hda_codec *codec)
  2555. +{
  2556. + unsigned int tmp;
  2557. +
  2558. + tmp = 0x00000003;
  2559. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2560. +
  2561. + tmp = 0x00000000;
  2562. + dspio_set_uint_param_no_source(codec, 0x80, 0x0A, tmp);
  2563. +
  2564. + tmp = 0x00000001;
  2565. + dspio_set_uint_param_no_source(codec, 0x80, 0x0B, tmp);
  2566. +
  2567. + tmp = 0x00000004;
  2568. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2569. +
  2570. + tmp = 0x00000005;
  2571. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2572. +
  2573. + tmp = 0x00000000;
  2574. + dspio_set_uint_param_no_source(codec, 0x80, 0x0C, tmp);
  2575. +
  2576. +}
  2577. +
  2578. +static void sbz_dsp_initial_mic_setup(struct hda_codec *codec)
  2579. +{
  2580. + unsigned int tmp;
  2581. +
  2582. + chipio_set_stream_control(codec, 0x03, 0);
  2583. + chipio_set_stream_control(codec, 0x04, 0);
  2584. +
  2585. + chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000);
  2586. + chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000);
  2587. +
  2588. + tmp = FLOAT_THREE;
  2589. + dspio_set_uint_param(codec, 0x80, 0x00, tmp);
  2590. +
  2591. + chipio_set_stream_control(codec, 0x03, 1);
  2592. + chipio_set_stream_control(codec, 0x04, 1);
  2593. +
  2594. + chipio_write(codec, 0x18b098, 0x0000000c);
  2595. + chipio_write(codec, 0x18b09C, 0x0000000c);
  2596. +}
  2597. +
  2598. +/*
  2599. * Setup default parameters for DSP
  2600. */
  2601. static void ca0132_setup_defaults(struct hda_codec *codec)
  2602. @@ -4332,16 +6388,150 @@
  2603. }
  2605. /*
  2606. + * Setup default parameters for Recon3Di DSP.
  2607. + */
  2608. +
  2609. +static void r3di_setup_defaults(struct hda_codec *codec)
  2610. +{
  2611. + struct ca0132_spec *spec = codec->spec;
  2612. + unsigned int tmp;
  2613. + int num_fx;
  2614. + int idx, i;
  2615. +
  2616. + if (spec->dsp_state != DSP_DOWNLOADED)
  2617. + return;
  2618. +
  2619. + r3di_dsp_scp_startup(codec);
  2620. +
  2621. + r3di_dsp_initial_mic_setup(codec);
  2622. +
  2623. + /*remove DSP headroom*/
  2624. + tmp = FLOAT_ZERO;
  2625. + dspio_set_uint_param(codec, 0x96, 0x3C, tmp);
  2626. +
  2627. + /* set WUH source */
  2628. + tmp = FLOAT_TWO;
  2629. + dspio_set_uint_param(codec, 0x31, 0x00, tmp);
  2630. + chipio_set_conn_rate(codec, MEM_CONNID_WUH, SR_48_000);
  2631. +
  2632. + /* Set speaker source? */
  2633. + dspio_set_uint_param(codec, 0x32, 0x00, tmp);
  2634. +
  2635. + r3di_gpio_dsp_status_set(codec, R3DI_DSP_DOWNLOADED);
  2636. +
  2637. + /* Setup effect defaults */
  2638. + num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT + 1;
  2639. + for (idx = 0; idx < num_fx; idx++) {
  2640. + for (i = 0; i <= ca0132_effects[idx].params; i++) {
  2641. + dspio_set_uint_param(codec, ca0132_effects[idx].mid,
  2642. + ca0132_effects[idx].reqs[i],
  2643. + ca0132_effects[idx].def_vals[i]);
  2644. + }
  2645. + }
  2646. +
  2647. +}
  2648. +
  2649. +/*
  2650. + * Setup default parameters for the Sound Blaster Z DSP. A lot more going on
  2651. + * than the Chromebook setup.
  2652. + */
  2653. +static void sbz_setup_defaults(struct hda_codec *codec)
  2654. +{
  2655. + struct ca0132_spec *spec = codec->spec;
  2656. + unsigned int tmp, stream_format;
  2657. + int num_fx;
  2658. + int idx, i;
  2659. +
  2660. + if (spec->quirk == QUIRK_SBZ)
  2661. + sbz_dsp_scp_startup(codec);
  2662. +
  2663. + if (spec->dsp_state != DSP_DOWNLOADED)
  2664. + return;
  2665. +
  2666. + sbz_dsp_scp_startup(codec);
  2667. +
  2668. + sbz_init_analog_mics(codec);
  2669. +
  2670. + sbz_connect_streams(codec);
  2671. +
  2672. + sbz_chipio_startup_data(codec);
  2673. +
  2674. + chipio_set_stream_control(codec, 0x03, 1);
  2675. + chipio_set_stream_control(codec, 0x04, 1);
  2676. +
  2677. + /* Sets internal input loopback to off, used to have a switch to
  2678. + * enable input loopback, but turned out to be way too buggy. */
  2679. + tmp = FLOAT_ONE;
  2680. + dspio_set_uint_param(codec, 0x37, 0x08, tmp);
  2681. + dspio_set_uint_param(codec, 0x37, 0x10, tmp);
  2682. +
  2683. + /*remove DSP headroom*/
  2684. + tmp = FLOAT_ZERO;
  2685. + dspio_set_uint_param(codec, 0x96, 0x3C, tmp);
  2686. +
  2687. + /* set WUH source */
  2688. + tmp = FLOAT_TWO;
  2689. + dspio_set_uint_param(codec, 0x31, 0x00, tmp);
  2690. + chipio_set_conn_rate(codec, MEM_CONNID_WUH, SR_48_000);
  2691. +
  2692. + /* Set speaker source? */
  2693. + dspio_set_uint_param(codec, 0x32, 0x00, tmp);
  2694. +
  2695. + sbz_dsp_initial_mic_setup(codec);
  2696. +
  2697. +
  2698. + /* out, in effects + voicefx */
  2699. + num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT + 1;
  2700. + for (idx = 0; idx < num_fx; idx++) {
  2701. + for (i = 0; i <= ca0132_effects[idx].params; i++) {
  2702. + dspio_set_uint_param(codec, ca0132_effects[idx].mid,
  2703. + ca0132_effects[idx].reqs[i],
  2704. + ca0132_effects[idx].def_vals[i]);
  2705. + }
  2706. + }
  2707. +
  2708. + /* Have to make a stream to bind the sound output to, otherwise
  2709. + * you'll get dead audio. Before I did this, it would bind to an
  2710. + * audio input, and would never work */
  2711. + stream_format = snd_hdac_calc_stream_format(48000, 2, SNDRV_PCM_FORMAT_S32_LE, 32, 0);
  2712. +
  2713. + snd_hda_codec_setup_stream(codec, spec->dacs[0], spec->dsp_stream_id,
  2714. + 0, stream_format);
  2715. +
  2716. + snd_hda_codec_cleanup_stream(codec, spec->dacs[0]);
  2717. +
  2718. + snd_hda_codec_setup_stream(codec, spec->dacs[0], spec->dsp_stream_id,
  2719. + 0, stream_format);
  2720. +
  2721. + snd_hda_codec_cleanup_stream(codec, spec->dacs[0]);
  2722. +
  2723. + return;
  2724. +}
  2725. +
  2726. +/*
  2727. * Initialization of flags in chip
  2728. */
  2729. static void ca0132_init_flags(struct hda_codec *codec)
  2730. {
  2731. - chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0);
  2732. - chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_COMMON_MODE, 0);
  2733. - chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_COMMON_MODE, 0);
  2734. - chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 0);
  2735. - chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0);
  2736. - chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_HIGH_PASS, 1);
  2737. + struct ca0132_spec *spec = codec->spec;
  2738. + if (spec->use_alt_functions) {
  2739. + chipio_set_control_flag(codec, CONTROL_FLAG_DSP_96KHZ, 1);
  2740. + chipio_set_control_flag(codec, CONTROL_FLAG_DAC_96KHZ, 1);
  2741. + chipio_set_control_flag(codec, CONTROL_FLAG_ADC_B_96KHZ, 1);
  2742. + chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_96KHZ, 1);
  2743. + chipio_set_control_flag(codec, CONTROL_FLAG_SRC_RATE_96KHZ, 1);
  2744. + chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0);
  2745. + chipio_set_control_flag(codec, CONTROL_FLAG_SPDIF2OUT, 0);
  2746. + chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0);
  2747. + chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 1);
  2748. + } else {
  2749. + chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0);
  2750. + chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_COMMON_MODE, 0);
  2751. + chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_COMMON_MODE, 0);
  2752. + chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 0);
  2753. + chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0);
  2754. + chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_HIGH_PASS, 1);
  2755. + }
  2756. }
  2758. /*
  2759. @@ -4349,8 +6539,17 @@
  2760. */
  2761. static void ca0132_init_params(struct hda_codec *codec)
  2762. {
  2763. - chipio_set_control_param(codec, CONTROL_PARAM_PORTA_160OHM_GAIN, 6);
  2764. - chipio_set_control_param(codec, CONTROL_PARAM_PORTD_160OHM_GAIN, 6);
  2765. + struct ca0132_spec *spec = codec->spec;
  2766. + if (spec->use_alt_functions) {
  2767. + chipio_set_conn_rate(codec, MEM_CONNID_WUH, SR_48_000);
  2768. + chipio_set_conn_rate(codec, 0x0B, SR_48_000);
  2769. + chipio_set_control_param(codec, CONTROL_PARAM_SPDIF1_SOURCE, 0);
  2770. + chipio_set_control_param(codec, 0, 0); // Dunno what this param is.
  2771. + chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, 0);
  2772. + }
  2773. +
  2774. + chipio_set_control_param(codec, CONTROL_PARAM_PORTA_160OHM_GAIN, 6);
  2775. + chipio_set_control_param(codec, CONTROL_PARAM_PORTD_160OHM_GAIN, 6);
  2776. }
  2778. static void ca0132_set_dsp_msr(struct hda_codec *codec, bool is96k)
  2779. @@ -4369,25 +6568,63 @@
  2781. static bool ca0132_download_dsp_images(struct hda_codec *codec)
  2782. {
  2783. - bool dsp_loaded = false;
  2784. - const struct dsp_image_seg *dsp_os_image;
  2785. - const struct firmware *fw_entry;
  2786. + bool dsp_loaded = false;
  2787. + struct ca0132_spec *spec = codec->spec;
  2788. + const struct dsp_image_seg *dsp_os_image;
  2789. + const struct firmware *fw_entry;
  2790. + /*
  2791. + * Alternate firmwares for different variants. The Recon3Di apparently
  2792. + * can use the default firmware, but I'll leave the option in case
  2793. + * it needs it again.
  2794. + */
  2795. + switch (spec->quirk) {
  2796. + case QUIRK_SBZ:
  2797. + if (request_firmware(&fw_entry, SBZ_EFX_FILE,
  2798. + codec->card->dev) != 0) {
  2799. + codec_dbg(codec, "SBZ alt firmware not detected. ");
  2800. + spec->alt_firmware_present = false;
  2801. + } else {
  2802. + codec_dbg(codec, "Sound Blaster Z firmware selected.");
  2803. + spec->alt_firmware_present = true;
  2804. + }
  2805. + break;
  2806. + case QUIRK_R3DI:
  2807. + if (request_firmware(&fw_entry, R3DI_EFX_FILE,
  2808. + codec->card->dev) != 0) {
  2809. + codec_dbg(codec, "Recon3Di alt firmware not detected.");
  2810. + spec->alt_firmware_present = false;
  2811. + } else {
  2812. + codec_dbg(codec, "Recon3Di firmware selected.");
  2813. + spec->alt_firmware_present = true;
  2814. + }
  2815. + break;
  2816. + default:
  2817. + spec->alt_firmware_present = false;
  2818. + break;
  2819. + }
  2820. + /* Use default ctefx.bin if no alt firmware is detected, or if none
  2821. + * exists for your particular codec. */
  2822. + if (spec->alt_firmware_present == false) {
  2823. + codec_dbg(codec, "Default firmware selected.");
  2824. + if (request_firmware(&fw_entry, EFX_FILE,
  2825. + codec->card->dev) != 0)
  2826. + return false;
  2827. + }
  2828. +
  2829. + codec_dbg(codec, "Inside ca0132_download_dsp_images");
  2830. +
  2831. + dsp_os_image = (struct dsp_image_seg *)(fw_entry->data);
  2832. + if (dspload_image(codec, dsp_os_image, 0, 0, true, 0)) {
  2833. + codec_err(codec, "ca0132 DSP load image failed\n");
  2834. + goto exit_download;
  2835. + }
  2837. - if (request_firmware(&fw_entry, EFX_FILE, codec->card->dev) != 0)
  2838. - return false;
  2839. -
  2840. - dsp_os_image = (struct dsp_image_seg *)(fw_entry->data);
  2841. - if (dspload_image(codec, dsp_os_image, 0, 0, true, 0)) {
  2842. - codec_err(codec, "ca0132 DSP load image failed\n");
  2843. - goto exit_download;
  2844. - }
  2845. -
  2846. - dsp_loaded = dspload_wait_loaded(codec);
  2847. + dsp_loaded = dspload_wait_loaded(codec);
  2849. exit_download:
  2850. - release_firmware(fw_entry);
  2851. + release_firmware(fw_entry);
  2853. - return dsp_loaded;
  2854. + return dsp_loaded;
  2855. }
  2857. static void ca0132_download_dsp(struct hda_codec *codec)
  2858. @@ -4402,13 +6639,17 @@
  2859. return; /* don't retry failures */
  2861. chipio_enable_clocks(codec);
  2862. - spec->dsp_state = DSP_DOWNLOADING;
  2863. - if (!ca0132_download_dsp_images(codec))
  2864. - spec->dsp_state = DSP_DOWNLOAD_FAILED;
  2865. - else
  2866. - spec->dsp_state = DSP_DOWNLOADED;
  2867. + if (spec->dsp_state != DSP_DOWNLOADED) {
  2868. + spec->dsp_state = DSP_DOWNLOADING;
  2870. - if (spec->dsp_state == DSP_DOWNLOADED)
  2871. + if (!ca0132_download_dsp_images(codec))
  2872. + spec->dsp_state = DSP_DOWNLOAD_FAILED;
  2873. + else
  2874. + spec->dsp_state = DSP_DOWNLOADED;
  2875. + }
  2876. +
  2877. + /* For codecs using alt functions, this is already done earlier */
  2878. + if (spec->dsp_state == DSP_DOWNLOADED && (!spec->use_alt_functions))
  2879. ca0132_set_dsp_msr(codec, true);
  2880. }
  2882. @@ -4454,6 +6695,10 @@
  2883. amic_callback);
  2884. snd_hda_jack_detect_enable_callback(codec, UNSOL_TAG_DSP,
  2885. ca0132_process_dsp_response);
  2886. + /* Front headphone jack detection */
  2887. + if (spec->use_alt_functions)
  2888. + snd_hda_jack_detect_enable_callback(codec,
  2889. + spec->unsol_tag_front_hp, hp_callback);
  2890. }
  2892. /*
  2893. @@ -4477,38 +6722,58 @@
  2894. };
  2896. /* Other verbs tables. Sends after DSP download. */
  2897. +
  2898. static struct hda_verb ca0132_init_verbs0[] = {
  2899. - /* chip init verbs */
  2900. - {0x15, 0x70D, 0xF0},
  2901. - {0x15, 0x70E, 0xFE},
  2902. - {0x15, 0x707, 0x75},
  2903. - {0x15, 0x707, 0xD3},
  2904. - {0x15, 0x707, 0x09},
  2905. - {0x15, 0x707, 0x53},
  2906. - {0x15, 0x707, 0xD4},
  2907. - {0x15, 0x707, 0xEF},
  2908. - {0x15, 0x707, 0x75},
  2909. - {0x15, 0x707, 0xD3},
  2910. - {0x15, 0x707, 0x09},
  2911. - {0x15, 0x707, 0x02},
  2912. - {0x15, 0x707, 0x37},
  2913. - {0x15, 0x707, 0x78},
  2914. - {0x15, 0x53C, 0xCE},
  2915. - {0x15, 0x575, 0xC9},
  2916. - {0x15, 0x53D, 0xCE},
  2917. - {0x15, 0x5B7, 0xC9},
  2918. - {0x15, 0x70D, 0xE8},
  2919. - {0x15, 0x70E, 0xFE},
  2920. - {0x15, 0x707, 0x02},
  2921. - {0x15, 0x707, 0x68},
  2922. - {0x15, 0x707, 0x62},
  2923. - {0x15, 0x53A, 0xCE},
  2924. - {0x15, 0x546, 0xC9},
  2925. - {0x15, 0x53B, 0xCE},
  2926. - {0x15, 0x5E8, 0xC9},
  2927. - {0x15, 0x717, 0x0D},
  2928. - {0x15, 0x718, 0x20},
  2929. - {}
  2930. + /* chip init verbs */
  2931. + {0x15, 0x70D, 0xF0},
  2932. + {0x15, 0x70E, 0xFE},
  2933. + {0x15, 0x707, 0x75},
  2934. + {0x15, 0x707, 0xD3},
  2935. + {0x15, 0x707, 0x09},
  2936. + {0x15, 0x707, 0x53},
  2937. + {0x15, 0x707, 0xD4},
  2938. + {0x15, 0x707, 0xEF},
  2939. + {0x15, 0x707, 0x75},
  2940. + {0x15, 0x707, 0xD3},
  2941. + {0x15, 0x707, 0x09},
  2942. + {0x15, 0x707, 0x02},
  2943. + {0x15, 0x707, 0x37},
  2944. + {0x15, 0x707, 0x78},
  2945. + {0x15, 0x53C, 0xCE},
  2946. + {0x15, 0x575, 0xC9},
  2947. + {0x15, 0x53D, 0xCE},
  2948. + {0x15, 0x5B7, 0xC9},
  2949. + {0x15, 0x70D, 0xE8},
  2950. + {0x15, 0x70E, 0xFE},
  2951. + {0x15, 0x707, 0x02},
  2952. + {0x15, 0x707, 0x68},
  2953. + {0x15, 0x707, 0x62},
  2954. + {0x15, 0x53A, 0xCE},
  2955. + {0x15, 0x546, 0xC9},
  2956. + {0x15, 0x53B, 0xCE},
  2957. + {0x15, 0x5E8, 0xC9},
  2958. + {}
  2959. +};
  2960. +
  2961. +/* Extra init verbs for SBZ */
  2962. +static struct hda_verb sbz_init_verbs[] = {
  2963. + {0x15, 0x70D, 0x20},
  2964. + {0x15, 0x70E, 0x19},
  2965. + {0x15, 0x707, 0x00},
  2966. + {0x15, 0x539, 0xCE},
  2967. + {0x15, 0x546, 0xC9},
  2968. + {0x15, 0x70D, 0xB7},
  2969. + {0x15, 0x70E, 0x09},
  2970. + {0x15, 0x707, 0x10},
  2971. + {0x15, 0x70D, 0xAF},
  2972. + {0x15, 0x70E, 0x09},
  2973. + {0x15, 0x707, 0x01},
  2974. + {0x15, 0x707, 0x05},
  2975. + {0x15, 0x70D, 0x73},
  2976. + {0x15, 0x70E, 0x09},
  2977. + {0x15, 0x707, 0x14},
  2978. + {0x15, 0x6FF, 0xC4},
  2979. + {}
  2980. };
  2982. static void ca0132_init_chip(struct hda_codec *codec)
  2983. @@ -4521,7 +6786,11 @@
  2984. mutex_init(&spec->chipio_mutex);
  2986. spec->cur_out_type = SPEAKER_OUT;
  2987. - spec->cur_mic_type = DIGITAL_MIC;
  2988. + if (!spec->use_alt_functions)
  2989. + spec->cur_mic_type = DIGITAL_MIC;
  2990. + else
  2991. + spec->cur_mic_type = REAR_MIC;
  2992. +
  2993. spec->cur_mic_boost = 0;
  2995. for (i = 0; i < VNODES_COUNT; i++) {
  2996. @@ -4539,6 +6808,15 @@
  2997. on = (unsigned int)ca0132_effects[i].reqs[0];
  2998. spec->effects_switch[i] = on ? 1 : 0;
  2999. }
  3000. + /*
  3001. + * Sets defaults for the effect slider controls, only for alternative
  3002. + * ca0132 codecs. Also sets x-bass crossover frequency to 80hz.
  3003. + */
  3004. + if (spec->use_alt_controls) {
  3005. + spec->xbass_xover_freq = 8;
  3006. + for(i = 0; i < EFFECT_LEVEL_SLIDERS; i++)
  3007. + spec->fx_ctl_val[i] = effect_slider_defaults[i];
  3008. + }
  3010. spec->voicefx_val = 0;
  3011. spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID] = 1;
  3012. @@ -4549,6 +6827,129 @@
  3013. #endif
  3014. }
  3016. +/*
  3017. + * Recon3Di exit specific commands.
  3018. + */
  3019. +/* prevents popping noise on shutdown */
  3020. +static void r3di_gpio_shutdown(struct hda_codec *codec)
  3021. +{
  3022. + snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0x00);
  3023. +}
  3024. +
  3025. +/*
  3026. + * Sound Blaster Z exit specific commands.
  3027. + */
  3028. +static void sbz_region2_exit(struct hda_codec *codec)
  3029. +{
  3030. + struct ca0132_spec *spec = codec->spec;
  3031. + unsigned int i;
  3032. +
  3033. + for(i = 0; i < 4; i++) {
  3034. + writeb(0x0, spec->mem_base + 0x100);
  3035. + }
  3036. + for(i = 0; i < 8; i++) {
  3037. + writeb(0xb3, spec->mem_base + 0x304);
  3038. + }
  3039. + /*
  3040. + * I believe these are GPIO, with the right most hex digit being the
  3041. + * gpio pin, and the second digit being on or off. We see this more in
  3042. + * the input/output select functions.
  3043. + */
  3044. + writew(0x0000, spec->mem_base + 0x320);
  3045. + writew(0x0001, spec->mem_base + 0x320);
  3046. + writew(0x0104, spec->mem_base + 0x320);
  3047. + writew(0x0005, spec->mem_base + 0x320);
  3048. + writew(0x0007, spec->mem_base + 0x320);
  3049. +
  3050. + return;
  3051. +}
  3052. +
  3053. +static void sbz_set_pin_ctl_default(struct hda_codec *codec)
  3054. +{
  3055. + hda_nid_t pins[5] = {0x0B, 0x0C, 0x0E, 0x12, 0x13};
  3056. + unsigned int i;
  3057. +
  3058. + snd_hda_codec_write(codec, 0x11, 0,
  3059. + AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40);
  3060. +
  3061. + for(i = 0; i < 5; i++) {
  3062. + snd_hda_codec_write(codec, pins[i], 0,
  3063. + AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00);
  3064. + }
  3065. +
  3066. + return;
  3067. +}
  3068. +
  3069. +static void sbz_clear_unsolicited(struct hda_codec *codec)
  3070. +{
  3071. + hda_nid_t pins[7] = {0x0B, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13};
  3072. + unsigned int i;
  3073. +
  3074. + for(i = 0; i < 7; i++) {
  3075. + snd_hda_codec_write(codec, pins[i], 0,
  3076. + AC_VERB_SET_UNSOLICITED_ENABLE, 0x00);
  3077. + }
  3078. +
  3079. + return;
  3080. +}
  3081. +
  3082. +/* On shutdown, sends commands in sets of three */
  3083. +static void sbz_gpio_shutdown_commands(struct hda_codec *codec, int dir,
  3084. + int mask, int data)
  3085. +{
  3086. + if (dir >= 0)
  3087. + snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
  3088. + dir);
  3089. + if (mask >= 0)
  3090. + snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK, mask);
  3091. +
  3092. + if (data >= 0)
  3093. + snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, data);
  3094. +
  3095. + return;
  3096. +}
  3097. +
  3098. +static void sbz_exit_chip(struct hda_codec *codec)
  3099. +{
  3100. + chipio_set_stream_control(codec, 0x03, 0);
  3101. + chipio_set_stream_control(codec, 0x04, 0);
  3102. +
  3103. + /* Mess with GPIO */
  3104. + sbz_gpio_shutdown_commands(codec, 0x07, 0x07, -1);
  3105. + sbz_gpio_shutdown_commands(codec, 0x07, 0x07, 0x05);
  3106. + sbz_gpio_shutdown_commands(codec, 0x07, 0x07, 0x01);
  3107. +
  3108. + chipio_set_stream_control(codec, 0x14, 0);
  3109. + chipio_set_stream_control(codec, 0x0C, 0);
  3110. +
  3111. + chipio_set_conn_rate(codec, 0x41, SR_192_000);
  3112. + chipio_set_conn_rate(codec, 0x91, SR_192_000);
  3113. +
  3114. + chipio_write(codec, 0x18a020, 0x00000083);
  3115. +
  3116. + sbz_gpio_shutdown_commands(codec, 0x07, 0x07, 0x03);
  3117. + sbz_gpio_shutdown_commands(codec, 0x07, 0x07, 0x07);
  3118. + sbz_gpio_shutdown_commands(codec, 0x07, 0x07, 0x06);
  3119. +
  3120. + chipio_set_stream_control(codec, 0x0C, 0);
  3121. +
  3122. + chipio_set_control_param(codec, 0x0D, 0x24);
  3123. +
  3124. + sbz_clear_unsolicited(codec);
  3125. + sbz_set_pin_ctl_default(codec);
  3126. +
  3127. + snd_hda_codec_write(codec, 0x0B, 0,
  3128. + AC_VERB_SET_EAPD_BTLENABLE, 0x00);
  3129. +
  3130. + if (dspload_is_loaded(codec))
  3131. + dsp_reset(codec);
  3132. +
  3133. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3134. + VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0x00);
  3135. +
  3136. + sbz_region2_exit(codec);
  3137. +}
  3138. +
  3139. static void ca0132_exit_chip(struct hda_codec *codec)
  3140. {
  3141. /* put any chip cleanup stuffs here. */
  3142. @@ -4557,28 +6958,265 @@
  3143. dsp_reset(codec);
  3144. }
  3146. +/*
  3147. + * This fixes a problem that was hard to reproduce. Very rarely, I would
  3148. + * boot up, and there would be no sound, but the DSP indicated it had loaded
  3149. + * properly. I did a few memory dumps to see if anything was different, and
  3150. + * there were a few areas of memory uninitialized with a1a2a3a4. This function
  3151. + * checks if those areas are uninitialized, and if they are, it'll attempt to
  3152. + * reload the card 3 times. Usually it fixes by the second.
  3153. + */
  3154. +static void sbz_dsp_startup_check_entered(struct hda_codec *codec)
  3155. +{
  3156. + struct ca0132_spec *spec = codec->spec;
  3157. + unsigned int dsp_data_check[4];
  3158. + unsigned int cur_address = 0x390;
  3159. + unsigned int i;
  3160. + unsigned int failure = 0;
  3161. + unsigned int reload = 3;
  3162. +
  3163. + if (spec->startup_check_entered)
  3164. + return;
  3165. +
  3166. + spec->startup_check_entered = true;
  3167. +
  3168. + for (i = 0; i < 4; i++) {
  3169. + chipio_read(codec, cur_address, &dsp_data_check[i]);
  3170. + cur_address += 0x4;
  3171. + }
  3172. + for (i = 0; i < 4; i++) {
  3173. + if (dsp_data_check[i] == 0xa1a2a3a4)
  3174. + failure = 1;
  3175. + }
  3176. +
  3177. + codec_dbg(codec, "Startup Check: %d ", failure);
  3178. + if(failure)
  3179. + codec_info(codec, "DSP not initialized properly."
  3180. + "Attempting to fix.");
  3181. + /*
  3182. + * While the failure condition is true, and we haven't reached our
  3183. + * three reload limit, continue trying to reload the driver and
  3184. + * fix the issue.
  3185. + */
  3186. + while (failure && (reload != 0)) {
  3187. + codec_info(codec, "Reloading... Tries left: %d", reload);
  3188. + sbz_exit_chip(codec);
  3189. + spec->dsp_state = DSP_DOWNLOAD_INIT;
  3190. + codec->patch_ops.init(codec);
  3191. + failure = 0;
  3192. + for (i = 0; i < 4; i++) {
  3193. + chipio_read(codec, cur_address, &dsp_data_check[i]);
  3194. + cur_address += 0x4;
  3195. + }
  3196. + for (i = 0; i < 4; i++) {
  3197. + if (dsp_data_check[i] == 0xa1a2a3a4)
  3198. + failure = 1;
  3199. + }
  3200. + reload--;
  3201. + }
  3202. +
  3203. + if(!failure && reload < 3)
  3204. + codec_info(codec, "DSP fixed.");
  3205. +
  3206. + if (!failure)
  3207. + return;
  3208. +
  3209. + codec_info(codec, "DSP failed to initialize properly. Either try a full"
  3210. + "shutdown or a suspend to clear the internal memory.");
  3211. +}
  3212. +
  3213. +/*
  3214. + * This is for the extra volume verbs 0x797 (left) and 0x798 (right). These add
  3215. + * extra precision for decibel values. If you had the dB value in floating point
  3216. + * you would take the value after the decimal point, multiply by 64, and divide
  3217. + * by 2. So for 8.59, it's (59 * 64) / 100. Useful if someone wanted to
  3218. + * implement fixed point or floating point dB volumes. For now, I'll set them
  3219. + * to 0 just incase a value has lingered from a boot into Windows.
  3220. + */
  3221. +static void ca0132_alt_vol_setup(struct hda_codec *codec)
  3222. +{
  3223. +
  3224. + snd_hda_codec_write(codec, 0x02, 0, 0x797, 0x00);
  3225. + snd_hda_codec_write(codec, 0x02, 0, 0x798, 0x00);
  3226. + snd_hda_codec_write(codec, 0x03, 0, 0x797, 0x00);
  3227. + snd_hda_codec_write(codec, 0x03, 0, 0x798, 0x00);
  3228. + snd_hda_codec_write(codec, 0x04, 0, 0x797, 0x00);
  3229. + snd_hda_codec_write(codec, 0x04, 0, 0x798, 0x00);
  3230. + snd_hda_codec_write(codec, 0x07, 0, 0x797, 0x00);
  3231. + snd_hda_codec_write(codec, 0x07, 0, 0x798, 0x00);
  3232. +}
  3233. +
  3234. +/*
  3235. + * Extra commands that don't really fit anywhere else.
  3236. + */
  3237. +static void sbz_pre_dsp_setup(struct hda_codec *codec)
  3238. +{
  3239. + struct ca0132_spec *spec = codec->spec;
  3240. +
  3241. + writel(0x00820680, spec->mem_base + 0x01C);
  3242. + writel(0x00820680, spec->mem_base + 0x01C);
  3243. +
  3244. + snd_hda_codec_write(codec, 0x15, 0, 0xd00, 0xfc);
  3245. + snd_hda_codec_write(codec, 0x15, 0, 0xd00, 0xfd);
  3246. + snd_hda_codec_write(codec, 0x15, 0, 0xd00, 0xfe);
  3247. + snd_hda_codec_write(codec, 0x15, 0, 0xd00, 0xff);
  3248. +
  3249. + chipio_write(codec, 0x18b0a4, 0x000000c2);
  3250. +
  3251. + snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x44);
  3252. +}
  3253. +
  3254. +/*
  3255. + * Extra commands that don't really fit anywhere else.
  3256. + */
  3257. +static void r3di_pre_dsp_setup(struct hda_codec *codec)
  3258. +{
  3259. + chipio_write(codec, 0x18b0a4, 0x000000c2);
  3260. +
  3261. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3262. + VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x1E);
  3263. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3264. + VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x1C);
  3265. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3266. + VENDOR_CHIPIO_8051_DATA_WRITE, 0x5B);
  3267. +
  3268. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3269. + VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x20);
  3270. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3271. + VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19);
  3272. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3273. + VENDOR_CHIPIO_8051_DATA_WRITE, 0x00);
  3274. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3275. + VENDOR_CHIPIO_8051_DATA_WRITE, 0x40);
  3276. +
  3277. + snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x04);
  3278. +}
  3279. +
  3280. +
  3281. +/*
  3282. + * These are sent before the DSP is downloaded. Not sure
  3283. + * what they do, or if they're necessary. Could possibly
  3284. + * be removed. Figure they're better to leave in.
  3285. + */
  3286. +static void sbz_region2_startup(struct hda_codec *codec)
  3287. +{
  3288. + struct ca0132_spec *spec = codec->spec;
  3289. +
  3290. + writel(0x00000000, spec->mem_base + 0x400);
  3291. + writel(0x00000000, spec->mem_base + 0x408);
  3292. + writel(0x00000000, spec->mem_base + 0x40C);
  3293. + writel(0x00880680, spec->mem_base + 0x01C);
  3294. + writel(0x00000083, spec->mem_base + 0xC0C);
  3295. + writel(0x00000030, spec->mem_base + 0xC00);
  3296. + writel(0x00000000, spec->mem_base + 0xC04);
  3297. + writel(0x00000003, spec->mem_base + 0xC0C);
  3298. + writel(0x00000003, spec->mem_base + 0xC0C);
  3299. + writel(0x00000003, spec->mem_base + 0xC0C);
  3300. + writel(0x00000003, spec->mem_base + 0xC0C);
  3301. + writel(0x000000C1, spec->mem_base + 0xC08);
  3302. + writel(0x000000F1, spec->mem_base + 0xC08);
  3303. + writel(0x00000001, spec->mem_base + 0xC08);
  3304. + writel(0x000000C7, spec->mem_base + 0xC08);
  3305. + writel(0x000000C1, spec->mem_base + 0xC08);
  3306. + writel(0x00000080, spec->mem_base + 0xC04);
  3307. +}
  3308. +
  3309. +/*
  3310. + * Extra init functions for alternative ca0132 codecs. Done
  3311. + * here so they don't clutter up the main ca0132_init function
  3312. + * anymore than they have to.
  3313. + */
  3314. +static void ca0132_alt_init(struct hda_codec *codec)
  3315. +{
  3316. + struct ca0132_spec *spec = codec->spec;
  3317. +
  3318. + ca0132_alt_vol_setup(codec);
  3319. +
  3320. + switch (spec->quirk) {
  3321. + case QUIRK_SBZ:
  3322. + codec_dbg(codec, "SBZ alt_init");
  3323. + ca0132_gpio_init(codec);
  3324. + sbz_pre_dsp_setup(codec);
  3325. + snd_hda_sequence_write(codec, spec->chip_init_verbs);
  3326. + snd_hda_sequence_write(codec, spec->sbz_init_verbs);
  3327. + break;
  3328. + case QUIRK_R3DI:
  3329. + codec_dbg(codec, "R3DI alt_init");
  3330. + ca0132_gpio_init(codec);
  3331. + ca0132_gpio_setup(codec);
  3332. + r3di_gpio_dsp_status_set(codec, R3DI_DSP_DOWNLOADING);
  3333. + r3di_pre_dsp_setup(codec);
  3334. + snd_hda_sequence_write(codec, spec->chip_init_verbs);
  3335. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 0x6FF, 0xC4);
  3336. + break;
  3337. + }
  3338. +}
  3339. +
  3340. static int ca0132_init(struct hda_codec *codec)
  3341. {
  3342. struct ca0132_spec *spec = codec->spec;
  3343. struct auto_pin_cfg *cfg = &spec->autocfg;
  3344. int i;
  3345. + bool dsp_loaded;
  3346. +
  3347. + /*
  3348. + * If the DSP is already downloaded, and init has been entered again,
  3349. + * there's only two reasons for it. One, the codec has awaken from a
  3350. + * suspended state, and in that case dspload_is_loaded will return
  3351. + * false, and the init will be ran again. The other reason it gets
  3352. + * re entered is on startup for some reason it triggers a suspend and
  3353. + * resume state. In this case, it will check if the DSP is downloaded,
  3354. + * and not run the init function again. For codecs using alt_functions,
  3355. + * it will check if the DSP is loaded properly.
  3356. + */
  3357. + if (spec->dsp_state == DSP_DOWNLOADED) {
  3358. + dsp_loaded = dspload_is_loaded(codec);
  3359. + if (dsp_loaded) {
  3360. + if (spec->quirk == QUIRK_SBZ)
  3361. + sbz_dsp_startup_check_entered(codec);
  3362. + return 0;
  3363. + } else {
  3364. + spec->dsp_reload = true;
  3365. + spec->dsp_state = DSP_DOWNLOAD_INIT;
  3366. + }
  3367. + }
  3369. if (spec->dsp_state != DSP_DOWNLOAD_FAILED)
  3370. spec->dsp_state = DSP_DOWNLOAD_INIT;
  3371. spec->curr_chip_addx = INVALID_CHIP_ADDRESS;
  3373. + if (spec->quirk == QUIRK_SBZ)
  3374. + sbz_region2_startup(codec);
  3375. +
  3376. snd_hda_power_up_pm(codec);
  3378. ca0132_init_unsol(codec);
  3379. -
  3380. ca0132_init_params(codec);
  3381. ca0132_init_flags(codec);
  3382. +
  3383. snd_hda_sequence_write(codec, spec->base_init_verbs);
  3384. +
  3385. + if (spec->quirk != QUIRK_NONE)
  3386. + ca0132_alt_init(codec);
  3387. +
  3388. ca0132_download_dsp(codec);
  3389. +
  3390. ca0132_refresh_widget_caps(codec);
  3391. - ca0132_setup_defaults(codec);
  3392. - ca0132_init_analog_mic2(codec);
  3393. - ca0132_init_dmic(codec);
  3394. +
  3395. + if (spec->quirk == QUIRK_SBZ)
  3396. + writew(0x0107, spec->mem_base + 0x320);
  3397. +
  3398. + switch (spec->quirk) {
  3399. + case QUIRK_R3DI:
  3400. + r3di_setup_defaults(codec);
  3401. + break;
  3402. + case QUIRK_NONE:
  3403. + case QUIRK_ALIENWARE:
  3404. + ca0132_setup_defaults(codec);
  3405. + ca0132_init_analog_mic2(codec);
  3406. + ca0132_init_dmic(codec);
  3407. + break;
  3408. + }
  3410. for (i = 0; i < spec->num_outputs; i++)
  3411. init_output(codec, spec->out_pins[i], spec->dacs[0]);
  3412. @@ -4590,14 +7228,45 @@
  3414. init_input(codec, cfg->dig_in_pin, spec->dig_in);
  3416. - snd_hda_sequence_write(codec, spec->chip_init_verbs);
  3417. - snd_hda_sequence_write(codec, spec->spec_init_verbs);
  3418. + if (!spec->use_alt_functions){
  3419. + snd_hda_sequence_write(codec, spec->chip_init_verbs);
  3420. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3421. + VENDOR_CHIPIO_PARAM_EX_ID_SET, 0x0D);
  3422. + snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
  3423. + VENDOR_CHIPIO_PARAM_EX_VALUE_SET, 0x20);
  3424. + }
  3426. - ca0132_select_out(codec);
  3427. - ca0132_select_mic(codec);
  3428. + if (spec->quirk == QUIRK_SBZ)
  3429. + ca0132_gpio_setup(codec);
  3430. +
  3431. + snd_hda_sequence_write(codec, spec->spec_init_verbs);
  3432. + switch (spec->quirk) {
  3433. + case QUIRK_SBZ:
  3434. + sbz_setup_defaults(codec);
  3435. + ca0132_alt_select_out(codec);
  3436. + ca0132_alt_select_in(codec);
  3437. + break;
  3438. + case QUIRK_R3DI:
  3439. + ca0132_alt_select_out(codec);
  3440. + ca0132_alt_select_in(codec);
  3441. + break;
  3442. + default:
  3443. + ca0132_select_out(codec);
  3444. + ca0132_select_mic(codec);
  3445. + break;
  3446. + }
  3448. snd_hda_jack_report_sync(codec);
  3450. + /*
  3451. + * Re set the PlayEnhancement switch on a resume event, because the
  3452. + * controls will not be reloaded.
  3453. + */
  3454. + if (spec->dsp_reload) {
  3455. + spec->dsp_reload = false;
  3456. + ca0132_pe_switch_set(codec);
  3457. + }
  3458. +
  3459. snd_hda_power_down_pm(codec);
  3461. return 0;
  3462. @@ -4609,19 +7278,40 @@
  3464. cancel_delayed_work_sync(&spec->unsol_hp_work);
  3465. snd_hda_power_up(codec);
  3466. - snd_hda_sequence_write(codec, spec->base_exit_verbs);
  3467. - ca0132_exit_chip(codec);
  3468. + switch (spec->quirk) {
  3469. + case QUIRK_SBZ:
  3470. + sbz_exit_chip(codec);
  3471. + /* unmap BAR region 2. */
  3472. + iounmap(spec->mem_base);
  3473. + break;
  3474. + case QUIRK_R3DI:
  3475. + r3di_gpio_shutdown(codec);
  3476. + snd_hda_sequence_write(codec, spec->base_exit_verbs);
  3477. + ca0132_exit_chip(codec);
  3478. + break;
  3479. + default:
  3480. + snd_hda_sequence_write(codec, spec->base_exit_verbs);
  3481. + ca0132_exit_chip(codec);
  3482. + break;
  3483. + }
  3484. snd_hda_power_down(codec);
  3485. kfree(spec->spec_init_verbs);
  3486. kfree(codec->spec);
  3487. }
  3489. +static void ca0132_reboot_notify(struct hda_codec *codec)
  3490. +{
  3491. + codec->patch_ops.free(codec);
  3492. + return;
  3493. +}
  3494. +
  3495. static const struct hda_codec_ops ca0132_patch_ops = {
  3496. .build_controls = ca0132_build_controls,
  3497. .build_pcms = ca0132_build_pcms,
  3498. .init = ca0132_init,
  3499. .free = ca0132_free,
  3500. .unsol_event = snd_hda_jack_unsol_event,
  3501. + .reboot_notify = ca0132_reboot_notify,
  3502. };
  3504. static void ca0132_config(struct hda_codec *codec)
  3505. @@ -4635,9 +7325,14 @@
  3507. spec->multiout.dac_nids = spec->dacs;
  3508. spec->multiout.num_dacs = 3;
  3509. - spec->multiout.max_channels = 2;
  3511. - if (spec->quirk == QUIRK_ALIENWARE) {
  3512. + if (!spec->use_alt_functions)
  3513. + spec->multiout.max_channels = 2;
  3514. + else
  3515. + spec->multiout.max_channels = 6;
  3516. +
  3517. + switch (spec->quirk) {
  3518. + case QUIRK_ALIENWARE:
  3519. codec_dbg(codec, "ca0132_config: QUIRK_ALIENWARE applied.\n");
  3520. snd_hda_apply_pincfgs(codec, alienware_pincfgs);
  3522. @@ -4657,7 +7352,71 @@
  3523. spec->input_pins[2] = 0x13;
  3524. spec->shared_mic_nid = 0x7;
  3525. spec->unsol_tag_amic1 = 0x11;
  3526. - } else {
  3527. + break;
  3528. + case QUIRK_SBZ:
  3529. + codec_dbg(codec, "ca0132_config: QUIRK_SBZ applied.\n");
  3530. + snd_hda_apply_pincfgs(codec, sbz_pincfgs);
  3531. +
  3532. + spec->num_outputs = 2;
  3533. + spec->out_pins[0] = 0x0B; /* Line out */
  3534. + spec->out_pins[1] = 0x0F; /* Rear headphone out */
  3535. + spec->out_pins[2] = 0x10; /* Front Headphone / Center/LFE*/
  3536. + spec->out_pins[3] = 0x11; /* Rear surround */
  3537. + spec->shared_out_nid = 0x2;
  3538. + spec->unsol_tag_hp = spec->out_pins[1];
  3539. + spec->unsol_tag_front_hp = spec->out_pins[2];
  3540. +
  3541. + spec->adcs[0] = 0x7; /* Rear Mic / Line-in */
  3542. + spec->adcs[1] = 0x8; /* Front Mic, but only if no DSP */
  3543. + spec->adcs[2] = 0xa; /* what u hear */
  3544. +
  3545. + spec->num_inputs = 2;
  3546. + spec->input_pins[0] = 0x12; /* Rear Mic / Line-in */
  3547. + spec->input_pins[1] = 0x13; /* What U Hear */
  3548. + spec->shared_mic_nid = 0x7;
  3549. + spec->unsol_tag_amic1 = spec->input_pins[0];
  3550. +
  3551. + /* SPDIF I/O */
  3552. + spec->dig_out = 0x05;
  3553. + spec->multiout.dig_out_nid = spec->dig_out;
  3554. + cfg->dig_out_pins[0] = 0x0c;
  3555. + cfg->dig_outs = 1;
  3556. + cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
  3557. + spec->dig_in = 0x09;
  3558. + cfg->dig_in_pin = 0x0e;
  3559. + cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
  3560. + break;
  3561. + case QUIRK_R3DI:
  3562. + codec_dbg(codec, "ca0132_config: QUIRK_R3DI applied.\n");
  3563. + snd_hda_apply_pincfgs(codec, r3di_pincfgs);
  3564. +
  3565. + spec->num_outputs = 2;
  3566. + spec->out_pins[0] = 0x0B; /* Line out */
  3567. + spec->out_pins[1] = 0x0F; /* Rear headphone out */
  3568. + spec->out_pins[2] = 0x10; /* Front Headphone / Center/LFE*/
  3569. + spec->out_pins[3] = 0x11; /* Rear surround */
  3570. + spec->shared_out_nid = 0x2;
  3571. + spec->unsol_tag_hp = spec->out_pins[1];
  3572. + spec->unsol_tag_front_hp = spec->out_pins[2];
  3573. +
  3574. + spec->adcs[0] = 0x07; /* Rear Mic / Line-in */
  3575. + spec->adcs[1] = 0x08; /* Front Mic, but only if no DSP */
  3576. + spec->adcs[2] = 0x0a; /* what u hear */
  3577. +
  3578. + spec->num_inputs = 2;
  3579. + spec->input_pins[0] = 0x12; /* Rear Mic / Line-in */
  3580. + spec->input_pins[1] = 0x13; /* What U Hear */
  3581. + spec->shared_mic_nid = 0x7;
  3582. + spec->unsol_tag_amic1 = spec->input_pins[0];
  3583. +
  3584. + /* SPDIF I/O */
  3585. + spec->dig_out = 0x05;
  3586. + spec->multiout.dig_out_nid = spec->dig_out;
  3587. + cfg->dig_out_pins[0] = 0x0c;
  3588. + cfg->dig_outs = 1;
  3589. + cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF;
  3590. + break;
  3591. + default:
  3592. spec->num_outputs = 2;
  3593. spec->out_pins[0] = 0x0b; /* speaker out */
  3594. spec->out_pins[1] = 0x10; /* headphone out */
  3595. @@ -4684,6 +7443,7 @@
  3596. spec->dig_in = 0x09;
  3597. cfg->dig_in_pin = 0x0e;
  3598. cfg->dig_in_type = HDA_PCM_TYPE_SPDIF;
  3599. + break;
  3600. }
  3601. }
  3603. @@ -4694,6 +7454,8 @@
  3604. struct ca0132_spec *spec = codec->spec;
  3606. spec->chip_init_verbs = ca0132_init_verbs0;
  3607. + if (spec->quirk == QUIRK_SBZ)
  3608. + spec->sbz_init_verbs = sbz_init_verbs;
  3609. spec->spec_init_verbs = kzalloc(sizeof(struct hda_verb) * NUM_SPEC_VERBS, GFP_KERNEL);
  3610. if (!spec->spec_init_verbs)
  3611. return -ENOMEM;
  3612. @@ -4757,9 +7519,46 @@
  3613. else
  3614. spec->quirk = QUIRK_NONE;
  3616. + /* Setup BAR Region 2 for Sound Blaster Z */
  3617. + if (spec->quirk == QUIRK_SBZ) {
  3618. + spec->mem_base = pci_iomap(codec->bus->pci, 2, 0xC20);
  3619. + if (spec->mem_base == NULL) {
  3620. + codec_dbg(codec, "pci_iomap failed!");
  3621. + codec_dbg(codec, "perhaps this is not an SBZ?");
  3622. + spec->quirk = QUIRK_NONE;
  3623. + }
  3624. + }
  3625. +
  3626. spec->dsp_state = DSP_DOWNLOAD_INIT;
  3627. spec->num_mixers = 1;
  3628. - spec->mixers[0] = ca0132_mixer;
  3629. +
  3630. + /* Set which mixers each quirk uses. */
  3631. + switch (spec->quirk) {
  3632. + case QUIRK_SBZ:
  3633. + spec->mixers[0] = sbz_mixer;
  3634. + snd_hda_codec_set_name(codec, "Sound Blaster Z");
  3635. + break;
  3636. + case QUIRK_R3DI:
  3637. + spec->mixers[0] = r3di_mixer;
  3638. + snd_hda_codec_set_name(codec, "Recon3Di");
  3639. + break;
  3640. + default:
  3641. + spec->mixers[0] = ca0132_mixer;
  3642. + break;
  3643. + }
  3644. +
  3645. + /* Setup whether or not to use alt functions/controls */
  3646. + switch (spec->quirk) {
  3647. + case QUIRK_SBZ:
  3648. + case QUIRK_R3DI:
  3649. + spec->use_alt_controls = true;
  3650. + spec->use_alt_functions = true;
  3651. + break;
  3652. + default:
  3653. + spec->use_alt_controls = false;
  3654. + spec->use_alt_functions = false;
  3655. + break;
  3656. + }
  3658. spec->base_init_verbs = ca0132_base_init_verbs;
  3659. spec->base_exit_verbs = ca0132_base_exit_verbs;
  3660.  
Powered by spacepaste. Paste removal.