Thomas Gleixner | 1a59d1b8 | 2019-05-27 08:55:05 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Jaroslav Kysela | c1017a4 | 2007-10-15 09:50:19 +0200 | [diff] [blame] | 3 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Creative Labs, Inc. |
| 5 | * Routines for effect processor FX8010 |
| 6 | * |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 7 | * Copyright (c) by James Courtier-Dutton <James@superbug.co.uk> |
| 8 | * Added EMU 1010 support. |
| 9 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | * BUGS: |
| 11 | * -- |
| 12 | * |
| 13 | * TODO: |
| 14 | * -- |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | */ |
| 16 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include <linux/pci.h> |
Randy.Dunlap | c59ede7 | 2006-01-11 12:17:46 -0800 | [diff] [blame] | 18 | #include <linux/capability.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <linux/delay.h> |
| 20 | #include <linux/slab.h> |
Andreas Schwab | bd01e7b | 2005-12-05 15:12:20 +0100 | [diff] [blame] | 21 | #include <linux/vmalloc.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include <linux/init.h> |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 23 | #include <linux/mutex.h> |
Clemens Ladisch | 4daf7a0 | 2010-05-25 09:04:49 +0200 | [diff] [blame] | 24 | #include <linux/moduleparam.h> |
Gustavo A. R. Silva | 5ae4f61 | 2018-12-18 11:52:16 -0600 | [diff] [blame] | 25 | #include <linux/nospec.h> |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 26 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <sound/core.h> |
James Courtier-Dutton | 31508f8 | 2006-07-22 17:02:10 +0100 | [diff] [blame] | 28 | #include <sound/tlv.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <sound/emu10k1.h> |
| 30 | |
| 31 | #if 0 /* for testing purposes - digital out -> capture */ |
| 32 | #define EMU10K1_CAPTURE_DIGITAL_OUT |
| 33 | #endif |
| 34 | #if 0 /* for testing purposes - set S/PDIF to AC3 output */ |
| 35 | #define EMU10K1_SET_AC3_IEC958 |
| 36 | #endif |
| 37 | #if 0 /* for testing purposes - feed the front signal to Center/LFE outputs */ |
| 38 | #define EMU10K1_CENTER_LFE_FROM_FRONT |
| 39 | #endif |
| 40 | |
Clemens Ladisch | 4daf7a0 | 2010-05-25 09:04:49 +0200 | [diff] [blame] | 41 | static bool high_res_gpr_volume; |
| 42 | module_param(high_res_gpr_volume, bool, 0444); |
| 43 | MODULE_PARM_DESC(high_res_gpr_volume, "GPR mixer controls use 31-bit range."); |
| 44 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | /* |
| 46 | * Tables |
| 47 | */ |
| 48 | |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 49 | static const char * const fxbuses[16] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | /* 0x00 */ "PCM Left", |
| 51 | /* 0x01 */ "PCM Right", |
| 52 | /* 0x02 */ "PCM Surround Left", |
| 53 | /* 0x03 */ "PCM Surround Right", |
| 54 | /* 0x04 */ "MIDI Left", |
| 55 | /* 0x05 */ "MIDI Right", |
| 56 | /* 0x06 */ "Center", |
| 57 | /* 0x07 */ "LFE", |
| 58 | /* 0x08 */ NULL, |
| 59 | /* 0x09 */ NULL, |
| 60 | /* 0x0a */ NULL, |
| 61 | /* 0x0b */ NULL, |
| 62 | /* 0x0c */ "MIDI Reverb", |
| 63 | /* 0x0d */ "MIDI Chorus", |
| 64 | /* 0x0e */ NULL, |
| 65 | /* 0x0f */ NULL |
| 66 | }; |
| 67 | |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 68 | static const char * const creative_ins[16] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | /* 0x00 */ "AC97 Left", |
| 70 | /* 0x01 */ "AC97 Right", |
| 71 | /* 0x02 */ "TTL IEC958 Left", |
| 72 | /* 0x03 */ "TTL IEC958 Right", |
| 73 | /* 0x04 */ "Zoom Video Left", |
| 74 | /* 0x05 */ "Zoom Video Right", |
| 75 | /* 0x06 */ "Optical IEC958 Left", |
| 76 | /* 0x07 */ "Optical IEC958 Right", |
| 77 | /* 0x08 */ "Line/Mic 1 Left", |
| 78 | /* 0x09 */ "Line/Mic 1 Right", |
| 79 | /* 0x0a */ "Coaxial IEC958 Left", |
| 80 | /* 0x0b */ "Coaxial IEC958 Right", |
| 81 | /* 0x0c */ "Line/Mic 2 Left", |
| 82 | /* 0x0d */ "Line/Mic 2 Right", |
| 83 | /* 0x0e */ NULL, |
| 84 | /* 0x0f */ NULL |
| 85 | }; |
| 86 | |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 87 | static const char * const audigy_ins[16] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | /* 0x00 */ "AC97 Left", |
| 89 | /* 0x01 */ "AC97 Right", |
| 90 | /* 0x02 */ "Audigy CD Left", |
| 91 | /* 0x03 */ "Audigy CD Right", |
| 92 | /* 0x04 */ "Optical IEC958 Left", |
| 93 | /* 0x05 */ "Optical IEC958 Right", |
| 94 | /* 0x06 */ NULL, |
| 95 | /* 0x07 */ NULL, |
| 96 | /* 0x08 */ "Line/Mic 2 Left", |
| 97 | /* 0x09 */ "Line/Mic 2 Right", |
| 98 | /* 0x0a */ "SPDIF Left", |
| 99 | /* 0x0b */ "SPDIF Right", |
| 100 | /* 0x0c */ "Aux2 Left", |
| 101 | /* 0x0d */ "Aux2 Right", |
| 102 | /* 0x0e */ NULL, |
| 103 | /* 0x0f */ NULL |
| 104 | }; |
| 105 | |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 106 | static const char * const creative_outs[32] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | /* 0x00 */ "AC97 Left", |
| 108 | /* 0x01 */ "AC97 Right", |
| 109 | /* 0x02 */ "Optical IEC958 Left", |
| 110 | /* 0x03 */ "Optical IEC958 Right", |
| 111 | /* 0x04 */ "Center", |
| 112 | /* 0x05 */ "LFE", |
| 113 | /* 0x06 */ "Headphone Left", |
| 114 | /* 0x07 */ "Headphone Right", |
| 115 | /* 0x08 */ "Surround Left", |
| 116 | /* 0x09 */ "Surround Right", |
| 117 | /* 0x0a */ "PCM Capture Left", |
| 118 | /* 0x0b */ "PCM Capture Right", |
| 119 | /* 0x0c */ "MIC Capture", |
| 120 | /* 0x0d */ "AC97 Surround Left", |
| 121 | /* 0x0e */ "AC97 Surround Right", |
| 122 | /* 0x0f */ NULL, |
| 123 | /* 0x10 */ NULL, |
| 124 | /* 0x11 */ "Analog Center", |
| 125 | /* 0x12 */ "Analog LFE", |
| 126 | /* 0x13 */ NULL, |
| 127 | /* 0x14 */ NULL, |
| 128 | /* 0x15 */ NULL, |
| 129 | /* 0x16 */ NULL, |
| 130 | /* 0x17 */ NULL, |
| 131 | /* 0x18 */ NULL, |
| 132 | /* 0x19 */ NULL, |
| 133 | /* 0x1a */ NULL, |
| 134 | /* 0x1b */ NULL, |
| 135 | /* 0x1c */ NULL, |
| 136 | /* 0x1d */ NULL, |
| 137 | /* 0x1e */ NULL, |
| 138 | /* 0x1f */ NULL, |
| 139 | }; |
| 140 | |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 141 | static const char * const audigy_outs[32] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | /* 0x00 */ "Digital Front Left", |
| 143 | /* 0x01 */ "Digital Front Right", |
| 144 | /* 0x02 */ "Digital Center", |
| 145 | /* 0x03 */ "Digital LEF", |
| 146 | /* 0x04 */ "Headphone Left", |
| 147 | /* 0x05 */ "Headphone Right", |
| 148 | /* 0x06 */ "Digital Rear Left", |
| 149 | /* 0x07 */ "Digital Rear Right", |
| 150 | /* 0x08 */ "Front Left", |
| 151 | /* 0x09 */ "Front Right", |
| 152 | /* 0x0a */ "Center", |
| 153 | /* 0x0b */ "LFE", |
| 154 | /* 0x0c */ NULL, |
| 155 | /* 0x0d */ NULL, |
| 156 | /* 0x0e */ "Rear Left", |
| 157 | /* 0x0f */ "Rear Right", |
| 158 | /* 0x10 */ "AC97 Front Left", |
| 159 | /* 0x11 */ "AC97 Front Right", |
Colin Ian King | bf8b47f | 2018-05-17 09:04:20 +0100 | [diff] [blame] | 160 | /* 0x12 */ "ADC Capture Left", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | /* 0x13 */ "ADC Capture Right", |
| 162 | /* 0x14 */ NULL, |
| 163 | /* 0x15 */ NULL, |
| 164 | /* 0x16 */ NULL, |
| 165 | /* 0x17 */ NULL, |
| 166 | /* 0x18 */ NULL, |
| 167 | /* 0x19 */ NULL, |
| 168 | /* 0x1a */ NULL, |
| 169 | /* 0x1b */ NULL, |
| 170 | /* 0x1c */ NULL, |
| 171 | /* 0x1d */ NULL, |
| 172 | /* 0x1e */ NULL, |
| 173 | /* 0x1f */ NULL, |
| 174 | }; |
| 175 | |
| 176 | static const u32 bass_table[41][5] = { |
| 177 | { 0x3e4f844f, 0x84ed4cc3, 0x3cc69927, 0x7b03553a, 0xc4da8486 }, |
| 178 | { 0x3e69a17a, 0x84c280fb, 0x3cd77cd4, 0x7b2f2a6f, 0xc4b08d1d }, |
| 179 | { 0x3e82ff42, 0x849991d5, 0x3ce7466b, 0x7b5917c6, 0xc48863ee }, |
| 180 | { 0x3e9bab3c, 0x847267f0, 0x3cf5ffe8, 0x7b813560, 0xc461f22c }, |
| 181 | { 0x3eb3b275, 0x844ced29, 0x3d03b295, 0x7ba79a1c, 0xc43d223b }, |
| 182 | { 0x3ecb2174, 0x84290c8b, 0x3d106714, 0x7bcc5ba3, 0xc419dfa5 }, |
| 183 | { 0x3ee2044b, 0x8406b244, 0x3d1c2561, 0x7bef8e77, 0xc3f8170f }, |
| 184 | { 0x3ef86698, 0x83e5cb96, 0x3d26f4d8, 0x7c114600, 0xc3d7b625 }, |
| 185 | { 0x3f0e5390, 0x83c646c9, 0x3d30dc39, 0x7c319498, 0xc3b8ab97 }, |
| 186 | { 0x3f23d60b, 0x83a81321, 0x3d39e1af, 0x7c508b9c, 0xc39ae704 }, |
| 187 | { 0x3f38f884, 0x838b20d2, 0x3d420ad2, 0x7c6e3b75, 0xc37e58f1 }, |
| 188 | { 0x3f4dc52c, 0x836f60ef, 0x3d495cab, 0x7c8ab3a6, 0xc362f2be }, |
| 189 | { 0x3f6245e8, 0x8354c565, 0x3d4fdbb8, 0x7ca602d6, 0xc348a69b }, |
| 190 | { 0x3f76845f, 0x833b40ec, 0x3d558bf0, 0x7cc036df, 0xc32f677c }, |
| 191 | { 0x3f8a8a03, 0x8322c6fb, 0x3d5a70c4, 0x7cd95cd7, 0xc317290b }, |
| 192 | { 0x3f9e6014, 0x830b4bc3, 0x3d5e8d25, 0x7cf1811a, 0xc2ffdfa5 }, |
| 193 | { 0x3fb20fae, 0x82f4c420, 0x3d61e37f, 0x7d08af56, 0xc2e9804a }, |
| 194 | { 0x3fc5a1cc, 0x82df2592, 0x3d6475c3, 0x7d1ef294, 0xc2d40096 }, |
| 195 | { 0x3fd91f55, 0x82ca6632, 0x3d664564, 0x7d345541, 0xc2bf56b9 }, |
| 196 | { 0x3fec9120, 0x82b67cac, 0x3d675356, 0x7d48e138, 0xc2ab796e }, |
| 197 | { 0x40000000, 0x82a36037, 0x3d67a012, 0x7d5c9fc9, 0xc2985fee }, |
| 198 | { 0x401374c7, 0x8291088a, 0x3d672b93, 0x7d6f99c3, 0xc28601f2 }, |
| 199 | { 0x4026f857, 0x827f6dd7, 0x3d65f559, 0x7d81d77c, 0xc27457a3 }, |
| 200 | { 0x403a939f, 0x826e88c5, 0x3d63fc63, 0x7d9360d4, 0xc2635996 }, |
| 201 | { 0x404e4faf, 0x825e5266, 0x3d613f32, 0x7da43d42, 0xc25300c6 }, |
| 202 | { 0x406235ba, 0x824ec434, 0x3d5dbbc3, 0x7db473d7, 0xc243468e }, |
| 203 | { 0x40764f1f, 0x823fd80c, 0x3d596f8f, 0x7dc40b44, 0xc23424a2 }, |
| 204 | { 0x408aa576, 0x82318824, 0x3d545787, 0x7dd309e2, 0xc2259509 }, |
| 205 | { 0x409f4296, 0x8223cf0b, 0x3d4e7012, 0x7de175b5, 0xc2179218 }, |
| 206 | { 0x40b430a0, 0x8216a7a1, 0x3d47b505, 0x7def5475, 0xc20a1670 }, |
| 207 | { 0x40c97a0a, 0x820a0d12, 0x3d4021a1, 0x7dfcab8d, 0xc1fd1cf5 }, |
| 208 | { 0x40df29a6, 0x81fdfad6, 0x3d37b08d, 0x7e098028, 0xc1f0a0ca }, |
| 209 | { 0x40f54ab1, 0x81f26ca9, 0x3d2e5bd1, 0x7e15d72b, 0xc1e49d52 }, |
| 210 | { 0x410be8da, 0x81e75e89, 0x3d241cce, 0x7e21b544, 0xc1d90e24 }, |
| 211 | { 0x41231051, 0x81dcccb3, 0x3d18ec37, 0x7e2d1ee6, 0xc1cdef10 }, |
| 212 | { 0x413acdd0, 0x81d2b39e, 0x3d0cc20a, 0x7e38184e, 0xc1c33c13 }, |
| 213 | { 0x41532ea7, 0x81c90ffb, 0x3cff9585, 0x7e42a58b, 0xc1b8f15a }, |
| 214 | { 0x416c40cd, 0x81bfdeb2, 0x3cf15d21, 0x7e4cca7c, 0xc1af0b3f }, |
| 215 | { 0x418612ea, 0x81b71cdc, 0x3ce20e85, 0x7e568ad3, 0xc1a58640 }, |
| 216 | { 0x41a0b465, 0x81aec7c5, 0x3cd19e7c, 0x7e5fea1e, 0xc19c5f03 }, |
| 217 | { 0x41bc3573, 0x81a6dcea, 0x3cc000e9, 0x7e68ebc2, 0xc1939250 } |
| 218 | }; |
| 219 | |
| 220 | static const u32 treble_table[41][5] = { |
| 221 | { 0x0125cba9, 0xfed5debd, 0x00599b6c, 0x0d2506da, 0xfa85b354 }, |
| 222 | { 0x0142f67e, 0xfeb03163, 0x0066cd0f, 0x0d14c69d, 0xfa914473 }, |
| 223 | { 0x016328bd, 0xfe860158, 0x0075b7f2, 0x0d03eb27, 0xfa9d32d2 }, |
| 224 | { 0x0186b438, 0xfe56c982, 0x00869234, 0x0cf27048, 0xfaa97fca }, |
| 225 | { 0x01adf358, 0xfe21f5fe, 0x00999842, 0x0ce051c2, 0xfab62ca5 }, |
| 226 | { 0x01d949fa, 0xfde6e287, 0x00af0d8d, 0x0ccd8b4a, 0xfac33aa7 }, |
| 227 | { 0x02092669, 0xfda4d8bf, 0x00c73d4c, 0x0cba1884, 0xfad0ab07 }, |
| 228 | { 0x023e0268, 0xfd5b0e4a, 0x00e27b54, 0x0ca5f509, 0xfade7ef2 }, |
| 229 | { 0x0278645c, 0xfd08a2b0, 0x01012509, 0x0c911c63, 0xfaecb788 }, |
| 230 | { 0x02b8e091, 0xfcac9d1a, 0x0123a262, 0x0c7b8a14, 0xfafb55df }, |
| 231 | { 0x03001a9a, 0xfc45e9ce, 0x014a6709, 0x0c65398f, 0xfb0a5aff }, |
| 232 | { 0x034ec6d7, 0xfbd3576b, 0x0175f397, 0x0c4e2643, 0xfb19c7e4 }, |
| 233 | { 0x03a5ac15, 0xfb5393ee, 0x01a6d6ed, 0x0c364b94, 0xfb299d7c }, |
| 234 | { 0x0405a562, 0xfac52968, 0x01ddafae, 0x0c1da4e2, 0xfb39dca5 }, |
| 235 | { 0x046fa3fe, 0xfa267a66, 0x021b2ddd, 0x0c042d8d, 0xfb4a8631 }, |
| 236 | { 0x04e4b17f, 0xf975be0f, 0x0260149f, 0x0be9e0f2, 0xfb5b9ae0 }, |
| 237 | { 0x0565f220, 0xf8b0fbe5, 0x02ad3c29, 0x0bceba73, 0xfb6d1b60 }, |
| 238 | { 0x05f4a745, 0xf7d60722, 0x030393d4, 0x0bb2b578, 0xfb7f084d }, |
| 239 | { 0x06923236, 0xf6e279bd, 0x03642465, 0x0b95cd75, 0xfb916233 }, |
| 240 | { 0x07401713, 0xf5d3aef9, 0x03d01283, 0x0b77fded, 0xfba42984 }, |
| 241 | { 0x08000000, 0xf4a6bd88, 0x0448a161, 0x0b594278, 0xfbb75e9f }, |
| 242 | { 0x08d3c097, 0xf3587131, 0x04cf35a4, 0x0b3996c9, 0xfbcb01cb }, |
| 243 | { 0x09bd59a2, 0xf1e543f9, 0x05655880, 0x0b18f6b2, 0xfbdf1333 }, |
| 244 | { 0x0abefd0f, 0xf04956ca, 0x060cbb12, 0x0af75e2c, 0xfbf392e8 }, |
| 245 | { 0x0bdb123e, 0xee806984, 0x06c739fe, 0x0ad4c962, 0xfc0880dd }, |
| 246 | { 0x0d143a94, 0xec85d287, 0x0796e150, 0x0ab134b0, 0xfc1ddce5 }, |
| 247 | { 0x0e6d5664, 0xea547598, 0x087df0a0, 0x0a8c9cb6, 0xfc33a6ad }, |
| 248 | { 0x0fe98a2a, 0xe7e6ba35, 0x097edf83, 0x0a66fe5b, 0xfc49ddc2 }, |
| 249 | { 0x118c4421, 0xe536813a, 0x0a9c6248, 0x0a4056d7, 0xfc608185 }, |
| 250 | { 0x1359422e, 0xe23d19eb, 0x0bd96efb, 0x0a18a3bf, 0xfc77912c }, |
| 251 | { 0x1554982b, 0xdef33645, 0x0d3942bd, 0x09efe312, 0xfc8f0bc1 }, |
| 252 | { 0x1782b68a, 0xdb50deb1, 0x0ebf676d, 0x09c6133f, 0xfca6f019 }, |
| 253 | { 0x19e8715d, 0xd74d64fd, 0x106fb999, 0x099b3337, 0xfcbf3cd6 }, |
| 254 | { 0x1c8b07b8, 0xd2df56ab, 0x124e6ec8, 0x096f4274, 0xfcd7f060 }, |
| 255 | { 0x1f702b6d, 0xcdfc6e92, 0x14601c10, 0x0942410b, 0xfcf108e5 }, |
| 256 | { 0x229e0933, 0xc89985cd, 0x16a9bcfa, 0x09142fb5, 0xfd0a8451 }, |
| 257 | { 0x261b5118, 0xc2aa8409, 0x1930bab6, 0x08e50fdc, 0xfd24604d }, |
| 258 | { 0x29ef3f5d, 0xbc224f28, 0x1bfaf396, 0x08b4e3aa, 0xfd3e9a3b }, |
| 259 | { 0x2e21a59b, 0xb4f2ba46, 0x1f0ec2d6, 0x0883ae15, 0xfd592f33 }, |
| 260 | { 0x32baf44b, 0xad0c7429, 0x227308a3, 0x085172eb, 0xfd741bfd }, |
| 261 | { 0x37c4448b, 0xa45ef51d, 0x262f3267, 0x081e36dc, 0xfd8f5d14 } |
| 262 | }; |
| 263 | |
James Courtier-Dutton | 7012b2d | 2006-07-28 22:27:56 +0100 | [diff] [blame] | 264 | /* dB gain = (float) 20 * log10( float(db_table_value) / 0x8000000 ) */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | static const u32 db_table[101] = { |
| 266 | 0x00000000, 0x01571f82, 0x01674b41, 0x01783a1b, 0x0189f540, |
| 267 | 0x019c8651, 0x01aff763, 0x01c45306, 0x01d9a446, 0x01eff6b8, |
| 268 | 0x0207567a, 0x021fd03d, 0x0239714c, 0x02544792, 0x027061a1, |
| 269 | 0x028dcebb, 0x02ac9edc, 0x02cce2bf, 0x02eeabe8, 0x03120cb0, |
| 270 | 0x0337184e, 0x035de2df, 0x03868173, 0x03b10a18, 0x03dd93e9, |
| 271 | 0x040c3713, 0x043d0cea, 0x04702ff3, 0x04a5bbf2, 0x04ddcdfb, |
| 272 | 0x0518847f, 0x0555ff62, 0x05966005, 0x05d9c95d, 0x06206005, |
| 273 | 0x066a4a52, 0x06b7b067, 0x0708bc4c, 0x075d9a01, 0x07b6779d, |
| 274 | 0x08138561, 0x0874f5d5, 0x08dafde1, 0x0945d4ed, 0x09b5b4fd, |
| 275 | 0x0a2adad1, 0x0aa58605, 0x0b25f936, 0x0bac7a24, 0x0c3951d8, |
| 276 | 0x0ccccccc, 0x0d673b17, 0x0e08f093, 0x0eb24510, 0x0f639481, |
| 277 | 0x101d3f2d, 0x10dfa9e6, 0x11ab3e3f, 0x12806ac3, 0x135fa333, |
| 278 | 0x144960c5, 0x153e2266, 0x163e6cfe, 0x174acbb7, 0x1863d04d, |
| 279 | 0x198a1357, 0x1abe349f, 0x1c00db77, 0x1d52b712, 0x1eb47ee6, |
| 280 | 0x2026f30f, 0x21aadcb6, 0x23410e7e, 0x24ea64f9, 0x26a7c71d, |
| 281 | 0x287a26c4, 0x2a62812c, 0x2c61df84, 0x2e795779, 0x30aa0bcf, |
| 282 | 0x32f52cfe, 0x355bf9d8, 0x37dfc033, 0x3a81dda4, 0x3d43c038, |
| 283 | 0x4026e73c, 0x432ce40f, 0x46575af8, 0x49a8040f, 0x4d20ac2a, |
| 284 | 0x50c335d3, 0x54919a57, 0x588dead1, 0x5cba514a, 0x611911ea, |
| 285 | 0x65ac8c2f, 0x6a773c39, 0x6f7bbc23, 0x74bcc56c, 0x7a3d3272, |
| 286 | 0x7fffffff, |
| 287 | }; |
| 288 | |
James Courtier-Dutton | 31508f8 | 2006-07-22 17:02:10 +0100 | [diff] [blame] | 289 | /* EMU10k1/EMU10k2 DSP control db gain */ |
Takashi Iwai | 0cb29ea | 2007-01-29 15:33:49 +0100 | [diff] [blame] | 290 | static const DECLARE_TLV_DB_SCALE(snd_emu10k1_db_scale1, -4000, 40, 1); |
Clemens Ladisch | 4daf7a0 | 2010-05-25 09:04:49 +0200 | [diff] [blame] | 291 | static const DECLARE_TLV_DB_LINEAR(snd_emu10k1_db_linear, TLV_DB_GAIN_MUTE, 0); |
James Courtier-Dutton | 31508f8 | 2006-07-22 17:02:10 +0100 | [diff] [blame] | 292 | |
Raymond Yau | bfe9fc8a | 2011-05-20 14:32:04 +0800 | [diff] [blame] | 293 | /* EMU10K1 bass/treble db gain */ |
| 294 | static const DECLARE_TLV_DB_SCALE(snd_emu10k1_bass_treble_db_scale, -1200, 60, 0); |
| 295 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | static const u32 onoff_table[2] = { |
| 297 | 0x00000000, 0x00000001 |
| 298 | }; |
| 299 | |
| 300 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | * controls |
| 302 | */ |
| 303 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 304 | static int snd_emu10k1_gpr_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 305 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 306 | struct snd_emu10k1_fx8010_ctl *ctl = |
| 307 | (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | |
| 309 | if (ctl->min == 0 && ctl->max == 1) |
| 310 | uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; |
| 311 | else |
| 312 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; |
| 313 | uinfo->count = ctl->vcount; |
| 314 | uinfo->value.integer.min = ctl->min; |
| 315 | uinfo->value.integer.max = ctl->max; |
| 316 | return 0; |
| 317 | } |
| 318 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 319 | static int snd_emu10k1_gpr_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 321 | struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); |
| 322 | struct snd_emu10k1_fx8010_ctl *ctl = |
| 323 | (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | unsigned long flags; |
| 325 | unsigned int i; |
| 326 | |
| 327 | spin_lock_irqsave(&emu->reg_lock, flags); |
| 328 | for (i = 0; i < ctl->vcount; i++) |
| 329 | ucontrol->value.integer.value[i] = ctl->value[i]; |
| 330 | spin_unlock_irqrestore(&emu->reg_lock, flags); |
| 331 | return 0; |
| 332 | } |
| 333 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 334 | static int snd_emu10k1_gpr_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 336 | struct snd_emu10k1 *emu = snd_kcontrol_chip(kcontrol); |
| 337 | struct snd_emu10k1_fx8010_ctl *ctl = |
| 338 | (struct snd_emu10k1_fx8010_ctl *) kcontrol->private_value; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | unsigned long flags; |
| 340 | unsigned int nval, val; |
| 341 | unsigned int i, j; |
| 342 | int change = 0; |
| 343 | |
| 344 | spin_lock_irqsave(&emu->reg_lock, flags); |
| 345 | for (i = 0; i < ctl->vcount; i++) { |
| 346 | nval = ucontrol->value.integer.value[i]; |
| 347 | if (nval < ctl->min) |
| 348 | nval = ctl->min; |
| 349 | if (nval > ctl->max) |
| 350 | nval = ctl->max; |
| 351 | if (nval != ctl->value[i]) |
| 352 | change = 1; |
| 353 | val = ctl->value[i] = nval; |
| 354 | switch (ctl->translation) { |
| 355 | case EMU10K1_GPR_TRANSLATION_NONE: |
| 356 | snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, val); |
| 357 | break; |
| 358 | case EMU10K1_GPR_TRANSLATION_TABLE100: |
| 359 | snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, db_table[val]); |
| 360 | break; |
| 361 | case EMU10K1_GPR_TRANSLATION_BASS: |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 362 | if ((ctl->count % 5) != 0 || (ctl->count / 5) != ctl->vcount) { |
| 363 | change = -EIO; |
| 364 | goto __error; |
| 365 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | for (j = 0; j < 5; j++) |
| 367 | snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[j * ctl->vcount + i], 0, bass_table[val][j]); |
| 368 | break; |
| 369 | case EMU10K1_GPR_TRANSLATION_TREBLE: |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 370 | if ((ctl->count % 5) != 0 || (ctl->count / 5) != ctl->vcount) { |
| 371 | change = -EIO; |
| 372 | goto __error; |
| 373 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | for (j = 0; j < 5; j++) |
| 375 | snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[j * ctl->vcount + i], 0, treble_table[val][j]); |
| 376 | break; |
| 377 | case EMU10K1_GPR_TRANSLATION_ONOFF: |
| 378 | snd_emu10k1_ptr_write(emu, emu->gpr_base + ctl->gpr[i], 0, onoff_table[val]); |
| 379 | break; |
| 380 | } |
| 381 | } |
| 382 | __error: |
| 383 | spin_unlock_irqrestore(&emu->reg_lock, flags); |
| 384 | return change; |
| 385 | } |
| 386 | |
| 387 | /* |
| 388 | * Interrupt handler |
| 389 | */ |
| 390 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 391 | static void snd_emu10k1_fx8010_interrupt(struct snd_emu10k1 *emu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 393 | struct snd_emu10k1_fx8010_irq *irq, *nirq; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | |
| 395 | irq = emu->fx8010.irq_handlers; |
| 396 | while (irq) { |
| 397 | nirq = irq->next; /* irq ptr can be removed from list */ |
| 398 | if (snd_emu10k1_ptr_read(emu, emu->gpr_base + irq->gpr_running, 0) & 0xffff0000) { |
| 399 | if (irq->handler) |
| 400 | irq->handler(emu, irq->private_data); |
| 401 | snd_emu10k1_ptr_write(emu, emu->gpr_base + irq->gpr_running, 0, 1); |
| 402 | } |
| 403 | irq = nirq; |
| 404 | } |
| 405 | } |
| 406 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 407 | int snd_emu10k1_fx8010_register_irq_handler(struct snd_emu10k1 *emu, |
| 408 | snd_fx8010_irq_handler_t *handler, |
| 409 | unsigned char gpr_running, |
| 410 | void *private_data, |
Takashi Iwai | 057666b | 2018-04-09 22:21:49 +0200 | [diff] [blame] | 411 | struct snd_emu10k1_fx8010_irq *irq) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | unsigned long flags; |
| 414 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | irq->handler = handler; |
| 416 | irq->gpr_running = gpr_running; |
| 417 | irq->private_data = private_data; |
| 418 | irq->next = NULL; |
| 419 | spin_lock_irqsave(&emu->fx8010.irq_lock, flags); |
| 420 | if (emu->fx8010.irq_handlers == NULL) { |
| 421 | emu->fx8010.irq_handlers = irq; |
| 422 | emu->dsp_interrupt = snd_emu10k1_fx8010_interrupt; |
| 423 | snd_emu10k1_intr_enable(emu, INTE_FXDSPENABLE); |
| 424 | } else { |
| 425 | irq->next = emu->fx8010.irq_handlers; |
| 426 | emu->fx8010.irq_handlers = irq; |
| 427 | } |
| 428 | spin_unlock_irqrestore(&emu->fx8010.irq_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | return 0; |
| 430 | } |
| 431 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 432 | int snd_emu10k1_fx8010_unregister_irq_handler(struct snd_emu10k1 *emu, |
| 433 | struct snd_emu10k1_fx8010_irq *irq) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 435 | struct snd_emu10k1_fx8010_irq *tmp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 436 | unsigned long flags; |
| 437 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | spin_lock_irqsave(&emu->fx8010.irq_lock, flags); |
Takashi Iwai | 12bda10 | 2021-06-08 16:05:14 +0200 | [diff] [blame] | 439 | tmp = emu->fx8010.irq_handlers; |
| 440 | if (tmp == irq) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | emu->fx8010.irq_handlers = tmp->next; |
| 442 | if (emu->fx8010.irq_handlers == NULL) { |
| 443 | snd_emu10k1_intr_disable(emu, INTE_FXDSPENABLE); |
| 444 | emu->dsp_interrupt = NULL; |
| 445 | } |
| 446 | } else { |
| 447 | while (tmp && tmp->next != irq) |
| 448 | tmp = tmp->next; |
| 449 | if (tmp) |
| 450 | tmp->next = tmp->next->next; |
| 451 | } |
| 452 | spin_unlock_irqrestore(&emu->fx8010.irq_lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | return 0; |
| 454 | } |
| 455 | |
| 456 | /************************************************************************* |
| 457 | * EMU10K1 effect manager |
| 458 | *************************************************************************/ |
| 459 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 460 | static void snd_emu10k1_write_op(struct snd_emu10k1_fx8010_code *icode, |
| 461 | unsigned int *ptr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 462 | u32 op, u32 r, u32 a, u32 x, u32 y) |
| 463 | { |
| 464 | u_int32_t *code; |
Takashi Iwai | da3cec3 | 2008-08-08 17:12:14 +0200 | [diff] [blame] | 465 | if (snd_BUG_ON(*ptr >= 512)) |
| 466 | return; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 467 | code = icode->code + (*ptr) * 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | set_bit(*ptr, icode->code_valid); |
| 469 | code[0] = ((x & 0x3ff) << 10) | (y & 0x3ff); |
| 470 | code[1] = ((op & 0x0f) << 20) | ((r & 0x3ff) << 10) | (a & 0x3ff); |
| 471 | (*ptr)++; |
| 472 | } |
| 473 | |
| 474 | #define OP(icode, ptr, op, r, a, x, y) \ |
| 475 | snd_emu10k1_write_op(icode, ptr, op, r, a, x, y) |
| 476 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 477 | static void snd_emu10k1_audigy_write_op(struct snd_emu10k1_fx8010_code *icode, |
| 478 | unsigned int *ptr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | u32 op, u32 r, u32 a, u32 x, u32 y) |
| 480 | { |
| 481 | u_int32_t *code; |
Takashi Iwai | da3cec3 | 2008-08-08 17:12:14 +0200 | [diff] [blame] | 482 | if (snd_BUG_ON(*ptr >= 1024)) |
| 483 | return; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 484 | code = icode->code + (*ptr) * 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 485 | set_bit(*ptr, icode->code_valid); |
| 486 | code[0] = ((x & 0x7ff) << 12) | (y & 0x7ff); |
| 487 | code[1] = ((op & 0x0f) << 24) | ((r & 0x7ff) << 12) | (a & 0x7ff); |
| 488 | (*ptr)++; |
| 489 | } |
| 490 | |
| 491 | #define A_OP(icode, ptr, op, r, a, x, y) \ |
| 492 | snd_emu10k1_audigy_write_op(icode, ptr, op, r, a, x, y) |
| 493 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 494 | static void snd_emu10k1_efx_write(struct snd_emu10k1 *emu, unsigned int pc, unsigned int data) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | { |
| 496 | pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE; |
| 497 | snd_emu10k1_ptr_write(emu, pc, 0, data); |
| 498 | } |
| 499 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 500 | unsigned int snd_emu10k1_efx_read(struct snd_emu10k1 *emu, unsigned int pc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | { |
| 502 | pc += emu->audigy ? A_MICROCODEBASE : MICROCODEBASE; |
| 503 | return snd_emu10k1_ptr_read(emu, pc, 0); |
| 504 | } |
| 505 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 506 | static int snd_emu10k1_gpr_poke(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 507 | struct snd_emu10k1_fx8010_code *icode, |
| 508 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 509 | { |
| 510 | int gpr; |
| 511 | u32 val; |
| 512 | |
| 513 | for (gpr = 0; gpr < (emu->audigy ? 0x200 : 0x100); gpr++) { |
| 514 | if (!test_bit(gpr, icode->gpr_valid)) |
| 515 | continue; |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 516 | if (in_kernel) |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 517 | val = icode->gpr_map[gpr]; |
| 518 | else if (get_user(val, (__user u32 *)&icode->gpr_map[gpr])) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 519 | return -EFAULT; |
| 520 | snd_emu10k1_ptr_write(emu, emu->gpr_base + gpr, 0, val); |
| 521 | } |
| 522 | return 0; |
| 523 | } |
| 524 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 525 | static int snd_emu10k1_gpr_peek(struct snd_emu10k1 *emu, |
| 526 | struct snd_emu10k1_fx8010_code *icode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 527 | { |
| 528 | int gpr; |
| 529 | u32 val; |
| 530 | |
| 531 | for (gpr = 0; gpr < (emu->audigy ? 0x200 : 0x100); gpr++) { |
| 532 | set_bit(gpr, icode->gpr_valid); |
| 533 | val = snd_emu10k1_ptr_read(emu, emu->gpr_base + gpr, 0); |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 534 | if (put_user(val, (__user u32 *)&icode->gpr_map[gpr])) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | return -EFAULT; |
| 536 | } |
| 537 | return 0; |
| 538 | } |
| 539 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 540 | static int snd_emu10k1_tram_poke(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 541 | struct snd_emu10k1_fx8010_code *icode, |
| 542 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 543 | { |
| 544 | int tram; |
| 545 | u32 addr, val; |
| 546 | |
| 547 | for (tram = 0; tram < (emu->audigy ? 0x100 : 0xa0); tram++) { |
| 548 | if (!test_bit(tram, icode->tram_valid)) |
| 549 | continue; |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 550 | if (in_kernel) { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 551 | val = icode->tram_data_map[tram]; |
| 552 | addr = icode->tram_addr_map[tram]; |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 553 | } else { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 554 | if (get_user(val, (__user __u32 *)&icode->tram_data_map[tram]) || |
| 555 | get_user(addr, (__user __u32 *)&icode->tram_addr_map[tram])) |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 556 | return -EFAULT; |
| 557 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 558 | snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + tram, 0, val); |
| 559 | if (!emu->audigy) { |
| 560 | snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + tram, 0, addr); |
| 561 | } else { |
| 562 | snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + tram, 0, addr << 12); |
| 563 | snd_emu10k1_ptr_write(emu, A_TANKMEMCTLREGBASE + tram, 0, addr >> 20); |
| 564 | } |
| 565 | } |
| 566 | return 0; |
| 567 | } |
| 568 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 569 | static int snd_emu10k1_tram_peek(struct snd_emu10k1 *emu, |
| 570 | struct snd_emu10k1_fx8010_code *icode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 571 | { |
| 572 | int tram; |
| 573 | u32 val, addr; |
| 574 | |
| 575 | memset(icode->tram_valid, 0, sizeof(icode->tram_valid)); |
| 576 | for (tram = 0; tram < (emu->audigy ? 0x100 : 0xa0); tram++) { |
| 577 | set_bit(tram, icode->tram_valid); |
| 578 | val = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + tram, 0); |
| 579 | if (!emu->audigy) { |
| 580 | addr = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + tram, 0); |
| 581 | } else { |
| 582 | addr = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + tram, 0) >> 12; |
| 583 | addr |= snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + tram, 0) << 20; |
| 584 | } |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 585 | if (put_user(val, (__user u32 *)&icode->tram_data_map[tram]) || |
| 586 | put_user(addr, (__user u32 *)&icode->tram_addr_map[tram])) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | return -EFAULT; |
| 588 | } |
| 589 | return 0; |
| 590 | } |
| 591 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 592 | static int snd_emu10k1_code_poke(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 593 | struct snd_emu10k1_fx8010_code *icode, |
| 594 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 595 | { |
| 596 | u32 pc, lo, hi; |
| 597 | |
| 598 | for (pc = 0; pc < (emu->audigy ? 2*1024 : 2*512); pc += 2) { |
| 599 | if (!test_bit(pc / 2, icode->code_valid)) |
| 600 | continue; |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 601 | if (in_kernel) { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 602 | lo = icode->code[pc + 0]; |
| 603 | hi = icode->code[pc + 1]; |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 604 | } else { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 605 | if (get_user(lo, (__user u32 *)&icode->code[pc + 0]) || |
| 606 | get_user(hi, (__user u32 *)&icode->code[pc + 1])) |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 607 | return -EFAULT; |
| 608 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 609 | snd_emu10k1_efx_write(emu, pc + 0, lo); |
| 610 | snd_emu10k1_efx_write(emu, pc + 1, hi); |
| 611 | } |
| 612 | return 0; |
| 613 | } |
| 614 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 615 | static int snd_emu10k1_code_peek(struct snd_emu10k1 *emu, |
| 616 | struct snd_emu10k1_fx8010_code *icode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 617 | { |
| 618 | u32 pc; |
| 619 | |
| 620 | memset(icode->code_valid, 0, sizeof(icode->code_valid)); |
| 621 | for (pc = 0; pc < (emu->audigy ? 2*1024 : 2*512); pc += 2) { |
| 622 | set_bit(pc / 2, icode->code_valid); |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 623 | if (put_user(snd_emu10k1_efx_read(emu, pc + 0), |
| 624 | (__user u32 *)&icode->code[pc + 0])) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 625 | return -EFAULT; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 626 | if (put_user(snd_emu10k1_efx_read(emu, pc + 1), |
| 627 | (__user u32 *)&icode->code[pc + 1])) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 628 | return -EFAULT; |
| 629 | } |
| 630 | return 0; |
| 631 | } |
| 632 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 633 | static struct snd_emu10k1_fx8010_ctl * |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 634 | snd_emu10k1_look_for_ctl(struct snd_emu10k1 *emu, |
| 635 | struct emu10k1_ctl_elem_id *_id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 636 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 637 | struct snd_ctl_elem_id *id = (struct snd_ctl_elem_id *)_id; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 638 | struct snd_emu10k1_fx8010_ctl *ctl; |
| 639 | struct snd_kcontrol *kcontrol; |
Matthias Kaehlcke | c2d7051 | 2007-09-17 14:41:16 +0200 | [diff] [blame] | 640 | |
| 641 | list_for_each_entry(ctl, &emu->fx8010.gpr_ctl, list) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 642 | kcontrol = ctl->kcontrol; |
| 643 | if (kcontrol->id.iface == id->iface && |
| 644 | !strcmp(kcontrol->id.name, id->name) && |
| 645 | kcontrol->id.index == id->index) |
| 646 | return ctl; |
| 647 | } |
| 648 | return NULL; |
| 649 | } |
| 650 | |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 651 | #define MAX_TLV_SIZE 256 |
| 652 | |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 653 | static unsigned int *copy_tlv(const unsigned int __user *_tlv, bool in_kernel) |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 654 | { |
| 655 | unsigned int data[2]; |
| 656 | unsigned int *tlv; |
| 657 | |
| 658 | if (!_tlv) |
| 659 | return NULL; |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 660 | if (in_kernel) |
Takashi Iwai | 6362364 | 2018-07-25 23:00:57 +0200 | [diff] [blame] | 661 | memcpy(data, (__force void *)_tlv, sizeof(data)); |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 662 | else if (copy_from_user(data, _tlv, sizeof(data))) |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 663 | return NULL; |
| 664 | if (data[1] >= MAX_TLV_SIZE) |
| 665 | return NULL; |
Takashi Iwai | 6735e57 | 2008-01-19 10:33:07 +0100 | [diff] [blame] | 666 | tlv = kmalloc(data[1] + sizeof(data), GFP_KERNEL); |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 667 | if (!tlv) |
| 668 | return NULL; |
| 669 | memcpy(tlv, data, sizeof(data)); |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 670 | if (in_kernel) { |
Takashi Iwai | 6362364 | 2018-07-25 23:00:57 +0200 | [diff] [blame] | 671 | memcpy(tlv + 2, (__force void *)(_tlv + 2), data[1]); |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 672 | } else if (copy_from_user(tlv + 2, _tlv + 2, data[1])) { |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 673 | kfree(tlv); |
| 674 | return NULL; |
| 675 | } |
| 676 | return tlv; |
| 677 | } |
| 678 | |
| 679 | static int copy_gctl(struct snd_emu10k1 *emu, |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 680 | struct snd_emu10k1_fx8010_control_gpr *dst, |
| 681 | struct snd_emu10k1_fx8010_control_gpr *src, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 682 | int idx, bool in_kernel) |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 683 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 684 | struct snd_emu10k1_fx8010_control_gpr __user *_src; |
| 685 | struct snd_emu10k1_fx8010_control_old_gpr *octl; |
| 686 | struct snd_emu10k1_fx8010_control_old_gpr __user *_octl; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 687 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 688 | _src = (struct snd_emu10k1_fx8010_control_gpr __user *)src; |
Takashi Iwai | 0b36f2b | 2017-08-18 10:55:10 +0200 | [diff] [blame] | 689 | if (emu->support_tlv) { |
| 690 | if (in_kernel) |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 691 | *dst = src[idx]; |
| 692 | else if (copy_from_user(dst, &_src[idx], sizeof(*src))) |
Takashi Iwai | 0b36f2b | 2017-08-18 10:55:10 +0200 | [diff] [blame] | 693 | return -EFAULT; |
| 694 | return 0; |
| 695 | } |
| 696 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 697 | octl = (struct snd_emu10k1_fx8010_control_old_gpr *)src; |
| 698 | _octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)octl; |
Takashi Iwai | 0b36f2b | 2017-08-18 10:55:10 +0200 | [diff] [blame] | 699 | if (in_kernel) |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 700 | memcpy(dst, &octl[idx], sizeof(*octl)); |
| 701 | else if (copy_from_user(dst, &_octl[idx], sizeof(*octl))) |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 702 | return -EFAULT; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 703 | dst->tlv = NULL; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 704 | return 0; |
| 705 | } |
| 706 | |
| 707 | static int copy_gctl_to_user(struct snd_emu10k1 *emu, |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 708 | struct snd_emu10k1_fx8010_control_gpr *dst, |
| 709 | struct snd_emu10k1_fx8010_control_gpr *src, |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 710 | int idx) |
| 711 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 712 | struct snd_emu10k1_fx8010_control_gpr __user *_dst; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 713 | struct snd_emu10k1_fx8010_control_old_gpr __user *octl; |
| 714 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 715 | _dst = (struct snd_emu10k1_fx8010_control_gpr __user *)dst; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 716 | if (emu->support_tlv) |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 717 | return copy_to_user(&_dst[idx], src, sizeof(*src)); |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 718 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 719 | octl = (struct snd_emu10k1_fx8010_control_old_gpr __user *)dst; |
| 720 | return copy_to_user(&octl[idx], src, sizeof(*octl)); |
| 721 | } |
| 722 | |
| 723 | static int copy_ctl_elem_id(const struct emu10k1_ctl_elem_id *list, int i, |
| 724 | struct emu10k1_ctl_elem_id *ret, bool in_kernel) |
| 725 | { |
| 726 | struct emu10k1_ctl_elem_id __user *_id = |
| 727 | (struct emu10k1_ctl_elem_id __user *)&list[i]; |
| 728 | |
| 729 | if (in_kernel) |
| 730 | *ret = list[i]; |
| 731 | else if (copy_from_user(ret, _id, sizeof(*ret))) |
| 732 | return -EFAULT; |
| 733 | return 0; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 734 | } |
| 735 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 736 | static int snd_emu10k1_verify_controls(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 737 | struct snd_emu10k1_fx8010_code *icode, |
| 738 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 739 | { |
| 740 | unsigned int i; |
Takashi Iwai | 2e46886 | 2019-12-20 16:34:11 +0100 | [diff] [blame] | 741 | struct emu10k1_ctl_elem_id id; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 742 | struct snd_emu10k1_fx8010_control_gpr *gctl; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 743 | struct snd_ctl_elem_id *gctl_id; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 744 | int err; |
| 745 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 746 | for (i = 0; i < icode->gpr_del_control_count; i++) { |
| 747 | err = copy_ctl_elem_id(icode->gpr_del_controls, i, &id, |
| 748 | in_kernel); |
| 749 | if (err < 0) |
| 750 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 751 | if (snd_emu10k1_look_for_ctl(emu, &id) == NULL) |
| 752 | return -ENOENT; |
| 753 | } |
| 754 | gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); |
| 755 | if (! gctl) |
| 756 | return -ENOMEM; |
| 757 | err = 0; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 758 | for (i = 0; i < icode->gpr_add_control_count; i++) { |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 759 | if (copy_gctl(emu, gctl, icode->gpr_add_controls, i, |
| 760 | in_kernel)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 761 | err = -EFAULT; |
| 762 | goto __error; |
| 763 | } |
| 764 | if (snd_emu10k1_look_for_ctl(emu, &gctl->id)) |
| 765 | continue; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 766 | gctl_id = (struct snd_ctl_elem_id *)&gctl->id; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 767 | down_read(&emu->card->controls_rwsem); |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 768 | if (snd_ctl_find_id(emu->card, gctl_id)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 769 | up_read(&emu->card->controls_rwsem); |
| 770 | err = -EEXIST; |
| 771 | goto __error; |
| 772 | } |
| 773 | up_read(&emu->card->controls_rwsem); |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 774 | if (gctl_id->iface != SNDRV_CTL_ELEM_IFACE_MIXER && |
| 775 | gctl_id->iface != SNDRV_CTL_ELEM_IFACE_PCM) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 776 | err = -EINVAL; |
| 777 | goto __error; |
| 778 | } |
| 779 | } |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 780 | for (i = 0; i < icode->gpr_list_control_count; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 781 | /* FIXME: we need to check the WRITE access */ |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 782 | if (copy_gctl(emu, gctl, icode->gpr_list_controls, i, |
| 783 | in_kernel)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 784 | err = -EFAULT; |
| 785 | goto __error; |
| 786 | } |
| 787 | } |
| 788 | __error: |
| 789 | kfree(gctl); |
| 790 | return err; |
| 791 | } |
| 792 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 793 | static void snd_emu10k1_ctl_private_free(struct snd_kcontrol *kctl) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 794 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 795 | struct snd_emu10k1_fx8010_ctl *ctl; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 796 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 797 | ctl = (struct snd_emu10k1_fx8010_ctl *) kctl->private_value; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 798 | kctl->private_value = 0; |
| 799 | list_del(&ctl->list); |
| 800 | kfree(ctl); |
Markus Elfring | 31604d3 | 2014-11-03 14:54:36 +0100 | [diff] [blame] | 801 | kfree(kctl->tlv.p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 802 | } |
| 803 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 804 | static int snd_emu10k1_add_controls(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 805 | struct snd_emu10k1_fx8010_code *icode, |
| 806 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 807 | { |
| 808 | unsigned int i, j; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 809 | struct snd_emu10k1_fx8010_control_gpr *gctl; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 810 | struct snd_ctl_elem_id *gctl_id; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 811 | struct snd_emu10k1_fx8010_ctl *ctl, *nctl; |
| 812 | struct snd_kcontrol_new knew; |
| 813 | struct snd_kcontrol *kctl; |
| 814 | struct snd_ctl_elem_value *val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 815 | int err = 0; |
| 816 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 817 | val = kmalloc(sizeof(*val), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 818 | gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); |
| 819 | nctl = kmalloc(sizeof(*nctl), GFP_KERNEL); |
| 820 | if (!val || !gctl || !nctl) { |
| 821 | err = -ENOMEM; |
| 822 | goto __error; |
| 823 | } |
| 824 | |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 825 | for (i = 0; i < icode->gpr_add_control_count; i++) { |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 826 | if (copy_gctl(emu, gctl, icode->gpr_add_controls, i, |
| 827 | in_kernel)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 828 | err = -EFAULT; |
| 829 | goto __error; |
| 830 | } |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 831 | gctl_id = (struct snd_ctl_elem_id *)&gctl->id; |
| 832 | if (gctl_id->iface != SNDRV_CTL_ELEM_IFACE_MIXER && |
| 833 | gctl_id->iface != SNDRV_CTL_ELEM_IFACE_PCM) { |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 834 | err = -EINVAL; |
| 835 | goto __error; |
| 836 | } |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 837 | if (!*gctl_id->name) { |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 838 | err = -EINVAL; |
| 839 | goto __error; |
| 840 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 841 | ctl = snd_emu10k1_look_for_ctl(emu, &gctl->id); |
| 842 | memset(&knew, 0, sizeof(knew)); |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 843 | knew.iface = gctl_id->iface; |
| 844 | knew.name = gctl_id->name; |
| 845 | knew.index = gctl_id->index; |
| 846 | knew.device = gctl_id->device; |
| 847 | knew.subdevice = gctl_id->subdevice; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 848 | knew.info = snd_emu10k1_gpr_ctl_info; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 849 | knew.tlv.p = copy_tlv((const unsigned int __user *)gctl->tlv, in_kernel); |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 850 | if (knew.tlv.p) |
James Courtier-Dutton | 31508f8 | 2006-07-22 17:02:10 +0100 | [diff] [blame] | 851 | knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | |
| 852 | SNDRV_CTL_ELEM_ACCESS_TLV_READ; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 853 | knew.get = snd_emu10k1_gpr_ctl_get; |
| 854 | knew.put = snd_emu10k1_gpr_ctl_put; |
| 855 | memset(nctl, 0, sizeof(*nctl)); |
| 856 | nctl->vcount = gctl->vcount; |
| 857 | nctl->count = gctl->count; |
| 858 | for (j = 0; j < 32; j++) { |
| 859 | nctl->gpr[j] = gctl->gpr[j]; |
| 860 | nctl->value[j] = ~gctl->value[j]; /* inverted, we want to write new value in gpr_ctl_put() */ |
| 861 | val->value.integer.value[j] = gctl->value[j]; |
| 862 | } |
| 863 | nctl->min = gctl->min; |
| 864 | nctl->max = gctl->max; |
| 865 | nctl->translation = gctl->translation; |
| 866 | if (ctl == NULL) { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 867 | ctl = kmalloc(sizeof(*ctl), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 868 | if (ctl == NULL) { |
| 869 | err = -ENOMEM; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 870 | kfree(knew.tlv.p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 871 | goto __error; |
| 872 | } |
| 873 | knew.private_value = (unsigned long)ctl; |
| 874 | *ctl = *nctl; |
Takashi Iwai | 12bda10 | 2021-06-08 16:05:14 +0200 | [diff] [blame] | 875 | kctl = snd_ctl_new1(&knew, emu); |
| 876 | err = snd_ctl_add(emu->card, kctl); |
| 877 | if (err < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 878 | kfree(ctl); |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 879 | kfree(knew.tlv.p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 880 | goto __error; |
| 881 | } |
| 882 | kctl->private_free = snd_emu10k1_ctl_private_free; |
| 883 | ctl->kcontrol = kctl; |
| 884 | list_add_tail(&ctl->list, &emu->fx8010.gpr_ctl); |
| 885 | } else { |
| 886 | /* overwrite */ |
| 887 | nctl->list = ctl->list; |
| 888 | nctl->kcontrol = ctl->kcontrol; |
| 889 | *ctl = *nctl; |
| 890 | snd_ctl_notify(emu->card, SNDRV_CTL_EVENT_MASK_VALUE | |
| 891 | SNDRV_CTL_EVENT_MASK_INFO, &ctl->kcontrol->id); |
| 892 | } |
| 893 | snd_emu10k1_gpr_ctl_put(ctl->kcontrol, val); |
| 894 | } |
| 895 | __error: |
| 896 | kfree(nctl); |
| 897 | kfree(gctl); |
| 898 | kfree(val); |
| 899 | return err; |
| 900 | } |
| 901 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 902 | static int snd_emu10k1_del_controls(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 903 | struct snd_emu10k1_fx8010_code *icode, |
| 904 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 905 | { |
| 906 | unsigned int i; |
Takashi Iwai | 2e46886 | 2019-12-20 16:34:11 +0100 | [diff] [blame] | 907 | struct emu10k1_ctl_elem_id id; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 908 | struct snd_emu10k1_fx8010_ctl *ctl; |
| 909 | struct snd_card *card = emu->card; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 910 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 911 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 912 | for (i = 0; i < icode->gpr_del_control_count; i++) { |
| 913 | err = copy_ctl_elem_id(icode->gpr_del_controls, i, &id, |
| 914 | in_kernel); |
| 915 | if (err < 0) |
| 916 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 917 | down_write(&card->controls_rwsem); |
| 918 | ctl = snd_emu10k1_look_for_ctl(emu, &id); |
| 919 | if (ctl) |
| 920 | snd_ctl_remove(card, ctl->kcontrol); |
| 921 | up_write(&card->controls_rwsem); |
| 922 | } |
| 923 | return 0; |
| 924 | } |
| 925 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 926 | static int snd_emu10k1_list_controls(struct snd_emu10k1 *emu, |
| 927 | struct snd_emu10k1_fx8010_code *icode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 928 | { |
| 929 | unsigned int i = 0, j; |
| 930 | unsigned int total = 0; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 931 | struct snd_emu10k1_fx8010_control_gpr *gctl; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 932 | struct snd_emu10k1_fx8010_ctl *ctl; |
| 933 | struct snd_ctl_elem_id *id; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 934 | |
| 935 | gctl = kmalloc(sizeof(*gctl), GFP_KERNEL); |
| 936 | if (! gctl) |
| 937 | return -ENOMEM; |
| 938 | |
Matthias Kaehlcke | c2d7051 | 2007-09-17 14:41:16 +0200 | [diff] [blame] | 939 | list_for_each_entry(ctl, &emu->fx8010.gpr_ctl, list) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 940 | total++; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 941 | if (icode->gpr_list_controls && |
| 942 | i < icode->gpr_list_control_count) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 943 | memset(gctl, 0, sizeof(*gctl)); |
| 944 | id = &ctl->kcontrol->id; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 945 | gctl->id.iface = (__force int)id->iface; |
Joe Perches | 75b1a8f | 2021-01-04 09:17:34 -0800 | [diff] [blame] | 946 | strscpy(gctl->id.name, id->name, sizeof(gctl->id.name)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 947 | gctl->id.index = id->index; |
| 948 | gctl->id.device = id->device; |
| 949 | gctl->id.subdevice = id->subdevice; |
| 950 | gctl->vcount = ctl->vcount; |
| 951 | gctl->count = ctl->count; |
| 952 | for (j = 0; j < 32; j++) { |
| 953 | gctl->gpr[j] = ctl->gpr[j]; |
| 954 | gctl->value[j] = ctl->value[j]; |
| 955 | } |
| 956 | gctl->min = ctl->min; |
| 957 | gctl->max = ctl->max; |
| 958 | gctl->translation = ctl->translation; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 959 | if (copy_gctl_to_user(emu, icode->gpr_list_controls, |
| 960 | gctl, i)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 961 | kfree(gctl); |
| 962 | return -EFAULT; |
| 963 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 964 | i++; |
| 965 | } |
| 966 | } |
| 967 | icode->gpr_list_control_total = total; |
| 968 | kfree(gctl); |
| 969 | return 0; |
| 970 | } |
| 971 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 972 | static int snd_emu10k1_icode_poke(struct snd_emu10k1 *emu, |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 973 | struct snd_emu10k1_fx8010_code *icode, |
| 974 | bool in_kernel) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 975 | { |
| 976 | int err = 0; |
| 977 | |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 978 | mutex_lock(&emu->fx8010.lock); |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 979 | err = snd_emu10k1_verify_controls(emu, icode, in_kernel); |
| 980 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 981 | goto __error; |
Joe Perches | 75b1a8f | 2021-01-04 09:17:34 -0800 | [diff] [blame] | 982 | strscpy(emu->fx8010.name, icode->name, sizeof(emu->fx8010.name)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 983 | /* stop FX processor - this may be dangerous, but it's better to miss |
| 984 | some samples than generate wrong ones - [jk] */ |
| 985 | if (emu->audigy) |
| 986 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP); |
| 987 | else |
| 988 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP); |
| 989 | /* ok, do the main job */ |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 990 | err = snd_emu10k1_del_controls(emu, icode, in_kernel); |
| 991 | if (err < 0) |
| 992 | goto __error; |
| 993 | err = snd_emu10k1_gpr_poke(emu, icode, in_kernel); |
| 994 | if (err < 0) |
| 995 | goto __error; |
| 996 | err = snd_emu10k1_tram_poke(emu, icode, in_kernel); |
| 997 | if (err < 0) |
| 998 | goto __error; |
| 999 | err = snd_emu10k1_code_poke(emu, icode, in_kernel); |
| 1000 | if (err < 0) |
| 1001 | goto __error; |
| 1002 | err = snd_emu10k1_add_controls(emu, icode, in_kernel); |
| 1003 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1004 | goto __error; |
| 1005 | /* start FX processor when the DSP code is updated */ |
| 1006 | if (emu->audigy) |
| 1007 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); |
| 1008 | else |
| 1009 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); |
| 1010 | __error: |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1011 | mutex_unlock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1012 | return err; |
| 1013 | } |
| 1014 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1015 | static int snd_emu10k1_icode_peek(struct snd_emu10k1 *emu, |
| 1016 | struct snd_emu10k1_fx8010_code *icode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1017 | { |
| 1018 | int err; |
| 1019 | |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1020 | mutex_lock(&emu->fx8010.lock); |
Joe Perches | 75b1a8f | 2021-01-04 09:17:34 -0800 | [diff] [blame] | 1021 | strscpy(icode->name, emu->fx8010.name, sizeof(icode->name)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1022 | /* ok, do the main job */ |
| 1023 | err = snd_emu10k1_gpr_peek(emu, icode); |
| 1024 | if (err >= 0) |
| 1025 | err = snd_emu10k1_tram_peek(emu, icode); |
| 1026 | if (err >= 0) |
| 1027 | err = snd_emu10k1_code_peek(emu, icode); |
| 1028 | if (err >= 0) |
| 1029 | err = snd_emu10k1_list_controls(emu, icode); |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1030 | mutex_unlock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1031 | return err; |
| 1032 | } |
| 1033 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1034 | static int snd_emu10k1_ipcm_poke(struct snd_emu10k1 *emu, |
| 1035 | struct snd_emu10k1_fx8010_pcm_rec *ipcm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1036 | { |
| 1037 | unsigned int i; |
| 1038 | int err = 0; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1039 | struct snd_emu10k1_fx8010_pcm *pcm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1040 | |
| 1041 | if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT) |
| 1042 | return -EINVAL; |
Gustavo A. R. Silva | 5ae4f61 | 2018-12-18 11:52:16 -0600 | [diff] [blame] | 1043 | ipcm->substream = array_index_nospec(ipcm->substream, |
| 1044 | EMU10K1_FX8010_PCM_COUNT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1045 | if (ipcm->channels > 32) |
| 1046 | return -EINVAL; |
| 1047 | pcm = &emu->fx8010.pcm[ipcm->substream]; |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1048 | mutex_lock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1049 | spin_lock_irq(&emu->reg_lock); |
| 1050 | if (pcm->opened) { |
| 1051 | err = -EBUSY; |
| 1052 | goto __error; |
| 1053 | } |
| 1054 | if (ipcm->channels == 0) { /* remove */ |
| 1055 | pcm->valid = 0; |
| 1056 | } else { |
| 1057 | /* FIXME: we need to add universal code to the PCM transfer routine */ |
| 1058 | if (ipcm->channels != 2) { |
| 1059 | err = -EINVAL; |
| 1060 | goto __error; |
| 1061 | } |
| 1062 | pcm->valid = 1; |
| 1063 | pcm->opened = 0; |
| 1064 | pcm->channels = ipcm->channels; |
| 1065 | pcm->tram_start = ipcm->tram_start; |
| 1066 | pcm->buffer_size = ipcm->buffer_size; |
| 1067 | pcm->gpr_size = ipcm->gpr_size; |
| 1068 | pcm->gpr_count = ipcm->gpr_count; |
| 1069 | pcm->gpr_tmpcount = ipcm->gpr_tmpcount; |
| 1070 | pcm->gpr_ptr = ipcm->gpr_ptr; |
| 1071 | pcm->gpr_trigger = ipcm->gpr_trigger; |
| 1072 | pcm->gpr_running = ipcm->gpr_running; |
| 1073 | for (i = 0; i < pcm->channels; i++) |
| 1074 | pcm->etram[i] = ipcm->etram[i]; |
| 1075 | } |
| 1076 | __error: |
| 1077 | spin_unlock_irq(&emu->reg_lock); |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1078 | mutex_unlock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1079 | return err; |
| 1080 | } |
| 1081 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1082 | static int snd_emu10k1_ipcm_peek(struct snd_emu10k1 *emu, |
| 1083 | struct snd_emu10k1_fx8010_pcm_rec *ipcm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1084 | { |
| 1085 | unsigned int i; |
| 1086 | int err = 0; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1087 | struct snd_emu10k1_fx8010_pcm *pcm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1088 | |
| 1089 | if (ipcm->substream >= EMU10K1_FX8010_PCM_COUNT) |
| 1090 | return -EINVAL; |
Gustavo A. R. Silva | 5ae4f61 | 2018-12-18 11:52:16 -0600 | [diff] [blame] | 1091 | ipcm->substream = array_index_nospec(ipcm->substream, |
| 1092 | EMU10K1_FX8010_PCM_COUNT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1093 | pcm = &emu->fx8010.pcm[ipcm->substream]; |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1094 | mutex_lock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1095 | spin_lock_irq(&emu->reg_lock); |
| 1096 | ipcm->channels = pcm->channels; |
| 1097 | ipcm->tram_start = pcm->tram_start; |
| 1098 | ipcm->buffer_size = pcm->buffer_size; |
| 1099 | ipcm->gpr_size = pcm->gpr_size; |
| 1100 | ipcm->gpr_ptr = pcm->gpr_ptr; |
| 1101 | ipcm->gpr_count = pcm->gpr_count; |
| 1102 | ipcm->gpr_tmpcount = pcm->gpr_tmpcount; |
| 1103 | ipcm->gpr_trigger = pcm->gpr_trigger; |
| 1104 | ipcm->gpr_running = pcm->gpr_running; |
| 1105 | for (i = 0; i < pcm->channels; i++) |
| 1106 | ipcm->etram[i] = pcm->etram[i]; |
| 1107 | ipcm->res1 = ipcm->res2 = 0; |
| 1108 | ipcm->pad = 0; |
| 1109 | spin_unlock_irq(&emu->reg_lock); |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 1110 | mutex_unlock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1111 | return err; |
| 1112 | } |
| 1113 | |
Mikael Magnusson | edf8e45 | 2005-09-13 11:32:58 +0200 | [diff] [blame] | 1114 | #define SND_EMU10K1_GPR_CONTROLS 44 |
| 1115 | #define SND_EMU10K1_INPUTS 12 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1116 | #define SND_EMU10K1_PLAYBACK_CHANNELS 8 |
| 1117 | #define SND_EMU10K1_CAPTURE_CHANNELS 4 |
| 1118 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1119 | static void |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1120 | snd_emu10k1_init_mono_control(struct snd_emu10k1_fx8010_control_gpr *ctl, |
| 1121 | const char *name, int gpr, int defval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1122 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1123 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1124 | strcpy(ctl->id.name, name); |
| 1125 | ctl->vcount = ctl->count = 1; |
| 1126 | ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; |
Clemens Ladisch | 4daf7a0 | 2010-05-25 09:04:49 +0200 | [diff] [blame] | 1127 | if (high_res_gpr_volume) { |
| 1128 | ctl->min = 0; |
| 1129 | ctl->max = 0x7fffffff; |
| 1130 | ctl->tlv = snd_emu10k1_db_linear; |
| 1131 | ctl->translation = EMU10K1_GPR_TRANSLATION_NONE; |
| 1132 | } else { |
| 1133 | ctl->min = 0; |
| 1134 | ctl->max = 100; |
| 1135 | ctl->tlv = snd_emu10k1_db_scale1; |
| 1136 | ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100; |
| 1137 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1138 | } |
| 1139 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1140 | static void |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1141 | snd_emu10k1_init_stereo_control(struct snd_emu10k1_fx8010_control_gpr *ctl, |
| 1142 | const char *name, int gpr, int defval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1143 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1144 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1145 | strcpy(ctl->id.name, name); |
| 1146 | ctl->vcount = ctl->count = 2; |
| 1147 | ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; |
| 1148 | ctl->gpr[1] = gpr + 1; ctl->value[1] = defval; |
Clemens Ladisch | 4daf7a0 | 2010-05-25 09:04:49 +0200 | [diff] [blame] | 1149 | if (high_res_gpr_volume) { |
| 1150 | ctl->min = 0; |
| 1151 | ctl->max = 0x7fffffff; |
| 1152 | ctl->tlv = snd_emu10k1_db_linear; |
| 1153 | ctl->translation = EMU10K1_GPR_TRANSLATION_NONE; |
| 1154 | } else { |
| 1155 | ctl->min = 0; |
| 1156 | ctl->max = 100; |
| 1157 | ctl->tlv = snd_emu10k1_db_scale1; |
| 1158 | ctl->translation = EMU10K1_GPR_TRANSLATION_TABLE100; |
| 1159 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1160 | } |
| 1161 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1162 | static void |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1163 | snd_emu10k1_init_mono_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, |
| 1164 | const char *name, int gpr, int defval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1165 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1166 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1167 | strcpy(ctl->id.name, name); |
| 1168 | ctl->vcount = ctl->count = 1; |
| 1169 | ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; |
| 1170 | ctl->min = 0; |
| 1171 | ctl->max = 1; |
| 1172 | ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF; |
| 1173 | } |
| 1174 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1175 | static void |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1176 | snd_emu10k1_init_stereo_onoff_control(struct snd_emu10k1_fx8010_control_gpr *ctl, |
| 1177 | const char *name, int gpr, int defval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1178 | { |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1179 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1180 | strcpy(ctl->id.name, name); |
| 1181 | ctl->vcount = ctl->count = 2; |
| 1182 | ctl->gpr[0] = gpr + 0; ctl->value[0] = defval; |
| 1183 | ctl->gpr[1] = gpr + 1; ctl->value[1] = defval; |
| 1184 | ctl->min = 0; |
| 1185 | ctl->max = 1; |
| 1186 | ctl->translation = EMU10K1_GPR_TRANSLATION_ONOFF; |
| 1187 | } |
| 1188 | |
Pavel Hofman | 13d4570 | 2007-06-11 12:21:20 +0200 | [diff] [blame] | 1189 | /* |
| 1190 | * Used for emu1010 - conversion from 32-bit capture inputs from HANA |
| 1191 | * to 2 x 16-bit registers in audigy - their values are read via DMA. |
| 1192 | * Conversion is performed by Audigy DSP instructions of FX8010. |
| 1193 | */ |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1194 | static int snd_emu10k1_audigy_dsp_convert_32_to_2x16( |
| 1195 | struct snd_emu10k1_fx8010_code *icode, |
| 1196 | u32 *ptr, int tmp, int bit_shifter16, |
| 1197 | int reg_in, int reg_out) |
| 1198 | { |
| 1199 | A_OP(icode, ptr, iACC3, A_GPR(tmp + 1), reg_in, A_C_00000000, A_C_00000000); |
| 1200 | A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp + 1), A_GPR(bit_shifter16 - 1), A_C_00000000); |
| 1201 | A_OP(icode, ptr, iTSTNEG, A_GPR(tmp + 2), A_GPR(tmp), A_C_80000000, A_GPR(bit_shifter16 - 2)); |
| 1202 | A_OP(icode, ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_C_80000000, A_C_00000000); |
| 1203 | A_OP(icode, ptr, iANDXOR, A_GPR(tmp), A_GPR(tmp), A_GPR(bit_shifter16 - 3), A_C_00000000); |
| 1204 | A_OP(icode, ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A_GPR(tmp), A_C_00010000); |
| 1205 | A_OP(icode, ptr, iANDXOR, reg_out, A_GPR(tmp), A_C_ffffffff, A_GPR(tmp + 2)); |
| 1206 | A_OP(icode, ptr, iACC3, reg_out + 1, A_GPR(tmp + 1), A_C_00000000, A_C_00000000); |
| 1207 | return 1; |
| 1208 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1209 | |
| 1210 | /* |
| 1211 | * initial DSP configuration for Audigy |
| 1212 | */ |
| 1213 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1214 | static int _snd_emu10k1_audigy_init_efx(struct snd_emu10k1 *emu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1215 | { |
| 1216 | int err, i, z, gpr, nctl; |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1217 | int bit_shifter16; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1218 | const int playback = 10; |
| 1219 | const int capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2); /* we reserve 10 voices */ |
| 1220 | const int stereo_mix = capture + 2; |
| 1221 | const int tmp = 0x88; |
| 1222 | u32 ptr; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1223 | struct snd_emu10k1_fx8010_code *icode = NULL; |
| 1224 | struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1225 | u32 *gpr_map; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1226 | |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1227 | err = -ENOMEM; |
| 1228 | icode = kzalloc(sizeof(*icode), GFP_KERNEL); |
| 1229 | if (!icode) |
| 1230 | return err; |
| 1231 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1232 | icode->gpr_map = kcalloc(512 + 256 + 256 + 2 * 1024, |
| 1233 | sizeof(u_int32_t), GFP_KERNEL); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1234 | if (!icode->gpr_map) |
| 1235 | goto __err_gpr; |
| 1236 | controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, |
| 1237 | sizeof(*controls), GFP_KERNEL); |
| 1238 | if (!controls) |
| 1239 | goto __err_ctrls; |
| 1240 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1241 | gpr_map = icode->gpr_map; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1242 | |
| 1243 | icode->tram_data_map = icode->gpr_map + 512; |
| 1244 | icode->tram_addr_map = icode->tram_data_map + 256; |
| 1245 | icode->code = icode->tram_addr_map + 256; |
| 1246 | |
| 1247 | /* clear free GPRs */ |
| 1248 | for (i = 0; i < 512; i++) |
| 1249 | set_bit(i, icode->gpr_valid); |
| 1250 | |
| 1251 | /* clear TRAM data & address lines */ |
| 1252 | for (i = 0; i < 256; i++) |
| 1253 | set_bit(i, icode->tram_valid); |
| 1254 | |
| 1255 | strcpy(icode->name, "Audigy DSP code for ALSA"); |
| 1256 | ptr = 0; |
| 1257 | nctl = 0; |
| 1258 | gpr = stereo_mix + 10; |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1259 | gpr_map[gpr++] = 0x00007fff; |
| 1260 | gpr_map[gpr++] = 0x00008000; |
| 1261 | gpr_map[gpr++] = 0x0000ffff; |
| 1262 | bit_shifter16 = gpr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1263 | |
| 1264 | /* stop FX processor */ |
| 1265 | snd_emu10k1_ptr_write(emu, A_DBG, 0, (emu->fx8010.dbg = 0) | A_DBG_SINGLE_STEP); |
| 1266 | |
James Courtier-Dutton | 19b99fb | 2005-12-04 18:03:03 +0100 | [diff] [blame] | 1267 | #if 1 |
Pavel Hofman | 13d4570 | 2007-06-11 12:21:20 +0200 | [diff] [blame] | 1268 | /* PCM front Playback Volume (independent from stereo mix) |
| 1269 | * playback = 0 + ( gpr * FXBUS_PCM_LEFT_FRONT >> 31) |
| 1270 | * where gpr contains attenuation from corresponding mixer control |
| 1271 | * (snd_emu10k1_init_stereo_control) |
| 1272 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1273 | A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_FRONT)); |
| 1274 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_FRONT)); |
| 1275 | snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Front Playback Volume", gpr, 100); |
| 1276 | gpr += 2; |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1277 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1278 | /* PCM Surround Playback (independent from stereo mix) */ |
| 1279 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_REAR)); |
| 1280 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_REAR)); |
| 1281 | snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Surround Playback Volume", gpr, 100); |
| 1282 | gpr += 2; |
| 1283 | |
| 1284 | /* PCM Side Playback (independent from stereo mix) */ |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1285 | if (emu->card_capabilities->spk71) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1286 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT_SIDE)); |
| 1287 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT_SIDE)); |
| 1288 | snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Side Playback Volume", gpr, 100); |
| 1289 | gpr += 2; |
| 1290 | } |
| 1291 | |
| 1292 | /* PCM Center Playback (independent from stereo mix) */ |
| 1293 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_CENTER)); |
| 1294 | snd_emu10k1_init_mono_control(&controls[nctl++], "PCM Center Playback Volume", gpr, 100); |
| 1295 | gpr++; |
| 1296 | |
| 1297 | /* PCM LFE Playback (independent from stereo mix) */ |
| 1298 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LFE)); |
| 1299 | snd_emu10k1_init_mono_control(&controls[nctl++], "PCM LFE Playback Volume", gpr, 100); |
| 1300 | gpr++; |
| 1301 | |
| 1302 | /* |
| 1303 | * Stereo Mix |
| 1304 | */ |
| 1305 | /* Wave (PCM) Playback Volume (will be renamed later) */ |
| 1306 | A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT)); |
| 1307 | A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT)); |
| 1308 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Wave Playback Volume", gpr, 100); |
| 1309 | gpr += 2; |
| 1310 | |
| 1311 | /* Synth Playback */ |
| 1312 | A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+0), A_GPR(stereo_mix+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT)); |
| 1313 | A_OP(icode, &ptr, iMAC0, A_GPR(stereo_mix+1), A_GPR(stereo_mix+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT)); |
| 1314 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Playback Volume", gpr, 100); |
| 1315 | gpr += 2; |
| 1316 | |
| 1317 | /* Wave (PCM) Capture */ |
| 1318 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_C_00000000, A_GPR(gpr), A_FXBUS(FXBUS_PCM_LEFT)); |
| 1319 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_C_00000000, A_GPR(gpr+1), A_FXBUS(FXBUS_PCM_RIGHT)); |
| 1320 | snd_emu10k1_init_stereo_control(&controls[nctl++], "PCM Capture Volume", gpr, 0); |
| 1321 | gpr += 2; |
| 1322 | |
| 1323 | /* Synth Capture */ |
| 1324 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_FXBUS(FXBUS_MIDI_LEFT)); |
| 1325 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_FXBUS(FXBUS_MIDI_RIGHT)); |
| 1326 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Synth Capture Volume", gpr, 0); |
| 1327 | gpr += 2; |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1328 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1329 | /* |
| 1330 | * inputs |
| 1331 | */ |
| 1332 | #define A_ADD_VOLUME_IN(var,vol,input) \ |
| 1333 | A_OP(icode, &ptr, iMAC0, A_GPR(var), A_GPR(var), A_GPR(vol), A_EXTIN(input)) |
| 1334 | |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1335 | /* emu1212 DSP 0 and DSP 1 Capture */ |
James Courtier-Dutton | 190d2c4 | 2007-11-04 14:08:26 +0000 | [diff] [blame] | 1336 | if (emu->card_capabilities->emu_model) { |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1337 | if (emu->card_capabilities->ca0108_chip) { |
| 1338 | /* Note:JCD:No longer bit shift lower 16bits to upper 16bits of 32bit value. */ |
| 1339 | A_OP(icode, &ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A3_EMU32IN(0x0), A_C_00000001); |
| 1340 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_GPR(tmp)); |
| 1341 | A_OP(icode, &ptr, iMACINT0, A_GPR(tmp), A_C_00000000, A3_EMU32IN(0x1), A_C_00000001); |
| 1342 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr), A_GPR(tmp)); |
| 1343 | } else { |
| 1344 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+0), A_GPR(capture+0), A_GPR(gpr), A_P16VIN(0x0)); |
| 1345 | A_OP(icode, &ptr, iMAC0, A_GPR(capture+1), A_GPR(capture+1), A_GPR(gpr+1), A_P16VIN(0x1)); |
| 1346 | } |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1347 | snd_emu10k1_init_stereo_control(&controls[nctl++], "EMU Capture Volume", gpr, 0); |
| 1348 | gpr += 2; |
| 1349 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1350 | /* AC'97 Playback Volume - used only for mic (renamed later) */ |
| 1351 | A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AC97_L); |
| 1352 | A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AC97_R); |
| 1353 | snd_emu10k1_init_stereo_control(&controls[nctl++], "AMic Playback Volume", gpr, 0); |
| 1354 | gpr += 2; |
| 1355 | /* AC'97 Capture Volume - used only for mic */ |
| 1356 | A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AC97_L); |
| 1357 | A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AC97_R); |
| 1358 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Mic Capture Volume", gpr, 0); |
| 1359 | gpr += 2; |
| 1360 | |
| 1361 | /* mic capture buffer */ |
| 1362 | A_OP(icode, &ptr, iINTERP, A_EXTOUT(A_EXTOUT_MIC_CAP), A_EXTIN(A_EXTIN_AC97_L), 0xcd, A_EXTIN(A_EXTIN_AC97_R)); |
| 1363 | |
| 1364 | /* Audigy CD Playback Volume */ |
| 1365 | A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_SPDIF_CD_L); |
| 1366 | A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_SPDIF_CD_R); |
| 1367 | snd_emu10k1_init_stereo_control(&controls[nctl++], |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1368 | emu->card_capabilities->ac97_chip ? "Audigy CD Playback Volume" : "CD Playback Volume", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1369 | gpr, 0); |
| 1370 | gpr += 2; |
| 1371 | /* Audigy CD Capture Volume */ |
| 1372 | A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_SPDIF_CD_L); |
| 1373 | A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_SPDIF_CD_R); |
| 1374 | snd_emu10k1_init_stereo_control(&controls[nctl++], |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1375 | emu->card_capabilities->ac97_chip ? "Audigy CD Capture Volume" : "CD Capture Volume", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1376 | gpr, 0); |
| 1377 | gpr += 2; |
| 1378 | |
| 1379 | /* Optical SPDIF Playback Volume */ |
| 1380 | A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_OPT_SPDIF_L); |
| 1381 | A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_OPT_SPDIF_R); |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 1382 | snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",PLAYBACK,VOLUME), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1383 | gpr += 2; |
| 1384 | /* Optical SPDIF Capture Volume */ |
| 1385 | A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_OPT_SPDIF_L); |
| 1386 | A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_OPT_SPDIF_R); |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 1387 | snd_emu10k1_init_stereo_control(&controls[nctl++], SNDRV_CTL_NAME_IEC958("Optical ",CAPTURE,VOLUME), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1388 | gpr += 2; |
| 1389 | |
| 1390 | /* Line2 Playback Volume */ |
| 1391 | A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_LINE2_L); |
| 1392 | A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_LINE2_R); |
| 1393 | snd_emu10k1_init_stereo_control(&controls[nctl++], |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1394 | emu->card_capabilities->ac97_chip ? "Line2 Playback Volume" : "Line Playback Volume", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1395 | gpr, 0); |
| 1396 | gpr += 2; |
| 1397 | /* Line2 Capture Volume */ |
| 1398 | A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_LINE2_L); |
| 1399 | A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_LINE2_R); |
| 1400 | snd_emu10k1_init_stereo_control(&controls[nctl++], |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1401 | emu->card_capabilities->ac97_chip ? "Line2 Capture Volume" : "Line Capture Volume", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1402 | gpr, 0); |
| 1403 | gpr += 2; |
| 1404 | |
| 1405 | /* Philips ADC Playback Volume */ |
| 1406 | A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_ADC_L); |
| 1407 | A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_ADC_R); |
| 1408 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Playback Volume", gpr, 0); |
| 1409 | gpr += 2; |
| 1410 | /* Philips ADC Capture Volume */ |
| 1411 | A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_ADC_L); |
| 1412 | A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_ADC_R); |
| 1413 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Analog Mix Capture Volume", gpr, 0); |
| 1414 | gpr += 2; |
| 1415 | |
| 1416 | /* Aux2 Playback Volume */ |
| 1417 | A_ADD_VOLUME_IN(stereo_mix, gpr, A_EXTIN_AUX2_L); |
| 1418 | A_ADD_VOLUME_IN(stereo_mix+1, gpr+1, A_EXTIN_AUX2_R); |
| 1419 | snd_emu10k1_init_stereo_control(&controls[nctl++], |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1420 | emu->card_capabilities->ac97_chip ? "Aux2 Playback Volume" : "Aux Playback Volume", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1421 | gpr, 0); |
| 1422 | gpr += 2; |
| 1423 | /* Aux2 Capture Volume */ |
| 1424 | A_ADD_VOLUME_IN(capture, gpr, A_EXTIN_AUX2_L); |
| 1425 | A_ADD_VOLUME_IN(capture+1, gpr+1, A_EXTIN_AUX2_R); |
| 1426 | snd_emu10k1_init_stereo_control(&controls[nctl++], |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1427 | emu->card_capabilities->ac97_chip ? "Aux2 Capture Volume" : "Aux Capture Volume", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1428 | gpr, 0); |
| 1429 | gpr += 2; |
| 1430 | |
| 1431 | /* Stereo Mix Front Playback Volume */ |
| 1432 | A_OP(icode, &ptr, iMAC0, A_GPR(playback), A_GPR(playback), A_GPR(gpr), A_GPR(stereo_mix)); |
| 1433 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+1), A_GPR(playback+1), A_GPR(gpr+1), A_GPR(stereo_mix+1)); |
| 1434 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Front Playback Volume", gpr, 100); |
| 1435 | gpr += 2; |
| 1436 | |
| 1437 | /* Stereo Mix Surround Playback */ |
| 1438 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+2), A_GPR(playback+2), A_GPR(gpr), A_GPR(stereo_mix)); |
| 1439 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+3), A_GPR(playback+3), A_GPR(gpr+1), A_GPR(stereo_mix+1)); |
| 1440 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Surround Playback Volume", gpr, 0); |
| 1441 | gpr += 2; |
| 1442 | |
| 1443 | /* Stereo Mix Center Playback */ |
| 1444 | /* Center = sub = Left/2 + Right/2 */ |
| 1445 | A_OP(icode, &ptr, iINTERP, A_GPR(tmp), A_GPR(stereo_mix), 0xcd, A_GPR(stereo_mix+1)); |
| 1446 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+4), A_GPR(playback+4), A_GPR(gpr), A_GPR(tmp)); |
| 1447 | snd_emu10k1_init_mono_control(&controls[nctl++], "Center Playback Volume", gpr, 0); |
| 1448 | gpr++; |
| 1449 | |
| 1450 | /* Stereo Mix LFE Playback */ |
| 1451 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+5), A_GPR(playback+5), A_GPR(gpr), A_GPR(tmp)); |
| 1452 | snd_emu10k1_init_mono_control(&controls[nctl++], "LFE Playback Volume", gpr, 0); |
| 1453 | gpr++; |
| 1454 | |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1455 | if (emu->card_capabilities->spk71) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1456 | /* Stereo Mix Side Playback */ |
| 1457 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+6), A_GPR(playback+6), A_GPR(gpr), A_GPR(stereo_mix)); |
| 1458 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+7), A_GPR(playback+7), A_GPR(gpr+1), A_GPR(stereo_mix+1)); |
| 1459 | snd_emu10k1_init_stereo_control(&controls[nctl++], "Side Playback Volume", gpr, 0); |
| 1460 | gpr += 2; |
| 1461 | } |
| 1462 | |
| 1463 | /* |
| 1464 | * outputs |
| 1465 | */ |
| 1466 | #define A_PUT_OUTPUT(out,src) A_OP(icode, &ptr, iACC3, A_EXTOUT(out), A_C_00000000, A_C_00000000, A_GPR(src)) |
| 1467 | #define A_PUT_STEREO_OUTPUT(out1,out2,src) \ |
| 1468 | {A_PUT_OUTPUT(out1,src); A_PUT_OUTPUT(out2,src+1);} |
| 1469 | |
| 1470 | #define _A_SWITCH(icode, ptr, dst, src, sw) \ |
| 1471 | A_OP((icode), ptr, iMACINT0, dst, A_C_00000000, src, sw); |
| 1472 | #define A_SWITCH(icode, ptr, dst, src, sw) \ |
| 1473 | _A_SWITCH(icode, ptr, A_GPR(dst), A_GPR(src), A_GPR(sw)) |
| 1474 | #define _A_SWITCH_NEG(icode, ptr, dst, src) \ |
| 1475 | A_OP((icode), ptr, iANDXOR, dst, src, A_C_00000001, A_C_00000001); |
| 1476 | #define A_SWITCH_NEG(icode, ptr, dst, src) \ |
| 1477 | _A_SWITCH_NEG(icode, ptr, A_GPR(dst), A_GPR(src)) |
| 1478 | |
| 1479 | |
| 1480 | /* |
| 1481 | * Process tone control |
| 1482 | */ |
| 1483 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), A_GPR(playback + 0), A_C_00000000, A_C_00000000); /* left */ |
| 1484 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), A_GPR(playback + 1), A_C_00000000, A_C_00000000); /* right */ |
| 1485 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2), A_GPR(playback + 2), A_C_00000000, A_C_00000000); /* rear left */ |
| 1486 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 3), A_GPR(playback + 3), A_C_00000000, A_C_00000000); /* rear right */ |
| 1487 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), A_GPR(playback + 4), A_C_00000000, A_C_00000000); /* center */ |
| 1488 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), A_GPR(playback + 5), A_C_00000000, A_C_00000000); /* LFE */ |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1489 | if (emu->card_capabilities->spk71) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1490 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 6), A_GPR(playback + 6), A_C_00000000, A_C_00000000); /* side left */ |
| 1491 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 7), A_GPR(playback + 7), A_C_00000000, A_C_00000000); /* side right */ |
| 1492 | } |
| 1493 | |
| 1494 | |
| 1495 | ctl = &controls[nctl + 0]; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1496 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1497 | strcpy(ctl->id.name, "Tone Control - Bass"); |
| 1498 | ctl->vcount = 2; |
| 1499 | ctl->count = 10; |
| 1500 | ctl->min = 0; |
| 1501 | ctl->max = 40; |
| 1502 | ctl->value[0] = ctl->value[1] = 20; |
| 1503 | ctl->translation = EMU10K1_GPR_TRANSLATION_BASS; |
| 1504 | ctl = &controls[nctl + 1]; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1505 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1506 | strcpy(ctl->id.name, "Tone Control - Treble"); |
| 1507 | ctl->vcount = 2; |
| 1508 | ctl->count = 10; |
| 1509 | ctl->min = 0; |
| 1510 | ctl->max = 40; |
| 1511 | ctl->value[0] = ctl->value[1] = 20; |
| 1512 | ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE; |
| 1513 | |
| 1514 | #define BASS_GPR 0x8c |
| 1515 | #define TREBLE_GPR 0x96 |
| 1516 | |
| 1517 | for (z = 0; z < 5; z++) { |
| 1518 | int j; |
| 1519 | for (j = 0; j < 2; j++) { |
| 1520 | controls[nctl + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j; |
| 1521 | controls[nctl + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j; |
| 1522 | } |
| 1523 | } |
| 1524 | for (z = 0; z < 4; z++) { /* front/rear/center-lfe/side */ |
| 1525 | int j, k, l, d; |
| 1526 | for (j = 0; j < 2; j++) { /* left/right */ |
| 1527 | k = 0xb0 + (z * 8) + (j * 4); |
| 1528 | l = 0xe0 + (z * 8) + (j * 4); |
| 1529 | d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j; |
| 1530 | |
| 1531 | A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(d), A_GPR(BASS_GPR + 0 + j)); |
| 1532 | A_OP(icode, &ptr, iMACMV, A_GPR(k+1), A_GPR(k), A_GPR(k+1), A_GPR(BASS_GPR + 4 + j)); |
| 1533 | A_OP(icode, &ptr, iMACMV, A_GPR(k), A_GPR(d), A_GPR(k), A_GPR(BASS_GPR + 2 + j)); |
| 1534 | A_OP(icode, &ptr, iMACMV, A_GPR(k+3), A_GPR(k+2), A_GPR(k+3), A_GPR(BASS_GPR + 8 + j)); |
| 1535 | A_OP(icode, &ptr, iMAC0, A_GPR(k+2), A_GPR_ACCU, A_GPR(k+2), A_GPR(BASS_GPR + 6 + j)); |
| 1536 | A_OP(icode, &ptr, iACC3, A_GPR(k+2), A_GPR(k+2), A_GPR(k+2), A_C_00000000); |
| 1537 | |
| 1538 | A_OP(icode, &ptr, iMAC0, A_C_00000000, A_C_00000000, A_GPR(k+2), A_GPR(TREBLE_GPR + 0 + j)); |
| 1539 | A_OP(icode, &ptr, iMACMV, A_GPR(l+1), A_GPR(l), A_GPR(l+1), A_GPR(TREBLE_GPR + 4 + j)); |
| 1540 | A_OP(icode, &ptr, iMACMV, A_GPR(l), A_GPR(k+2), A_GPR(l), A_GPR(TREBLE_GPR + 2 + j)); |
| 1541 | A_OP(icode, &ptr, iMACMV, A_GPR(l+3), A_GPR(l+2), A_GPR(l+3), A_GPR(TREBLE_GPR + 8 + j)); |
| 1542 | A_OP(icode, &ptr, iMAC0, A_GPR(l+2), A_GPR_ACCU, A_GPR(l+2), A_GPR(TREBLE_GPR + 6 + j)); |
| 1543 | A_OP(icode, &ptr, iMACINT0, A_GPR(l+2), A_C_00000000, A_GPR(l+2), A_C_00000010); |
| 1544 | |
| 1545 | A_OP(icode, &ptr, iACC3, A_GPR(d), A_GPR(l+2), A_C_00000000, A_C_00000000); |
| 1546 | |
| 1547 | if (z == 2) /* center */ |
| 1548 | break; |
| 1549 | } |
| 1550 | } |
| 1551 | nctl += 2; |
| 1552 | |
| 1553 | #undef BASS_GPR |
| 1554 | #undef TREBLE_GPR |
| 1555 | |
| 1556 | for (z = 0; z < 8; z++) { |
| 1557 | A_SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0); |
| 1558 | A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0); |
| 1559 | A_SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1); |
| 1560 | A_OP(icode, &ptr, iACC3, A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000); |
| 1561 | } |
| 1562 | snd_emu10k1_init_stereo_onoff_control(controls + nctl++, "Tone Control - Switch", gpr, 0); |
| 1563 | gpr += 2; |
| 1564 | |
| 1565 | /* Master volume (will be renamed later) */ |
| 1566 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+0+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+0+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1567 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+1+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+1+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1568 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+2+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+2+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1569 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+3+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+3+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1570 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+4+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+4+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1571 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+5+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+5+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1572 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+6+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+6+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1573 | A_OP(icode, &ptr, iMAC0, A_GPR(playback+7+SND_EMU10K1_PLAYBACK_CHANNELS), A_C_00000000, A_GPR(gpr), A_GPR(playback+7+SND_EMU10K1_PLAYBACK_CHANNELS)); |
| 1574 | snd_emu10k1_init_mono_control(&controls[nctl++], "Wave Master Playback Volume", gpr, 0); |
| 1575 | gpr += 2; |
| 1576 | |
| 1577 | /* analog speakers */ |
| 1578 | A_PUT_STEREO_OUTPUT(A_EXTOUT_AFRONT_L, A_EXTOUT_AFRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1579 | A_PUT_STEREO_OUTPUT(A_EXTOUT_AREAR_L, A_EXTOUT_AREAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1580 | A_PUT_OUTPUT(A_EXTOUT_ACENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1581 | A_PUT_OUTPUT(A_EXTOUT_ALFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS); |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 1582 | if (emu->card_capabilities->spk71) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1583 | A_PUT_STEREO_OUTPUT(A_EXTOUT_ASIDE_L, A_EXTOUT_ASIDE_R, playback+6 + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1584 | |
| 1585 | /* headphone */ |
| 1586 | A_PUT_STEREO_OUTPUT(A_EXTOUT_HEADPHONE_L, A_EXTOUT_HEADPHONE_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1587 | |
| 1588 | /* digital outputs */ |
| 1589 | /* A_PUT_STEREO_OUTPUT(A_EXTOUT_FRONT_L, A_EXTOUT_FRONT_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); */ |
James Courtier-Dutton | 190d2c4 | 2007-11-04 14:08:26 +0000 | [diff] [blame] | 1590 | if (emu->card_capabilities->emu_model) { |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1591 | /* EMU1010 Outputs from PCM Front, Rear, Center, LFE, Side */ |
Takashi Iwai | 6f002b0 | 2014-02-25 17:02:09 +0100 | [diff] [blame] | 1592 | dev_info(emu->card->dev, "EMU outputs on\n"); |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1593 | for (z = 0; z < 8; z++) { |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1594 | if (emu->card_capabilities->ca0108_chip) { |
| 1595 | A_OP(icode, &ptr, iACC3, A3_EMU32OUT(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000); |
| 1596 | } else { |
| 1597 | A_OP(icode, &ptr, iACC3, A_EMU32OUTL(z), A_GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), A_C_00000000, A_C_00000000); |
| 1598 | } |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1599 | } |
| 1600 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1601 | |
| 1602 | /* IEC958 Optical Raw Playback Switch */ |
| 1603 | gpr_map[gpr++] = 0; |
| 1604 | gpr_map[gpr++] = 0x1008; |
| 1605 | gpr_map[gpr++] = 0xffff0000; |
| 1606 | for (z = 0; z < 2; z++) { |
| 1607 | A_OP(icode, &ptr, iMAC0, A_GPR(tmp + 2), A_FXBUS(FXBUS_PT_LEFT + z), A_C_00000000, A_C_00000000); |
| 1608 | A_OP(icode, &ptr, iSKIP, A_GPR_COND, A_GPR_COND, A_GPR(gpr - 2), A_C_00000001); |
| 1609 | A_OP(icode, &ptr, iACC3, A_GPR(tmp + 2), A_C_00000000, A_C_00010000, A_GPR(tmp + 2)); |
| 1610 | A_OP(icode, &ptr, iANDXOR, A_GPR(tmp + 2), A_GPR(tmp + 2), A_GPR(gpr - 1), A_C_00000000); |
| 1611 | A_SWITCH(icode, &ptr, tmp + 0, tmp + 2, gpr + z); |
| 1612 | A_SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z); |
| 1613 | A_SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1); |
| 1614 | if ((z==1) && (emu->card_capabilities->spdif_bug)) { |
| 1615 | /* Due to a SPDIF output bug on some Audigy cards, this code delays the Right channel by 1 sample */ |
Takashi Iwai | 6f002b0 | 2014-02-25 17:02:09 +0100 | [diff] [blame] | 1616 | dev_info(emu->card->dev, |
| 1617 | "Installing spdif_bug patch: %s\n", |
| 1618 | emu->card_capabilities->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1619 | A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(gpr - 3), A_C_00000000, A_C_00000000); |
| 1620 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 3), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000); |
| 1621 | } else { |
| 1622 | A_OP(icode, &ptr, iACC3, A_EXTOUT(A_EXTOUT_FRONT_L + z), A_GPR(tmp + 0), A_GPR(tmp + 1), A_C_00000000); |
| 1623 | } |
| 1624 | } |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 1625 | snd_emu10k1_init_stereo_onoff_control(controls + nctl++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1626 | gpr += 2; |
| 1627 | |
| 1628 | A_PUT_STEREO_OUTPUT(A_EXTOUT_REAR_L, A_EXTOUT_REAR_R, playback+2 + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1629 | A_PUT_OUTPUT(A_EXTOUT_CENTER, playback+4 + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1630 | A_PUT_OUTPUT(A_EXTOUT_LFE, playback+5 + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1631 | |
| 1632 | /* ADC buffer */ |
| 1633 | #ifdef EMU10K1_CAPTURE_DIGITAL_OUT |
| 1634 | A_PUT_STEREO_OUTPUT(A_EXTOUT_ADC_CAP_L, A_EXTOUT_ADC_CAP_R, playback + SND_EMU10K1_PLAYBACK_CHANNELS); |
| 1635 | #else |
| 1636 | A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_L, capture); |
| 1637 | A_PUT_OUTPUT(A_EXTOUT_ADC_CAP_R, capture+1); |
| 1638 | #endif |
| 1639 | |
James Courtier-Dutton | 190d2c4 | 2007-11-04 14:08:26 +0000 | [diff] [blame] | 1640 | if (emu->card_capabilities->emu_model) { |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1641 | if (emu->card_capabilities->ca0108_chip) { |
Takashi Iwai | 6f002b0 | 2014-02-25 17:02:09 +0100 | [diff] [blame] | 1642 | dev_info(emu->card->dev, "EMU2 inputs on\n"); |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1643 | for (z = 0; z < 0x10; z++) { |
| 1644 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, |
| 1645 | bit_shifter16, |
| 1646 | A3_EMU32IN(z), |
| 1647 | A_FXBUS2(z*2) ); |
| 1648 | } |
| 1649 | } else { |
Takashi Iwai | 6f002b0 | 2014-02-25 17:02:09 +0100 | [diff] [blame] | 1650 | dev_info(emu->card->dev, "EMU inputs on\n"); |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1651 | /* Capture 16 (originally 8) channels of S32_LE sound */ |
| 1652 | |
Takashi Iwai | 28a97c1 | 2009-02-05 16:08:14 +0100 | [diff] [blame] | 1653 | /* |
Takashi Iwai | 6f002b0 | 2014-02-25 17:02:09 +0100 | [diff] [blame] | 1654 | dev_dbg(emu->card->dev, "emufx.c: gpr=0x%x, tmp=0x%x\n", |
Takashi Iwai | 28a97c1 | 2009-02-05 16:08:14 +0100 | [diff] [blame] | 1655 | gpr, tmp); |
| 1656 | */ |
James Courtier-Dutton | 90fd5ce | 2007-07-23 14:01:46 +0100 | [diff] [blame] | 1657 | /* For the EMU1010: How to get 32bit values from the DSP. High 16bits into L, low 16bits into R. */ |
| 1658 | /* A_P16VIN(0) is delayed by one sample, |
| 1659 | * so all other A_P16VIN channels will need to also be delayed |
| 1660 | */ |
| 1661 | /* Left ADC in. 1 of 2 */ |
| 1662 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_P16VIN(0x0), A_FXBUS2(0) ); |
| 1663 | /* Right ADC in 1 of 2 */ |
| 1664 | gpr_map[gpr++] = 0x00000000; |
| 1665 | /* Delaying by one sample: instead of copying the input |
| 1666 | * value A_P16VIN to output A_FXBUS2 as in the first channel, |
| 1667 | * we use an auxiliary register, delaying the value by one |
| 1668 | * sample |
| 1669 | */ |
| 1670 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(2) ); |
| 1671 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x1), A_C_00000000, A_C_00000000); |
| 1672 | gpr_map[gpr++] = 0x00000000; |
| 1673 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(4) ); |
| 1674 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x2), A_C_00000000, A_C_00000000); |
| 1675 | gpr_map[gpr++] = 0x00000000; |
| 1676 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(6) ); |
| 1677 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x3), A_C_00000000, A_C_00000000); |
| 1678 | /* For 96kHz mode */ |
| 1679 | /* Left ADC in. 2 of 2 */ |
| 1680 | gpr_map[gpr++] = 0x00000000; |
| 1681 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0x8) ); |
| 1682 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x4), A_C_00000000, A_C_00000000); |
| 1683 | /* Right ADC in 2 of 2 */ |
| 1684 | gpr_map[gpr++] = 0x00000000; |
| 1685 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xa) ); |
| 1686 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x5), A_C_00000000, A_C_00000000); |
| 1687 | gpr_map[gpr++] = 0x00000000; |
| 1688 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xc) ); |
| 1689 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x6), A_C_00000000, A_C_00000000); |
| 1690 | gpr_map[gpr++] = 0x00000000; |
| 1691 | snd_emu10k1_audigy_dsp_convert_32_to_2x16( icode, &ptr, tmp, bit_shifter16, A_GPR(gpr - 1), A_FXBUS2(0xe) ); |
| 1692 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x7), A_C_00000000, A_C_00000000); |
| 1693 | /* Pavel Hofman - we still have voices, A_FXBUS2s, and |
| 1694 | * A_P16VINs available - |
| 1695 | * let's add 8 more capture channels - total of 16 |
| 1696 | */ |
| 1697 | gpr_map[gpr++] = 0x00000000; |
| 1698 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1699 | bit_shifter16, |
| 1700 | A_GPR(gpr - 1), |
| 1701 | A_FXBUS2(0x10)); |
| 1702 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x8), |
| 1703 | A_C_00000000, A_C_00000000); |
| 1704 | gpr_map[gpr++] = 0x00000000; |
| 1705 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1706 | bit_shifter16, |
| 1707 | A_GPR(gpr - 1), |
| 1708 | A_FXBUS2(0x12)); |
| 1709 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0x9), |
| 1710 | A_C_00000000, A_C_00000000); |
| 1711 | gpr_map[gpr++] = 0x00000000; |
| 1712 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1713 | bit_shifter16, |
| 1714 | A_GPR(gpr - 1), |
| 1715 | A_FXBUS2(0x14)); |
| 1716 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xa), |
| 1717 | A_C_00000000, A_C_00000000); |
| 1718 | gpr_map[gpr++] = 0x00000000; |
| 1719 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1720 | bit_shifter16, |
| 1721 | A_GPR(gpr - 1), |
| 1722 | A_FXBUS2(0x16)); |
| 1723 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xb), |
| 1724 | A_C_00000000, A_C_00000000); |
| 1725 | gpr_map[gpr++] = 0x00000000; |
| 1726 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1727 | bit_shifter16, |
| 1728 | A_GPR(gpr - 1), |
| 1729 | A_FXBUS2(0x18)); |
| 1730 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xc), |
| 1731 | A_C_00000000, A_C_00000000); |
| 1732 | gpr_map[gpr++] = 0x00000000; |
| 1733 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1734 | bit_shifter16, |
| 1735 | A_GPR(gpr - 1), |
| 1736 | A_FXBUS2(0x1a)); |
| 1737 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xd), |
| 1738 | A_C_00000000, A_C_00000000); |
| 1739 | gpr_map[gpr++] = 0x00000000; |
| 1740 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1741 | bit_shifter16, |
| 1742 | A_GPR(gpr - 1), |
| 1743 | A_FXBUS2(0x1c)); |
| 1744 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xe), |
| 1745 | A_C_00000000, A_C_00000000); |
| 1746 | gpr_map[gpr++] = 0x00000000; |
| 1747 | snd_emu10k1_audigy_dsp_convert_32_to_2x16(icode, &ptr, tmp, |
| 1748 | bit_shifter16, |
| 1749 | A_GPR(gpr - 1), |
| 1750 | A_FXBUS2(0x1e)); |
| 1751 | A_OP(icode, &ptr, iACC3, A_GPR(gpr - 1), A_P16VIN(0xf), |
| 1752 | A_C_00000000, A_C_00000000); |
| 1753 | } |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 1754 | |
| 1755 | #if 0 |
| 1756 | for (z = 4; z < 8; z++) { |
| 1757 | A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000); |
| 1758 | } |
| 1759 | for (z = 0xc; z < 0x10; z++) { |
| 1760 | A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_C_00000000); |
| 1761 | } |
| 1762 | #endif |
| 1763 | } else { |
| 1764 | /* EFX capture - capture the 16 EXTINs */ |
| 1765 | /* Capture 16 channels of S16_LE sound */ |
| 1766 | for (z = 0; z < 16; z++) { |
| 1767 | A_OP(icode, &ptr, iACC3, A_FXBUS2(z), A_C_00000000, A_C_00000000, A_EXTIN(z)); |
| 1768 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1769 | } |
| 1770 | |
James Courtier-Dutton | 19b99fb | 2005-12-04 18:03:03 +0100 | [diff] [blame] | 1771 | #endif /* JCD test */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1772 | /* |
| 1773 | * ok, set up done.. |
| 1774 | */ |
| 1775 | |
| 1776 | if (gpr > tmp) { |
| 1777 | snd_BUG(); |
| 1778 | err = -EIO; |
| 1779 | goto __err; |
| 1780 | } |
| 1781 | /* clear remaining instruction memory */ |
| 1782 | while (ptr < 0x400) |
| 1783 | A_OP(icode, &ptr, 0x0f, 0xc0, 0xc0, 0xcf, 0xc0); |
| 1784 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1785 | icode->gpr_add_control_count = nctl; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1786 | icode->gpr_add_controls = controls; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 1787 | emu->support_tlv = 1; /* support TLV */ |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 1788 | err = snd_emu10k1_icode_poke(emu, icode, true); |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 1789 | emu->support_tlv = 0; /* clear again */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1790 | |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1791 | __err: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1792 | kfree(controls); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1793 | __err_ctrls: |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1794 | kfree(icode->gpr_map); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1795 | __err_gpr: |
| 1796 | kfree(icode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1797 | return err; |
| 1798 | } |
| 1799 | |
| 1800 | |
| 1801 | /* |
| 1802 | * initial DSP configuration for Emu10k1 |
| 1803 | */ |
| 1804 | |
| 1805 | /* when volume = max, then copy only to avoid volume modification */ |
| 1806 | /* with iMAC0 (negative values) */ |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1807 | static void _volume(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1808 | { |
| 1809 | OP(icode, ptr, iMAC0, dst, C_00000000, src, vol); |
| 1810 | OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); |
| 1811 | OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000001); |
| 1812 | OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000); |
| 1813 | } |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1814 | static void _volume_add(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1815 | { |
| 1816 | OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); |
| 1817 | OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); |
| 1818 | OP(icode, ptr, iMACINT0, dst, dst, src, C_00000001); |
| 1819 | OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001); |
| 1820 | OP(icode, ptr, iMAC0, dst, dst, src, vol); |
| 1821 | } |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1822 | static void _volume_out(struct snd_emu10k1_fx8010_code *icode, u32 *ptr, u32 dst, u32 src, u32 vol) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1823 | { |
| 1824 | OP(icode, ptr, iANDXOR, C_00000000, vol, C_ffffffff, C_7fffffff); |
| 1825 | OP(icode, ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); |
| 1826 | OP(icode, ptr, iACC3, dst, src, C_00000000, C_00000000); |
| 1827 | OP(icode, ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000001); |
| 1828 | OP(icode, ptr, iMAC0, dst, C_00000000, src, vol); |
| 1829 | } |
| 1830 | |
| 1831 | #define VOLUME(icode, ptr, dst, src, vol) \ |
| 1832 | _volume(icode, ptr, GPR(dst), GPR(src), GPR(vol)) |
| 1833 | #define VOLUME_IN(icode, ptr, dst, src, vol) \ |
| 1834 | _volume(icode, ptr, GPR(dst), EXTIN(src), GPR(vol)) |
| 1835 | #define VOLUME_ADD(icode, ptr, dst, src, vol) \ |
| 1836 | _volume_add(icode, ptr, GPR(dst), GPR(src), GPR(vol)) |
| 1837 | #define VOLUME_ADDIN(icode, ptr, dst, src, vol) \ |
| 1838 | _volume_add(icode, ptr, GPR(dst), EXTIN(src), GPR(vol)) |
| 1839 | #define VOLUME_OUT(icode, ptr, dst, src, vol) \ |
| 1840 | _volume_out(icode, ptr, EXTOUT(dst), GPR(src), GPR(vol)) |
| 1841 | #define _SWITCH(icode, ptr, dst, src, sw) \ |
| 1842 | OP((icode), ptr, iMACINT0, dst, C_00000000, src, sw); |
| 1843 | #define SWITCH(icode, ptr, dst, src, sw) \ |
| 1844 | _SWITCH(icode, ptr, GPR(dst), GPR(src), GPR(sw)) |
| 1845 | #define SWITCH_IN(icode, ptr, dst, src, sw) \ |
| 1846 | _SWITCH(icode, ptr, GPR(dst), EXTIN(src), GPR(sw)) |
| 1847 | #define _SWITCH_NEG(icode, ptr, dst, src) \ |
| 1848 | OP((icode), ptr, iANDXOR, dst, src, C_00000001, C_00000001); |
| 1849 | #define SWITCH_NEG(icode, ptr, dst, src) \ |
| 1850 | _SWITCH_NEG(icode, ptr, GPR(dst), GPR(src)) |
| 1851 | |
| 1852 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 1853 | static int _snd_emu10k1_init_efx(struct snd_emu10k1 *emu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1854 | { |
| 1855 | int err, i, z, gpr, tmp, playback, capture; |
| 1856 | u32 ptr; |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 1857 | struct snd_emu10k1_fx8010_code *icode; |
| 1858 | struct snd_emu10k1_fx8010_pcm_rec *ipcm = NULL; |
| 1859 | struct snd_emu10k1_fx8010_control_gpr *controls = NULL, *ctl; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1860 | u32 *gpr_map; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1861 | |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1862 | err = -ENOMEM; |
| 1863 | icode = kzalloc(sizeof(*icode), GFP_KERNEL); |
| 1864 | if (!icode) |
| 1865 | return err; |
| 1866 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1867 | icode->gpr_map = kcalloc(256 + 160 + 160 + 2 * 512, |
| 1868 | sizeof(u_int32_t), GFP_KERNEL); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 1869 | if (!icode->gpr_map) |
| 1870 | goto __err_gpr; |
| 1871 | |
| 1872 | controls = kcalloc(SND_EMU10K1_GPR_CONTROLS, |
| 1873 | sizeof(struct snd_emu10k1_fx8010_control_gpr), |
| 1874 | GFP_KERNEL); |
| 1875 | if (!controls) |
| 1876 | goto __err_ctrls; |
| 1877 | |
| 1878 | ipcm = kzalloc(sizeof(*ipcm), GFP_KERNEL); |
| 1879 | if (!ipcm) |
| 1880 | goto __err_ipcm; |
| 1881 | |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 1882 | gpr_map = icode->gpr_map; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1883 | |
| 1884 | icode->tram_data_map = icode->gpr_map + 256; |
| 1885 | icode->tram_addr_map = icode->tram_data_map + 160; |
| 1886 | icode->code = icode->tram_addr_map + 160; |
| 1887 | |
| 1888 | /* clear free GPRs */ |
| 1889 | for (i = 0; i < 256; i++) |
| 1890 | set_bit(i, icode->gpr_valid); |
| 1891 | |
| 1892 | /* clear TRAM data & address lines */ |
| 1893 | for (i = 0; i < 160; i++) |
| 1894 | set_bit(i, icode->tram_valid); |
| 1895 | |
| 1896 | strcpy(icode->name, "SB Live! FX8010 code for ALSA v1.2 by Jaroslav Kysela"); |
| 1897 | ptr = 0; i = 0; |
Mikael Magnusson | edf8e45 | 2005-09-13 11:32:58 +0200 | [diff] [blame] | 1898 | /* we have 12 inputs */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1899 | playback = SND_EMU10K1_INPUTS; |
| 1900 | /* we have 6 playback channels and tone control doubles */ |
| 1901 | capture = playback + (SND_EMU10K1_PLAYBACK_CHANNELS * 2); |
| 1902 | gpr = capture + SND_EMU10K1_CAPTURE_CHANNELS; |
| 1903 | tmp = 0x88; /* we need 4 temporary GPR */ |
| 1904 | /* from 0x8c to 0xff is the area for tone control */ |
| 1905 | |
| 1906 | /* stop FX processor */ |
| 1907 | snd_emu10k1_ptr_write(emu, DBG, 0, (emu->fx8010.dbg = 0) | EMU10K1_DBG_SINGLE_STEP); |
| 1908 | |
| 1909 | /* |
| 1910 | * Process FX Buses |
| 1911 | */ |
| 1912 | OP(icode, &ptr, iMACINT0, GPR(0), C_00000000, FXBUS(FXBUS_PCM_LEFT), C_00000004); |
| 1913 | OP(icode, &ptr, iMACINT0, GPR(1), C_00000000, FXBUS(FXBUS_PCM_RIGHT), C_00000004); |
| 1914 | OP(icode, &ptr, iMACINT0, GPR(2), C_00000000, FXBUS(FXBUS_MIDI_LEFT), C_00000004); |
| 1915 | OP(icode, &ptr, iMACINT0, GPR(3), C_00000000, FXBUS(FXBUS_MIDI_RIGHT), C_00000004); |
| 1916 | OP(icode, &ptr, iMACINT0, GPR(4), C_00000000, FXBUS(FXBUS_PCM_LEFT_REAR), C_00000004); |
| 1917 | OP(icode, &ptr, iMACINT0, GPR(5), C_00000000, FXBUS(FXBUS_PCM_RIGHT_REAR), C_00000004); |
| 1918 | OP(icode, &ptr, iMACINT0, GPR(6), C_00000000, FXBUS(FXBUS_PCM_CENTER), C_00000004); |
| 1919 | OP(icode, &ptr, iMACINT0, GPR(7), C_00000000, FXBUS(FXBUS_PCM_LFE), C_00000004); |
| 1920 | OP(icode, &ptr, iMACINT0, GPR(8), C_00000000, C_00000000, C_00000000); /* S/PDIF left */ |
| 1921 | OP(icode, &ptr, iMACINT0, GPR(9), C_00000000, C_00000000, C_00000000); /* S/PDIF right */ |
Mikael Magnusson | edf8e45 | 2005-09-13 11:32:58 +0200 | [diff] [blame] | 1922 | OP(icode, &ptr, iMACINT0, GPR(10), C_00000000, FXBUS(FXBUS_PCM_LEFT_FRONT), C_00000004); |
| 1923 | OP(icode, &ptr, iMACINT0, GPR(11), C_00000000, FXBUS(FXBUS_PCM_RIGHT_FRONT), C_00000004); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1924 | |
| 1925 | /* Raw S/PDIF PCM */ |
| 1926 | ipcm->substream = 0; |
| 1927 | ipcm->channels = 2; |
| 1928 | ipcm->tram_start = 0; |
| 1929 | ipcm->buffer_size = (64 * 1024) / 2; |
| 1930 | ipcm->gpr_size = gpr++; |
| 1931 | ipcm->gpr_ptr = gpr++; |
| 1932 | ipcm->gpr_count = gpr++; |
| 1933 | ipcm->gpr_tmpcount = gpr++; |
| 1934 | ipcm->gpr_trigger = gpr++; |
| 1935 | ipcm->gpr_running = gpr++; |
| 1936 | ipcm->etram[0] = 0; |
| 1937 | ipcm->etram[1] = 1; |
| 1938 | |
| 1939 | gpr_map[gpr + 0] = 0xfffff000; |
| 1940 | gpr_map[gpr + 1] = 0xffff0000; |
| 1941 | gpr_map[gpr + 2] = 0x70000000; |
| 1942 | gpr_map[gpr + 3] = 0x00000007; |
| 1943 | gpr_map[gpr + 4] = 0x001f << 11; |
| 1944 | gpr_map[gpr + 5] = 0x001c << 11; |
| 1945 | gpr_map[gpr + 6] = (0x22 - 0x01) - 1; /* skip at 01 to 22 */ |
| 1946 | gpr_map[gpr + 7] = (0x22 - 0x06) - 1; /* skip at 06 to 22 */ |
| 1947 | gpr_map[gpr + 8] = 0x2000000 + (2<<11); |
| 1948 | gpr_map[gpr + 9] = 0x4000000 + (2<<11); |
| 1949 | gpr_map[gpr + 10] = 1<<11; |
| 1950 | gpr_map[gpr + 11] = (0x24 - 0x0a) - 1; /* skip at 0a to 24 */ |
| 1951 | gpr_map[gpr + 12] = 0; |
| 1952 | |
| 1953 | /* if the trigger flag is not set, skip */ |
| 1954 | /* 00: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_trigger), C_00000000, C_00000000); |
| 1955 | /* 01: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_ZERO, GPR(gpr + 6)); |
| 1956 | /* if the running flag is set, we're running */ |
| 1957 | /* 02: */ OP(icode, &ptr, iMAC0, C_00000000, GPR(ipcm->gpr_running), C_00000000, C_00000000); |
| 1958 | /* 03: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000004); |
| 1959 | /* wait until ((GPR_DBAC>>11) & 0x1f) == 0x1c) */ |
| 1960 | /* 04: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), GPR_DBAC, GPR(gpr + 4), C_00000000); |
| 1961 | /* 05: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(gpr + 5)); |
| 1962 | /* 06: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 7)); |
| 1963 | /* 07: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000010, C_00000001, C_00000000); |
| 1964 | |
| 1965 | /* 08: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000000, C_00000001); |
| 1966 | /* 09: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), GPR(gpr + 12), C_ffffffff, C_00000000); |
| 1967 | /* 0a: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, GPR(gpr + 11)); |
| 1968 | /* 0b: */ OP(icode, &ptr, iACC3, GPR(gpr + 12), C_00000001, C_00000000, C_00000000); |
| 1969 | |
| 1970 | /* 0c: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[0]), GPR(gpr + 0), C_00000000); |
| 1971 | /* 0d: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000); |
| 1972 | /* 0e: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2)); |
| 1973 | /* 0f: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001); |
| 1974 | /* 10: */ OP(icode, &ptr, iANDXOR, GPR(8), GPR(8), GPR(gpr + 1), GPR(gpr + 2)); |
| 1975 | |
| 1976 | /* 11: */ OP(icode, &ptr, iANDXOR, GPR(tmp + 0), ETRAM_DATA(ipcm->etram[1]), GPR(gpr + 0), C_00000000); |
| 1977 | /* 12: */ OP(icode, &ptr, iLOG, GPR(tmp + 0), GPR(tmp + 0), GPR(gpr + 3), C_00000000); |
| 1978 | /* 13: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(tmp + 0), GPR(gpr + 1), GPR(gpr + 2)); |
| 1979 | /* 14: */ OP(icode, &ptr, iSKIP, C_00000000, GPR_COND, CC_REG_MINUS, C_00000001); |
| 1980 | /* 15: */ OP(icode, &ptr, iANDXOR, GPR(9), GPR(9), GPR(gpr + 1), GPR(gpr + 2)); |
| 1981 | |
| 1982 | /* 16: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(ipcm->gpr_ptr), C_00000001, C_00000000); |
| 1983 | /* 17: */ OP(icode, &ptr, iMACINT0, C_00000000, GPR(tmp + 0), C_ffffffff, GPR(ipcm->gpr_size)); |
| 1984 | /* 18: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_MINUS, C_00000001); |
| 1985 | /* 19: */ OP(icode, &ptr, iACC3, GPR(tmp + 0), C_00000000, C_00000000, C_00000000); |
| 1986 | /* 1a: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_ptr), GPR(tmp + 0), C_00000000, C_00000000); |
| 1987 | |
| 1988 | /* 1b: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_tmpcount), C_ffffffff, C_00000000); |
| 1989 | /* 1c: */ OP(icode, &ptr, iSKIP, GPR_COND, GPR_COND, CC_REG_NONZERO, C_00000002); |
| 1990 | /* 1d: */ OP(icode, &ptr, iACC3, GPR(ipcm->gpr_tmpcount), GPR(ipcm->gpr_count), C_00000000, C_00000000); |
| 1991 | /* 1e: */ OP(icode, &ptr, iACC3, GPR_IRQ, C_80000000, C_00000000, C_00000000); |
| 1992 | /* 1f: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00000001, C_00010000); |
| 1993 | |
| 1994 | /* 20: */ OP(icode, &ptr, iANDXOR, GPR(ipcm->gpr_running), GPR(ipcm->gpr_running), C_00010000, C_00000001); |
| 1995 | /* 21: */ OP(icode, &ptr, iSKIP, C_00000000, C_7fffffff, C_7fffffff, C_00000002); |
| 1996 | |
| 1997 | /* 22: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[0]), GPR(gpr + 8), GPR_DBAC, C_ffffffff); |
| 1998 | /* 23: */ OP(icode, &ptr, iMACINT1, ETRAM_ADDR(ipcm->etram[1]), GPR(gpr + 9), GPR_DBAC, C_ffffffff); |
| 1999 | |
| 2000 | /* 24: */ |
| 2001 | gpr += 13; |
| 2002 | |
| 2003 | /* Wave Playback Volume */ |
| 2004 | for (z = 0; z < 2; z++) |
| 2005 | VOLUME(icode, &ptr, playback + z, z, gpr + z); |
| 2006 | snd_emu10k1_init_stereo_control(controls + i++, "Wave Playback Volume", gpr, 100); |
| 2007 | gpr += 2; |
| 2008 | |
| 2009 | /* Wave Surround Playback Volume */ |
| 2010 | for (z = 0; z < 2; z++) |
| 2011 | VOLUME(icode, &ptr, playback + 2 + z, z, gpr + z); |
| 2012 | snd_emu10k1_init_stereo_control(controls + i++, "Wave Surround Playback Volume", gpr, 0); |
| 2013 | gpr += 2; |
| 2014 | |
| 2015 | /* Wave Center/LFE Playback Volume */ |
| 2016 | OP(icode, &ptr, iACC3, GPR(tmp + 0), FXBUS(FXBUS_PCM_LEFT), FXBUS(FXBUS_PCM_RIGHT), C_00000000); |
| 2017 | OP(icode, &ptr, iMACINT0, GPR(tmp + 0), C_00000000, GPR(tmp + 0), C_00000002); |
| 2018 | VOLUME(icode, &ptr, playback + 4, tmp + 0, gpr); |
| 2019 | snd_emu10k1_init_mono_control(controls + i++, "Wave Center Playback Volume", gpr++, 0); |
| 2020 | VOLUME(icode, &ptr, playback + 5, tmp + 0, gpr); |
| 2021 | snd_emu10k1_init_mono_control(controls + i++, "Wave LFE Playback Volume", gpr++, 0); |
| 2022 | |
| 2023 | /* Wave Capture Volume + Switch */ |
| 2024 | for (z = 0; z < 2; z++) { |
| 2025 | SWITCH(icode, &ptr, tmp + 0, z, gpr + 2 + z); |
| 2026 | VOLUME(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2027 | } |
| 2028 | snd_emu10k1_init_stereo_control(controls + i++, "Wave Capture Volume", gpr, 0); |
| 2029 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Wave Capture Switch", gpr + 2, 0); |
| 2030 | gpr += 4; |
| 2031 | |
| 2032 | /* Synth Playback Volume */ |
| 2033 | for (z = 0; z < 2; z++) |
| 2034 | VOLUME_ADD(icode, &ptr, playback + z, 2 + z, gpr + z); |
| 2035 | snd_emu10k1_init_stereo_control(controls + i++, "Synth Playback Volume", gpr, 100); |
| 2036 | gpr += 2; |
| 2037 | |
| 2038 | /* Synth Capture Volume + Switch */ |
| 2039 | for (z = 0; z < 2; z++) { |
| 2040 | SWITCH(icode, &ptr, tmp + 0, 2 + z, gpr + 2 + z); |
| 2041 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2042 | } |
| 2043 | snd_emu10k1_init_stereo_control(controls + i++, "Synth Capture Volume", gpr, 0); |
| 2044 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Synth Capture Switch", gpr + 2, 0); |
| 2045 | gpr += 4; |
| 2046 | |
| 2047 | /* Surround Digital Playback Volume (renamed later without Digital) */ |
| 2048 | for (z = 0; z < 2; z++) |
| 2049 | VOLUME_ADD(icode, &ptr, playback + 2 + z, 4 + z, gpr + z); |
| 2050 | snd_emu10k1_init_stereo_control(controls + i++, "Surround Digital Playback Volume", gpr, 100); |
| 2051 | gpr += 2; |
| 2052 | |
| 2053 | /* Surround Capture Volume + Switch */ |
| 2054 | for (z = 0; z < 2; z++) { |
| 2055 | SWITCH(icode, &ptr, tmp + 0, 4 + z, gpr + 2 + z); |
| 2056 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2057 | } |
| 2058 | snd_emu10k1_init_stereo_control(controls + i++, "Surround Capture Volume", gpr, 0); |
| 2059 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Surround Capture Switch", gpr + 2, 0); |
| 2060 | gpr += 4; |
| 2061 | |
| 2062 | /* Center Playback Volume (renamed later without Digital) */ |
| 2063 | VOLUME_ADD(icode, &ptr, playback + 4, 6, gpr); |
| 2064 | snd_emu10k1_init_mono_control(controls + i++, "Center Digital Playback Volume", gpr++, 100); |
| 2065 | |
| 2066 | /* LFE Playback Volume + Switch (renamed later without Digital) */ |
| 2067 | VOLUME_ADD(icode, &ptr, playback + 5, 7, gpr); |
| 2068 | snd_emu10k1_init_mono_control(controls + i++, "LFE Digital Playback Volume", gpr++, 100); |
| 2069 | |
Mikael Magnusson | edf8e45 | 2005-09-13 11:32:58 +0200 | [diff] [blame] | 2070 | /* Front Playback Volume */ |
| 2071 | for (z = 0; z < 2; z++) |
| 2072 | VOLUME_ADD(icode, &ptr, playback + z, 10 + z, gpr + z); |
| 2073 | snd_emu10k1_init_stereo_control(controls + i++, "Front Playback Volume", gpr, 100); |
| 2074 | gpr += 2; |
| 2075 | |
| 2076 | /* Front Capture Volume + Switch */ |
| 2077 | for (z = 0; z < 2; z++) { |
| 2078 | SWITCH(icode, &ptr, tmp + 0, 10 + z, gpr + 2); |
| 2079 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2080 | } |
| 2081 | snd_emu10k1_init_stereo_control(controls + i++, "Front Capture Volume", gpr, 0); |
| 2082 | snd_emu10k1_init_mono_onoff_control(controls + i++, "Front Capture Switch", gpr + 2, 0); |
| 2083 | gpr += 3; |
| 2084 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2085 | /* |
| 2086 | * Process inputs |
| 2087 | */ |
| 2088 | |
| 2089 | if (emu->fx8010.extin_mask & ((1<<EXTIN_AC97_L)|(1<<EXTIN_AC97_R))) { |
| 2090 | /* AC'97 Playback Volume */ |
| 2091 | VOLUME_ADDIN(icode, &ptr, playback + 0, EXTIN_AC97_L, gpr); gpr++; |
| 2092 | VOLUME_ADDIN(icode, &ptr, playback + 1, EXTIN_AC97_R, gpr); gpr++; |
| 2093 | snd_emu10k1_init_stereo_control(controls + i++, "AC97 Playback Volume", gpr-2, 0); |
| 2094 | /* AC'97 Capture Volume */ |
| 2095 | VOLUME_ADDIN(icode, &ptr, capture + 0, EXTIN_AC97_L, gpr); gpr++; |
| 2096 | VOLUME_ADDIN(icode, &ptr, capture + 1, EXTIN_AC97_R, gpr); gpr++; |
| 2097 | snd_emu10k1_init_stereo_control(controls + i++, "AC97 Capture Volume", gpr-2, 100); |
| 2098 | } |
| 2099 | |
| 2100 | if (emu->fx8010.extin_mask & ((1<<EXTIN_SPDIF_CD_L)|(1<<EXTIN_SPDIF_CD_R))) { |
| 2101 | /* IEC958 TTL Playback Volume */ |
| 2102 | for (z = 0; z < 2; z++) |
| 2103 | VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_SPDIF_CD_L + z, gpr + z); |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2104 | snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",PLAYBACK,VOLUME), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2105 | gpr += 2; |
| 2106 | |
| 2107 | /* IEC958 TTL Capture Volume + Switch */ |
| 2108 | for (z = 0; z < 2; z++) { |
| 2109 | SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_SPDIF_CD_L + z, gpr + 2 + z); |
| 2110 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2111 | } |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2112 | snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,VOLUME), gpr, 0); |
| 2113 | snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("TTL ",CAPTURE,SWITCH), gpr + 2, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2114 | gpr += 4; |
| 2115 | } |
| 2116 | |
| 2117 | if (emu->fx8010.extin_mask & ((1<<EXTIN_ZOOM_L)|(1<<EXTIN_ZOOM_R))) { |
| 2118 | /* Zoom Video Playback Volume */ |
| 2119 | for (z = 0; z < 2; z++) |
| 2120 | VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_ZOOM_L + z, gpr + z); |
| 2121 | snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Playback Volume", gpr, 0); |
| 2122 | gpr += 2; |
| 2123 | |
| 2124 | /* Zoom Video Capture Volume + Switch */ |
| 2125 | for (z = 0; z < 2; z++) { |
| 2126 | SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_ZOOM_L + z, gpr + 2 + z); |
| 2127 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2128 | } |
| 2129 | snd_emu10k1_init_stereo_control(controls + i++, "Zoom Video Capture Volume", gpr, 0); |
| 2130 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Zoom Video Capture Switch", gpr + 2, 0); |
| 2131 | gpr += 4; |
| 2132 | } |
| 2133 | |
| 2134 | if (emu->fx8010.extin_mask & ((1<<EXTIN_TOSLINK_L)|(1<<EXTIN_TOSLINK_R))) { |
| 2135 | /* IEC958 Optical Playback Volume */ |
| 2136 | for (z = 0; z < 2; z++) |
| 2137 | VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_TOSLINK_L + z, gpr + z); |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2138 | snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",PLAYBACK,VOLUME), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2139 | gpr += 2; |
| 2140 | |
| 2141 | /* IEC958 Optical Capture Volume */ |
| 2142 | for (z = 0; z < 2; z++) { |
| 2143 | SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_TOSLINK_L + z, gpr + 2 + z); |
| 2144 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2145 | } |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2146 | snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,VOLUME), gpr, 0); |
| 2147 | snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("LiveDrive ",CAPTURE,SWITCH), gpr + 2, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2148 | gpr += 4; |
| 2149 | } |
| 2150 | |
| 2151 | if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE1_L)|(1<<EXTIN_LINE1_R))) { |
| 2152 | /* Line LiveDrive Playback Volume */ |
| 2153 | for (z = 0; z < 2; z++) |
| 2154 | VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE1_L + z, gpr + z); |
| 2155 | snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Playback Volume", gpr, 0); |
| 2156 | gpr += 2; |
| 2157 | |
| 2158 | /* Line LiveDrive Capture Volume + Switch */ |
| 2159 | for (z = 0; z < 2; z++) { |
| 2160 | SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE1_L + z, gpr + 2 + z); |
| 2161 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2162 | } |
| 2163 | snd_emu10k1_init_stereo_control(controls + i++, "Line LiveDrive Capture Volume", gpr, 0); |
| 2164 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line LiveDrive Capture Switch", gpr + 2, 0); |
| 2165 | gpr += 4; |
| 2166 | } |
| 2167 | |
| 2168 | if (emu->fx8010.extin_mask & ((1<<EXTIN_COAX_SPDIF_L)|(1<<EXTIN_COAX_SPDIF_R))) { |
| 2169 | /* IEC958 Coax Playback Volume */ |
| 2170 | for (z = 0; z < 2; z++) |
| 2171 | VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_COAX_SPDIF_L + z, gpr + z); |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2172 | snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",PLAYBACK,VOLUME), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2173 | gpr += 2; |
| 2174 | |
| 2175 | /* IEC958 Coax Capture Volume + Switch */ |
| 2176 | for (z = 0; z < 2; z++) { |
| 2177 | SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_COAX_SPDIF_L + z, gpr + 2 + z); |
| 2178 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2179 | } |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2180 | snd_emu10k1_init_stereo_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,VOLUME), gpr, 0); |
| 2181 | snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Coaxial ",CAPTURE,SWITCH), gpr + 2, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2182 | gpr += 4; |
| 2183 | } |
| 2184 | |
| 2185 | if (emu->fx8010.extin_mask & ((1<<EXTIN_LINE2_L)|(1<<EXTIN_LINE2_R))) { |
| 2186 | /* Line LiveDrive Playback Volume */ |
| 2187 | for (z = 0; z < 2; z++) |
| 2188 | VOLUME_ADDIN(icode, &ptr, playback + z, EXTIN_LINE2_L + z, gpr + z); |
| 2189 | snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Playback Volume", gpr, 0); |
| 2190 | controls[i-1].id.index = 1; |
| 2191 | gpr += 2; |
| 2192 | |
| 2193 | /* Line LiveDrive Capture Volume */ |
| 2194 | for (z = 0; z < 2; z++) { |
| 2195 | SWITCH_IN(icode, &ptr, tmp + 0, EXTIN_LINE2_L + z, gpr + 2 + z); |
| 2196 | VOLUME_ADD(icode, &ptr, capture + z, tmp + 0, gpr + z); |
| 2197 | } |
| 2198 | snd_emu10k1_init_stereo_control(controls + i++, "Line2 LiveDrive Capture Volume", gpr, 0); |
| 2199 | controls[i-1].id.index = 1; |
| 2200 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Line2 LiveDrive Capture Switch", gpr + 2, 0); |
| 2201 | controls[i-1].id.index = 1; |
| 2202 | gpr += 4; |
| 2203 | } |
| 2204 | |
| 2205 | /* |
| 2206 | * Process tone control |
| 2207 | */ |
| 2208 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), GPR(playback + 0), C_00000000, C_00000000); /* left */ |
| 2209 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), GPR(playback + 1), C_00000000, C_00000000); /* right */ |
| 2210 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2), GPR(playback + 2), C_00000000, C_00000000); /* rear left */ |
| 2211 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 3), GPR(playback + 3), C_00000000, C_00000000); /* rear right */ |
| 2212 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), GPR(playback + 4), C_00000000, C_00000000); /* center */ |
| 2213 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), GPR(playback + 5), C_00000000, C_00000000); /* LFE */ |
| 2214 | |
| 2215 | ctl = &controls[i + 0]; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 2216 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2217 | strcpy(ctl->id.name, "Tone Control - Bass"); |
| 2218 | ctl->vcount = 2; |
| 2219 | ctl->count = 10; |
| 2220 | ctl->min = 0; |
| 2221 | ctl->max = 40; |
| 2222 | ctl->value[0] = ctl->value[1] = 20; |
Raymond Yau | bfe9fc8a | 2011-05-20 14:32:04 +0800 | [diff] [blame] | 2223 | ctl->tlv = snd_emu10k1_bass_treble_db_scale; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2224 | ctl->translation = EMU10K1_GPR_TRANSLATION_BASS; |
| 2225 | ctl = &controls[i + 1]; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 2226 | ctl->id.iface = (__force int)SNDRV_CTL_ELEM_IFACE_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2227 | strcpy(ctl->id.name, "Tone Control - Treble"); |
| 2228 | ctl->vcount = 2; |
| 2229 | ctl->count = 10; |
| 2230 | ctl->min = 0; |
| 2231 | ctl->max = 40; |
| 2232 | ctl->value[0] = ctl->value[1] = 20; |
Raymond Yau | bfe9fc8a | 2011-05-20 14:32:04 +0800 | [diff] [blame] | 2233 | ctl->tlv = snd_emu10k1_bass_treble_db_scale; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2234 | ctl->translation = EMU10K1_GPR_TRANSLATION_TREBLE; |
| 2235 | |
| 2236 | #define BASS_GPR 0x8c |
| 2237 | #define TREBLE_GPR 0x96 |
| 2238 | |
| 2239 | for (z = 0; z < 5; z++) { |
| 2240 | int j; |
| 2241 | for (j = 0; j < 2; j++) { |
| 2242 | controls[i + 0].gpr[z * 2 + j] = BASS_GPR + z * 2 + j; |
| 2243 | controls[i + 1].gpr[z * 2 + j] = TREBLE_GPR + z * 2 + j; |
| 2244 | } |
| 2245 | } |
| 2246 | for (z = 0; z < 3; z++) { /* front/rear/center-lfe */ |
| 2247 | int j, k, l, d; |
| 2248 | for (j = 0; j < 2; j++) { /* left/right */ |
| 2249 | k = 0xa0 + (z * 8) + (j * 4); |
| 2250 | l = 0xd0 + (z * 8) + (j * 4); |
| 2251 | d = playback + SND_EMU10K1_PLAYBACK_CHANNELS + z * 2 + j; |
| 2252 | |
| 2253 | OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(d), GPR(BASS_GPR + 0 + j)); |
| 2254 | OP(icode, &ptr, iMACMV, GPR(k+1), GPR(k), GPR(k+1), GPR(BASS_GPR + 4 + j)); |
| 2255 | OP(icode, &ptr, iMACMV, GPR(k), GPR(d), GPR(k), GPR(BASS_GPR + 2 + j)); |
| 2256 | OP(icode, &ptr, iMACMV, GPR(k+3), GPR(k+2), GPR(k+3), GPR(BASS_GPR + 8 + j)); |
| 2257 | OP(icode, &ptr, iMAC0, GPR(k+2), GPR_ACCU, GPR(k+2), GPR(BASS_GPR + 6 + j)); |
| 2258 | OP(icode, &ptr, iACC3, GPR(k+2), GPR(k+2), GPR(k+2), C_00000000); |
| 2259 | |
| 2260 | OP(icode, &ptr, iMAC0, C_00000000, C_00000000, GPR(k+2), GPR(TREBLE_GPR + 0 + j)); |
| 2261 | OP(icode, &ptr, iMACMV, GPR(l+1), GPR(l), GPR(l+1), GPR(TREBLE_GPR + 4 + j)); |
| 2262 | OP(icode, &ptr, iMACMV, GPR(l), GPR(k+2), GPR(l), GPR(TREBLE_GPR + 2 + j)); |
| 2263 | OP(icode, &ptr, iMACMV, GPR(l+3), GPR(l+2), GPR(l+3), GPR(TREBLE_GPR + 8 + j)); |
| 2264 | OP(icode, &ptr, iMAC0, GPR(l+2), GPR_ACCU, GPR(l+2), GPR(TREBLE_GPR + 6 + j)); |
| 2265 | OP(icode, &ptr, iMACINT0, GPR(l+2), C_00000000, GPR(l+2), C_00000010); |
| 2266 | |
| 2267 | OP(icode, &ptr, iACC3, GPR(d), GPR(l+2), C_00000000, C_00000000); |
| 2268 | |
| 2269 | if (z == 2) /* center */ |
| 2270 | break; |
| 2271 | } |
| 2272 | } |
| 2273 | i += 2; |
| 2274 | |
| 2275 | #undef BASS_GPR |
| 2276 | #undef TREBLE_GPR |
| 2277 | |
| 2278 | for (z = 0; z < 6; z++) { |
| 2279 | SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, gpr + 0); |
| 2280 | SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 0); |
| 2281 | SWITCH(icode, &ptr, tmp + 1, playback + z, tmp + 1); |
| 2282 | OP(icode, &ptr, iACC3, GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000); |
| 2283 | } |
| 2284 | snd_emu10k1_init_stereo_onoff_control(controls + i++, "Tone Control - Switch", gpr, 0); |
| 2285 | gpr += 2; |
| 2286 | |
| 2287 | /* |
| 2288 | * Process outputs |
| 2289 | */ |
| 2290 | if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_L)|(1<<EXTOUT_AC97_R))) { |
| 2291 | /* AC'97 Playback Volume */ |
| 2292 | |
| 2293 | for (z = 0; z < 2; z++) |
| 2294 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + z), C_00000000, C_00000000); |
| 2295 | } |
| 2296 | |
| 2297 | if (emu->fx8010.extout_mask & ((1<<EXTOUT_TOSLINK_L)|(1<<EXTOUT_TOSLINK_R))) { |
| 2298 | /* IEC958 Optical Raw Playback Switch */ |
| 2299 | |
| 2300 | for (z = 0; z < 2; z++) { |
| 2301 | SWITCH(icode, &ptr, tmp + 0, 8 + z, gpr + z); |
| 2302 | SWITCH_NEG(icode, &ptr, tmp + 1, gpr + z); |
| 2303 | SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1); |
| 2304 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_TOSLINK_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000); |
| 2305 | #ifdef EMU10K1_CAPTURE_DIGITAL_OUT |
| 2306 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(tmp + 0), GPR(tmp + 1), C_00000000); |
| 2307 | #endif |
| 2308 | } |
| 2309 | |
Clemens Ladisch | 10e8d78 | 2005-08-03 13:40:08 +0200 | [diff] [blame] | 2310 | snd_emu10k1_init_stereo_onoff_control(controls + i++, SNDRV_CTL_NAME_IEC958("Optical Raw ",PLAYBACK,SWITCH), gpr, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2311 | gpr += 2; |
| 2312 | } |
| 2313 | |
| 2314 | if (emu->fx8010.extout_mask & ((1<<EXTOUT_HEADPHONE_L)|(1<<EXTOUT_HEADPHONE_R))) { |
| 2315 | /* Headphone Playback Volume */ |
| 2316 | |
| 2317 | for (z = 0; z < 2; z++) { |
| 2318 | SWITCH(icode, &ptr, tmp + 0, playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4 + z, gpr + 2 + z); |
| 2319 | SWITCH_NEG(icode, &ptr, tmp + 1, gpr + 2 + z); |
| 2320 | SWITCH(icode, &ptr, tmp + 1, playback + SND_EMU10K1_PLAYBACK_CHANNELS + z, tmp + 1); |
| 2321 | OP(icode, &ptr, iACC3, GPR(tmp + 0), GPR(tmp + 0), GPR(tmp + 1), C_00000000); |
| 2322 | VOLUME_OUT(icode, &ptr, EXTOUT_HEADPHONE_L + z, tmp + 0, gpr + z); |
| 2323 | } |
| 2324 | |
| 2325 | snd_emu10k1_init_stereo_control(controls + i++, "Headphone Playback Volume", gpr + 0, 0); |
| 2326 | controls[i-1].id.index = 1; /* AC'97 can have also Headphone control */ |
| 2327 | snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone Center Playback Switch", gpr + 2, 0); |
| 2328 | controls[i-1].id.index = 1; |
| 2329 | snd_emu10k1_init_mono_onoff_control(controls + i++, "Headphone LFE Playback Switch", gpr + 3, 0); |
| 2330 | controls[i-1].id.index = 1; |
| 2331 | |
| 2332 | gpr += 4; |
| 2333 | } |
| 2334 | |
| 2335 | if (emu->fx8010.extout_mask & ((1<<EXTOUT_REAR_L)|(1<<EXTOUT_REAR_R))) |
| 2336 | for (z = 0; z < 2; z++) |
| 2337 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000); |
| 2338 | |
| 2339 | if (emu->fx8010.extout_mask & ((1<<EXTOUT_AC97_REAR_L)|(1<<EXTOUT_AC97_REAR_R))) |
| 2340 | for (z = 0; z < 2; z++) |
| 2341 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_REAR_L + z), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 2 + z), C_00000000, C_00000000); |
| 2342 | |
| 2343 | if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_CENTER)) { |
| 2344 | #ifndef EMU10K1_CENTER_LFE_FROM_FRONT |
| 2345 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000); |
| 2346 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 4), C_00000000, C_00000000); |
| 2347 | #else |
| 2348 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_CENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000); |
| 2349 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ACENTER), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 0), C_00000000, C_00000000); |
| 2350 | #endif |
| 2351 | } |
| 2352 | |
| 2353 | if (emu->fx8010.extout_mask & (1<<EXTOUT_AC97_LFE)) { |
| 2354 | #ifndef EMU10K1_CENTER_LFE_FROM_FRONT |
| 2355 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000); |
| 2356 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 5), C_00000000, C_00000000); |
| 2357 | #else |
| 2358 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_AC97_LFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000); |
| 2359 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ALFE), GPR(playback + SND_EMU10K1_PLAYBACK_CHANNELS + 1), C_00000000, C_00000000); |
| 2360 | #endif |
| 2361 | } |
| 2362 | |
| 2363 | #ifndef EMU10K1_CAPTURE_DIGITAL_OUT |
| 2364 | for (z = 0; z < 2; z++) |
| 2365 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_ADC_CAP_L + z), GPR(capture + z), C_00000000, C_00000000); |
| 2366 | #endif |
| 2367 | |
| 2368 | if (emu->fx8010.extout_mask & (1<<EXTOUT_MIC_CAP)) |
| 2369 | OP(icode, &ptr, iACC3, EXTOUT(EXTOUT_MIC_CAP), GPR(capture + 2), C_00000000, C_00000000); |
| 2370 | |
| 2371 | /* EFX capture - capture the 16 EXTINS */ |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 2372 | if (emu->card_capabilities->sblive51) { |
| 2373 | /* On the Live! 5.1, FXBUS2(1) and FXBUS(2) are shared with EXTOUT_ACENTER |
| 2374 | * and EXTOUT_ALFE, so we can't connect inputs to them for multitrack recording. |
| 2375 | * |
| 2376 | * Since only 14 of the 16 EXTINs are used, this is not a big problem. |
| 2377 | * We route AC97L and R to FX capture 14 and 15, SPDIF CD in to FX capture |
| 2378 | * 0 and 3, then the rest of the EXTINs to the corresponding FX capture |
| 2379 | * channel. Multitrack recorders will still see the center/lfe output signal |
| 2380 | * on the second and third channels. |
| 2381 | */ |
| 2382 | OP(icode, &ptr, iACC3, FXBUS2(14), C_00000000, C_00000000, EXTIN(0)); |
| 2383 | OP(icode, &ptr, iACC3, FXBUS2(15), C_00000000, C_00000000, EXTIN(1)); |
| 2384 | OP(icode, &ptr, iACC3, FXBUS2(0), C_00000000, C_00000000, EXTIN(2)); |
| 2385 | OP(icode, &ptr, iACC3, FXBUS2(3), C_00000000, C_00000000, EXTIN(3)); |
| 2386 | for (z = 4; z < 14; z++) |
| 2387 | OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z)); |
| 2388 | } else { |
| 2389 | for (z = 0; z < 16; z++) |
| 2390 | OP(icode, &ptr, iACC3, FXBUS2(z), C_00000000, C_00000000, EXTIN(z)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2391 | } |
Lee Revell | 2b637da | 2005-03-30 13:51:18 +0200 | [diff] [blame] | 2392 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2393 | |
| 2394 | if (gpr > tmp) { |
| 2395 | snd_BUG(); |
| 2396 | err = -EIO; |
| 2397 | goto __err; |
| 2398 | } |
| 2399 | if (i > SND_EMU10K1_GPR_CONTROLS) { |
| 2400 | snd_BUG(); |
| 2401 | err = -EIO; |
| 2402 | goto __err; |
| 2403 | } |
| 2404 | |
| 2405 | /* clear remaining instruction memory */ |
| 2406 | while (ptr < 0x200) |
| 2407 | OP(icode, &ptr, iACC3, C_00000000, C_00000000, C_00000000, C_00000000); |
| 2408 | |
Takashi Iwai | 12bda10 | 2021-06-08 16:05:14 +0200 | [diff] [blame] | 2409 | err = snd_emu10k1_fx8010_tram_setup(emu, ipcm->buffer_size); |
| 2410 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2411 | goto __err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2412 | icode->gpr_add_control_count = i; |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 2413 | icode->gpr_add_controls = controls; |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 2414 | emu->support_tlv = 1; /* support TLV */ |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 2415 | err = snd_emu10k1_icode_poke(emu, icode, true); |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 2416 | emu->support_tlv = 0; /* clear again */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2417 | if (err >= 0) |
| 2418 | err = snd_emu10k1_ipcm_poke(emu, ipcm); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 2419 | __err: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2420 | kfree(ipcm); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 2421 | __err_ipcm: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2422 | kfree(controls); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 2423 | __err_ctrls: |
Takashi Iwai | 81b4509 | 2020-02-02 10:07:23 +0100 | [diff] [blame] | 2424 | kfree(icode->gpr_map); |
Geyslan G. Bem | f1b4863 | 2013-10-17 19:57:12 -0300 | [diff] [blame] | 2425 | __err_gpr: |
| 2426 | kfree(icode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2427 | return err; |
| 2428 | } |
| 2429 | |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 2430 | int snd_emu10k1_init_efx(struct snd_emu10k1 *emu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2431 | { |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2432 | spin_lock_init(&emu->fx8010.irq_lock); |
| 2433 | INIT_LIST_HEAD(&emu->fx8010.gpr_ctl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2434 | if (emu->audigy) |
| 2435 | return _snd_emu10k1_audigy_init_efx(emu); |
| 2436 | else |
| 2437 | return _snd_emu10k1_init_efx(emu); |
| 2438 | } |
| 2439 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2440 | void snd_emu10k1_free_efx(struct snd_emu10k1 *emu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2441 | { |
| 2442 | /* stop processor */ |
| 2443 | if (emu->audigy) |
| 2444 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = A_DBG_SINGLE_STEP); |
| 2445 | else |
| 2446 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = EMU10K1_DBG_SINGLE_STEP); |
| 2447 | } |
| 2448 | |
James Courtier-Dutton | 9f4bd5d | 2006-10-01 10:48:04 +0100 | [diff] [blame] | 2449 | #if 0 /* FIXME: who use them? */ |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2450 | int snd_emu10k1_fx8010_tone_control_activate(struct snd_emu10k1 *emu, int output) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2451 | { |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 2452 | if (output < 0 || output >= 6) |
| 2453 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2454 | snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 1); |
| 2455 | return 0; |
| 2456 | } |
| 2457 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2458 | int snd_emu10k1_fx8010_tone_control_deactivate(struct snd_emu10k1 *emu, int output) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2459 | { |
Takashi Iwai | 7c22f1a | 2005-10-10 11:46:31 +0200 | [diff] [blame] | 2460 | if (output < 0 || output >= 6) |
| 2461 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2462 | snd_emu10k1_ptr_write(emu, emu->gpr_base + 0x94 + output, 0, 0); |
| 2463 | return 0; |
| 2464 | } |
| 2465 | #endif |
| 2466 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2467 | int snd_emu10k1_fx8010_tram_setup(struct snd_emu10k1 *emu, u32 size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2468 | { |
| 2469 | u8 size_reg = 0; |
| 2470 | |
| 2471 | /* size is in samples */ |
| 2472 | if (size != 0) { |
| 2473 | size = (size - 1) >> 13; |
| 2474 | |
| 2475 | while (size) { |
| 2476 | size >>= 1; |
| 2477 | size_reg++; |
| 2478 | } |
| 2479 | size = 0x2000 << size_reg; |
| 2480 | } |
| 2481 | if ((emu->fx8010.etram_pages.bytes / 2) == size) |
| 2482 | return 0; |
| 2483 | spin_lock_irq(&emu->emu_lock); |
| 2484 | outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG); |
| 2485 | spin_unlock_irq(&emu->emu_lock); |
| 2486 | snd_emu10k1_ptr_write(emu, TCB, 0, 0); |
| 2487 | snd_emu10k1_ptr_write(emu, TCBS, 0, 0); |
| 2488 | if (emu->fx8010.etram_pages.area != NULL) { |
| 2489 | snd_dma_free_pages(&emu->fx8010.etram_pages); |
| 2490 | emu->fx8010.etram_pages.area = NULL; |
| 2491 | emu->fx8010.etram_pages.bytes = 0; |
| 2492 | } |
| 2493 | |
| 2494 | if (size > 0) { |
Takashi Iwai | 6974f8a | 2019-11-05 16:18:55 +0100 | [diff] [blame] | 2495 | if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &emu->pci->dev, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2496 | size * 2, &emu->fx8010.etram_pages) < 0) |
| 2497 | return -ENOMEM; |
| 2498 | memset(emu->fx8010.etram_pages.area, 0, size * 2); |
| 2499 | snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr); |
| 2500 | snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg); |
| 2501 | spin_lock_irq(&emu->emu_lock); |
| 2502 | outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG); |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2503 | spin_unlock_irq(&emu->emu_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2504 | } |
| 2505 | |
| 2506 | return 0; |
| 2507 | } |
| 2508 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2509 | static int snd_emu10k1_fx8010_open(struct snd_hwdep * hw, struct file *file) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2510 | { |
| 2511 | return 0; |
| 2512 | } |
| 2513 | |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 2514 | static void copy_string(char *dst, const char *src, const char *null, int idx) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2515 | { |
| 2516 | if (src == NULL) |
| 2517 | sprintf(dst, "%s %02X", null, idx); |
| 2518 | else |
| 2519 | strcpy(dst, src); |
| 2520 | } |
| 2521 | |
Mariusz Kozlowski | 5188245 | 2007-08-11 11:06:09 +0200 | [diff] [blame] | 2522 | static void snd_emu10k1_fx8010_info(struct snd_emu10k1 *emu, |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2523 | struct snd_emu10k1_fx8010_info *info) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2524 | { |
Takashi Iwai | 6fddce2 | 2020-01-05 15:47:29 +0100 | [diff] [blame] | 2525 | const char * const *fxbus, * const *extin, * const *extout; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2526 | unsigned short fxbus_mask, extin_mask, extout_mask; |
| 2527 | int res; |
| 2528 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2529 | info->internal_tram_size = emu->fx8010.itram_size; |
| 2530 | info->external_tram_size = emu->fx8010.etram_pages.bytes / 2; |
| 2531 | fxbus = fxbuses; |
| 2532 | extin = emu->audigy ? audigy_ins : creative_ins; |
| 2533 | extout = emu->audigy ? audigy_outs : creative_outs; |
| 2534 | fxbus_mask = emu->fx8010.fxbus_mask; |
| 2535 | extin_mask = emu->fx8010.extin_mask; |
| 2536 | extout_mask = emu->fx8010.extout_mask; |
| 2537 | for (res = 0; res < 16; res++, fxbus++, extin++, extout++) { |
| 2538 | copy_string(info->fxbus_names[res], fxbus_mask & (1 << res) ? *fxbus : NULL, "FXBUS", res); |
| 2539 | copy_string(info->extin_names[res], extin_mask & (1 << res) ? *extin : NULL, "Unused", res); |
| 2540 | copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res); |
| 2541 | } |
| 2542 | for (res = 16; res < 32; res++, extout++) |
| 2543 | copy_string(info->extout_names[res], extout_mask & (1 << res) ? *extout : NULL, "Unused", res); |
| 2544 | info->gpr_controls = emu->fx8010.gpr_count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2545 | } |
| 2546 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2547 | static int snd_emu10k1_fx8010_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2548 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2549 | struct snd_emu10k1 *emu = hw->private_data; |
| 2550 | struct snd_emu10k1_fx8010_info *info; |
| 2551 | struct snd_emu10k1_fx8010_code *icode; |
| 2552 | struct snd_emu10k1_fx8010_pcm_rec *ipcm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2553 | unsigned int addr; |
| 2554 | void __user *argp = (void __user *)arg; |
| 2555 | int res; |
| 2556 | |
| 2557 | switch (cmd) { |
Takashi Iwai | f7ba7fc | 2007-01-19 18:34:47 +0100 | [diff] [blame] | 2558 | case SNDRV_EMU10K1_IOCTL_PVERSION: |
| 2559 | emu->support_tlv = 1; |
| 2560 | return put_user(SNDRV_EMU10K1_VERSION, (int __user *)argp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2561 | case SNDRV_EMU10K1_IOCTL_INFO: |
Willy Tarreau | 49434c6c | 2018-09-08 08:12:21 +0200 | [diff] [blame] | 2562 | info = kzalloc(sizeof(*info), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2563 | if (!info) |
| 2564 | return -ENOMEM; |
Mariusz Kozlowski | 5188245 | 2007-08-11 11:06:09 +0200 | [diff] [blame] | 2565 | snd_emu10k1_fx8010_info(emu, info); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2566 | if (copy_to_user(argp, info, sizeof(*info))) { |
| 2567 | kfree(info); |
| 2568 | return -EFAULT; |
| 2569 | } |
| 2570 | kfree(info); |
| 2571 | return 0; |
| 2572 | case SNDRV_EMU10K1_IOCTL_CODE_POKE: |
| 2573 | if (!capable(CAP_SYS_ADMIN)) |
| 2574 | return -EPERM; |
Li Zefan | 336500f | 2009-04-10 09:44:31 +0800 | [diff] [blame] | 2575 | |
| 2576 | icode = memdup_user(argp, sizeof(*icode)); |
| 2577 | if (IS_ERR(icode)) |
| 2578 | return PTR_ERR(icode); |
Takashi Iwai | d42fe63 | 2017-05-10 17:11:34 +0200 | [diff] [blame] | 2579 | res = snd_emu10k1_icode_poke(emu, icode, false); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2580 | kfree(icode); |
| 2581 | return res; |
| 2582 | case SNDRV_EMU10K1_IOCTL_CODE_PEEK: |
Li Zefan | 336500f | 2009-04-10 09:44:31 +0800 | [diff] [blame] | 2583 | icode = memdup_user(argp, sizeof(*icode)); |
| 2584 | if (IS_ERR(icode)) |
| 2585 | return PTR_ERR(icode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2586 | res = snd_emu10k1_icode_peek(emu, icode); |
| 2587 | if (res == 0 && copy_to_user(argp, icode, sizeof(*icode))) { |
| 2588 | kfree(icode); |
| 2589 | return -EFAULT; |
| 2590 | } |
| 2591 | kfree(icode); |
| 2592 | return res; |
| 2593 | case SNDRV_EMU10K1_IOCTL_PCM_POKE: |
Li Zefan | 336500f | 2009-04-10 09:44:31 +0800 | [diff] [blame] | 2594 | ipcm = memdup_user(argp, sizeof(*ipcm)); |
| 2595 | if (IS_ERR(ipcm)) |
| 2596 | return PTR_ERR(ipcm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2597 | res = snd_emu10k1_ipcm_poke(emu, ipcm); |
| 2598 | kfree(ipcm); |
| 2599 | return res; |
| 2600 | case SNDRV_EMU10K1_IOCTL_PCM_PEEK: |
Li Zefan | 336500f | 2009-04-10 09:44:31 +0800 | [diff] [blame] | 2601 | ipcm = memdup_user(argp, sizeof(*ipcm)); |
| 2602 | if (IS_ERR(ipcm)) |
| 2603 | return PTR_ERR(ipcm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2604 | res = snd_emu10k1_ipcm_peek(emu, ipcm); |
| 2605 | if (res == 0 && copy_to_user(argp, ipcm, sizeof(*ipcm))) { |
| 2606 | kfree(ipcm); |
| 2607 | return -EFAULT; |
| 2608 | } |
| 2609 | kfree(ipcm); |
| 2610 | return res; |
| 2611 | case SNDRV_EMU10K1_IOCTL_TRAM_SETUP: |
| 2612 | if (!capable(CAP_SYS_ADMIN)) |
| 2613 | return -EPERM; |
| 2614 | if (get_user(addr, (unsigned int __user *)argp)) |
| 2615 | return -EFAULT; |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 2616 | mutex_lock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2617 | res = snd_emu10k1_fx8010_tram_setup(emu, addr); |
Ingo Molnar | 62932df | 2006-01-16 16:34:20 +0100 | [diff] [blame] | 2618 | mutex_unlock(&emu->fx8010.lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2619 | return res; |
| 2620 | case SNDRV_EMU10K1_IOCTL_STOP: |
| 2621 | if (!capable(CAP_SYS_ADMIN)) |
| 2622 | return -EPERM; |
| 2623 | if (emu->audigy) |
| 2624 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP); |
| 2625 | else |
| 2626 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP); |
| 2627 | return 0; |
| 2628 | case SNDRV_EMU10K1_IOCTL_CONTINUE: |
| 2629 | if (!capable(CAP_SYS_ADMIN)) |
| 2630 | return -EPERM; |
| 2631 | if (emu->audigy) |
| 2632 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg = 0); |
| 2633 | else |
| 2634 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg = 0); |
| 2635 | return 0; |
| 2636 | case SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER: |
| 2637 | if (!capable(CAP_SYS_ADMIN)) |
| 2638 | return -EPERM; |
| 2639 | if (emu->audigy) |
| 2640 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_ZC); |
| 2641 | else |
| 2642 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_ZC); |
| 2643 | udelay(10); |
| 2644 | if (emu->audigy) |
| 2645 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); |
| 2646 | else |
| 2647 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); |
| 2648 | return 0; |
| 2649 | case SNDRV_EMU10K1_IOCTL_SINGLE_STEP: |
| 2650 | if (!capable(CAP_SYS_ADMIN)) |
| 2651 | return -EPERM; |
| 2652 | if (get_user(addr, (unsigned int __user *)argp)) |
| 2653 | return -EFAULT; |
| 2654 | if (addr > 0x1ff) |
| 2655 | return -EINVAL; |
| 2656 | if (emu->audigy) |
| 2657 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | addr); |
| 2658 | else |
| 2659 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | addr); |
| 2660 | udelay(10); |
| 2661 | if (emu->audigy) |
| 2662 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg |= A_DBG_SINGLE_STEP | A_DBG_STEP_ADDR | addr); |
| 2663 | else |
| 2664 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg |= EMU10K1_DBG_SINGLE_STEP | EMU10K1_DBG_STEP | addr); |
| 2665 | return 0; |
| 2666 | case SNDRV_EMU10K1_IOCTL_DBG_READ: |
| 2667 | if (emu->audigy) |
| 2668 | addr = snd_emu10k1_ptr_read(emu, A_DBG, 0); |
| 2669 | else |
| 2670 | addr = snd_emu10k1_ptr_read(emu, DBG, 0); |
| 2671 | if (put_user(addr, (unsigned int __user *)argp)) |
| 2672 | return -EFAULT; |
| 2673 | return 0; |
| 2674 | } |
| 2675 | return -ENOTTY; |
| 2676 | } |
| 2677 | |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2678 | static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2679 | { |
| 2680 | return 0; |
| 2681 | } |
| 2682 | |
Lars-Peter Clausen | bb814c3 | 2015-01-02 12:24:49 +0100 | [diff] [blame] | 2683 | int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2684 | { |
Takashi Iwai | eb4698f3 | 2005-11-17 14:50:13 +0100 | [diff] [blame] | 2685 | struct snd_hwdep *hw; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2686 | int err; |
| 2687 | |
Takashi Iwai | 12bda10 | 2021-06-08 16:05:14 +0200 | [diff] [blame] | 2688 | err = snd_hwdep_new(emu->card, "FX8010", device, &hw); |
| 2689 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2690 | return err; |
| 2691 | strcpy(hw->name, "EMU10K1 (FX8010)"); |
| 2692 | hw->iface = SNDRV_HWDEP_IFACE_EMU10K1; |
| 2693 | hw->ops.open = snd_emu10k1_fx8010_open; |
| 2694 | hw->ops.ioctl = snd_emu10k1_fx8010_ioctl; |
| 2695 | hw->ops.release = snd_emu10k1_fx8010_release; |
| 2696 | hw->private_data = emu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2697 | return 0; |
| 2698 | } |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2699 | |
Takashi Iwai | c7561cd | 2012-08-14 18:12:04 +0200 | [diff] [blame] | 2700 | #ifdef CONFIG_PM_SLEEP |
Bill Pemberton | e23e7a1 | 2012-12-06 12:35:10 -0500 | [diff] [blame] | 2701 | int snd_emu10k1_efx_alloc_pm_buffer(struct snd_emu10k1 *emu) |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2702 | { |
| 2703 | int len; |
| 2704 | |
| 2705 | len = emu->audigy ? 0x200 : 0x100; |
Kees Cook | 6da2ec5 | 2018-06-12 13:55:00 -0700 | [diff] [blame] | 2706 | emu->saved_gpr = kmalloc_array(len, 4, GFP_KERNEL); |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2707 | if (! emu->saved_gpr) |
| 2708 | return -ENOMEM; |
| 2709 | len = emu->audigy ? 0x100 : 0xa0; |
Kees Cook | 6da2ec5 | 2018-06-12 13:55:00 -0700 | [diff] [blame] | 2710 | emu->tram_val_saved = kmalloc_array(len, 4, GFP_KERNEL); |
| 2711 | emu->tram_addr_saved = kmalloc_array(len, 4, GFP_KERNEL); |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2712 | if (! emu->tram_val_saved || ! emu->tram_addr_saved) |
| 2713 | return -ENOMEM; |
| 2714 | len = emu->audigy ? 2 * 1024 : 2 * 512; |
Kees Cook | 42bc47b | 2018-06-12 14:27:11 -0700 | [diff] [blame] | 2715 | emu->saved_icode = vmalloc(array_size(len, 4)); |
Takashi Iwai | 09668b4 | 2005-11-17 16:14:10 +0100 | [diff] [blame] | 2716 | if (! emu->saved_icode) |
| 2717 | return -ENOMEM; |
| 2718 | return 0; |
| 2719 | } |
| 2720 | |
| 2721 | void snd_emu10k1_efx_free_pm_buffer(struct snd_emu10k1 *emu) |
| 2722 | { |
| 2723 | kfree(emu->saved_gpr); |
| 2724 | kfree(emu->tram_val_saved); |
| 2725 | kfree(emu->tram_addr_saved); |
| 2726 | vfree(emu->saved_icode); |
| 2727 | } |
| 2728 | |
| 2729 | /* |
| 2730 | * save/restore GPR, TRAM and codes |
| 2731 | */ |
| 2732 | void snd_emu10k1_efx_suspend(struct snd_emu10k1 *emu) |
| 2733 | { |
| 2734 | int i, len; |
| 2735 | |
| 2736 | len = emu->audigy ? 0x200 : 0x100; |
| 2737 | for (i = 0; i < len; i++) |
| 2738 | emu->saved_gpr[i] = snd_emu10k1_ptr_read(emu, emu->gpr_base + i, 0); |
| 2739 | |
| 2740 | len = emu->audigy ? 0x100 : 0xa0; |
| 2741 | for (i = 0; i < len; i++) { |
| 2742 | emu->tram_val_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMDATAREGBASE + i, 0); |
| 2743 | emu->tram_addr_saved[i] = snd_emu10k1_ptr_read(emu, TANKMEMADDRREGBASE + i, 0); |
| 2744 | if (emu->audigy) { |
| 2745 | emu->tram_addr_saved[i] >>= 12; |
| 2746 | emu->tram_addr_saved[i] |= |
| 2747 | snd_emu10k1_ptr_read(emu, A_TANKMEMCTLREGBASE + i, 0) << 20; |
| 2748 | } |
| 2749 | } |
| 2750 | |
| 2751 | len = emu->audigy ? 2 * 1024 : 2 * 512; |
| 2752 | for (i = 0; i < len; i++) |
| 2753 | emu->saved_icode[i] = snd_emu10k1_efx_read(emu, i); |
| 2754 | } |
| 2755 | |
| 2756 | void snd_emu10k1_efx_resume(struct snd_emu10k1 *emu) |
| 2757 | { |
| 2758 | int i, len; |
| 2759 | |
| 2760 | /* set up TRAM */ |
| 2761 | if (emu->fx8010.etram_pages.bytes > 0) { |
| 2762 | unsigned size, size_reg = 0; |
| 2763 | size = emu->fx8010.etram_pages.bytes / 2; |
| 2764 | size = (size - 1) >> 13; |
| 2765 | while (size) { |
| 2766 | size >>= 1; |
| 2767 | size_reg++; |
| 2768 | } |
| 2769 | outl(HCFG_LOCKTANKCACHE_MASK | inl(emu->port + HCFG), emu->port + HCFG); |
| 2770 | snd_emu10k1_ptr_write(emu, TCB, 0, emu->fx8010.etram_pages.addr); |
| 2771 | snd_emu10k1_ptr_write(emu, TCBS, 0, size_reg); |
| 2772 | outl(inl(emu->port + HCFG) & ~HCFG_LOCKTANKCACHE_MASK, emu->port + HCFG); |
| 2773 | } |
| 2774 | |
| 2775 | if (emu->audigy) |
| 2776 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg | A_DBG_SINGLE_STEP); |
| 2777 | else |
| 2778 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg | EMU10K1_DBG_SINGLE_STEP); |
| 2779 | |
| 2780 | len = emu->audigy ? 0x200 : 0x100; |
| 2781 | for (i = 0; i < len; i++) |
| 2782 | snd_emu10k1_ptr_write(emu, emu->gpr_base + i, 0, emu->saved_gpr[i]); |
| 2783 | |
| 2784 | len = emu->audigy ? 0x100 : 0xa0; |
| 2785 | for (i = 0; i < len; i++) { |
| 2786 | snd_emu10k1_ptr_write(emu, TANKMEMDATAREGBASE + i, 0, |
| 2787 | emu->tram_val_saved[i]); |
| 2788 | if (! emu->audigy) |
| 2789 | snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, |
| 2790 | emu->tram_addr_saved[i]); |
| 2791 | else { |
| 2792 | snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, |
| 2793 | emu->tram_addr_saved[i] << 12); |
| 2794 | snd_emu10k1_ptr_write(emu, TANKMEMADDRREGBASE + i, 0, |
| 2795 | emu->tram_addr_saved[i] >> 20); |
| 2796 | } |
| 2797 | } |
| 2798 | |
| 2799 | len = emu->audigy ? 2 * 1024 : 2 * 512; |
| 2800 | for (i = 0; i < len; i++) |
| 2801 | snd_emu10k1_efx_write(emu, i, emu->saved_icode[i]); |
| 2802 | |
| 2803 | /* start FX processor when the DSP code is updated */ |
| 2804 | if (emu->audigy) |
| 2805 | snd_emu10k1_ptr_write(emu, A_DBG, 0, emu->fx8010.dbg); |
| 2806 | else |
| 2807 | snd_emu10k1_ptr_write(emu, DBG, 0, emu->fx8010.dbg); |
| 2808 | } |
| 2809 | #endif |