Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame^] | 1 | /* |
| 2 | * Routines for Trident 4DWave NX/DX soundcards - Synthesizer |
| 3 | * Copyright (c) by Scott McNab <jedi@tartarus.uwa.edu.au> |
| 4 | * |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | * |
| 20 | */ |
| 21 | |
| 22 | #include <sound/driver.h> |
| 23 | #include <asm/io.h> |
| 24 | #include <linux/init.h> |
| 25 | #include <linux/slab.h> |
| 26 | #include <linux/pci.h> |
| 27 | #include <sound/core.h> |
| 28 | #include <sound/trident.h> |
| 29 | #include <sound/seq_device.h> |
| 30 | |
| 31 | MODULE_AUTHOR("Scott McNab <jedi@tartarus.uwa.edu.au>"); |
| 32 | MODULE_DESCRIPTION("Routines for Trident 4DWave NX/DX soundcards - Synthesizer"); |
| 33 | MODULE_LICENSE("GPL"); |
| 34 | |
| 35 | /* linear to log pan conversion table (4.2 channel attenuation format) */ |
| 36 | static unsigned int pan_table[63] = { |
| 37 | 7959, 7733, 7514, 7301, 7093, 6892, 6697, 6507, |
| 38 | 6322, 6143, 5968, 5799, 5634, 5475, 5319, 5168, |
| 39 | 5022, 4879, 4741, 4606, 4475, 4349, 4225, 4105, |
| 40 | 3989, 3876, 3766, 3659, 3555, 3454, 3356, 3261, |
| 41 | 3168, 3078, 2991, 2906, 2824, 2744, 2666, 2590, |
| 42 | 2517, 2445, 2376, 2308, 2243, 2179, 2117, 2057, |
| 43 | 1999, 1942, 1887, 1833, 1781, 1731, 1682, 1634, |
| 44 | 1588, 1543, 1499, 1456, 1415, 1375, 1336 |
| 45 | }; |
| 46 | |
| 47 | #define LOG_TABLE_SIZE 386 |
| 48 | |
| 49 | /* Linear half-attenuation to log conversion table in the format: |
| 50 | * {linear volume, logarithmic attenuation equivalent}, ... |
| 51 | * |
| 52 | * Provides conversion from a linear half-volume value in the range |
| 53 | * [0,8192] to a logarithmic attenuation value in the range 0 to 6.02dB. |
| 54 | * Halving the linear volume is equivalent to an additional 6dB of |
| 55 | * logarithmic attenuation. The algorithm used in log_from_linear() |
| 56 | * therefore uses this table as follows: |
| 57 | * |
| 58 | * - loop and for every time the volume is less than half the maximum |
| 59 | * volume (16384), add another 6dB and halve the maximum value used |
| 60 | * for this comparison. |
| 61 | * - when the volume is greater than half the maximum volume, take |
| 62 | * the difference of the volume to half volume (in the range [0,8192]) |
| 63 | * and look up the log_table[] to find the nearest entry. |
| 64 | * - take the logarithic component of this entry and add it to the |
| 65 | * resulting attenuation. |
| 66 | * |
| 67 | * Thus this routine provides a linear->log conversion for a range of |
| 68 | * [0,16384] using only 386 table entries |
| 69 | * |
| 70 | * Note: although this table stores log attenuation in 8.8 format, values |
| 71 | * were only calculated for 6 bits fractional precision, since that is |
| 72 | * the most precision offered by the trident hardware. |
| 73 | */ |
| 74 | |
| 75 | static unsigned short log_table[LOG_TABLE_SIZE*2] = |
| 76 | { |
| 77 | 4, 0x0604, 19, 0x0600, 34, 0x05fc, |
| 78 | 49, 0x05f8, 63, 0x05f4, 78, 0x05f0, 93, 0x05ec, 108, 0x05e8, |
| 79 | 123, 0x05e4, 138, 0x05e0, 153, 0x05dc, 168, 0x05d8, 183, 0x05d4, |
| 80 | 198, 0x05d0, 213, 0x05cc, 228, 0x05c8, 244, 0x05c4, 259, 0x05c0, |
| 81 | 274, 0x05bc, 289, 0x05b8, 304, 0x05b4, 320, 0x05b0, 335, 0x05ac, |
| 82 | 350, 0x05a8, 366, 0x05a4, 381, 0x05a0, 397, 0x059c, 412, 0x0598, |
| 83 | 428, 0x0594, 443, 0x0590, 459, 0x058c, 474, 0x0588, 490, 0x0584, |
| 84 | 506, 0x0580, 521, 0x057c, 537, 0x0578, 553, 0x0574, 568, 0x0570, |
| 85 | 584, 0x056c, 600, 0x0568, 616, 0x0564, 632, 0x0560, 647, 0x055c, |
| 86 | 663, 0x0558, 679, 0x0554, 695, 0x0550, 711, 0x054c, 727, 0x0548, |
| 87 | 743, 0x0544, 759, 0x0540, 776, 0x053c, 792, 0x0538, 808, 0x0534, |
| 88 | 824, 0x0530, 840, 0x052c, 857, 0x0528, 873, 0x0524, 889, 0x0520, |
| 89 | 906, 0x051c, 922, 0x0518, 938, 0x0514, 955, 0x0510, 971, 0x050c, |
| 90 | 988, 0x0508, 1004, 0x0504, 1021, 0x0500, 1037, 0x04fc, 1054, 0x04f8, |
| 91 | 1071, 0x04f4, 1087, 0x04f0, 1104, 0x04ec, 1121, 0x04e8, 1138, 0x04e4, |
| 92 | 1154, 0x04e0, 1171, 0x04dc, 1188, 0x04d8, 1205, 0x04d4, 1222, 0x04d0, |
| 93 | 1239, 0x04cc, 1256, 0x04c8, 1273, 0x04c4, 1290, 0x04c0, 1307, 0x04bc, |
| 94 | 1324, 0x04b8, 1341, 0x04b4, 1358, 0x04b0, 1376, 0x04ac, 1393, 0x04a8, |
| 95 | 1410, 0x04a4, 1427, 0x04a0, 1445, 0x049c, 1462, 0x0498, 1479, 0x0494, |
| 96 | 1497, 0x0490, 1514, 0x048c, 1532, 0x0488, 1549, 0x0484, 1567, 0x0480, |
| 97 | 1584, 0x047c, 1602, 0x0478, 1620, 0x0474, 1637, 0x0470, 1655, 0x046c, |
| 98 | 1673, 0x0468, 1690, 0x0464, 1708, 0x0460, 1726, 0x045c, 1744, 0x0458, |
| 99 | 1762, 0x0454, 1780, 0x0450, 1798, 0x044c, 1816, 0x0448, 1834, 0x0444, |
| 100 | 1852, 0x0440, 1870, 0x043c, 1888, 0x0438, 1906, 0x0434, 1924, 0x0430, |
| 101 | 1943, 0x042c, 1961, 0x0428, 1979, 0x0424, 1997, 0x0420, 2016, 0x041c, |
| 102 | 2034, 0x0418, 2053, 0x0414, 2071, 0x0410, 2089, 0x040c, 2108, 0x0408, |
| 103 | 2127, 0x0404, 2145, 0x0400, 2164, 0x03fc, 2182, 0x03f8, 2201, 0x03f4, |
| 104 | 2220, 0x03f0, 2239, 0x03ec, 2257, 0x03e8, 2276, 0x03e4, 2295, 0x03e0, |
| 105 | 2314, 0x03dc, 2333, 0x03d8, 2352, 0x03d4, 2371, 0x03d0, 2390, 0x03cc, |
| 106 | 2409, 0x03c8, 2428, 0x03c4, 2447, 0x03c0, 2466, 0x03bc, 2485, 0x03b8, |
| 107 | 2505, 0x03b4, 2524, 0x03b0, 2543, 0x03ac, 2562, 0x03a8, 2582, 0x03a4, |
| 108 | 2601, 0x03a0, 2621, 0x039c, 2640, 0x0398, 2660, 0x0394, 2679, 0x0390, |
| 109 | 2699, 0x038c, 2718, 0x0388, 2738, 0x0384, 2758, 0x0380, 2777, 0x037c, |
| 110 | 2797, 0x0378, 2817, 0x0374, 2837, 0x0370, 2857, 0x036c, 2876, 0x0368, |
| 111 | 2896, 0x0364, 2916, 0x0360, 2936, 0x035c, 2956, 0x0358, 2976, 0x0354, |
| 112 | 2997, 0x0350, 3017, 0x034c, 3037, 0x0348, 3057, 0x0344, 3077, 0x0340, |
| 113 | 3098, 0x033c, 3118, 0x0338, 3138, 0x0334, 3159, 0x0330, 3179, 0x032c, |
| 114 | 3200, 0x0328, 3220, 0x0324, 3241, 0x0320, 3261, 0x031c, 3282, 0x0318, |
| 115 | 3303, 0x0314, 3323, 0x0310, 3344, 0x030c, 3365, 0x0308, 3386, 0x0304, |
| 116 | 3406, 0x0300, 3427, 0x02fc, 3448, 0x02f8, 3469, 0x02f4, 3490, 0x02f0, |
| 117 | 3511, 0x02ec, 3532, 0x02e8, 3553, 0x02e4, 3575, 0x02e0, 3596, 0x02dc, |
| 118 | 3617, 0x02d8, 3638, 0x02d4, 3660, 0x02d0, 3681, 0x02cc, 3702, 0x02c8, |
| 119 | 3724, 0x02c4, 3745, 0x02c0, 3767, 0x02bc, 3788, 0x02b8, 3810, 0x02b4, |
| 120 | 3831, 0x02b0, 3853, 0x02ac, 3875, 0x02a8, 3896, 0x02a4, 3918, 0x02a0, |
| 121 | 3940, 0x029c, 3962, 0x0298, 3984, 0x0294, 4006, 0x0290, 4028, 0x028c, |
| 122 | 4050, 0x0288, 4072, 0x0284, 4094, 0x0280, 4116, 0x027c, 4138, 0x0278, |
| 123 | 4160, 0x0274, 4182, 0x0270, 4205, 0x026c, 4227, 0x0268, 4249, 0x0264, |
| 124 | 4272, 0x0260, 4294, 0x025c, 4317, 0x0258, 4339, 0x0254, 4362, 0x0250, |
| 125 | 4384, 0x024c, 4407, 0x0248, 4430, 0x0244, 4453, 0x0240, 4475, 0x023c, |
| 126 | 4498, 0x0238, 4521, 0x0234, 4544, 0x0230, 4567, 0x022c, 4590, 0x0228, |
| 127 | 4613, 0x0224, 4636, 0x0220, 4659, 0x021c, 4682, 0x0218, 4705, 0x0214, |
| 128 | 4728, 0x0210, 4752, 0x020c, 4775, 0x0208, 4798, 0x0204, 4822, 0x0200, |
| 129 | 4845, 0x01fc, 4869, 0x01f8, 4892, 0x01f4, 4916, 0x01f0, 4939, 0x01ec, |
| 130 | 4963, 0x01e8, 4987, 0x01e4, 5010, 0x01e0, 5034, 0x01dc, 5058, 0x01d8, |
| 131 | 5082, 0x01d4, 5106, 0x01d0, 5130, 0x01cc, 5154, 0x01c8, 5178, 0x01c4, |
| 132 | 5202, 0x01c0, 5226, 0x01bc, 5250, 0x01b8, 5274, 0x01b4, 5299, 0x01b0, |
| 133 | 5323, 0x01ac, 5347, 0x01a8, 5372, 0x01a4, 5396, 0x01a0, 5420, 0x019c, |
| 134 | 5445, 0x0198, 5469, 0x0194, 5494, 0x0190, 5519, 0x018c, 5543, 0x0188, |
| 135 | 5568, 0x0184, 5593, 0x0180, 5618, 0x017c, 5643, 0x0178, 5668, 0x0174, |
| 136 | 5692, 0x0170, 5717, 0x016c, 5743, 0x0168, 5768, 0x0164, 5793, 0x0160, |
| 137 | 5818, 0x015c, 5843, 0x0158, 5868, 0x0154, 5894, 0x0150, 5919, 0x014c, |
| 138 | 5945, 0x0148, 5970, 0x0144, 5995, 0x0140, 6021, 0x013c, 6047, 0x0138, |
| 139 | 6072, 0x0134, 6098, 0x0130, 6124, 0x012c, 6149, 0x0128, 6175, 0x0124, |
| 140 | 6201, 0x0120, 6227, 0x011c, 6253, 0x0118, 6279, 0x0114, 6305, 0x0110, |
| 141 | 6331, 0x010c, 6357, 0x0108, 6384, 0x0104, 6410, 0x0100, 6436, 0x00fc, |
| 142 | 6462, 0x00f8, 6489, 0x00f4, 6515, 0x00f0, 6542, 0x00ec, 6568, 0x00e8, |
| 143 | 6595, 0x00e4, 6621, 0x00e0, 6648, 0x00dc, 6675, 0x00d8, 6702, 0x00d4, |
| 144 | 6728, 0x00d0, 6755, 0x00cc, 6782, 0x00c8, 6809, 0x00c4, 6836, 0x00c0, |
| 145 | 6863, 0x00bc, 6890, 0x00b8, 6917, 0x00b4, 6945, 0x00b0, 6972, 0x00ac, |
| 146 | 6999, 0x00a8, 7027, 0x00a4, 7054, 0x00a0, 7081, 0x009c, 7109, 0x0098, |
| 147 | 7136, 0x0094, 7164, 0x0090, 7192, 0x008c, 7219, 0x0088, 7247, 0x0084, |
| 148 | 7275, 0x0080, 7303, 0x007c, 7331, 0x0078, 7359, 0x0074, 7387, 0x0070, |
| 149 | 7415, 0x006c, 7443, 0x0068, 7471, 0x0064, 7499, 0x0060, 7527, 0x005c, |
| 150 | 7556, 0x0058, 7584, 0x0054, 7613, 0x0050, 7641, 0x004c, 7669, 0x0048, |
| 151 | 7698, 0x0044, 7727, 0x0040, 7755, 0x003c, 7784, 0x0038, 7813, 0x0034, |
| 152 | 7842, 0x0030, 7870, 0x002c, 7899, 0x0028, 7928, 0x0024, 7957, 0x0020, |
| 153 | 7986, 0x001c, 8016, 0x0018, 8045, 0x0014, 8074, 0x0010, 8103, 0x000c, |
| 154 | 8133, 0x0008, 8162, 0x0004, 8192, 0x0000 |
| 155 | }; |
| 156 | |
| 157 | static unsigned short lookup_volume_table( unsigned short value ) |
| 158 | { |
| 159 | /* This code is an optimised version of: |
| 160 | * int i = 0; |
| 161 | * while( volume_table[i*2] < value ) |
| 162 | * i++; |
| 163 | * return volume_table[i*2+1]; |
| 164 | */ |
| 165 | unsigned short *ptr = log_table; |
| 166 | while( *ptr < value ) |
| 167 | ptr += 2; |
| 168 | return *(ptr+1); |
| 169 | } |
| 170 | |
| 171 | /* this function calculates a 8.8 fixed point logarithmic attenuation |
| 172 | * value from a linear volume value in the range 0 to 16384 */ |
| 173 | static unsigned short log_from_linear( unsigned short value ) |
| 174 | { |
| 175 | if (value >= 16384) |
| 176 | return 0x0000; |
| 177 | if (value) { |
| 178 | unsigned short result = 0; |
| 179 | int v, c; |
| 180 | for( c = 0, v = 8192; c < 14; c++, v >>= 1 ) { |
| 181 | if( value >= v ) { |
| 182 | result += lookup_volume_table( (value - v) << c ); |
| 183 | return result; |
| 184 | } |
| 185 | result += 0x0605; /* 6.0205 (result of -20*log10(0.5)) */ |
| 186 | } |
| 187 | } |
| 188 | return 0xffff; |
| 189 | } |
| 190 | |
| 191 | /* |
| 192 | * Sample handling operations |
| 193 | */ |
| 194 | |
| 195 | static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position); |
| 196 | static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode); |
| 197 | static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq); |
| 198 | static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume); |
| 199 | static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop); |
| 200 | static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position); |
| 201 | static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data); |
| 202 | |
| 203 | static snd_trident_sample_ops_t sample_ops = |
| 204 | { |
| 205 | sample_start, |
| 206 | sample_stop, |
| 207 | sample_freq, |
| 208 | sample_volume, |
| 209 | sample_loop, |
| 210 | sample_pos, |
| 211 | sample_private1 |
| 212 | }; |
| 213 | |
| 214 | static void snd_trident_simple_init(snd_trident_voice_t * voice) |
| 215 | { |
| 216 | //voice->handler_wave = interrupt_wave; |
| 217 | //voice->handler_volume = interrupt_volume; |
| 218 | //voice->handler_effect = interrupt_effect; |
| 219 | //voice->volume_change = NULL; |
| 220 | voice->sample_ops = &sample_ops; |
| 221 | } |
| 222 | |
| 223 | static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position) |
| 224 | { |
| 225 | simple_instrument_t *simple; |
| 226 | snd_seq_kinstr_t *instr; |
| 227 | unsigned long flags; |
| 228 | unsigned int loop_start, loop_end, sample_start, sample_end, start_offset; |
| 229 | unsigned int value; |
| 230 | unsigned int shift = 0; |
| 231 | |
| 232 | instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); |
| 233 | if (instr == NULL) |
| 234 | return; |
| 235 | voice->instr = instr->instr; /* copy ID to speedup aliases */ |
| 236 | simple = KINSTR_DATA(instr); |
| 237 | |
| 238 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 239 | |
| 240 | if (trident->device == TRIDENT_DEVICE_ID_SI7018) |
| 241 | voice->GVSel = 1; /* route to Wave volume */ |
| 242 | |
| 243 | voice->CTRL = 0; |
| 244 | voice->Alpha = 0; |
| 245 | voice->FMS = 0; |
| 246 | |
| 247 | loop_start = simple->loop_start >> 4; |
| 248 | loop_end = simple->loop_end >> 4; |
| 249 | sample_start = (simple->start + position) >> 4; |
| 250 | if( sample_start >= simple->size ) |
| 251 | sample_start = simple->start >> 4; |
| 252 | sample_end = simple->size; |
| 253 | start_offset = position >> 4; |
| 254 | |
| 255 | if (simple->format & SIMPLE_WAVE_16BIT) { |
| 256 | voice->CTRL |= 8; |
| 257 | shift++; |
| 258 | } |
| 259 | if (simple->format & SIMPLE_WAVE_STEREO) { |
| 260 | voice->CTRL |= 4; |
| 261 | shift++; |
| 262 | } |
| 263 | if (!(simple->format & SIMPLE_WAVE_UNSIGNED)) |
| 264 | voice->CTRL |= 2; |
| 265 | |
| 266 | voice->LBA = simple->address.memory; |
| 267 | |
| 268 | if (simple->format & SIMPLE_WAVE_LOOP) { |
| 269 | voice->CTRL |= 1; |
| 270 | voice->LBA += loop_start << shift; |
| 271 | if( start_offset >= loop_start ) { |
| 272 | voice->CSO = start_offset - loop_start; |
| 273 | voice->negCSO = 0; |
| 274 | } else { |
| 275 | voice->CSO = loop_start - start_offset; |
| 276 | voice->negCSO = 1; |
| 277 | } |
| 278 | voice->ESO = loop_end - loop_start - 1; |
| 279 | } else { |
| 280 | voice->LBA += start_offset << shift; |
| 281 | voice->CSO = sample_start; |
| 282 | voice->ESO = sample_end - 1; |
| 283 | voice->negCSO = 0; |
| 284 | } |
| 285 | |
| 286 | if (voice->flags & SNDRV_TRIDENT_VFLG_RUNNING) { |
| 287 | snd_trident_stop_voice(trident, voice->number); |
| 288 | voice->flags &= ~SNDRV_TRIDENT_VFLG_RUNNING; |
| 289 | } |
| 290 | |
| 291 | /* set CSO sign */ |
| 292 | value = inl(TRID_REG(trident, T4D_SIGN_CSO_A)); |
| 293 | if( voice->negCSO ) { |
| 294 | value |= 1 << (voice->number&31); |
| 295 | } else { |
| 296 | value &= ~(1 << (voice->number&31)); |
| 297 | } |
| 298 | outl(value,TRID_REG(trident, T4D_SIGN_CSO_A)); |
| 299 | |
| 300 | voice->Attribute = 0; |
| 301 | snd_trident_write_voice_regs(trident, voice); |
| 302 | snd_trident_start_voice(trident, voice->number); |
| 303 | voice->flags |= SNDRV_TRIDENT_VFLG_RUNNING; |
| 304 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 305 | snd_seq_instr_free_use(trident->synth.ilist, instr); |
| 306 | } |
| 307 | |
| 308 | static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode) |
| 309 | { |
| 310 | unsigned long flags; |
| 311 | |
| 312 | if (!(voice->flags & SNDRV_TRIDENT_VFLG_RUNNING)) |
| 313 | return; |
| 314 | |
| 315 | switch (mode) { |
| 316 | default: |
| 317 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 318 | snd_trident_stop_voice(trident, voice->number); |
| 319 | voice->flags &= ~SNDRV_TRIDENT_VFLG_RUNNING; |
| 320 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 321 | break; |
| 322 | case SAMPLE_STOP_LOOP: /* disable loop only */ |
| 323 | voice->CTRL &= ~1; |
| 324 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 325 | outb((unsigned char) voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); |
| 326 | outw((((voice->CTRL << 12) | (voice->EC & 0x0fff)) & 0xffff), CH_GVSEL_PAN_VOL_CTRL_EC); |
| 327 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 328 | break; |
| 329 | } |
| 330 | } |
| 331 | |
| 332 | static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq) |
| 333 | { |
| 334 | unsigned long flags; |
| 335 | freq >>= 4; |
| 336 | |
| 337 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 338 | if (freq == 44100) |
| 339 | voice->Delta = 0xeb3; |
| 340 | else if (freq == 8000) |
| 341 | voice->Delta = 0x2ab; |
| 342 | else if (freq == 48000) |
| 343 | voice->Delta = 0x1000; |
| 344 | else |
| 345 | voice->Delta = (((freq << 12) + freq) / 48000) & 0x0000ffff; |
| 346 | |
| 347 | outb((unsigned char) voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); |
| 348 | if (trident->device == TRIDENT_DEVICE_ID_NX) { |
| 349 | outb((unsigned char) voice->Delta, TRID_REG(trident, CH_NX_DELTA_CSO + 3)); |
| 350 | outb((unsigned char) (voice->Delta >> 8), TRID_REG(trident, CH_NX_DELTA_ESO + 3)); |
| 351 | } else { |
| 352 | outw((unsigned short) voice->Delta, TRID_REG(trident, CH_DX_ESO_DELTA)); |
| 353 | } |
| 354 | |
| 355 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 356 | } |
| 357 | |
| 358 | static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume) |
| 359 | { |
| 360 | unsigned long flags; |
| 361 | unsigned short value; |
| 362 | |
| 363 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 364 | voice->GVSel = 0; /* use global music volume */ |
| 365 | voice->FMC = 0x03; /* fixme: can we do something useful with FMC? */ |
| 366 | if (volume->volume >= 0) { |
| 367 | volume->volume &= 0x3fff; |
| 368 | /* linear volume -> logarithmic attenuation conversion |
| 369 | * uses EC register for greater resolution (6.6 bits) than Vol register (5.3 bits) |
| 370 | * Vol register used when additional attenuation is required */ |
| 371 | voice->RVol = 0; |
| 372 | voice->CVol = 0; |
| 373 | value = log_from_linear( volume->volume ); |
| 374 | voice->Vol = 0; |
| 375 | voice->EC = (value & 0x3fff) >> 2; |
| 376 | if (value > 0x3fff) { |
| 377 | voice->EC |= 0xfc0; |
| 378 | if (value < 0x5f00 ) |
| 379 | voice->Vol = ((value >> 8) - 0x3f) << 5; |
| 380 | else { |
| 381 | voice->Vol = 0x3ff; |
| 382 | voice->EC = 0xfff; |
| 383 | } |
| 384 | } |
| 385 | } |
| 386 | if (volume->lr >= 0) { |
| 387 | volume->lr &= 0x3fff; |
| 388 | /* approximate linear pan by attenuating channels */ |
| 389 | if (volume->lr >= 0x2000) { /* attenuate left (pan right) */ |
| 390 | value = 0x3fff - volume->lr; |
| 391 | for (voice->Pan = 0; voice->Pan < 63; voice->Pan++ ) |
| 392 | if (value >= pan_table[voice->Pan] ) |
| 393 | break; |
| 394 | } else { /* attenuate right (pan left) */ |
| 395 | for (voice->Pan = 0; voice->Pan < 63; voice->Pan++ ) |
| 396 | if ((unsigned int)volume->lr >= pan_table[voice->Pan] ) |
| 397 | break; |
| 398 | voice->Pan |= 0x40; |
| 399 | } |
| 400 | } |
| 401 | outb((unsigned char) voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); |
| 402 | outl((voice->GVSel << 31) | ((voice->Pan & 0x0000007f) << 24) | |
| 403 | ((voice->Vol & 0x000000ff) << 16) | ((voice->CTRL & 0x0000000f) << 12) | |
| 404 | (voice->EC & 0x00000fff), TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC)); |
| 405 | value = ((voice->FMC & 0x03) << 14) | ((voice->RVol & 0x7f) << 7) | (voice->CVol & 0x7f); |
| 406 | outw(value, TRID_REG(trident, CH_DX_FMC_RVOL_CVOL)); |
| 407 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 408 | } |
| 409 | |
| 410 | static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop) |
| 411 | { |
| 412 | unsigned long flags; |
| 413 | simple_instrument_t *simple; |
| 414 | snd_seq_kinstr_t *instr; |
| 415 | unsigned int loop_start, loop_end; |
| 416 | |
| 417 | instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); |
| 418 | if (instr == NULL) |
| 419 | return; |
| 420 | voice->instr = instr->instr; /* copy ID to speedup aliases */ |
| 421 | simple = KINSTR_DATA(instr); |
| 422 | |
| 423 | loop_start = loop->start >> 4; |
| 424 | loop_end = loop->end >> 4; |
| 425 | |
| 426 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 427 | |
| 428 | voice->LBA = simple->address.memory + loop_start; |
| 429 | voice->CSO = 0; |
| 430 | voice->ESO = loop_end - loop_start - 1; |
| 431 | |
| 432 | outb((unsigned char) voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); |
| 433 | outb((voice->LBA >> 16), TRID_REG(trident, CH_LBA + 2)); |
| 434 | outw((voice->LBA & 0xffff), TRID_REG(trident, CH_LBA)); |
| 435 | if (trident->device == TRIDENT_DEVICE_ID_NX) { |
| 436 | outb((voice->ESO >> 16), TRID_REG(trident, CH_NX_DELTA_ESO + 2)); |
| 437 | outw((voice->ESO & 0xffff), TRID_REG(trident, CH_NX_DELTA_ESO)); |
| 438 | outb((voice->CSO >> 16), TRID_REG(trident, CH_NX_DELTA_CSO + 2)); |
| 439 | outw((voice->CSO & 0xffff), TRID_REG(trident, CH_NX_DELTA_CSO)); |
| 440 | } else { |
| 441 | outw((voice->ESO & 0xffff), TRID_REG(trident, CH_DX_ESO_DELTA + 2)); |
| 442 | outw((voice->CSO & 0xffff), TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2)); |
| 443 | } |
| 444 | |
| 445 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 446 | snd_seq_instr_free_use(trident->synth.ilist, instr); |
| 447 | } |
| 448 | |
| 449 | static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position) |
| 450 | { |
| 451 | unsigned long flags; |
| 452 | simple_instrument_t *simple; |
| 453 | snd_seq_kinstr_t *instr; |
| 454 | unsigned int value; |
| 455 | |
| 456 | instr = snd_seq_instr_find(trident->synth.ilist, &voice->instr, 0, 1); |
| 457 | if (instr == NULL) |
| 458 | return; |
| 459 | voice->instr = instr->instr; /* copy ID to speedup aliases */ |
| 460 | simple = KINSTR_DATA(instr); |
| 461 | |
| 462 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 463 | |
| 464 | if (simple->format & SIMPLE_WAVE_LOOP) { |
| 465 | if( position >= simple->loop_start ) { |
| 466 | voice->CSO = (position - simple->loop_start) >> 4; |
| 467 | voice->negCSO = 0; |
| 468 | } else { |
| 469 | voice->CSO = (simple->loop_start - position) >> 4; |
| 470 | voice->negCSO = 1; |
| 471 | } |
| 472 | } else { |
| 473 | voice->CSO = position >> 4; |
| 474 | voice->negCSO = 0; |
| 475 | } |
| 476 | |
| 477 | /* set CSO sign */ |
| 478 | value = inl(TRID_REG(trident, T4D_SIGN_CSO_A)); |
| 479 | if( voice->negCSO ) { |
| 480 | value |= 1 << (voice->number&31); |
| 481 | } else { |
| 482 | value &= ~(1 << (voice->number&31)); |
| 483 | } |
| 484 | outl(value,TRID_REG(trident, T4D_SIGN_CSO_A)); |
| 485 | |
| 486 | |
| 487 | outb((unsigned char) voice->number, TRID_REG(trident, T4D_LFO_GC_CIR)); |
| 488 | if (trident->device == TRIDENT_DEVICE_ID_NX) { |
| 489 | outw((voice->CSO & 0xffff), TRID_REG(trident, CH_NX_DELTA_CSO)); |
| 490 | outb((voice->CSO >> 16), TRID_REG(trident, CH_NX_DELTA_CSO + 2)); |
| 491 | } else { |
| 492 | outw((voice->CSO & 0xffff), TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2); |
| 493 | } |
| 494 | |
| 495 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 496 | snd_seq_instr_free_use(trident->synth.ilist, instr); |
| 497 | } |
| 498 | |
| 499 | static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data) |
| 500 | { |
| 501 | } |
| 502 | |
| 503 | /* |
| 504 | * Memory management / sample loading |
| 505 | */ |
| 506 | |
| 507 | static int snd_trident_simple_put_sample(void *private_data, simple_instrument_t * instr, |
| 508 | char __user *data, long len, int atomic) |
| 509 | { |
| 510 | trident_t *trident = private_data; |
| 511 | int size = instr->size; |
| 512 | int shift = 0; |
| 513 | |
| 514 | if (instr->format & SIMPLE_WAVE_BACKWARD || |
| 515 | instr->format & SIMPLE_WAVE_BIDIR || |
| 516 | instr->format & SIMPLE_WAVE_ULAW) |
| 517 | return -EINVAL; /* not supported */ |
| 518 | |
| 519 | if (instr->format & SIMPLE_WAVE_16BIT) |
| 520 | shift++; |
| 521 | if (instr->format & SIMPLE_WAVE_STEREO) |
| 522 | shift++; |
| 523 | size <<= shift; |
| 524 | |
| 525 | if (trident->synth.current_size + size > trident->synth.max_size) |
| 526 | return -ENOMEM; |
| 527 | |
| 528 | if (!access_ok(VERIFY_READ, data, size)) |
| 529 | return -EFAULT; |
| 530 | |
| 531 | if (trident->tlb.entries) { |
| 532 | snd_util_memblk_t *memblk; |
| 533 | memblk = snd_trident_synth_alloc(trident, size); |
| 534 | if (memblk == NULL) |
| 535 | return -ENOMEM; |
| 536 | if (snd_trident_synth_copy_from_user(trident, memblk, 0, data, size) ) { |
| 537 | snd_trident_synth_free(trident, memblk); |
| 538 | return -EFAULT; |
| 539 | } |
| 540 | instr->address.ptr = (unsigned char*)memblk; |
| 541 | instr->address.memory = memblk->offset; |
| 542 | } else { |
| 543 | struct snd_dma_buffer dmab; |
| 544 | if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), |
| 545 | size, &dmab) < 0) |
| 546 | return -ENOMEM; |
| 547 | |
| 548 | if (copy_from_user(dmab.area, data, size)) { |
| 549 | snd_dma_free_pages(&dmab); |
| 550 | return -EFAULT; |
| 551 | } |
| 552 | instr->address.ptr = dmab.area; |
| 553 | instr->address.memory = dmab.addr; |
| 554 | } |
| 555 | |
| 556 | trident->synth.current_size += size; |
| 557 | return 0; |
| 558 | } |
| 559 | |
| 560 | static int snd_trident_simple_get_sample(void *private_data, simple_instrument_t * instr, |
| 561 | char __user *data, long len, int atomic) |
| 562 | { |
| 563 | //trident_t *trident = private_data; |
| 564 | int size = instr->size; |
| 565 | int shift = 0; |
| 566 | |
| 567 | if (instr->format & SIMPLE_WAVE_16BIT) |
| 568 | shift++; |
| 569 | if (instr->format & SIMPLE_WAVE_STEREO) |
| 570 | shift++; |
| 571 | size <<= shift; |
| 572 | |
| 573 | if (!access_ok(VERIFY_WRITE, data, size)) |
| 574 | return -EFAULT; |
| 575 | |
| 576 | /* FIXME: not implemented yet */ |
| 577 | |
| 578 | return -EBUSY; |
| 579 | } |
| 580 | |
| 581 | static int snd_trident_simple_remove_sample(void *private_data, simple_instrument_t * instr, |
| 582 | int atomic) |
| 583 | { |
| 584 | trident_t *trident = private_data; |
| 585 | int size = instr->size; |
| 586 | |
| 587 | if (instr->format & SIMPLE_WAVE_16BIT) |
| 588 | size <<= 1; |
| 589 | if (instr->format & SIMPLE_WAVE_STEREO) |
| 590 | size <<= 1; |
| 591 | |
| 592 | if (trident->tlb.entries) { |
| 593 | snd_util_memblk_t *memblk = (snd_util_memblk_t*)instr->address.ptr; |
| 594 | if (memblk) |
| 595 | snd_trident_synth_free(trident, memblk); |
| 596 | else |
| 597 | return -EFAULT; |
| 598 | } else { |
| 599 | struct snd_dma_buffer dmab; |
| 600 | dmab.dev.type = SNDRV_DMA_TYPE_DEV; |
| 601 | dmab.dev.dev = snd_dma_pci_data(trident->pci); |
| 602 | dmab.area = instr->address.ptr; |
| 603 | dmab.addr = instr->address.memory; |
| 604 | dmab.bytes = size; |
| 605 | snd_dma_free_pages(&dmab); |
| 606 | } |
| 607 | |
| 608 | trident->synth.current_size -= size; |
| 609 | if (trident->synth.current_size < 0) /* shouldn't need this check... */ |
| 610 | trident->synth.current_size = 0; |
| 611 | |
| 612 | return 0; |
| 613 | } |
| 614 | |
| 615 | static void select_instrument(trident_t * trident, snd_trident_voice_t * v) |
| 616 | { |
| 617 | snd_seq_kinstr_t *instr; |
| 618 | instr = snd_seq_instr_find(trident->synth.ilist, &v->instr, 0, 1); |
| 619 | if (instr != NULL) { |
| 620 | if (instr->ops) { |
| 621 | if (!strcmp(instr->ops->instr_type, SNDRV_SEQ_INSTR_ID_SIMPLE)) |
| 622 | snd_trident_simple_init(v); |
| 623 | } |
| 624 | snd_seq_instr_free_use(trident->synth.ilist, instr); |
| 625 | } |
| 626 | } |
| 627 | |
| 628 | /* |
| 629 | |
| 630 | */ |
| 631 | |
| 632 | static void event_sample(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 633 | { |
| 634 | if (v->sample_ops && v->sample_ops->sample_stop) |
| 635 | v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY); |
| 636 | v->instr.std = ev->data.sample.param.sample.std; |
| 637 | if (v->instr.std & 0xff000000) { /* private instrument */ |
| 638 | v->instr.std &= 0x00ffffff; |
| 639 | v->instr.std |= (unsigned int)ev->source.client << 24; |
| 640 | } |
| 641 | v->instr.bank = ev->data.sample.param.sample.bank; |
| 642 | v->instr.prg = ev->data.sample.param.sample.prg; |
| 643 | select_instrument(p->trident, v); |
| 644 | } |
| 645 | |
| 646 | static void event_cluster(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 647 | { |
| 648 | if (v->sample_ops && v->sample_ops->sample_stop) |
| 649 | v->sample_ops->sample_stop(p->trident, v, SAMPLE_STOP_IMMEDIATELY); |
| 650 | v->instr.cluster = ev->data.sample.param.cluster.cluster; |
| 651 | select_instrument(p->trident, v); |
| 652 | } |
| 653 | |
| 654 | static void event_start(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 655 | { |
| 656 | if (v->sample_ops && v->sample_ops->sample_start) |
| 657 | v->sample_ops->sample_start(p->trident, v, ev->data.sample.param.position); |
| 658 | } |
| 659 | |
| 660 | static void event_stop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 661 | { |
| 662 | if (v->sample_ops && v->sample_ops->sample_stop) |
| 663 | v->sample_ops->sample_stop(p->trident, v, ev->data.sample.param.stop_mode); |
| 664 | } |
| 665 | |
| 666 | static void event_freq(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 667 | { |
| 668 | if (v->sample_ops && v->sample_ops->sample_freq) |
| 669 | v->sample_ops->sample_freq(p->trident, v, ev->data.sample.param.frequency); |
| 670 | } |
| 671 | |
| 672 | static void event_volume(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 673 | { |
| 674 | if (v->sample_ops && v->sample_ops->sample_volume) |
| 675 | v->sample_ops->sample_volume(p->trident, v, &ev->data.sample.param.volume); |
| 676 | } |
| 677 | |
| 678 | static void event_loop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 679 | { |
| 680 | if (v->sample_ops && v->sample_ops->sample_loop) |
| 681 | v->sample_ops->sample_loop(p->trident, v, &ev->data.sample.param.loop); |
| 682 | } |
| 683 | |
| 684 | static void event_position(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 685 | { |
| 686 | if (v->sample_ops && v->sample_ops->sample_pos) |
| 687 | v->sample_ops->sample_pos(p->trident, v, ev->data.sample.param.position); |
| 688 | } |
| 689 | |
| 690 | static void event_private1(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v) |
| 691 | { |
| 692 | if (v->sample_ops && v->sample_ops->sample_private1) |
| 693 | v->sample_ops->sample_private1(p->trident, v, (unsigned char *) &ev->data.sample.param.raw8); |
| 694 | } |
| 695 | |
| 696 | typedef void (trident_sample_event_handler_t) (snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v); |
| 697 | |
| 698 | static trident_sample_event_handler_t *trident_sample_event_handlers[9] = |
| 699 | { |
| 700 | event_sample, |
| 701 | event_cluster, |
| 702 | event_start, |
| 703 | event_stop, |
| 704 | event_freq, |
| 705 | event_volume, |
| 706 | event_loop, |
| 707 | event_position, |
| 708 | event_private1 |
| 709 | }; |
| 710 | |
| 711 | static void snd_trident_sample_event(snd_seq_event_t * ev, snd_trident_port_t * p) |
| 712 | { |
| 713 | int idx, voice; |
| 714 | trident_t *trident = p->trident; |
| 715 | snd_trident_voice_t *v; |
| 716 | unsigned long flags; |
| 717 | |
| 718 | idx = ev->type - SNDRV_SEQ_EVENT_SAMPLE; |
| 719 | if (idx < 0 || idx > 8) |
| 720 | return; |
| 721 | for (voice = 0; voice < 64; voice++) { |
| 722 | v = &trident->synth.voices[voice]; |
| 723 | if (v->use && v->client == ev->source.client && |
| 724 | v->port == ev->source.port && |
| 725 | v->index == ev->data.sample.channel) { |
| 726 | spin_lock_irqsave(&trident->event_lock, flags); |
| 727 | trident_sample_event_handlers[idx] (ev, p, v); |
| 728 | spin_unlock_irqrestore(&trident->event_lock, flags); |
| 729 | return; |
| 730 | } |
| 731 | } |
| 732 | } |
| 733 | |
| 734 | /* |
| 735 | |
| 736 | */ |
| 737 | |
| 738 | static void snd_trident_synth_free_voices(trident_t * trident, int client, int port) |
| 739 | { |
| 740 | int idx; |
| 741 | snd_trident_voice_t *voice; |
| 742 | |
| 743 | for (idx = 0; idx < 32; idx++) { |
| 744 | voice = &trident->synth.voices[idx]; |
| 745 | if (voice->use && voice->client == client && voice->port == port) |
| 746 | snd_trident_free_voice(trident, voice); |
| 747 | } |
| 748 | } |
| 749 | |
| 750 | static int snd_trident_synth_use(void *private_data, snd_seq_port_subscribe_t * info) |
| 751 | { |
| 752 | snd_trident_port_t *port = (snd_trident_port_t *) private_data; |
| 753 | trident_t *trident = port->trident; |
| 754 | snd_trident_voice_t *voice; |
| 755 | unsigned int idx; |
| 756 | unsigned long flags; |
| 757 | |
| 758 | if (info->voices > 32) |
| 759 | return -EINVAL; |
| 760 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 761 | for (idx = 0; idx < info->voices; idx++) { |
| 762 | voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_SYNTH, info->sender.client, info->sender.port); |
| 763 | if (voice == NULL) { |
| 764 | snd_trident_synth_free_voices(trident, info->sender.client, info->sender.port); |
| 765 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 766 | return -EBUSY; |
| 767 | } |
| 768 | voice->index = idx; |
| 769 | voice->Vol = 0x3ff; |
| 770 | voice->EC = 0x0fff; |
| 771 | } |
| 772 | #if 0 |
| 773 | for (idx = 0; idx < info->midi_voices; idx++) { |
| 774 | port->midi_has_voices = 1; |
| 775 | voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_MIDI, info->sender.client, info->sender.port); |
| 776 | if (voice == NULL) { |
| 777 | snd_trident_synth_free_voices(trident, info->sender.client, info->sender.port); |
| 778 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 779 | return -EBUSY; |
| 780 | } |
| 781 | voice->Vol = 0x3ff; |
| 782 | voice->EC = 0x0fff; |
| 783 | } |
| 784 | #endif |
| 785 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 786 | return 0; |
| 787 | } |
| 788 | |
| 789 | static int snd_trident_synth_unuse(void *private_data, snd_seq_port_subscribe_t * info) |
| 790 | { |
| 791 | snd_trident_port_t *port = (snd_trident_port_t *) private_data; |
| 792 | trident_t *trident = port->trident; |
| 793 | unsigned long flags; |
| 794 | |
| 795 | spin_lock_irqsave(&trident->reg_lock, flags); |
| 796 | snd_trident_synth_free_voices(trident, info->sender.client, info->sender.port); |
| 797 | spin_unlock_irqrestore(&trident->reg_lock, flags); |
| 798 | return 0; |
| 799 | } |
| 800 | |
| 801 | /* |
| 802 | |
| 803 | */ |
| 804 | |
| 805 | static void snd_trident_synth_free_private_instruments(snd_trident_port_t * p, int client) |
| 806 | { |
| 807 | snd_seq_instr_header_t ifree; |
| 808 | |
| 809 | memset(&ifree, 0, sizeof(ifree)); |
| 810 | ifree.cmd = SNDRV_SEQ_INSTR_FREE_CMD_PRIVATE; |
| 811 | snd_seq_instr_list_free_cond(p->trident->synth.ilist, &ifree, client, 0); |
| 812 | } |
| 813 | |
| 814 | static int snd_trident_synth_event_input(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop) |
| 815 | { |
| 816 | snd_trident_port_t *p = (snd_trident_port_t *) private_data; |
| 817 | |
| 818 | if (p == NULL) |
| 819 | return -EINVAL; |
| 820 | if (ev->type >= SNDRV_SEQ_EVENT_SAMPLE && |
| 821 | ev->type <= SNDRV_SEQ_EVENT_SAMPLE_PRIVATE1) { |
| 822 | snd_trident_sample_event(ev, p); |
| 823 | return 0; |
| 824 | } |
| 825 | if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM && |
| 826 | ev->source.port == SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE) { |
| 827 | if (ev->type == SNDRV_SEQ_EVENT_CLIENT_EXIT) { |
| 828 | snd_trident_synth_free_private_instruments(p, ev->data.addr.client); |
| 829 | return 0; |
| 830 | } |
| 831 | } |
| 832 | if (direct) { |
| 833 | if (ev->type >= SNDRV_SEQ_EVENT_INSTR_BEGIN) { |
| 834 | snd_seq_instr_event(&p->trident->synth.simple_ops.kops, |
| 835 | p->trident->synth.ilist, ev, |
| 836 | p->trident->synth.seq_client, atomic, hop); |
| 837 | return 0; |
| 838 | } |
| 839 | } |
| 840 | return 0; |
| 841 | } |
| 842 | |
| 843 | static void snd_trident_synth_instr_notify(void *private_data, |
| 844 | snd_seq_kinstr_t * instr, |
| 845 | int what) |
| 846 | { |
| 847 | int idx; |
| 848 | trident_t *trident = private_data; |
| 849 | snd_trident_voice_t *pvoice; |
| 850 | unsigned long flags; |
| 851 | |
| 852 | spin_lock_irqsave(&trident->event_lock, flags); |
| 853 | for (idx = 0; idx < 64; idx++) { |
| 854 | pvoice = &trident->synth.voices[idx]; |
| 855 | if (pvoice->use && !memcmp(&pvoice->instr, &instr->instr, sizeof(pvoice->instr))) { |
| 856 | if (pvoice->sample_ops && pvoice->sample_ops->sample_stop) { |
| 857 | pvoice->sample_ops->sample_stop(trident, pvoice, SAMPLE_STOP_IMMEDIATELY); |
| 858 | } else { |
| 859 | snd_trident_stop_voice(trident, pvoice->number); |
| 860 | pvoice->flags &= ~SNDRV_TRIDENT_VFLG_RUNNING; |
| 861 | } |
| 862 | } |
| 863 | } |
| 864 | spin_unlock_irqrestore(&trident->event_lock, flags); |
| 865 | } |
| 866 | |
| 867 | /* |
| 868 | |
| 869 | */ |
| 870 | |
| 871 | static void snd_trident_synth_free_port(void *private_data) |
| 872 | { |
| 873 | snd_trident_port_t *p = (snd_trident_port_t *) private_data; |
| 874 | |
| 875 | if (p) |
| 876 | snd_midi_channel_free_set(p->chset); |
| 877 | } |
| 878 | |
| 879 | static int snd_trident_synth_create_port(trident_t * trident, int idx) |
| 880 | { |
| 881 | snd_trident_port_t *p; |
| 882 | snd_seq_port_callback_t callbacks; |
| 883 | char name[32]; |
| 884 | char *str; |
| 885 | int result; |
| 886 | |
| 887 | p = &trident->synth.seq_ports[idx]; |
| 888 | p->chset = snd_midi_channel_alloc_set(16); |
| 889 | if (p->chset == NULL) |
| 890 | return -ENOMEM; |
| 891 | p->chset->private_data = p; |
| 892 | p->trident = trident; |
| 893 | p->client = trident->synth.seq_client; |
| 894 | |
| 895 | memset(&callbacks, 0, sizeof(callbacks)); |
| 896 | callbacks.owner = THIS_MODULE; |
| 897 | callbacks.use = snd_trident_synth_use; |
| 898 | callbacks.unuse = snd_trident_synth_unuse; |
| 899 | callbacks.event_input = snd_trident_synth_event_input; |
| 900 | callbacks.private_free = snd_trident_synth_free_port; |
| 901 | callbacks.private_data = p; |
| 902 | |
| 903 | str = "???"; |
| 904 | switch (trident->device) { |
| 905 | case TRIDENT_DEVICE_ID_DX: str = "Trident 4DWave-DX"; break; |
| 906 | case TRIDENT_DEVICE_ID_NX: str = "Trident 4DWave-NX"; break; |
| 907 | case TRIDENT_DEVICE_ID_SI7018: str = "SiS 7018"; break; |
| 908 | } |
| 909 | sprintf(name, "%s port %i", str, idx); |
| 910 | p->chset->port = snd_seq_event_port_attach(trident->synth.seq_client, |
| 911 | &callbacks, |
| 912 | SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE, |
| 913 | SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE | |
| 914 | SNDRV_SEQ_PORT_TYPE_SYNTH, |
| 915 | 16, 0, |
| 916 | name); |
| 917 | if (p->chset->port < 0) { |
| 918 | result = p->chset->port; |
| 919 | snd_trident_synth_free_port(p); |
| 920 | return result; |
| 921 | } |
| 922 | p->port = p->chset->port; |
| 923 | return 0; |
| 924 | } |
| 925 | |
| 926 | /* |
| 927 | |
| 928 | */ |
| 929 | |
| 930 | static int snd_trident_synth_new_device(snd_seq_device_t *dev) |
| 931 | { |
| 932 | trident_t *trident; |
| 933 | int client, i; |
| 934 | snd_seq_client_callback_t callbacks; |
| 935 | snd_seq_client_info_t cinfo; |
| 936 | snd_seq_port_subscribe_t sub; |
| 937 | snd_simple_ops_t *simpleops; |
| 938 | char *str; |
| 939 | |
| 940 | trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); |
| 941 | if (trident == NULL) |
| 942 | return -EINVAL; |
| 943 | |
| 944 | trident->synth.seq_client = -1; |
| 945 | |
| 946 | /* allocate new client */ |
| 947 | memset(&callbacks, 0, sizeof(callbacks)); |
| 948 | callbacks.private_data = trident; |
| 949 | callbacks.allow_output = callbacks.allow_input = 1; |
| 950 | client = trident->synth.seq_client = |
| 951 | snd_seq_create_kernel_client(trident->card, 1, &callbacks); |
| 952 | if (client < 0) |
| 953 | return client; |
| 954 | |
| 955 | /* change name of client */ |
| 956 | memset(&cinfo, 0, sizeof(cinfo)); |
| 957 | cinfo.client = client; |
| 958 | cinfo.type = KERNEL_CLIENT; |
| 959 | str = "???"; |
| 960 | switch (trident->device) { |
| 961 | case TRIDENT_DEVICE_ID_DX: str = "Trident 4DWave-DX"; break; |
| 962 | case TRIDENT_DEVICE_ID_NX: str = "Trident 4DWave-NX"; break; |
| 963 | case TRIDENT_DEVICE_ID_SI7018: str = "SiS 7018"; break; |
| 964 | } |
| 965 | sprintf(cinfo.name, str); |
| 966 | snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &cinfo); |
| 967 | |
| 968 | for (i = 0; i < 4; i++) |
| 969 | snd_trident_synth_create_port(trident, i); |
| 970 | |
| 971 | trident->synth.ilist = snd_seq_instr_list_new(); |
| 972 | if (trident->synth.ilist == NULL) { |
| 973 | snd_seq_delete_kernel_client(client); |
| 974 | trident->synth.seq_client = -1; |
| 975 | return -ENOMEM; |
| 976 | } |
| 977 | trident->synth.ilist->flags = SNDRV_SEQ_INSTR_FLG_DIRECT; |
| 978 | |
| 979 | simpleops = &trident->synth.simple_ops; |
| 980 | snd_seq_simple_init(simpleops, trident, NULL); |
| 981 | simpleops->put_sample = snd_trident_simple_put_sample; |
| 982 | simpleops->get_sample = snd_trident_simple_get_sample; |
| 983 | simpleops->remove_sample = snd_trident_simple_remove_sample; |
| 984 | simpleops->notify = snd_trident_synth_instr_notify; |
| 985 | |
| 986 | memset(&sub, 0, sizeof(sub)); |
| 987 | sub.sender.client = SNDRV_SEQ_CLIENT_SYSTEM; |
| 988 | sub.sender.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE; |
| 989 | sub.dest.client = client; |
| 990 | sub.dest.port = 0; |
| 991 | snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &sub); |
| 992 | |
| 993 | return 0; |
| 994 | } |
| 995 | |
| 996 | static int snd_trident_synth_delete_device(snd_seq_device_t *dev) |
| 997 | { |
| 998 | trident_t *trident; |
| 999 | |
| 1000 | trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev); |
| 1001 | if (trident == NULL) |
| 1002 | return -EINVAL; |
| 1003 | |
| 1004 | if (trident->synth.seq_client >= 0) { |
| 1005 | snd_seq_delete_kernel_client(trident->synth.seq_client); |
| 1006 | trident->synth.seq_client = -1; |
| 1007 | } |
| 1008 | if (trident->synth.ilist) |
| 1009 | snd_seq_instr_list_free(&trident->synth.ilist); |
| 1010 | return 0; |
| 1011 | } |
| 1012 | |
| 1013 | static int __init alsa_trident_synth_init(void) |
| 1014 | { |
| 1015 | static snd_seq_dev_ops_t ops = |
| 1016 | { |
| 1017 | snd_trident_synth_new_device, |
| 1018 | snd_trident_synth_delete_device |
| 1019 | }; |
| 1020 | |
| 1021 | return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_TRIDENT, &ops, |
| 1022 | sizeof(trident_t*)); |
| 1023 | } |
| 1024 | |
| 1025 | static void __exit alsa_trident_synth_exit(void) |
| 1026 | { |
| 1027 | snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_TRIDENT); |
| 1028 | } |
| 1029 | |
| 1030 | module_init(alsa_trident_synth_init) |
| 1031 | module_exit(alsa_trident_synth_exit) |