?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[POWERPC] cell: cbe_cpufreq cleanup and crash fix
[linux-2.6/kvm.git] / arch / ppc / 8xx_io / cs4218_tdm.c
bloba956f28ab162b8d825a8cc068ca62a021249a313
1
2 /* This is a modified version of linux/drivers/sound/dmasound.c to
3 * support the CS4218 codec on the 8xx TDM port. Thanks to everyone
4 * that contributed to the dmasound software (which includes me :-).
5 *
6 * The CS4218 is configured in Mode 4, sub-mode 0. This provides
7 * left/right data only on the TDM port, as a 32-bit word, per frame
8 * pulse. The control of the CS4218 is provided by some other means,
9 * like the SPI port.
10 * Dan Malek (dmalek@jlc.net)
11 */
12
13 #include <linux/module.h>
14 #include <linux/sched.h>
15 #include <linux/timer.h>
16 #include <linux/major.h>
17 #include <linux/fcntl.h>
18 #include <linux/errno.h>
19 #include <linux/mm.h>
20 #include <linux/slab.h>
21 #include <linux/sound.h>
22 #include <linux/init.h>
23 #include <linux/delay.h>
24
25 #include <asm/system.h>
26 #include <asm/irq.h>
27 #include <asm/pgtable.h>
28 #include <asm/uaccess.h>
29 #include <asm/io.h>
30
31 /* Should probably do something different with this path name.....
32 * Actually, I should just stop using it...
33 */
34 #include "cs4218.h"
35 #include <linux/soundcard.h>
36
37 #include <asm/mpc8xx.h>
38 #include <asm/8xx_immap.h>
39 #include <asm/commproc.h>
40
41 #define DMASND_CS4218 5
42
43 #define MAX_CATCH_RADIUS 10
44 #define MIN_BUFFERS 4
45 #define MIN_BUFSIZE 4
46 #define MAX_BUFSIZE 128
47
48 #define HAS_8BIT_TABLES
49
50 static int sq_unit = -1;
51 static int mixer_unit = -1;
52 static int state_unit = -1;
53 static int irq_installed = 0;
54 static char **sound_buffers = NULL;
55 static char **sound_read_buffers = NULL;
56
57 static DEFINE_SPINLOCK(cs4218_lock);
58
59 /* Local copies of things we put in the control register. Output
60 * volume, like most codecs is really attenuation.
61 */
62 static int cs4218_rate_index;
63
64 /*
65 * Stuff for outputting a beep. The values range from -327 to +327
66 * so we can multiply by an amplitude in the range 0..100 to get a
67 * signed short value to put in the output buffer.
68 */
69 static short beep_wform[256] = {
70 0, 40, 79, 117, 153, 187, 218, 245,
71 269, 288, 304, 316, 323, 327, 327, 324,
72 318, 310, 299, 288, 275, 262, 249, 236,
73 224, 213, 204, 196, 190, 186, 183, 182,
74 182, 183, 186, 189, 192, 196, 200, 203,
75 206, 208, 209, 209, 209, 207, 204, 201,
76 197, 193, 188, 183, 179, 174, 170, 166,
77 163, 161, 160, 159, 159, 160, 161, 162,
78 164, 166, 168, 169, 171, 171, 171, 170,
79 169, 167, 163, 159, 155, 150, 144, 139,
80 133, 128, 122, 117, 113, 110, 107, 105,
81 103, 103, 103, 103, 104, 104, 105, 105,
82 105, 103, 101, 97, 92, 86, 78, 68,
83 58, 45, 32, 18, 3, -11, -26, -41,
84 -55, -68, -79, -88, -95, -100, -102, -102,
85 -99, -93, -85, -75, -62, -48, -33, -16,
86 0, 16, 33, 48, 62, 75, 85, 93,
87 99, 102, 102, 100, 95, 88, 79, 68,
88 55, 41, 26, 11, -3, -18, -32, -45,
89 -58, -68, -78, -86, -92, -97, -101, -103,
90 -105, -105, -105, -104, -104, -103, -103, -103,
91 -103, -105, -107, -110, -113, -117, -122, -128,
92 -133, -139, -144, -150, -155, -159, -163, -167,
93 -169, -170, -171, -171, -171, -169, -168, -166,
94 -164, -162, -161, -160, -159, -159, -160, -161,
95 -163, -166, -170, -174, -179, -183, -188, -193,
96 -197, -201, -204, -207, -209, -209, -209, -208,
97 -206, -203, -200, -196, -192, -189, -186, -183,
98 -182, -182, -183, -186, -190, -196, -204, -213,
99 -224, -236, -249, -262, -275, -288, -299, -310,
100 -318, -324, -327, -327, -323, -316, -304, -288,
101 -269, -245, -218, -187, -153, -117, -79, -40,
102 };
103
104 #define BEEP_SPEED 5 /* 22050 Hz sample rate */
105 #define BEEP_BUFLEN 512
106 #define BEEP_VOLUME 15 /* 0 - 100 */
107
108 static int beep_volume = BEEP_VOLUME;
109 static int beep_playing = 0;
110 static int beep_state = 0;
111 static short *beep_buf;
112 static void (*orig_mksound)(unsigned int, unsigned int);
113
114 /* This is found someplace else......I guess in the keyboard driver
115 * we don't include.
116 */
117 static void (*kd_mksound)(unsigned int, unsigned int);
118
119 static int catchRadius = 0;
120 static int numBufs = 4, bufSize = 32;
121 static int numReadBufs = 4, readbufSize = 32;
122
123
124 /* TDM/Serial transmit and receive buffer descriptors.
125 */
126 static volatile cbd_t *rx_base, *rx_cur, *tx_base, *tx_cur;
127
128 module_param(catchRadius, int, 0);
129 module_param(numBufs, int, 0);
130 module_param(bufSize, int, 0);
131 module_param(numreadBufs, int, 0);
132 module_param(readbufSize, int, 0);
133
134 #define arraysize(x) (sizeof(x)/sizeof(*(x)))
135 #define le2be16(x) (((x)<<8 & 0xff00) | ((x)>>8 & 0x00ff))
136 #define le2be16dbl(x) (((x)<<8 & 0xff00ff00) | ((x)>>8 & 0x00ff00ff))
137
138 #define IOCTL_IN(arg, ret) \
139 do { int error = get_user(ret, (int *)(arg)); \
140 if (error) return error; \
141 } while (0)
142 #define IOCTL_OUT(arg, ret) ioctl_return((int *)(arg), ret)
143
144 /* CS4218 serial port control in mode 4.
145 */
146 #define CS_INTMASK ((uint)0x40000000)
147 #define CS_DO1 ((uint)0x20000000)
148 #define CS_LATTEN ((uint)0x1f000000)
149 #define CS_RATTEN ((uint)0x00f80000)
150 #define CS_MUTE ((uint)0x00040000)
151 #define CS_ISL ((uint)0x00020000)
152 #define CS_ISR ((uint)0x00010000)
153 #define CS_LGAIN ((uint)0x0000f000)
154 #define CS_RGAIN ((uint)0x00000f00)
155
156 #define CS_LATTEN_SET(X) (((X) & 0x1f) << 24)
157 #define CS_RATTEN_SET(X) (((X) & 0x1f) << 19)
158 #define CS_LGAIN_SET(X) (((X) & 0x0f) << 12)
159 #define CS_RGAIN_SET(X) (((X) & 0x0f) << 8)
160
161 #define CS_LATTEN_GET(X) (((X) >> 24) & 0x1f)
162 #define CS_RATTEN_GET(X) (((X) >> 19) & 0x1f)
163 #define CS_LGAIN_GET(X) (((X) >> 12) & 0x0f)
164 #define CS_RGAIN_GET(X) (((X) >> 8) & 0x0f)
165
166 /* The control register is effectively write only. We have to keep a copy
167 * of what we write.
168 */
169 static uint cs4218_control;
170
171 /* A place to store expanding information.
172 */
173 static int expand_bal;
174 static int expand_data;
175
176 /* Since I can't make the microcode patch work for the SPI, I just
177 * clock the bits using software.
178 */
179 static void sw_spi_init(void);
180 static void sw_spi_io(u_char *obuf, u_char *ibuf, uint bcnt);
181 static uint cs4218_ctl_write(uint ctlreg);
182
183 /*** Some low level helpers **************************************************/
184
185 /* 16 bit mu-law */
186
187 static short ulaw2dma16[] = {
188 -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
189 -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
190 -15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
191 -11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316,
192 -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
193 -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
194 -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
195 -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
196 -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
197 -1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
198 -876, -844, -812, -780, -748, -716, -684, -652,
199 -620, -588, -556, -524, -492, -460, -428, -396,
200 -372, -356, -340, -324, -308, -292, -276, -260,
201 -244, -228, -212, -196, -180, -164, -148, -132,
202 -120, -112, -104, -96, -88, -80, -72, -64,
203 -56, -48, -40, -32, -24, -16, -8, 0,
204 32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
205 23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
206 15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
207 11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
208 7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
209 5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
210 3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
211 2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
212 1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
213 1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
214 876, 844, 812, 780, 748, 716, 684, 652,
215 620, 588, 556, 524, 492, 460, 428, 396,
216 372, 356, 340, 324, 308, 292, 276, 260,
217 244, 228, 212, 196, 180, 164, 148, 132,
218 120, 112, 104, 96, 88, 80, 72, 64,
219 56, 48, 40, 32, 24, 16, 8, 0,
220 };
221
222 /* 16 bit A-law */
223
224 static short alaw2dma16[] = {
225 -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
226 -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
227 -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
228 -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
229 -22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
230 -30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
231 -11008, -10496, -12032, -11520, -8960, -8448, -9984, -9472,
232 -15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
233 -344, -328, -376, -360, -280, -264, -312, -296,
234 -472, -456, -504, -488, -408, -392, -440, -424,
235 -88, -72, -120, -104, -24, -8, -56, -40,
236 -216, -200, -248, -232, -152, -136, -184, -168,
237 -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
238 -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
239 -688, -656, -752, -720, -560, -528, -624, -592,
240 -944, -912, -1008, -976, -816, -784, -880, -848,
241 5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
242 7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
243 2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
244 3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
245 22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
246 30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
247 11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
248 15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
249 344, 328, 376, 360, 280, 264, 312, 296,
250 472, 456, 504, 488, 408, 392, 440, 424,
251 88, 72, 120, 104, 24, 8, 56, 40,
252 216, 200, 248, 232, 152, 136, 184, 168,
253 1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
254 1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
255 688, 656, 752, 720, 560, 528, 624, 592,
256 944, 912, 1008, 976, 816, 784, 880, 848,
257 };
258
259
260 /*** Translations ************************************************************/
261
262
263 static ssize_t cs4218_ct_law(const u_char *userPtr, size_t userCount,
264 u_char frame[], ssize_t *frameUsed,
265 ssize_t frameLeft);
266 static ssize_t cs4218_ct_s8(const u_char *userPtr, size_t userCount,
267 u_char frame[], ssize_t *frameUsed,
268 ssize_t frameLeft);
269 static ssize_t cs4218_ct_u8(const u_char *userPtr, size_t userCount,
270 u_char frame[], ssize_t *frameUsed,
271 ssize_t frameLeft);
272 static ssize_t cs4218_ct_s16(const u_char *userPtr, size_t userCount,
273 u_char frame[], ssize_t *frameUsed,
274 ssize_t frameLeft);
275 static ssize_t cs4218_ct_u16(const u_char *userPtr, size_t userCount,
276 u_char frame[], ssize_t *frameUsed,
277 ssize_t frameLeft);
278 static ssize_t cs4218_ctx_law(const u_char *userPtr, size_t userCount,
279 u_char frame[], ssize_t *frameUsed,
280 ssize_t frameLeft);
281 static ssize_t cs4218_ctx_s8(const u_char *userPtr, size_t userCount,
282 u_char frame[], ssize_t *frameUsed,
283 ssize_t frameLeft);
284 static ssize_t cs4218_ctx_u8(const u_char *userPtr, size_t userCount,
285 u_char frame[], ssize_t *frameUsed,
286 ssize_t frameLeft);
287 static ssize_t cs4218_ctx_s16(const u_char *userPtr, size_t userCount,
288 u_char frame[], ssize_t *frameUsed,
289 ssize_t frameLeft);
290 static ssize_t cs4218_ctx_u16(const u_char *userPtr, size_t userCount,
291 u_char frame[], ssize_t *frameUsed,
292 ssize_t frameLeft);
293 static ssize_t cs4218_ct_s16_read(const u_char *userPtr, size_t userCount,
294 u_char frame[], ssize_t *frameUsed,
295 ssize_t frameLeft);
296 static ssize_t cs4218_ct_u16_read(const u_char *userPtr, size_t userCount,
297 u_char frame[], ssize_t *frameUsed,
298 ssize_t frameLeft);
299
300
301 /*** Low level stuff *********************************************************/
302
303 struct cs_sound_settings {
304 MACHINE mach; /* machine dependent things */
305 SETTINGS hard; /* hardware settings */
306 SETTINGS soft; /* software settings */
307 SETTINGS dsp; /* /dev/dsp default settings */
308 TRANS *trans_write; /* supported translations for playback */
309 TRANS *trans_read; /* supported translations for record */
310 int volume_left; /* volume (range is machine dependent) */
311 int volume_right;
312 int bass; /* tone (range is machine dependent) */
313 int treble;
314 int gain;
315 int minDev; /* minor device number currently open */
316 };
317
318 static struct cs_sound_settings sound;
319
320 static void *CS_Alloc(unsigned int size, gfp_t flags);
321 static void CS_Free(void *ptr, unsigned int size);
322 static int CS_IrqInit(void);
323 #ifdef MODULE
324 static void CS_IrqCleanup(void);
325 #endif /* MODULE */
326 static void CS_Silence(void);
327 static void CS_Init(void);
328 static void CS_Play(void);
329 static void CS_Record(void);
330 static int CS_SetFormat(int format);
331 static int CS_SetVolume(int volume);
332 static void cs4218_tdm_tx_intr(void *devid);
333 static void cs4218_tdm_rx_intr(void *devid);
334 static void cs4218_intr(void *devid);
335 static int cs_get_volume(uint reg);
336 static int cs_volume_setter(int volume, int mute);
337 static int cs_get_gain(uint reg);
338 static int cs_set_gain(int gain);
339 static void cs_mksound(unsigned int hz, unsigned int ticks);
340 static void cs_nosound(unsigned long xx);
341
342 /*** Mid level stuff *********************************************************/
343
344
345 static void sound_silence(void);
346 static void sound_init(void);
347 static int sound_set_format(int format);
348 static int sound_set_speed(int speed);
349 static int sound_set_stereo(int stereo);
350 static int sound_set_volume(int volume);
351
352 static ssize_t sound_copy_translate(const u_char *userPtr,
353 size_t userCount,
354 u_char frame[], ssize_t *frameUsed,
355 ssize_t frameLeft);
356 static ssize_t sound_copy_translate_read(const u_char *userPtr,
357 size_t userCount,
358 u_char frame[], ssize_t *frameUsed,
359 ssize_t frameLeft);
360
361
362 /*
363 * /dev/mixer abstraction
364 */
365
366 struct sound_mixer {
367 int busy;
368 int modify_counter;
369 };
370
371 static struct sound_mixer mixer;
372
373 static struct sound_queue sq;
374 static struct sound_queue read_sq;
375
376 #define sq_block_address(i) (sq.buffers[i])
377 #define SIGNAL_RECEIVED (signal_pending(current))
378 #define NON_BLOCKING(open_mode) (open_mode & O_NONBLOCK)
379 #define ONE_SECOND HZ /* in jiffies (100ths of a second) */
380 #define NO_TIME_LIMIT 0xffffffff
381
382 /*
383 * /dev/sndstat
384 */
385
386 struct sound_state {
387 int busy;
388 char buf[512];
389 int len, ptr;
390 };
391
392 static struct sound_state state;
393
394 /*** Common stuff ********************************************************/
395
396 static long long sound_lseek(struct file *file, long long offset, int orig);
397
398 /*** Config & Setup **********************************************************/
399
400 void dmasound_setup(char *str, int *ints);
401
402 /*** Translations ************************************************************/
403
404
405 /* ++TeSche: radically changed for new expanding purposes...
406 *
407 * These two routines now deal with copying/expanding/translating the samples
408 * from user space into our buffer at the right frequency. They take care about
409 * how much data there's actually to read, how much buffer space there is and
410 * to convert samples into the right frequency/encoding. They will only work on
411 * complete samples so it may happen they leave some bytes in the input stream
412 * if the user didn't write a multiple of the current sample size. They both
413 * return the number of bytes they've used from both streams so you may detect
414 * such a situation. Luckily all programs should be able to cope with that.
415 *
416 * I think I've optimized anything as far as one can do in plain C, all
417 * variables should fit in registers and the loops are really short. There's
418 * one loop for every possible situation. Writing a more generalized and thus
419 * parameterized loop would only produce slower code. Feel free to optimize
420 * this in assembler if you like. :)
421 *
422 * I think these routines belong here because they're not yet really hardware
423 * independent, especially the fact that the Falcon can play 16bit samples
424 * only in stereo is hardcoded in both of them!
425 *
426 * ++geert: split in even more functions (one per format)
427 */
428
429 static ssize_t cs4218_ct_law(const u_char *userPtr, size_t userCount,
430 u_char frame[], ssize_t *frameUsed,
431 ssize_t frameLeft)
432 {
433 short *table = sound.soft.format == AFMT_MU_LAW ? ulaw2dma16: alaw2dma16;
434 ssize_t count, used;
435 short *p = (short *) &frame[*frameUsed];
436 int val, stereo = sound.soft.stereo;
437
438 frameLeft >>= 2;
439 if (stereo)
440 userCount >>= 1;
441 used = count = min(userCount, frameLeft);
442 while (count > 0) {
443 u_char data;
444 if (get_user(data, userPtr++))
445 return -EFAULT;
446 val = table[data];
447 *p++ = val;
448 if (stereo) {
449 if (get_user(data, userPtr++))
450 return -EFAULT;
451 val = table[data];
452 }
453 *p++ = val;
454 count--;
455 }
456 *frameUsed += used * 4;
457 return stereo? used * 2: used;
458 }
459
460
461 static ssize_t cs4218_ct_s8(const u_char *userPtr, size_t userCount,
462 u_char frame[], ssize_t *frameUsed,
463 ssize_t frameLeft)
464 {
465 ssize_t count, used;
466 short *p = (short *) &frame[*frameUsed];
467 int val, stereo = sound.soft.stereo;
468
469 frameLeft >>= 2;
470 if (stereo)
471 userCount >>= 1;
472 used = count = min(userCount, frameLeft);
473 while (count > 0) {
474 u_char data;
475 if (get_user(data, userPtr++))
476 return -EFAULT;
477 val = data << 8;
478 *p++ = val;
479 if (stereo) {
480 if (get_user(data, userPtr++))
481 return -EFAULT;
482 val = data << 8;
483 }
484 *p++ = val;
485 count--;
486 }
487 *frameUsed += used * 4;
488 return stereo? used * 2: used;
489 }
490
491
492 static ssize_t cs4218_ct_u8(const u_char *userPtr, size_t userCount,
493 u_char frame[], ssize_t *frameUsed,
494 ssize_t frameLeft)
495 {
496 ssize_t count, used;
497 short *p = (short *) &frame[*frameUsed];
498 int val, stereo = sound.soft.stereo;
499
500 frameLeft >>= 2;
501 if (stereo)
502 userCount >>= 1;
503 used = count = min(userCount, frameLeft);
504 while (count > 0) {
505 u_char data;
506 if (get_user(data, userPtr++))
507 return -EFAULT;
508 val = (data ^ 0x80) << 8;
509 *p++ = val;
510 if (stereo) {
511 if (get_user(data, userPtr++))
512 return -EFAULT;
513 val = (data ^ 0x80) << 8;
514 }
515 *p++ = val;
516 count--;
517 }
518 *frameUsed += used * 4;
519 return stereo? used * 2: used;
520 }
521
522
523 /* This is the default format of the codec. Signed, 16-bit stereo
524 * generated by an application shouldn't have to be copied at all.
525 * We should just get the phsical address of the buffers and update
526 * the TDM BDs directly.
527 */
528 static ssize_t cs4218_ct_s16(const u_char *userPtr, size_t userCount,
529 u_char frame[], ssize_t *frameUsed,
530 ssize_t frameLeft)
531 {
532 ssize_t count, used;
533 int stereo = sound.soft.stereo;
534 short *fp = (short *) &frame[*frameUsed];
535
536 frameLeft >>= 2;
537 userCount >>= (stereo? 2: 1);
538 used = count = min(userCount, frameLeft);
539 if (!stereo) {
540 short *up = (short *) userPtr;
541 while (count > 0) {
542 short data;
543 if (get_user(data, up++))
544 return -EFAULT;
545 *fp++ = data;
546 *fp++ = data;
547 count--;
548 }
549 } else {
550 if (copy_from_user(fp, userPtr, count * 4))
551 return -EFAULT;
552 }
553 *frameUsed += used * 4;
554 return stereo? used * 4: used * 2;
555 }
556
557 static ssize_t cs4218_ct_u16(const u_char *userPtr, size_t userCount,
558 u_char frame[], ssize_t *frameUsed,
559 ssize_t frameLeft)
560 {
561 ssize_t count, used;
562 int mask = (sound.soft.format == AFMT_U16_LE? 0x0080: 0x8000);
563 int stereo = sound.soft.stereo;
564 short *fp = (short *) &frame[*frameUsed];
565 short *up = (short *) userPtr;
566
567 frameLeft >>= 2;
568 userCount >>= (stereo? 2: 1);
569 used = count = min(userCount, frameLeft);
570 while (count > 0) {
571 int data;
572 if (get_user(data, up++))
573 return -EFAULT;
574 data ^= mask;
575 *fp++ = data;
576 if (stereo) {
577 if (get_user(data, up++))
578 return -EFAULT;
579 data ^= mask;
580 }
581 *fp++ = data;
582 count--;
583 }
584 *frameUsed += used * 4;
585 return stereo? used * 4: used * 2;
586 }
587
588
589 static ssize_t cs4218_ctx_law(const u_char *userPtr, size_t userCount,
590 u_char frame[], ssize_t *frameUsed,
591 ssize_t frameLeft)
592 {
593 unsigned short *table = (unsigned short *)
594 (sound.soft.format == AFMT_MU_LAW ? ulaw2dma16: alaw2dma16);
595 unsigned int data = expand_data;
596 unsigned int *p = (unsigned int *) &frame[*frameUsed];
597 int bal = expand_bal;
598 int hSpeed = sound.hard.speed, sSpeed = sound.soft.speed;
599 int utotal, ftotal;
600 int stereo = sound.soft.stereo;
601
602 frameLeft >>= 2;
603 if (stereo)
604 userCount >>= 1;
605 ftotal = frameLeft;
606 utotal = userCount;
607 while (frameLeft) {
608 u_char c;
609 if (bal < 0) {
610 if (userCount == 0)
611 break;
612 if (get_user(c, userPtr++))
613 return -EFAULT;
614 data = table[c];
615 if (stereo) {
616 if (get_user(c, userPtr++))
617 return -EFAULT;
618 data = (data << 16) + table[c];
619 } else
620 data = (data << 16) + data;
621 userCount--;
622 bal += hSpeed;
623 }
624 *p++ = data;
625 frameLeft--;
626 bal -= sSpeed;
627 }
628 expand_bal = bal;
629 expand_data = data;
630 *frameUsed += (ftotal - frameLeft) * 4;
631 utotal -= userCount;
632 return stereo? utotal * 2: utotal;
633 }
634
635
636 static ssize_t cs4218_ctx_s8(const u_char *userPtr, size_t userCount,
637 u_char frame[], ssize_t *frameUsed,
638 ssize_t frameLeft)
639 {
640 unsigned int *p = (unsigned int *) &frame[*frameUsed];
641 unsigned int data = expand_data;
642 int bal = expand_bal;
643 int hSpeed = sound.hard.speed, sSpeed = sound.soft.speed;
644 int stereo = sound.soft.stereo;
645 int utotal, ftotal;
646
647 frameLeft >>= 2;
648 if (stereo)
649 userCount >>= 1;
650 ftotal = frameLeft;
651 utotal = userCount;
652 while (frameLeft) {
653 u_char c;
654 if (bal < 0) {
655 if (userCount == 0)
656 break;
657 if (get_user(c, userPtr++))
658 return -EFAULT;
659 data = c << 8;
660 if (stereo) {
661 if (get_user(c, userPtr++))
662 return -EFAULT;
663 data = (data << 16) + (c << 8);
664 } else
665 data = (data << 16) + data;
666 userCount--;
667 bal += hSpeed;
668 }
669 *p++ = data;
670 frameLeft--;
671 bal -= sSpeed;
672 }
673 expand_bal = bal;
674 expand_data = data;
675 *frameUsed += (ftotal - frameLeft) * 4;
676 utotal -= userCount;
677 return stereo? utotal * 2: utotal;
678 }
679
680
681 static ssize_t cs4218_ctx_u8(const u_char *userPtr, size_t userCount,
682 u_char frame[], ssize_t *frameUsed,
683 ssize_t frameLeft)
684 {
685 unsigned int *p = (unsigned int *) &frame[*frameUsed];
686 unsigned int data = expand_data;
687 int bal = expand_bal;
688 int hSpeed = sound.hard.speed, sSpeed = sound.soft.speed;
689 int stereo = sound.soft.stereo;
690 int utotal, ftotal;
691
692 frameLeft >>= 2;
693 if (stereo)
694 userCount >>= 1;
695 ftotal = frameLeft;
696 utotal = userCount;
697 while (frameLeft) {
698 u_char c;
699 if (bal < 0) {
700 if (userCount == 0)
701 break;
702 if (get_user(c, userPtr++))
703 return -EFAULT;
704 data = (c ^ 0x80) << 8;
705 if (stereo) {
706 if (get_user(c, userPtr++))
707 return -EFAULT;
708 data = (data << 16) + ((c ^ 0x80) << 8);
709 } else
710 data = (data << 16) + data;
711 userCount--;
712 bal += hSpeed;
713 }
714 *p++ = data;
715 frameLeft--;
716 bal -= sSpeed;
717 }
718 expand_bal = bal;
719 expand_data = data;
720 *frameUsed += (ftotal - frameLeft) * 4;
721 utotal -= userCount;
722 return stereo? utotal * 2: utotal;
723 }
724
725
726 static ssize_t cs4218_ctx_s16(const u_char *userPtr, size_t userCount,
727 u_char frame[], ssize_t *frameUsed,
728 ssize_t frameLeft)
729 {
730 unsigned int *p = (unsigned int *) &frame[*frameUsed];
731 unsigned int data = expand_data;
732 unsigned short *up = (unsigned short *) userPtr;
733 int bal = expand_bal;
734 int hSpeed = sound.hard.speed, sSpeed = sound.soft.speed;
735 int stereo = sound.soft.stereo;
736 int utotal, ftotal;
737
738 frameLeft >>= 2;
739 userCount >>= (stereo? 2: 1);
740 ftotal = frameLeft;
741 utotal = userCount;
742 while (frameLeft) {
743 unsigned short c;
744 if (bal < 0) {
745 if (userCount == 0)
746 break;
747 if (get_user(data, up++))
748 return -EFAULT;
749 if (stereo) {
750 if (get_user(c, up++))
751 return -EFAULT;
752 data = (data << 16) + c;
753 } else
754 data = (data << 16) + data;
755 userCount--;
756 bal += hSpeed;
757 }
758 *p++ = data;
759 frameLeft--;
760 bal -= sSpeed;
761 }
762 expand_bal = bal;
763 expand_data = data;
764 *frameUsed += (ftotal - frameLeft) * 4;
765 utotal -= userCount;
766 return stereo? utotal * 4: utotal * 2;
767 }
768
769
770 static ssize_t cs4218_ctx_u16(const u_char *userPtr, size_t userCount,
771 u_char frame[], ssize_t *frameUsed,
772 ssize_t frameLeft)
773 {
774 int mask = (sound.soft.format == AFMT_U16_LE? 0x0080: 0x8000);
775 unsigned int *p = (unsigned int *) &frame[*frameUsed];
776 unsigned int data = expand_data;
777 unsigned short *up = (unsigned short *) userPtr;
778 int bal = expand_bal;
779 int hSpeed = sound.hard.speed, sSpeed = sound.soft.speed;
780 int stereo = sound.soft.stereo;
781 int utotal, ftotal;
782
783 frameLeft >>= 2;
784 userCount >>= (stereo? 2: 1);
785 ftotal = frameLeft;
786 utotal = userCount;
787 while (frameLeft) {
788 unsigned short c;
789 if (bal < 0) {
790 if (userCount == 0)
791 break;
792 if (get_user(data, up++))
793 return -EFAULT;
794 data ^= mask;
795 if (stereo) {
796 if (get_user(c, up++))
797 return -EFAULT;
798 data = (data << 16) + (c ^ mask);
799 } else
800 data = (data << 16) + data;
801 userCount--;
802 bal += hSpeed;
803 }
804 *p++ = data;
805 frameLeft--;
806 bal -= sSpeed;
807 }
808 expand_bal = bal;
809 expand_data = data;
810 *frameUsed += (ftotal - frameLeft) * 4;
811 utotal -= userCount;
812 return stereo? utotal * 4: utotal * 2;
813 }
814
815 static ssize_t cs4218_ct_s8_read(const u_char *userPtr, size_t userCount,
816 u_char frame[], ssize_t *frameUsed,
817 ssize_t frameLeft)
818 {
819 ssize_t count, used;
820 short *p = (short *) &frame[*frameUsed];
821 int val, stereo = sound.soft.stereo;
822
823 frameLeft >>= 2;
824 if (stereo)
825 userCount >>= 1;
826 used = count = min(userCount, frameLeft);
827 while (count > 0) {
828 u_char data;
829
830 val = *p++;
831 data = val >> 8;
832 if (put_user(data, (u_char *)userPtr++))
833 return -EFAULT;
834 if (stereo) {
835 val = *p;
836 data = val >> 8;
837 if (put_user(data, (u_char *)userPtr++))
838 return -EFAULT;
839 }
840 p++;
841 count--;
842 }
843 *frameUsed += used * 4;
844 return stereo? used * 2: used;
845 }
846
847
848 static ssize_t cs4218_ct_u8_read(const u_char *userPtr, size_t userCount,
849 u_char frame[], ssize_t *frameUsed,
850 ssize_t frameLeft)
851 {
852 ssize_t count, used;
853 short *p = (short *) &frame[*frameUsed];
854 int val, stereo = sound.soft.stereo;
855
856 frameLeft >>= 2;
857 if (stereo)
858 userCount >>= 1;
859 used = count = min(userCount, frameLeft);
860 while (count > 0) {
861 u_char data;
862
863 val = *p++;
864 data = (val >> 8) ^ 0x80;
865 if (put_user(data, (u_char *)userPtr++))
866 return -EFAULT;
867 if (stereo) {
868 val = *p;
869 data = (val >> 8) ^ 0x80;
870 if (put_user(data, (u_char *)userPtr++))
871 return -EFAULT;
872 }
873 p++;
874 count--;
875 }
876 *frameUsed += used * 4;
877 return stereo? used * 2: used;
878 }
879
880
881 static ssize_t cs4218_ct_s16_read(const u_char *userPtr, size_t userCount,
882 u_char frame[], ssize_t *frameUsed,
883 ssize_t frameLeft)
884 {
885 ssize_t count, used;
886 int stereo = sound.soft.stereo;
887 short *fp = (short *) &frame[*frameUsed];
888
889 frameLeft >>= 2;
890 userCount >>= (stereo? 2: 1);
891 used = count = min(userCount, frameLeft);
892 if (!stereo) {
893 short *up = (short *) userPtr;
894 while (count > 0) {
895 short data;
896 data = *fp;
897 if (put_user(data, up++))
898 return -EFAULT;
899 fp+=2;
900 count--;
901 }
902 } else {
903 if (copy_to_user((u_char *)userPtr, fp, count * 4))
904 return -EFAULT;
905 }
906 *frameUsed += used * 4;
907 return stereo? used * 4: used * 2;
908 }
909
910 static ssize_t cs4218_ct_u16_read(const u_char *userPtr, size_t userCount,
911 u_char frame[], ssize_t *frameUsed,
912 ssize_t frameLeft)
913 {
914 ssize_t count, used;
915 int mask = (sound.soft.format == AFMT_U16_LE? 0x0080: 0x8000);
916 int stereo = sound.soft.stereo;
917 short *fp = (short *) &frame[*frameUsed];
918 short *up = (short *) userPtr;
919
920 frameLeft >>= 2;
921 userCount >>= (stereo? 2: 1);
922 used = count = min(userCount, frameLeft);
923 while (count > 0) {
924 int data;
925
926 data = *fp++;
927 data ^= mask;
928 if (put_user(data, up++))
929 return -EFAULT;
930 if (stereo) {
931 data = *fp;
932 data ^= mask;
933 if (put_user(data, up++))
934 return -EFAULT;
935 }
936 fp++;
937 count--;
938 }
939 *frameUsed += used * 4;
940 return stereo? used * 4: used * 2;
941 }
942
943 static TRANS transCSNormal = {
944 cs4218_ct_law, cs4218_ct_law, cs4218_ct_s8, cs4218_ct_u8,
945 cs4218_ct_s16, cs4218_ct_u16, cs4218_ct_s16, cs4218_ct_u16
946 };
947
948 static TRANS transCSExpand = {
949 cs4218_ctx_law, cs4218_ctx_law, cs4218_ctx_s8, cs4218_ctx_u8,
950 cs4218_ctx_s16, cs4218_ctx_u16, cs4218_ctx_s16, cs4218_ctx_u16
951 };
952
953 static TRANS transCSNormalRead = {
954 NULL, NULL, cs4218_ct_s8_read, cs4218_ct_u8_read,
955 cs4218_ct_s16_read, cs4218_ct_u16_read,
956 cs4218_ct_s16_read, cs4218_ct_u16_read
957 };
958
959 /*** Low level stuff *********************************************************/
960
961 static void *CS_Alloc(unsigned int size, gfp_t flags)
962 {
963 int order;
964
965 size >>= 13;
966 for (order=0; order < 5; order++) {
967 if (size == 0)
968 break;
969 size >>= 1;
970 }
971 return (void *)__get_free_pages(flags, order);
972 }
973
974 static void CS_Free(void *ptr, unsigned int size)
975 {
976 int order;
977
978 size >>= 13;
979 for (order=0; order < 5; order++) {
980 if (size == 0)
981 break;
982 size >>= 1;
983 }
984 free_pages((ulong)ptr, order);
985 }
986
987 static int __init CS_IrqInit(void)
988 {
989 cpm_install_handler(CPMVEC_SMC2, cs4218_intr, NULL);
990 return 1;
991 }
992
993 #ifdef MODULE
994 static void CS_IrqCleanup(void)
995 {
996 volatile smc_t *sp;
997 volatile cpm8xx_t *cp;
998
999 /* First disable transmitter and receiver.
1000 */
1001 sp = &cpmp->cp_smc[1];
1002 sp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
1003
1004 /* And now shut down the SMC.
1005 */
1006 cp = cpmp; /* Get pointer to Communication Processor */
1007 cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC2,
1008 CPM_CR_STOP_TX) | CPM_CR_FLG;
1009 while (cp->cp_cpcr & CPM_CR_FLG);
1010
1011 /* Release the interrupt handler.
1012 */
1013 cpm_free_handler(CPMVEC_SMC2);
1014
1015 kfree(beep_buf);
1016 kd_mksound = orig_mksound;
1017 }
1018 #endif /* MODULE */
1019
1020 static void CS_Silence(void)
1021 {
1022 volatile smc_t *sp;
1023
1024 /* Disable transmitter.
1025 */
1026 sp = &cpmp->cp_smc[1];
1027 sp->smc_smcmr &= ~SMCMR_TEN;
1028 }
1029
1030 /* Frequencies depend upon external oscillator. There are two
1031 * choices, 12.288 and 11.2896 MHz. The RPCG audio supports both through
1032 * and external control register selection bit.
1033 */
1034 static int cs4218_freqs[] = {
1035 /* 12.288 11.2896 */
1036 48000, 44100,
1037 32000, 29400,
1038 24000, 22050,
1039 19200, 17640,
1040 16000, 14700,
1041 12000, 11025,
1042 9600, 8820,
1043 8000, 7350
1044 };
1045
1046 static void CS_Init(void)
1047 {
1048 int i, tolerance;
1049
1050 switch (sound.soft.format) {
1051 case AFMT_S16_LE:
1052 case AFMT_U16_LE:
1053 sound.hard.format = AFMT_S16_LE;
1054 break;
1055 default:
1056 sound.hard.format = AFMT_S16_BE;
1057 break;
1058 }
1059 sound.hard.stereo = 1;
1060 sound.hard.size = 16;
1061
1062 /*
1063 * If we have a sample rate which is within catchRadius percent
1064 * of the requested value, we don't have to expand the samples.
1065 * Otherwise choose the next higher rate.
1066 */
1067 i = (sizeof(cs4218_freqs) / sizeof(int));
1068 do {
1069 tolerance = catchRadius * cs4218_freqs[--i] / 100;
1070 } while (sound.soft.speed > cs4218_freqs[i] + tolerance && i > 0);
1071 if (sound.soft.speed >= cs4218_freqs[i] - tolerance)
1072 sound.trans_write = &transCSNormal;
1073 else
1074 sound.trans_write = &transCSExpand;
1075 sound.trans_read = &transCSNormalRead;
1076 sound.hard.speed = cs4218_freqs[i];
1077 cs4218_rate_index = i;
1078
1079 /* The CS4218 has seven selectable clock dividers for the sample
1080 * clock. The HIOX then provides one of two external rates.
1081 * An even numbered frequency table index uses the high external
1082 * clock rate.
1083 */
1084 *(uint *)HIOX_CSR4_ADDR &= ~(HIOX_CSR4_AUDCLKHI | HIOX_CSR4_AUDCLKSEL);
1085 if ((i & 1) == 0)
1086 *(uint *)HIOX_CSR4_ADDR |= HIOX_CSR4_AUDCLKHI;
1087 i >>= 1;
1088 *(uint *)HIOX_CSR4_ADDR |= (i & HIOX_CSR4_AUDCLKSEL);
1089
1090 expand_bal = -sound.soft.speed;
1091 }
1092
1093 static int CS_SetFormat(int format)
1094 {
1095 int size;
1096
1097 switch (format) {
1098 case AFMT_QUERY:
1099 return sound.soft.format;
1100 case AFMT_MU_LAW:
1101 case AFMT_A_LAW:
1102 case AFMT_U8:
1103 case AFMT_S8:
1104 size = 8;
1105 break;
1106 case AFMT_S16_BE:
1107 case AFMT_U16_BE:
1108 case AFMT_S16_LE:
1109 case AFMT_U16_LE:
1110 size = 16;
1111 break;
1112 default: /* :-) */
1113 printk(KERN_ERR "dmasound: unknown format 0x%x, using AFMT_U8\n",
1114 format);
1115 size = 8;
1116 format = AFMT_U8;
1117 }
1118
1119 sound.soft.format = format;
1120 sound.soft.size = size;
1121 if (sound.minDev == SND_DEV_DSP) {
1122 sound.dsp.format = format;
1123 sound.dsp.size = size;
1124 }
1125
1126 CS_Init();
1127
1128 return format;
1129 }
1130
1131 /* Volume is the amount of attenuation we tell the codec to impose
1132 * on the outputs. There are 32 levels, with 0 the "loudest".
1133 */
1134 #define CS_VOLUME_TO_MASK(x) (31 - ((((x) - 1) * 31) / 99))
1135 #define CS_MASK_TO_VOLUME(y) (100 - ((y) * 99 / 31))
1136
1137 static int cs_get_volume(uint reg)
1138 {
1139 int volume;
1140
1141 volume = CS_MASK_TO_VOLUME(CS_LATTEN_GET(reg));
1142 volume |= CS_MASK_TO_VOLUME(CS_RATTEN_GET(reg)) << 8;
1143 return volume;
1144 }
1145
1146 static int cs_volume_setter(int volume, int mute)
1147 {
1148 uint tempctl;
1149
1150 if (mute && volume == 0) {
1151 tempctl = cs4218_control | CS_MUTE;
1152 } else {
1153 tempctl = cs4218_control & ~CS_MUTE;
1154 tempctl = tempctl & ~(CS_LATTEN | CS_RATTEN);
1155 tempctl |= CS_LATTEN_SET(CS_VOLUME_TO_MASK(volume & 0xff));
1156 tempctl |= CS_RATTEN_SET(CS_VOLUME_TO_MASK((volume >> 8) & 0xff));
1157 volume = cs_get_volume(tempctl);
1158 }
1159 if (tempctl != cs4218_control) {
1160 cs4218_ctl_write(tempctl);
1161 }
1162 return volume;
1163 }
1164
1165
1166 /* Gain has 16 steps from 0 to 15. These are in 1.5dB increments from
1167 * 0 (no gain) to 22.5 dB.
1168 */
1169 #define CS_RECLEVEL_TO_GAIN(v) \
1170 ((v) < 0 ? 0 : (v) > 100 ? 15 : (v) * 3 / 20)
1171 #define CS_GAIN_TO_RECLEVEL(v) (((v) * 20 + 2) / 3)
1172
1173 static int cs_get_gain(uint reg)
1174 {
1175 int gain;
1176
1177 gain = CS_GAIN_TO_RECLEVEL(CS_LGAIN_GET(reg));
1178 gain |= CS_GAIN_TO_RECLEVEL(CS_RGAIN_GET(reg)) << 8;
1179 return gain;
1180 }
1181
1182 static int cs_set_gain(int gain)
1183 {
1184 uint tempctl;
1185
1186 tempctl = cs4218_control & ~(CS_LGAIN | CS_RGAIN);
1187 tempctl |= CS_LGAIN_SET(CS_RECLEVEL_TO_GAIN(gain & 0xff));
1188 tempctl |= CS_RGAIN_SET(CS_RECLEVEL_TO_GAIN((gain >> 8) & 0xff));
1189 gain = cs_get_gain(tempctl);
1190
1191 if (tempctl != cs4218_control) {
1192 cs4218_ctl_write(tempctl);
1193 }
1194 return gain;
1195 }
1196
1197 static int CS_SetVolume(int volume)
1198 {
1199 return cs_volume_setter(volume, CS_MUTE);
1200 }
1201
1202 static void CS_Play(void)
1203 {
1204 int i, count;
1205 unsigned long flags;
1206 volatile cbd_t *bdp;
1207 volatile cpm8xx_t *cp;
1208
1209 /* Protect buffer */
1210 spin_lock_irqsave(&cs4218_lock, flags);
1211 #if 0
1212 if (awacs_beep_state) {
1213 /* sound takes precedence over beeps */
1214 out_le32(&awacs_txdma->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
1215 out_le32(&awacs->control,
1216 (in_le32(&awacs->control) & ~0x1f00)
1217 | (awacs_rate_index << 8));
1218 out_le32(&awacs->byteswap, sound.hard.format != AFMT_S16_BE);
1219 out_le32(&awacs_txdma->cmdptr, virt_to_bus(&(awacs_tx_cmds[(sq.front+sq.active) % sq.max_count])));
1220
1221 beep_playing = 0;
1222 awacs_beep_state = 0;
1223 }
1224 #endif
1225 i = sq.front + sq.active;
1226 if (i >= sq.max_count)
1227 i -= sq.max_count;
1228 while (sq.active < 2 && sq.active < sq.count) {
1229 count = (sq.count == sq.active + 1)?sq.rear_size:sq.block_size;
1230 if (count < sq.block_size && !sq.syncing)
1231 /* last block not yet filled, and we're not syncing. */
1232 break;
1233
1234 bdp = &tx_base[i];
1235 bdp->cbd_datlen = count;
1236
1237 flush_dcache_range((ulong)sound_buffers[i],
1238 (ulong)(sound_buffers[i] + count));
1239
1240 if (++i >= sq.max_count)
1241 i = 0;
1242
1243 if (sq.active == 0) {
1244 /* The SMC does not load its fifo until the first
1245 * TDM frame pulse, so the transmit data gets shifted
1246 * by one word. To compensate for this, we incorrectly
1247 * transmit the first buffer and shorten it by one
1248 * word. Subsequent buffers are then aligned properly.
1249 */
1250 bdp->cbd_datlen -= 2;
1251
1252 /* Start up the SMC Transmitter.
1253 */
1254 cp = cpmp;
1255 cp->cp_smc[1].smc_smcmr |= SMCMR_TEN;
1256 cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC2,
1257 CPM_CR_RESTART_TX) | CPM_CR_FLG;
1258 while (cp->cp_cpcr & CPM_CR_FLG);
1259 }
1260
1261 /* Buffer is ready now.
1262 */
1263 bdp->cbd_sc |= BD_SC_READY;
1264
1265 ++sq.active;
1266 }
1267 spin_unlock_irqrestore(&cs4218_lock, flags);
1268 }
1269
1270
1271 static void CS_Record(void)
1272 {
1273 unsigned long flags;
1274 volatile smc_t *sp;
1275
1276 if (read_sq.active)
1277 return;
1278
1279 /* Protect buffer */
1280 spin_lock_irqsave(&cs4218_lock, flags);
1281
1282 /* This is all we have to do......Just start it up.
1283 */
1284 sp = &cpmp->cp_smc[1];
1285 sp->smc_smcmr |= SMCMR_REN;
1286
1287 read_sq.active = 1;
1288
1289 spin_unlock_irqrestore(&cs4218_lock, flags);
1290 }
1291
1292
1293 static void
1294 cs4218_tdm_tx_intr(void *devid)
1295 {
1296 int i = sq.front;
1297 volatile cbd_t *bdp;
1298
1299 while (sq.active > 0) {
1300 bdp = &tx_base[i];
1301 if (bdp->cbd_sc & BD_SC_READY)
1302 break; /* this frame is still going */
1303 --sq.count;
1304 --sq.active;
1305 if (++i >= sq.max_count)
1306 i = 0;
1307 }
1308 if (i != sq.front)
1309 WAKE_UP(sq.action_queue);
1310 sq.front = i;
1311
1312 CS_Play();
1313
1314 if (!sq.active)
1315 WAKE_UP(sq.sync_queue);
1316 }
1317
1318
1319 static void
1320 cs4218_tdm_rx_intr(void *devid)
1321 {
1322
1323 /* We want to blow 'em off when shutting down.
1324 */
1325 if (read_sq.active == 0)
1326 return;
1327
1328 /* Check multiple buffers in case we were held off from
1329 * interrupt processing for a long time. Geeze, I really hope
1330 * this doesn't happen.
1331 */
1332 while ((rx_base[read_sq.rear].cbd_sc & BD_SC_EMPTY) == 0) {
1333
1334 /* Invalidate the data cache range for this buffer.
1335 */
1336 invalidate_dcache_range(
1337 (uint)(sound_read_buffers[read_sq.rear]),
1338 (uint)(sound_read_buffers[read_sq.rear] + read_sq.block_size));
1339
1340 /* Make buffer available again and move on.
1341 */
1342 rx_base[read_sq.rear].cbd_sc |= BD_SC_EMPTY;
1343 read_sq.rear++;
1344
1345 /* Wrap the buffer ring.
1346 */
1347 if (read_sq.rear >= read_sq.max_active)
1348 read_sq.rear = 0;
1349
1350 /* If we have caught up to the front buffer, bump it.
1351 * This will cause weird (but not fatal) results if the
1352 * read loop is currently using this buffer. The user is
1353 * behind in this case anyway, so weird things are going
1354 * to happen.
1355 */
1356 if (read_sq.rear == read_sq.front) {
1357 read_sq.front++;
1358 if (read_sq.front >= read_sq.max_active)
1359 read_sq.front = 0;
1360 }
1361 }
1362
1363 WAKE_UP(read_sq.action_queue);
1364 }
1365
1366 static void cs_nosound(unsigned long xx)
1367 {
1368 unsigned long flags;
1369
1370 /* not sure if this is needed, since hardware command is #if 0'd */
1371 spin_lock_irqsave(&cs4218_lock, flags);
1372 if (beep_playing) {
1373 #if 0
1374 st_le16(&beep_dbdma_cmd->command, DBDMA_STOP);
1375 #endif
1376 beep_playing = 0;
1377 }
1378 spin_unlock_irqrestore(&cs4218_lock, flags);
1379 }
1380
1381 static DEFINE_TIMER(beep_timer, cs_nosound, 0, 0);
1382
1383 static void cs_mksound(unsigned int hz, unsigned int ticks)
1384 {
1385 unsigned long flags;
1386 int beep_speed = BEEP_SPEED;
1387 int srate = cs4218_freqs[beep_speed];
1388 int period, ncycles, nsamples;
1389 int i, j, f;
1390 short *p;
1391 static int beep_hz_cache;
1392 static int beep_nsamples_cache;
1393 static int beep_volume_cache;
1394
1395 if (hz <= srate / BEEP_BUFLEN || hz > srate / 2) {
1396 #if 1
1397 /* this is a hack for broken X server code */
1398 hz = 750;
1399 ticks = 12;
1400 #else
1401 /* cancel beep currently playing */
1402 awacs_nosound(0);
1403 return;
1404 #endif
1405 }
1406 /* lock while modifying beep_timer */
1407 spin_lock_irqsave(&cs4218_lock, flags);
1408 del_timer(&beep_timer);
1409 if (ticks) {
1410 beep_timer.expires = jiffies + ticks;
1411 add_timer(&beep_timer);
1412 }
1413 if (beep_playing || sq.active || beep_buf == NULL) {
1414 spin_unlock_irqrestore(&cs4218_lock, flags);
1415 return; /* too hard, sorry :-( */
1416 }
1417 beep_playing = 1;
1418 #if 0
1419 st_le16(&beep_dbdma_cmd->command, OUTPUT_MORE + BR_ALWAYS);
1420 #endif
1421 spin_unlock_irqrestore(&cs4218_lock, flags);
1422
1423 if (hz == beep_hz_cache && beep_volume == beep_volume_cache) {
1424 nsamples = beep_nsamples_cache;
1425 } else {
1426 period = srate * 256 / hz; /* fixed point */
1427 ncycles = BEEP_BUFLEN * 256 / period;
1428 nsamples = (period * ncycles) >> 8;
1429 f = ncycles * 65536 / nsamples;
1430 j = 0;
1431 p = beep_buf;
1432 for (i = 0; i < nsamples; ++i, p += 2) {
1433 p[0] = p[1] = beep_wform[j >> 8] * beep_volume;
1434 j = (j + f) & 0xffff;
1435 }
1436 beep_hz_cache = hz;
1437 beep_volume_cache = beep_volume;
1438 beep_nsamples_cache = nsamples;
1439 }
1440
1441 #if 0
1442 st_le16(&beep_dbdma_cmd->req_count, nsamples*4);
1443 st_le16(&beep_dbdma_cmd->xfer_status, 0);
1444 st_le32(&beep_dbdma_cmd->cmd_dep, virt_to_bus(beep_dbdma_cmd));
1445 st_le32(&beep_dbdma_cmd->phy_addr, virt_to_bus(beep_buf));
1446 awacs_beep_state = 1;
1447
1448 spin_lock_irqsave(&cs4218_lock, flags);
1449 if (beep_playing) { /* i.e. haven't been terminated already */
1450 out_le32(&awacs_txdma->control, (RUN|WAKE|FLUSH|PAUSE) << 16);
1451 out_le32(&awacs->control,
1452 (in_le32(&awacs->control) & ~0x1f00)
1453 | (beep_speed << 8));
1454 out_le32(&awacs->byteswap, 0);
1455 out_le32(&awacs_txdma->cmdptr, virt_to_bus(beep_dbdma_cmd));
1456 out_le32(&awacs_txdma->control, RUN | (RUN << 16));
1457 }
1458 spin_unlock_irqrestore(&cs4218_lock, flags);
1459 #endif
1460 }
1461
1462 static MACHINE mach_cs4218 = {
1463 .owner = THIS_MODULE,
1464 .name = "HIOX CS4218",
1465 .name2 = "Built-in Sound",
1466 .dma_alloc = CS_Alloc,
1467 .dma_free = CS_Free,
1468 .irqinit = CS_IrqInit,
1469 #ifdef MODULE
1470 .irqcleanup = CS_IrqCleanup,
1471 #endif /* MODULE */
1472 .init = CS_Init,
1473 .silence = CS_Silence,
1474 .setFormat = CS_SetFormat,
1475 .setVolume = CS_SetVolume,
1476 .play = CS_Play
1477 };
1478
1479
1480 /*** Mid level stuff *********************************************************/
1481
1482
1483 static void sound_silence(void)
1484 {
1485 /* update hardware settings one more */
1486 (*sound.mach.init)();
1487
1488 (*sound.mach.silence)();
1489 }
1490
1491
1492 static void sound_init(void)
1493 {
1494 (*sound.mach.init)();
1495 }
1496
1497
1498 static int sound_set_format(int format)
1499 {
1500 return(*sound.mach.setFormat)(format);
1501 }
1502
1503
1504 static int sound_set_speed(int speed)
1505 {
1506 if (speed < 0)
1507 return(sound.soft.speed);
1508
1509 sound.soft.speed = speed;
1510 (*sound.mach.init)();
1511 if (sound.minDev == SND_DEV_DSP)
1512 sound.dsp.speed = sound.soft.speed;
1513
1514 return(sound.soft.speed);
1515 }
1516
1517
1518 static int sound_set_stereo(int stereo)
1519 {
1520 if (stereo < 0)
1521 return(sound.soft.stereo);
1522
1523 stereo = !!stereo; /* should be 0 or 1 now */
1524
1525 sound.soft.stereo = stereo;
1526 if (sound.minDev == SND_DEV_DSP)
1527 sound.dsp.stereo = stereo;
1528 (*sound.mach.init)();
1529
1530 return(stereo);
1531 }
1532
1533
1534 static int sound_set_volume(int volume)
1535 {
1536 return(*sound.mach.setVolume)(volume);
1537 }
1538
1539 static ssize_t sound_copy_translate(const u_char *userPtr,
1540 size_t userCount,
1541 u_char frame[], ssize_t *frameUsed,
1542 ssize_t frameLeft)
1543 {
1544 ssize_t (*ct_func)(const u_char *, size_t, u_char *, ssize_t *, ssize_t) = NULL;
1545
1546 switch (sound.soft.format) {
1547 case AFMT_MU_LAW:
1548 ct_func = sound.trans_write->ct_ulaw;
1549 break;
1550 case AFMT_A_LAW:
1551 ct_func = sound.trans_write->ct_alaw;
1552 break;
1553 case AFMT_S8:
1554 ct_func = sound.trans_write->ct_s8;
1555 break;
1556 case AFMT_U8:
1557 ct_func = sound.trans_write->ct_u8;
1558 break;
1559 case AFMT_S16_BE:
1560 ct_func = sound.trans_write->ct_s16be;
1561 break;
1562 case AFMT_U16_BE:
1563 ct_func = sound.trans_write->ct_u16be;
1564 break;
1565 case AFMT_S16_LE:
1566 ct_func = sound.trans_write->ct_s16le;
1567 break;
1568 case AFMT_U16_LE:
1569 ct_func = sound.trans_write->ct_u16le;
1570 break;
1571 }
1572 if (ct_func)
1573 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
1574 else
1575 return 0;
1576 }
1577
1578 static ssize_t sound_copy_translate_read(const u_char *userPtr,
1579 size_t userCount,
1580 u_char frame[], ssize_t *frameUsed,
1581 ssize_t frameLeft)
1582 {
1583 ssize_t (*ct_func)(const u_char *, size_t, u_char *, ssize_t *, ssize_t) = NULL;
1584
1585 switch (sound.soft.format) {
1586 case AFMT_MU_LAW:
1587 ct_func = sound.trans_read->ct_ulaw;
1588 break;
1589 case AFMT_A_LAW:
1590 ct_func = sound.trans_read->ct_alaw;
1591 break;
1592 case AFMT_S8:
1593 ct_func = sound.trans_read->ct_s8;
1594 break;
1595 case AFMT_U8:
1596 ct_func = sound.trans_read->ct_u8;
1597 break;
1598 case AFMT_S16_BE:
1599 ct_func = sound.trans_read->ct_s16be;
1600 break;
1601 case AFMT_U16_BE:
1602 ct_func = sound.trans_read->ct_u16be;
1603 break;
1604 case AFMT_S16_LE:
1605 ct_func = sound.trans_read->ct_s16le;
1606 break;
1607 case AFMT_U16_LE:
1608 ct_func = sound.trans_read->ct_u16le;
1609 break;
1610 }
1611 if (ct_func)
1612 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
1613 else
1614 return 0;
1615 }
1616
1617
1618 /*
1619 * /dev/mixer abstraction
1620 */
1621
1622 static int mixer_open(struct inode *inode, struct file *file)
1623 {
1624 mixer.busy = 1;
1625 return nonseekable_open(inode, file);
1626 }
1627
1628
1629 static int mixer_release(struct inode *inode, struct file *file)
1630 {
1631 mixer.busy = 0;
1632 return 0;
1633 }
1634
1635
1636 static int mixer_ioctl(struct inode *inode, struct file *file, u_int cmd,
1637 u_long arg)
1638 {
1639 int data;
1640 uint tmpcs;
1641
1642 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
1643 mixer.modify_counter++;
1644 if (cmd == OSS_GETVERSION)
1645 return IOCTL_OUT(arg, SOUND_VERSION);
1646 switch (cmd) {
1647 case SOUND_MIXER_INFO: {
1648 mixer_info info;
1649 strlcpy(info.id, "CS4218_TDM", sizeof(info.id));
1650 strlcpy(info.name, "CS4218_TDM", sizeof(info.name));
1651 info.name[sizeof(info.name)-1] = 0;
1652 info.modify_counter = mixer.modify_counter;
1653 if (copy_to_user((int *)arg, &info, sizeof(info)))
1654 return -EFAULT;
1655 return 0;
1656 }
1657 case SOUND_MIXER_READ_DEVMASK:
1658 data = SOUND_MASK_VOLUME | SOUND_MASK_LINE
1659 | SOUND_MASK_MIC | SOUND_MASK_RECLEV
1660 | SOUND_MASK_ALTPCM;
1661 return IOCTL_OUT(arg, data);
1662 case SOUND_MIXER_READ_RECMASK:
1663 data = SOUND_MASK_LINE | SOUND_MASK_MIC;
1664 return IOCTL_OUT(arg, data);
1665 case SOUND_MIXER_READ_RECSRC:
1666 if (cs4218_control & CS_DO1)
1667 data = SOUND_MASK_LINE;
1668 else
1669 data = SOUND_MASK_MIC;
1670 return IOCTL_OUT(arg, data);
1671 case SOUND_MIXER_WRITE_RECSRC:
1672 IOCTL_IN(arg, data);
1673 data &= (SOUND_MASK_LINE | SOUND_MASK_MIC);
1674 if (data & SOUND_MASK_LINE)
1675 tmpcs = cs4218_control |
1676 (CS_ISL | CS_ISR | CS_DO1);
1677 if (data & SOUND_MASK_MIC)
1678 tmpcs = cs4218_control &
1679 ~(CS_ISL | CS_ISR | CS_DO1);
1680 if (tmpcs != cs4218_control)
1681 cs4218_ctl_write(tmpcs);
1682 return IOCTL_OUT(arg, data);
1683 case SOUND_MIXER_READ_STEREODEVS:
1684 data = SOUND_MASK_VOLUME | SOUND_MASK_RECLEV;
1685 return IOCTL_OUT(arg, data);
1686 case SOUND_MIXER_READ_CAPS:
1687 return IOCTL_OUT(arg, 0);
1688 case SOUND_MIXER_READ_VOLUME:
1689 data = (cs4218_control & CS_MUTE)? 0:
1690 cs_get_volume(cs4218_control);
1691 return IOCTL_OUT(arg, data);
1692 case SOUND_MIXER_WRITE_VOLUME:
1693 IOCTL_IN(arg, data);
1694 return IOCTL_OUT(arg, sound_set_volume(data));
1695 case SOUND_MIXER_WRITE_ALTPCM: /* really bell volume */
1696 IOCTL_IN(arg, data);
1697 beep_volume = data & 0xff;
1698 /* fall through */
1699 case SOUND_MIXER_READ_ALTPCM:
1700 return IOCTL_OUT(arg, beep_volume);
1701 case SOUND_MIXER_WRITE_RECLEV:
1702 IOCTL_IN(arg, data);
1703 data = cs_set_gain(data);
1704 return IOCTL_OUT(arg, data);
1705 case SOUND_MIXER_READ_RECLEV:
1706 data = cs_get_gain(cs4218_control);
1707 return IOCTL_OUT(arg, data);
1708 }
1709
1710 return -EINVAL;
1711 }
1712
1713
1714 static const struct file_operations mixer_fops =
1715 {
1716 .owner = THIS_MODULE,
1717 .llseek = sound_lseek,
1718 .ioctl = mixer_ioctl,
1719 .open = mixer_open,
1720 .release = mixer_release,
1721 };
1722
1723
1724 static void __init mixer_init(void)
1725 {
1726 mixer_unit = register_sound_mixer(&mixer_fops, -1);
1727 if (mixer_unit < 0)
1728 return;
1729
1730 mixer.busy = 0;
1731 sound.treble = 0;
1732 sound.bass = 0;
1733
1734 /* Set Line input, no gain, no attenuation.
1735 */
1736 cs4218_control = CS_ISL | CS_ISR | CS_DO1;
1737 cs4218_control |= CS_LGAIN_SET(0) | CS_RGAIN_SET(0);
1738 cs4218_control |= CS_LATTEN_SET(0) | CS_RATTEN_SET(0);
1739 cs4218_ctl_write(cs4218_control);
1740 }
1741
1742
1743 /*
1744 * Sound queue stuff, the heart of the driver
1745 */
1746
1747
1748 static int sq_allocate_buffers(void)
1749 {
1750 int i;
1751
1752 if (sound_buffers)
1753 return 0;
1754 sound_buffers = kmalloc (numBufs * sizeof(char *), GFP_KERNEL);
1755 if (!sound_buffers)
1756 return -ENOMEM;
1757 for (i = 0; i < numBufs; i++) {
1758 sound_buffers[i] = sound.mach.dma_alloc (bufSize << 10, GFP_KERNEL);
1759 if (!sound_buffers[i]) {
1760 while (i--)
1761 sound.mach.dma_free (sound_buffers[i], bufSize << 10);
1762 kfree (sound_buffers);
1763 sound_buffers = 0;
1764 return -ENOMEM;
1765 }
1766 }
1767 return 0;
1768 }
1769
1770
1771 static void sq_release_buffers(void)
1772 {
1773 int i;
1774
1775 if (sound_buffers) {
1776 for (i = 0; i < numBufs; i++)
1777 sound.mach.dma_free (sound_buffers[i], bufSize << 10);
1778 kfree (sound_buffers);
1779 sound_buffers = 0;
1780 }
1781 }
1782
1783
1784 static int sq_allocate_read_buffers(void)
1785 {
1786 int i;
1787
1788 if (sound_read_buffers)
1789 return 0;
1790 sound_read_buffers = kmalloc(numReadBufs * sizeof(char *), GFP_KERNEL);
1791 if (!sound_read_buffers)
1792 return -ENOMEM;
1793 for (i = 0; i < numBufs; i++) {
1794 sound_read_buffers[i] = sound.mach.dma_alloc (readbufSize<<10,
1795 GFP_KERNEL);
1796 if (!sound_read_buffers[i]) {
1797 while (i--)
1798 sound.mach.dma_free (sound_read_buffers[i],
1799 readbufSize << 10);
1800 kfree (sound_read_buffers);
1801 sound_read_buffers = 0;
1802 return -ENOMEM;
1803 }
1804 }
1805 return 0;
1806 }
1807
1808 static void sq_release_read_buffers(void)
1809 {
1810 int i;
1811
1812 if (sound_read_buffers) {
1813 cpmp->cp_smc[1].smc_smcmr &= ~SMCMR_REN;
1814 for (i = 0; i < numReadBufs; i++)
1815 sound.mach.dma_free (sound_read_buffers[i],
1816 bufSize << 10);
1817 kfree (sound_read_buffers);
1818 sound_read_buffers = 0;
1819 }
1820 }
1821
1822
1823 static void sq_setup(int numBufs, int bufSize, char **write_buffers)
1824 {
1825 int i;
1826 volatile cbd_t *bdp;
1827 volatile cpm8xx_t *cp;
1828 volatile smc_t *sp;
1829
1830 /* Make sure the SMC transmit is shut down.
1831 */
1832 cp = cpmp;
1833 sp = &cpmp->cp_smc[1];
1834 sp->smc_smcmr &= ~SMCMR_TEN;
1835
1836 sq.max_count = numBufs;
1837 sq.max_active = numBufs;
1838 sq.block_size = bufSize;
1839 sq.buffers = write_buffers;
1840
1841 sq.front = sq.count = 0;
1842 sq.rear = -1;
1843 sq.syncing = 0;
1844 sq.active = 0;
1845
1846 bdp = tx_base;
1847 for (i=0; i<numBufs; i++) {
1848 bdp->cbd_bufaddr = virt_to_bus(write_buffers[i]);
1849 bdp++;
1850 }
1851
1852 /* This causes the SMC to sync up with the first buffer again.
1853 */
1854 cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC2, CPM_CR_INIT_TX) | CPM_CR_FLG;
1855 while (cp->cp_cpcr & CPM_CR_FLG);
1856 }
1857
1858 static void read_sq_setup(int numBufs, int bufSize, char **read_buffers)
1859 {
1860 int i;
1861 volatile cbd_t *bdp;
1862 volatile cpm8xx_t *cp;
1863 volatile smc_t *sp;
1864
1865 /* Make sure the SMC receive is shut down.
1866 */
1867 cp = cpmp;
1868 sp = &cpmp->cp_smc[1];
1869 sp->smc_smcmr &= ~SMCMR_REN;
1870
1871 read_sq.max_count = numBufs;
1872 read_sq.max_active = numBufs;
1873 read_sq.block_size = bufSize;
1874 read_sq.buffers = read_buffers;
1875
1876 read_sq.front = read_sq.count = 0;
1877 read_sq.rear = 0;
1878 read_sq.rear_size = 0;
1879 read_sq.syncing = 0;
1880 read_sq.active = 0;
1881
1882 bdp = rx_base;
1883 for (i=0; i<numReadBufs; i++) {
1884 bdp->cbd_bufaddr = virt_to_bus(read_buffers[i]);
1885 bdp->cbd_datlen = read_sq.block_size;
1886 bdp++;
1887 }
1888
1889 /* This causes the SMC to sync up with the first buffer again.
1890 */
1891 cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC2, CPM_CR_INIT_RX) | CPM_CR_FLG;
1892 while (cp->cp_cpcr & CPM_CR_FLG);
1893 }
1894
1895
1896 static void sq_play(void)
1897 {
1898 (*sound.mach.play)();
1899 }
1900
1901
1902 /* ++TeSche: radically changed this one too */
1903
1904 static ssize_t sq_write(struct file *file, const char *src, size_t uLeft,
1905 loff_t *ppos)
1906 {
1907 ssize_t uWritten = 0;
1908 u_char *dest;
1909 ssize_t uUsed, bUsed, bLeft;
1910
1911 /* ++TeSche: Is something like this necessary?
1912 * Hey, that's an honest question! Or does any other part of the
1913 * filesystem already checks this situation? I really don't know.
1914 */
1915 if (uLeft == 0)
1916 return 0;
1917
1918 /* The interrupt doesn't start to play the last, incomplete frame.
1919 * Thus we can append to it without disabling the interrupts! (Note
1920 * also that sq.rear isn't affected by the interrupt.)
1921 */
1922
1923 if (sq.count > 0 && (bLeft = sq.block_size-sq.rear_size) > 0) {
1924 dest = sq_block_address(sq.rear);
1925 bUsed = sq.rear_size;
1926 uUsed = sound_copy_translate(src, uLeft, dest, &bUsed, bLeft);
1927 if (uUsed <= 0)
1928 return uUsed;
1929 src += uUsed;
1930 uWritten += uUsed;
1931 uLeft -= uUsed;
1932 sq.rear_size = bUsed;
1933 }
1934
1935 do {
1936 while (sq.count == sq.max_active) {
1937 sq_play();
1938 if (NON_BLOCKING(sq.open_mode))
1939 return uWritten > 0 ? uWritten : -EAGAIN;
1940 SLEEP(sq.action_queue);
1941 if (SIGNAL_RECEIVED)
1942 return uWritten > 0 ? uWritten : -EINTR;
1943 }
1944
1945 /* Here, we can avoid disabling the interrupt by first
1946 * copying and translating the data, and then updating
1947 * the sq variables. Until this is done, the interrupt
1948 * won't see the new frame and we can work on it
1949 * undisturbed.
1950 */
1951
1952 dest = sq_block_address((sq.rear+1) % sq.max_count);
1953 bUsed = 0;
1954 bLeft = sq.block_size;
1955 uUsed = sound_copy_translate(src, uLeft, dest, &bUsed, bLeft);
1956 if (uUsed <= 0)
1957 break;
1958 src += uUsed;
1959 uWritten += uUsed;
1960 uLeft -= uUsed;
1961 if (bUsed) {
1962 sq.rear = (sq.rear+1) % sq.max_count;
1963 sq.rear_size = bUsed;
1964 sq.count++;
1965 }
1966 } while (bUsed); /* uUsed may have been 0 */
1967
1968 sq_play();
1969
1970 return uUsed < 0? uUsed: uWritten;
1971 }
1972
1973
1974 /***********/
1975
1976 /* Here is how the values are used for reading.
1977 * The value 'active' simply indicates the DMA is running. This is
1978 * done so the driver semantics are DMA starts when the first read is
1979 * posted. The value 'front' indicates the buffer we should next
1980 * send to the user. The value 'rear' indicates the buffer the DMA is
1981 * currently filling. When 'front' == 'rear' the buffer "ring" is
1982 * empty (we always have an empty available). The 'rear_size' is used
1983 * to track partial offsets into the current buffer. Right now, I just keep
1984 * The DMA running. If the reader can't keep up, the interrupt tosses
1985 * the oldest buffer. We could also shut down the DMA in this case.
1986 */
1987 static ssize_t sq_read(struct file *file, char *dst, size_t uLeft,
1988 loff_t *ppos)
1989 {
1990
1991 ssize_t uRead, bLeft, bUsed, uUsed;
1992
1993 if (uLeft == 0)
1994 return 0;
1995
1996 if (!read_sq.active)
1997 CS_Record(); /* Kick off the record process. */
1998
1999 uRead = 0;
2000
2001 /* Move what the user requests, depending upon other options.
2002 */
2003 while (uLeft > 0) {
2004
2005 /* When front == rear, the DMA is not done yet.
2006 */
2007 while (read_sq.front == read_sq.rear) {
2008 if (NON_BLOCKING(read_sq.open_mode)) {
2009 return uRead > 0 ? uRead : -EAGAIN;
2010 }
2011 SLEEP(read_sq.action_queue);
2012 if (SIGNAL_RECEIVED)
2013 return uRead > 0 ? uRead : -EINTR;
2014 }
2015
2016 /* The amount we move is either what is left in the
2017 * current buffer or what the user wants.
2018 */
2019 bLeft = read_sq.block_size - read_sq.rear_size;
2020 bUsed = read_sq.rear_size;
2021 uUsed = sound_copy_translate_read(dst, uLeft,
2022 read_sq.buffers[read_sq.front], &bUsed, bLeft);
2023 if (uUsed <= 0)
2024 return uUsed;
2025 dst += uUsed;
2026 uRead += uUsed;
2027 uLeft -= uUsed;
2028 read_sq.rear_size += bUsed;
2029 if (read_sq.rear_size >= read_sq.block_size) {
2030 read_sq.rear_size = 0;
2031 read_sq.front++;
2032 if (read_sq.front >= read_sq.max_active)
2033 read_sq.front = 0;
2034 }
2035 }
2036 return uRead;
2037 }
2038
2039 static int sq_open(struct inode *inode, struct file *file)
2040 {
2041 int rc = 0;
2042
2043 if (file->f_mode & FMODE_WRITE) {
2044 if (sq.busy) {
2045 rc = -EBUSY;
2046 if (NON_BLOCKING(file->f_flags))
2047 goto err_out;
2048 rc = -EINTR;
2049 while (sq.busy) {
2050 SLEEP(sq.open_queue);
2051 if (SIGNAL_RECEIVED)
2052 goto err_out;
2053 }
2054 }
2055 sq.busy = 1; /* Let's play spot-the-race-condition */
2056
2057 if (sq_allocate_buffers()) goto err_out_nobusy;
2058
2059 sq_setup(numBufs, bufSize<<10,sound_buffers);
2060 sq.open_mode = file->f_mode;
2061 }
2062
2063
2064 if (file->f_mode & FMODE_READ) {
2065 if (read_sq.busy) {
2066 rc = -EBUSY;
2067 if (NON_BLOCKING(file->f_flags))
2068 goto err_out;
2069 rc = -EINTR;
2070 while (read_sq.busy) {
2071 SLEEP(read_sq.open_queue);
2072 if (SIGNAL_RECEIVED)
2073 goto err_out;
2074 }
2075 rc = 0;
2076 }
2077 read_sq.busy = 1;
2078 if (sq_allocate_read_buffers()) goto err_out_nobusy;
2079
2080 read_sq_setup(numReadBufs,readbufSize<<10, sound_read_buffers);
2081 read_sq.open_mode = file->f_mode;
2082 }
2083
2084 /* Start up the 4218 by:
2085 * Reset.
2086 * Enable, unreset.
2087 */
2088 *((volatile uint *)HIOX_CSR4_ADDR) &= ~HIOX_CSR4_RSTAUDIO;
2089 eieio();
2090 *((volatile uint *)HIOX_CSR4_ADDR) |= HIOX_CSR4_ENAUDIO;
2091 mdelay(50);
2092 *((volatile uint *)HIOX_CSR4_ADDR) |= HIOX_CSR4_RSTAUDIO;
2093
2094 /* We need to send the current control word in case someone
2095 * opened /dev/mixer and changed things while we were shut
2096 * down. Chances are good the initialization that follows
2097 * would have done this, but it is still possible it wouldn't.
2098 */
2099 cs4218_ctl_write(cs4218_control);
2100
2101 sound.minDev = iminor(inode) & 0x0f;
2102 sound.soft = sound.dsp;
2103 sound.hard = sound.dsp;
2104 sound_init();
2105 if ((iminor(inode) & 0x0f) == SND_DEV_AUDIO) {
2106 sound_set_speed(8000);
2107 sound_set_stereo(0);
2108 sound_set_format(AFMT_MU_LAW);
2109 }
2110
2111 return nonseekable_open(inode, file);
2112
2113 err_out_nobusy:
2114 if (file->f_mode & FMODE_WRITE) {
2115 sq.busy = 0;
2116 WAKE_UP(sq.open_queue);
2117 }
2118 if (file->f_mode & FMODE_READ) {
2119 read_sq.busy = 0;
2120 WAKE_UP(read_sq.open_queue);
2121 }
2122 err_out:
2123 return rc;
2124 }
2125
2126
2127 static void sq_reset(void)
2128 {
2129 sound_silence();
2130 sq.active = 0;
2131 sq.count = 0;
2132 sq.front = (sq.rear+1) % sq.max_count;
2133 #if 0
2134 init_tdm_buffers();
2135 #endif
2136 }
2137
2138
2139 static int sq_fsync(struct file *filp, struct dentry *dentry)
2140 {
2141 int rc = 0;
2142
2143 sq.syncing = 1;
2144 sq_play(); /* there may be an incomplete frame waiting */
2145
2146 while (sq.active) {
2147 SLEEP(sq.sync_queue);
2148 if (SIGNAL_RECEIVED) {
2149 /* While waiting for audio output to drain, an
2150 * interrupt occurred. Stop audio output immediately
2151 * and clear the queue. */
2152 sq_reset();
2153 rc = -EINTR;
2154 break;
2155 }
2156 }
2157
2158 sq.syncing = 0;
2159 return rc;
2160 }
2161
2162 static int sq_release(struct inode *inode, struct file *file)
2163 {
2164 int rc = 0;
2165
2166 if (sq.busy)
2167 rc = sq_fsync(file, file->f_path.dentry);
2168 sound.soft = sound.dsp;
2169 sound.hard = sound.dsp;
2170 sound_silence();
2171
2172 sq_release_read_buffers();
2173 sq_release_buffers();
2174
2175 if (file->f_mode & FMODE_READ) {
2176 read_sq.busy = 0;
2177 WAKE_UP(read_sq.open_queue);
2178 }
2179
2180 if (file->f_mode & FMODE_WRITE) {
2181 sq.busy = 0;
2182 WAKE_UP(sq.open_queue);
2183 }
2184
2185 /* Shut down the SMC.
2186 */
2187 cpmp->cp_smc[1].smc_smcmr &= ~(SMCMR_TEN | SMCMR_REN);
2188
2189 /* Shut down the codec.
2190 */
2191 *((volatile uint *)HIOX_CSR4_ADDR) |= HIOX_CSR4_RSTAUDIO;
2192 eieio();
2193 *((volatile uint *)HIOX_CSR4_ADDR) &= ~HIOX_CSR4_ENAUDIO;
2194
2195 /* Wake up a process waiting for the queue being released.
2196 * Note: There may be several processes waiting for a call
2197 * to open() returning. */
2198
2199 return rc;
2200 }
2201
2202
2203 static int sq_ioctl(struct inode *inode, struct file *file, u_int cmd,
2204 u_long arg)
2205 {
2206 u_long fmt;
2207 int data;
2208 #if 0
2209 int size, nbufs;
2210 #else
2211 int size;
2212 #endif
2213
2214 switch (cmd) {
2215 case SNDCTL_DSP_RESET:
2216 sq_reset();
2217 return 0;
2218 case SNDCTL_DSP_POST:
2219 case SNDCTL_DSP_SYNC:
2220 return sq_fsync(file, file->f_path.dentry);
2221
2222 /* ++TeSche: before changing any of these it's
2223 * probably wise to wait until sound playing has
2224 * settled down. */
2225 case SNDCTL_DSP_SPEED:
2226 sq_fsync(file, file->f_path.dentry);
2227 IOCTL_IN(arg, data);
2228 return IOCTL_OUT(arg, sound_set_speed(data));
2229 case SNDCTL_DSP_STEREO:
2230 sq_fsync(file, file->f_path.dentry);
2231 IOCTL_IN(arg, data);
2232 return IOCTL_OUT(arg, sound_set_stereo(data));
2233 case SOUND_PCM_WRITE_CHANNELS:
2234 sq_fsync(file, file->f_path.dentry);
2235 IOCTL_IN(arg, data);
2236 return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
2237 case SNDCTL_DSP_SETFMT:
2238 sq_fsync(file, file->f_path.dentry);
2239 IOCTL_IN(arg, data);
2240 return IOCTL_OUT(arg, sound_set_format(data));
2241 case SNDCTL_DSP_GETFMTS:
2242 fmt = 0;
2243 if (sound.trans_write) {
2244 if (sound.trans_write->ct_ulaw)
2245 fmt |= AFMT_MU_LAW;
2246 if (sound.trans_write->ct_alaw)
2247 fmt |= AFMT_A_LAW;
2248 if (sound.trans_write->ct_s8)
2249 fmt |= AFMT_S8;
2250 if (sound.trans_write->ct_u8)
2251 fmt |= AFMT_U8;
2252 if (sound.trans_write->ct_s16be)
2253 fmt |= AFMT_S16_BE;
2254 if (sound.trans_write->ct_u16be)
2255 fmt |= AFMT_U16_BE;
2256 if (sound.trans_write->ct_s16le)
2257 fmt |= AFMT_S16_LE;
2258 if (sound.trans_write->ct_u16le)
2259 fmt |= AFMT_U16_LE;
2260 }
2261 return IOCTL_OUT(arg, fmt);
2262 case SNDCTL_DSP_GETBLKSIZE:
2263 size = sq.block_size
2264 * sound.soft.size * (sound.soft.stereo + 1)
2265 / (sound.hard.size * (sound.hard.stereo + 1));
2266 return IOCTL_OUT(arg, size);
2267 case SNDCTL_DSP_SUBDIVIDE:
2268 break;
2269 #if 0 /* Sorry can't do this at the moment. The CPM allocated buffers
2270 * long ago that can't be changed.
2271 */
2272 case SNDCTL_DSP_SETFRAGMENT:
2273 if (sq.count || sq.active || sq.syncing)
2274 return -EINVAL;
2275 IOCTL_IN(arg, size);
2276 nbufs = size >> 16;
2277 if (nbufs < 2 || nbufs > numBufs)
2278 nbufs = numBufs;
2279 size &= 0xffff;
2280 if (size >= 8 && size <= 30) {
2281 size = 1 << size;
2282 size *= sound.hard.size * (sound.hard.stereo + 1);
2283 size /= sound.soft.size * (sound.soft.stereo + 1);
2284 if (size > (bufSize << 10))
2285 size = bufSize << 10;
2286 } else
2287 size = bufSize << 10;
2288 sq_setup(numBufs, size, sound_buffers);
2289 sq.max_active = nbufs;
2290 return 0;
2291 #endif
2292
2293 default:
2294 return mixer_ioctl(inode, file, cmd, arg);
2295 }
2296 return -EINVAL;
2297 }
2298
2299
2300
2301 static const struct file_operations sq_fops =
2302 {
2303 .owner = THIS_MODULE,
2304 .llseek = sound_lseek,
2305 .read = sq_read, /* sq_read */
2306 .write = sq_write,
2307 .ioctl = sq_ioctl,
2308 .open = sq_open,
2309 .release = sq_release,
2310 };
2311
2312
2313 static void __init sq_init(void)
2314 {
2315 sq_unit = register_sound_dsp(&sq_fops, -1);
2316 if (sq_unit < 0)
2317 return;
2318
2319 init_waitqueue_head(&sq.action_queue);
2320 init_waitqueue_head(&sq.open_queue);
2321 init_waitqueue_head(&sq.sync_queue);
2322 init_waitqueue_head(&read_sq.action_queue);
2323 init_waitqueue_head(&read_sq.open_queue);
2324 init_waitqueue_head(&read_sq.sync_queue);
2325
2326 sq.busy = 0;
2327 read_sq.busy = 0;
2328
2329 /* whatever you like as startup mode for /dev/dsp,
2330 * (/dev/audio hasn't got a startup mode). note that
2331 * once changed a new open() will *not* restore these!
2332 */
2333 sound.dsp.format = AFMT_S16_BE;
2334 sound.dsp.stereo = 1;
2335 sound.dsp.size = 16;
2336
2337 /* set minimum rate possible without expanding */
2338 sound.dsp.speed = 8000;
2339
2340 /* before the first open to /dev/dsp this wouldn't be set */
2341 sound.soft = sound.dsp;
2342 sound.hard = sound.dsp;
2343
2344 sound_silence();
2345 }
2346
2347 /*
2348 * /dev/sndstat
2349 */
2350
2351
2352 /* state.buf should not overflow! */
2353
2354 static int state_open(struct inode *inode, struct file *file)
2355 {
2356 char *buffer = state.buf, *mach = "", cs4218_buf[50];
2357 int len = 0;
2358
2359 if (state.busy)
2360 return -EBUSY;
2361
2362 state.ptr = 0;
2363 state.busy = 1;
2364
2365 sprintf(cs4218_buf, "Crystal CS4218 on TDM, ");
2366 mach = cs4218_buf;
2367
2368 len += sprintf(buffer+len, "%sDMA sound driver:\n", mach);
2369
2370 len += sprintf(buffer+len, "\tsound.format = 0x%x", sound.soft.format);
2371 switch (sound.soft.format) {
2372 case AFMT_MU_LAW:
2373 len += sprintf(buffer+len, " (mu-law)");
2374 break;
2375 case AFMT_A_LAW:
2376 len += sprintf(buffer+len, " (A-law)");
2377 break;
2378 case AFMT_U8:
2379 len += sprintf(buffer+len, " (unsigned 8 bit)");
2380 break;
2381 case AFMT_S8:
2382 len += sprintf(buffer+len, " (signed 8 bit)");
2383 break;
2384 case AFMT_S16_BE:
2385 len += sprintf(buffer+len, " (signed 16 bit big)");
2386 break;
2387 case AFMT_U16_BE:
2388 len += sprintf(buffer+len, " (unsigned 16 bit big)");
2389 break;
2390 case AFMT_S16_LE:
2391 len += sprintf(buffer+len, " (signed 16 bit little)");
2392 break;
2393 case AFMT_U16_LE:
2394 len += sprintf(buffer+len, " (unsigned 16 bit little)");
2395 break;
2396 }
2397 len += sprintf(buffer+len, "\n");
2398 len += sprintf(buffer+len, "\tsound.speed = %dHz (phys. %dHz)\n",
2399 sound.soft.speed, sound.hard.speed);
2400 len += sprintf(buffer+len, "\tsound.stereo = 0x%x (%s)\n",
2401 sound.soft.stereo, sound.soft.stereo ? "stereo" : "mono");
2402 len += sprintf(buffer+len, "\tsq.block_size = %d sq.max_count = %d"
2403 " sq.max_active = %d\n",
2404 sq.block_size, sq.max_count, sq.max_active);
2405 len += sprintf(buffer+len, "\tsq.count = %d sq.rear_size = %d\n", sq.count,
2406 sq.rear_size);
2407 len += sprintf(buffer+len, "\tsq.active = %d sq.syncing = %d\n",
2408 sq.active, sq.syncing);
2409 state.len = len;
2410 return nonseekable_open(inode, file);
2411 }
2412
2413
2414 static int state_release(struct inode *inode, struct file *file)
2415 {
2416 state.busy = 0;
2417 return 0;
2418 }
2419
2420
2421 static ssize_t state_read(struct file *file, char *buf, size_t count,
2422 loff_t *ppos)
2423 {
2424 int n = state.len - state.ptr;
2425 if (n > count)
2426 n = count;
2427 if (n <= 0)
2428 return 0;
2429 if (copy_to_user(buf, &state.buf[state.ptr], n))
2430 return -EFAULT;
2431 state.ptr += n;
2432 return n;
2433 }
2434
2435
2436 static const struct file_operations state_fops =
2437 {
2438 .owner = THIS_MODULE,
2439 .llseek = sound_lseek,
2440 .read = state_read,
2441 .open = state_open,
2442 .release = state_release,
2443 };
2444
2445
2446 static void __init state_init(void)
2447 {
2448 state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
2449 if (state_unit < 0)
2450 return;
2451 state.busy = 0;
2452 }
2453
2454
2455 /*** Common stuff ********************************************************/
2456
2457 static long long sound_lseek(struct file *file, long long offset, int orig)
2458 {
2459 return -ESPIPE;
2460 }
2461
2462
2463 /*** Config & Setup **********************************************************/
2464
2465
2466 int __init tdm8xx_sound_init(void)
2467 {
2468 int i, has_sound;
2469 uint dp_offset;
2470 volatile uint *sirp;
2471 volatile cbd_t *bdp;
2472 volatile cpm8xx_t *cp;
2473 volatile smc_t *sp;
2474 volatile smc_uart_t *up;
2475 volatile immap_t *immap;
2476
2477 has_sound = 0;
2478
2479 /* Program the SI/TSA to use TDMa, connected to SMC2, for 4 bytes.
2480 */
2481 cp = cpmp; /* Get pointer to Communication Processor */
2482 immap = (immap_t *)IMAP_ADDR; /* and to internal registers */
2483
2484 /* Set all TDMa control bits to zero. This enables most features
2485 * we want.
2486 */
2487 cp->cp_simode &= ~0x00000fff;
2488
2489 /* Enable common receive/transmit clock pins, use IDL format.
2490 * Sync on falling edge, transmit rising clock, receive falling
2491 * clock, delay 1 bit on both Tx and Rx. Common Tx/Rx clocks and
2492 * sync.
2493 * Connect SMC2 to TSA.
2494 */
2495 cp->cp_simode |= 0x80000141;
2496
2497 /* Configure port A pins for TDMa operation.
2498 * The RPX-Lite (MPC850/823) loses SMC2 when TDM is used.
2499 */
2500 immap->im_ioport.iop_papar |= 0x01c0; /* Enable TDMa functions */
2501 immap->im_ioport.iop_padir |= 0x00c0; /* Enable TDMa Tx/Rx */
2502 immap->im_ioport.iop_padir &= ~0x0100; /* Enable L1RCLKa */
2503
2504 immap->im_ioport.iop_pcpar |= 0x0800; /* Enable L1RSYNCa */
2505 immap->im_ioport.iop_pcdir &= ~0x0800;
2506
2507 /* Initialize the SI TDM routing table. We use TDMa only.
2508 * The receive table and transmit table each have only one
2509 * entry, to capture/send four bytes after each frame pulse.
2510 * The 16-bit ram entry is 0000 0001 1000 1111. (SMC2)
2511 */
2512 cp->cp_sigmr = 0;
2513 sirp = (uint *)cp->cp_siram;
2514
2515 *sirp = 0x018f0000; /* Receive entry */
2516 sirp += 64;
2517 *sirp = 0x018f0000; /* Tramsmit entry */
2518
2519 /* Enable single TDMa routing.
2520 */
2521 cp->cp_sigmr = 0x04;
2522
2523 /* Initialize the SMC for transparent operation.
2524 */
2525 sp = &cpmp->cp_smc[1];
2526 up = (smc_uart_t *)&cp->cp_dparam[PROFF_SMC2];
2527
2528 /* We need to allocate a transmit and receive buffer
2529 * descriptors from dual port ram.
2530 */
2531 dp_addr = cpm_dpalloc(sizeof(cbd_t) * numReadBufs, 8);
2532
2533 /* Set the physical address of the host memory
2534 * buffers in the buffer descriptors, and the
2535 * virtual address for us to work with.
2536 */
2537 bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
2538 up->smc_rbase = dp_offset;
2539 rx_cur = rx_base = (cbd_t *)bdp;
2540
2541 for (i=0; i<(numReadBufs-1); i++) {
2542 bdp->cbd_bufaddr = 0;
2543 bdp->cbd_datlen = 0;
2544 bdp->cbd_sc = BD_SC_EMPTY | BD_SC_INTRPT;
2545 bdp++;
2546 }
2547 bdp->cbd_bufaddr = 0;
2548 bdp->cbd_datlen = 0;
2549 bdp->cbd_sc = BD_SC_WRAP | BD_SC_EMPTY | BD_SC_INTRPT;
2550
2551 /* Now, do the same for the transmit buffers.
2552 */
2553 dp_offset = cpm_dpalloc(sizeof(cbd_t) * numBufs, 8);
2554
2555 bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
2556 up->smc_tbase = dp_offset;
2557 tx_cur = tx_base = (cbd_t *)bdp;
2558
2559 for (i=0; i<(numBufs-1); i++) {
2560 bdp->cbd_bufaddr = 0;
2561 bdp->cbd_datlen = 0;
2562 bdp->cbd_sc = BD_SC_INTRPT;
2563 bdp++;
2564 }
2565 bdp->cbd_bufaddr = 0;
2566 bdp->cbd_datlen = 0;
2567 bdp->cbd_sc = (BD_SC_WRAP | BD_SC_INTRPT);
2568
2569 /* Set transparent SMC mode.
2570 * A few things are specific to our application. The codec interface
2571 * is MSB first, hence the REVD selection. The CD/CTS pulse are
2572 * used by the TSA to indicate the frame start to the SMC.
2573 */
2574 up->smc_rfcr = SCC_EB;
2575 up->smc_tfcr = SCC_EB;
2576 up->smc_mrblr = readbufSize * 1024;
2577
2578 /* Set 16-bit reversed data, transparent mode.
2579 */
2580 sp->smc_smcmr = smcr_mk_clen(15) |
2581 SMCMR_SM_TRANS | SMCMR_REVD | SMCMR_BS;
2582
2583 /* Enable and clear events.
2584 * Because of FIFO delays, all we need is the receive interrupt
2585 * and we can process both the current receive and current
2586 * transmit interrupt within a few microseconds of the transmit.
2587 */
2588 sp->smc_smce = 0xff;
2589 sp->smc_smcm = SMCM_TXE | SMCM_TX | SMCM_RX;
2590
2591 /* Send the CPM an initialize command.
2592 */
2593 cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC2,
2594 CPM_CR_INIT_TRX) | CPM_CR_FLG;
2595 while (cp->cp_cpcr & CPM_CR_FLG);
2596
2597 sound.mach = mach_cs4218;
2598 has_sound = 1;
2599
2600 /* Initialize beep stuff */
2601 orig_mksound = kd_mksound;
2602 kd_mksound = cs_mksound;
2603 beep_buf = kmalloc(BEEP_BUFLEN * 4, GFP_KERNEL);
2604 if (beep_buf == NULL)
2605 printk(KERN_WARNING "dmasound: no memory for "
2606 "beep buffer\n");
2607
2608 if (!has_sound)
2609 return -ENODEV;
2610
2611 /* Initialize the software SPI.
2612 */
2613 sw_spi_init();
2614
2615 /* Set up sound queue, /dev/audio and /dev/dsp. */
2616
2617 /* Set default settings. */
2618 sq_init();
2619
2620 /* Set up /dev/sndstat. */
2621 state_init();
2622
2623 /* Set up /dev/mixer. */
2624 mixer_init();
2625
2626 if (!sound.mach.irqinit()) {
2627 printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
2628 return -ENODEV;
2629 }
2630 #ifdef MODULE
2631 irq_installed = 1;
2632 #endif
2633
2634 printk(KERN_INFO "DMA sound driver installed, using %d buffers of %dk.\n",
2635 numBufs, bufSize);
2636
2637 return 0;
2638 }
2639
2640 /* Due to FIFOs and bit delays, the transmit interrupt occurs a few
2641 * microseconds ahead of the receive interrupt.
2642 * When we get an interrupt, we service the transmit first, then
2643 * check for a receive to prevent the overhead of returning through
2644 * the interrupt handler only to get back here right away during
2645 * full duplex operation.
2646 */
2647 static void
2648 cs4218_intr(void *dev_id)
2649 {
2650 volatile smc_t *sp;
2651 volatile cpm8xx_t *cp;
2652
2653 sp = &cpmp->cp_smc[1];
2654
2655 if (sp->smc_smce & SCCM_TX) {
2656 sp->smc_smce = SCCM_TX;
2657 cs4218_tdm_tx_intr((void *)sp);
2658 }
2659
2660 if (sp->smc_smce & SCCM_RX) {
2661 sp->smc_smce = SCCM_RX;
2662 cs4218_tdm_rx_intr((void *)sp);
2663 }
2664
2665 if (sp->smc_smce & SCCM_TXE) {
2666 /* Transmit underrun. This happens with the application
2667 * didn't keep up sending buffers. We tell the SMC to
2668 * restart, which will cause it to poll the current (next)
2669 * BD. If the user supplied data since this occurred,
2670 * we just start running again. If they didn't, the SMC
2671 * will poll the descriptor until data is placed there.
2672 */
2673 sp->smc_smce = SCCM_TXE;
2674 cp = cpmp; /* Get pointer to Communication Processor */
2675 cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC2,
2676 CPM_CR_RESTART_TX) | CPM_CR_FLG;
2677 while (cp->cp_cpcr & CPM_CR_FLG);
2678 }
2679 }
2680
2681
2682 #define MAXARGS 8 /* Should be sufficient for now */
2683
2684 void __init dmasound_setup(char *str, int *ints)
2685 {
2686 /* check the bootstrap parameter for "dmasound=" */
2687
2688 switch (ints[0]) {
2689 case 3:
2690 if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
2691 printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
2692 else
2693 catchRadius = ints[3];
2694 /* fall through */
2695 case 2:
2696 if (ints[1] < MIN_BUFFERS)
2697 printk("dmasound_setup: invalid number of buffers, using default = %d\n", numBufs);
2698 else
2699 numBufs = ints[1];
2700 if (ints[2] < MIN_BUFSIZE || ints[2] > MAX_BUFSIZE)
2701 printk("dmasound_setup: invalid buffer size, using default = %d\n", bufSize);
2702 else
2703 bufSize = ints[2];
2704 break;
2705 case 0:
2706 break;
2707 default:
2708 printk("dmasound_setup: invalid number of arguments\n");
2709 }
2710 }
2711
2712 /* Software SPI functions.
2713 * These are on Port B.
2714 */
2715 #define PB_SPICLK ((uint)0x00000002)
2716 #define PB_SPIMOSI ((uint)0x00000004)
2717 #define PB_SPIMISO ((uint)0x00000008)
2718
2719 static
2720 void sw_spi_init(void)
2721 {
2722 volatile cpm8xx_t *cp;
2723 volatile uint *hcsr4;
2724
2725 hcsr4 = (volatile uint *)HIOX_CSR4_ADDR;
2726 cp = cpmp; /* Get pointer to Communication Processor */
2727
2728 *hcsr4 &= ~HIOX_CSR4_AUDSPISEL; /* Disable SPI select */
2729
2730 /* Make these Port B signals general purpose I/O.
2731 * First, make sure the clock is low.
2732 */
2733 cp->cp_pbdat &= ~PB_SPICLK;
2734 cp->cp_pbpar &= ~(PB_SPICLK | PB_SPIMOSI | PB_SPIMISO);
2735
2736 /* Clock and Master Output are outputs.
2737 */
2738 cp->cp_pbdir |= (PB_SPICLK | PB_SPIMOSI);
2739
2740 /* Master Input.
2741 */
2742 cp->cp_pbdir &= ~PB_SPIMISO;
2743
2744 }
2745
2746 /* Write the CS4218 control word out the SPI port. While the
2747 * the control word is going out, the status word is arriving.
2748 */
2749 static
2750 uint cs4218_ctl_write(uint ctlreg)
2751 {
2752 uint status;
2753
2754 sw_spi_io((u_char *)&ctlreg, (u_char *)&status, 4);
2755
2756 /* Shadow the control register.....I guess we could do
2757 * the same for the status, but for now we just return it
2758 * and let the caller decide.
2759 */
2760 cs4218_control = ctlreg;
2761 return status;
2762 }
2763
2764 static
2765 void sw_spi_io(u_char *obuf, u_char *ibuf, uint bcnt)
2766 {
2767 int bits, i;
2768 u_char outbyte, inbyte;
2769 volatile cpm8xx_t *cp;
2770 volatile uint *hcsr4;
2771
2772 hcsr4 = (volatile uint *)HIOX_CSR4_ADDR;
2773 cp = cpmp; /* Get pointer to Communication Processor */
2774
2775 /* The timing on the bus is pretty slow. Code inefficiency
2776 * and eieio() is our friend here :-).
2777 */
2778 cp->cp_pbdat &= ~PB_SPICLK;
2779 *hcsr4 |= HIOX_CSR4_AUDSPISEL; /* Enable SPI select */
2780 eieio();
2781
2782 /* Clock in/out the bytes. Data is valid on the falling edge
2783 * of the clock. Data is MSB first.
2784 */
2785 for (i=0; i<bcnt; i++) {
2786 outbyte = *obuf++;
2787 inbyte = 0;
2788 for (bits=0; bits<8; bits++) {
2789 eieio();
2790 cp->cp_pbdat |= PB_SPICLK;
2791 eieio();
2792 if (outbyte & 0x80)
2793 cp->cp_pbdat |= PB_SPIMOSI;
2794 else
2795 cp->cp_pbdat &= ~PB_SPIMOSI;
2796 eieio();
2797 cp->cp_pbdat &= ~PB_SPICLK;
2798 eieio();
2799 outbyte <<= 1;
2800 inbyte <<= 1;
2801 if (cp->cp_pbdat & PB_SPIMISO)
2802 inbyte |= 1;
2803 }
2804 *ibuf++ = inbyte;
2805 }
2806
2807 *hcsr4 &= ~HIOX_CSR4_AUDSPISEL; /* Disable SPI select */
2808 eieio();
2809 }
2810
2811 void cleanup_module(void)
2812 {
2813 if (irq_installed) {
2814 sound_silence();
2815 #ifdef MODULE
2816 sound.mach.irqcleanup();
2817 #endif
2818 }
2819
2820 sq_release_read_buffers();
2821 sq_release_buffers();
2822
2823 if (mixer_unit >= 0)
2824 unregister_sound_mixer(mixer_unit);
2825 if (state_unit >= 0)
2826 unregister_sound_special(state_unit);
2827 if (sq_unit >= 0)
2828 unregister_sound_dsp(sq_unit);
2829 }
2830
2831 module_init(tdm8xx_sound_init);
2832 module_exit(cleanup_module);
2833
kernel-based virtual machine