projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[POWERPC] Add new interrupt mapping core and change platforms to use it
[deliverable/linux.git] / sound / oss / dmasound / dmasound_awacs.c
1 /*
2 * linux/sound/oss/dmasound/dmasound_awacs.c
3 *
4 * PowerMac `AWACS' and `Burgundy' DMA Sound Driver
5 * with some limited support for DACA & Tumbler
6 *
7 * See linux/sound/oss/dmasound/dmasound_core.c for copyright and
8 * history prior to 2001/01/26.
9 *
10 * 26/01/2001 ed 0.1 Iain Sandoe
11 * - added version info.
12 * - moved dbdma command buffer allocation to PMacXXXSqSetup()
13 * - fixed up beep dbdma cmd buffers
14 *
15 * 08/02/2001 [0.2]
16 * - make SNDCTL_DSP_GETFMTS return the correct info for the h/w
17 * - move soft format translations to a separate file
18 * - [0.3] make SNDCTL_DSP_GETCAPS return correct info.
19 * - [0.4] more informative machine name strings.
20 * - [0.5]
21 * - record changes.
22 * - made the default_hard/soft entries.
23 * 04/04/2001 [0.6]
24 * - minor correction to bit assignments in awacs_defs.h
25 * - incorporate mixer changes from 2.2.x back-port.
26 * - take out passthru as a rec input (it isn't).
27 * - make Input Gain slider work the 'right way up'.
28 * - try to make the mixer sliders more logical - so now the
29 * input selectors are just two-state (>50% == ON) and the
30 * Input Gain slider handles the rest of the gain issues.
31 * - try to pick slider representations that most closely match
32 * the actual use - e.g. IGain for input gain...
33 * - first stab at over/under-run detection.
34 * - minor cosmetic changes to IRQ identification.
35 * - fix bug where rates > max would be reported as supported.
36 * - first stab at over/under-run detection.
37 * - make use of i2c for mixer settings conditional on perch
38 * rather than cuda (some machines without perch have cuda).
39 * - fix bug where TX stops when dbdma status comes up "DEAD"
40 * so far only reported on PowerComputing clones ... but.
41 * - put in AWACS/Screamer register write timeouts.
42 * - part way to partitioning the init() stuff
43 * - first pass at 'tumbler' stuff (not support - just an attempt
44 * to allow the driver to load on new G4s).
45 * 01/02/2002 [0.7] - BenH
46 * - all sort of minor bits went in since the latest update, I
47 * bumped the version number for that reason
48 *
49 * 07/26/2002 [0.8] - BenH
50 * - More minor bits since last changelog (I should be more careful
51 * with those)
52 * - Support for snapper & better tumbler integration by Toby Sargeant
53 * - Headphone detect for scremer by Julien Blache
54 * - More tumbler fixed by Andreas Schwab
55 * 11/29/2003 [0.8.1] - Renzo Davoli (King Enzo)
56 * - Support for Snapper line in
57 * - snapper input resampling (for rates < 44100)
58 * - software line gain control
59 */
60
61 /* GENERAL FIXME/TODO: check that the assumptions about what is written to
62 mac-io is valid for DACA & Tumbler.
63
64 This driver is in bad need of a rewrite. The dbdma code has to be split,
65 some proper device-tree parsing code has to be written, etc...
66 */
67
68 #include <linux/types.h>
69 #include <linux/module.h>
70 #include <linux/slab.h>
71 #include <linux/init.h>
72 #include <linux/delay.h>
73 #include <linux/soundcard.h>
74 #include <linux/adb.h>
75 #include <linux/nvram.h>
76 #include <linux/tty.h>
77 #include <linux/vt_kern.h>
78 #include <linux/spinlock.h>
79 #include <linux/kmod.h>
80 #include <linux/interrupt.h>
81 #include <linux/input.h>
82 #include <linux/mutex.h>
83 #ifdef CONFIG_ADB_CUDA
84 #include <linux/cuda.h>
85 #endif
86 #ifdef CONFIG_ADB_PMU
87 #include <linux/pmu.h>
88 #endif
89
90 #include <asm/uaccess.h>
91 #include <asm/prom.h>
92 #include <asm/machdep.h>
93 #include <asm/io.h>
94 #include <asm/dbdma.h>
95 #include <asm/pmac_feature.h>
96 #include <asm/irq.h>
97 #include <asm/nvram.h>
98
99 #include "awacs_defs.h"
100 #include "dmasound.h"
101 #include "tas3001c.h"
102 #include "tas3004.h"
103 #include "tas_common.h"
104
105 #define DMASOUND_AWACS_REVISION 0
106 #define DMASOUND_AWACS_EDITION 7
107
108 #define AWACS_SNAPPER 110 /* fake revision # for snapper */
109 #define AWACS_BURGUNDY 100 /* fake revision # for burgundy */
110 #define AWACS_TUMBLER 90 /* fake revision # for tumbler */
111 #define AWACS_DACA 80 /* fake revision # for daca (ibook) */
112 #define AWACS_AWACS 2 /* holding revision for AWACS */
113 #define AWACS_SCREAMER 3 /* holding revision for Screamer */
114 /*
115 * Interrupt numbers and addresses, & info obtained from the device tree.
116 */
117 static int awacs_irq, awacs_tx_irq, awacs_rx_irq;
118 static volatile struct awacs_regs __iomem *awacs;
119 static volatile u32 __iomem *i2s;
120 static volatile struct dbdma_regs __iomem *awacs_txdma, *awacs_rxdma;
121 static int awacs_rate_index;
122 static int awacs_subframe;
123 static struct device_node* awacs_node;
124 static struct device_node* i2s_node;
125 static struct resource awacs_rsrc[3];
126
127 static char awacs_name[64];
128 static int awacs_revision;
129 static int awacs_sleeping;
130 static DEFINE_MUTEX(dmasound_mutex);
131
132 static int sound_device_id; /* exists after iMac revA */
133 static int hw_can_byteswap = 1 ; /* most pmac sound h/w can */
134
135 /* model info */
136 /* To be replaced with better interaction with pmac_feature.c */
137 static int is_pbook_3X00;
138 static int is_pbook_g3;
139
140 /* expansion info */
141 static int has_perch;
142 static int has_ziva;
143
144 /* for earlier powerbooks which need fiddling with mac-io to enable
145 * cd etc.
146 */
147 static unsigned char __iomem *latch_base;
148 static unsigned char __iomem *macio_base;
149
150 /*
151 * Space for the DBDMA command blocks.
152 */
153 static void *awacs_tx_cmd_space;
154 static volatile struct dbdma_cmd *awacs_tx_cmds;
155 static int number_of_tx_cmd_buffers;
156
157 static void *awacs_rx_cmd_space;
158 static volatile struct dbdma_cmd *awacs_rx_cmds;
159 static int number_of_rx_cmd_buffers;
160
161 /*
162 * Cached values of AWACS registers (we can't read them).
163 * Except on the burgundy (and screamer). XXX
164 */
165
166 int awacs_reg[8];
167 int awacs_reg1_save;
168
169 /* tracking values for the mixer contents
170 */
171
172 static int spk_vol;
173 static int line_vol;
174 static int passthru_vol;
175
176 static int ip_gain; /* mic preamp settings */
177 static int rec_lev = 0x4545 ; /* default CD gain 69 % */
178 static int mic_lev;
179 static int cd_lev = 0x6363 ; /* 99 % */
180 static int line_lev;
181
182 static int hdp_connected;
183
184 /*
185 * Stuff for outputting a beep. The values range from -327 to +327
186 * so we can multiply by an amplitude in the range 0..100 to get a
187 * signed short value to put in the output buffer.
188 */
189 static short beep_wform[256] = {
190 0, 40, 79, 117, 153, 187, 218, 245,
191 269, 288, 304, 316, 323, 327, 327, 324,
192 318, 310, 299, 288, 275, 262, 249, 236,
193 224, 213, 204, 196, 190, 186, 183, 182,
194 182, 183, 186, 189, 192, 196, 200, 203,
195 206, 208, 209, 209, 209, 207, 204, 201,
196 197, 193, 188, 183, 179, 174, 170, 166,
197 163, 161, 160, 159, 159, 160, 161, 162,
198 164, 166, 168, 169, 171, 171, 171, 170,
199 169, 167, 163, 159, 155, 150, 144, 139,
200 133, 128, 122, 117, 113, 110, 107, 105,
201 103, 103, 103, 103, 104, 104, 105, 105,
202 105, 103, 101, 97, 92, 86, 78, 68,
203 58, 45, 32, 18, 3, -11, -26, -41,
204 -55, -68, -79, -88, -95, -100, -102, -102,
205 -99, -93, -85, -75, -62, -48, -33, -16,
206 0, 16, 33, 48, 62, 75, 85, 93,
207 99, 102, 102, 100, 95, 88, 79, 68,
208 55, 41, 26, 11, -3, -18, -32, -45,
209 -58, -68, -78, -86, -92, -97, -101, -103,
210 -105, -105, -105, -104, -104, -103, -103, -103,
211 -103, -105, -107, -110, -113, -117, -122, -128,
212 -133, -139, -144, -150, -155, -159, -163, -167,
213 -169, -170, -171, -171, -171, -169, -168, -166,
214 -164, -162, -161, -160, -159, -159, -160, -161,
215 -163, -166, -170, -174, -179, -183, -188, -193,
216 -197, -201, -204, -207, -209, -209, -209, -208,
217 -206, -203, -200, -196, -192, -189, -186, -183,
218 -182, -182, -183, -186, -190, -196, -204, -213,
219 -224, -236, -249, -262, -275, -288, -299, -310,
220 -318, -324, -327, -327, -323, -316, -304, -288,
221 -269, -245, -218, -187, -153, -117, -79, -40,
222 };
223
224 /* beep support */
225 #define BEEP_SRATE 22050 /* 22050 Hz sample rate */
226 #define BEEP_BUFLEN 512
227 #define BEEP_VOLUME 15 /* 0 - 100 */
228
229 static int beep_vol = BEEP_VOLUME;
230 static int beep_playing;
231 static int awacs_beep_state;
232 static short *beep_buf;
233 static void *beep_dbdma_cmd_space;
234 static volatile struct dbdma_cmd *beep_dbdma_cmd;
235
236 /* Burgundy functions */
237 static void awacs_burgundy_wcw(unsigned addr,unsigned newval);
238 static unsigned awacs_burgundy_rcw(unsigned addr);
239 static void awacs_burgundy_write_volume(unsigned address, int volume);
240 static int awacs_burgundy_read_volume(unsigned address);
241 static void awacs_burgundy_write_mvolume(unsigned address, int volume);
242 static int awacs_burgundy_read_mvolume(unsigned address);
243
244 /* we will allocate a single 'emergency' dbdma cmd block to use if the
245 tx status comes up "DEAD". This happens on some PowerComputing Pmac
246 clones, either owing to a bug in dbdma or some interaction between
247 IDE and sound. However, this measure would deal with DEAD status if
248 if appeared elsewhere.
249
250 for the sake of memory efficiency we'll allocate this cmd as part of
251 the beep cmd stuff.
252 */
253
254 static volatile struct dbdma_cmd *emergency_dbdma_cmd;
255
256 #ifdef CONFIG_PM
257 /*
258 * Stuff for restoring after a sleep.
259 */
260 static int awacs_sleep_notify(struct pmu_sleep_notifier *self, int when);
261 struct pmu_sleep_notifier awacs_sleep_notifier = {
262 awacs_sleep_notify, SLEEP_LEVEL_SOUND,
263 };
264 #endif /* CONFIG_PM */
265
266 /* for (soft) sample rate translations */
267 int expand_bal; /* Balance factor for expanding (not volume!) */
268 int expand_read_bal; /* Balance factor for expanding reads (not volume!) */
269
270 /*** Low level stuff *********************************************************/
271
272 static void *PMacAlloc(unsigned int size, gfp_t flags);
273 static void PMacFree(void *ptr, unsigned int size);
274 static int PMacIrqInit(void);
275 #ifdef MODULE
276 static void PMacIrqCleanup(void);
277 #endif
278 static void PMacSilence(void);
279 static void PMacInit(void);
280 static int PMacSetFormat(int format);
281 static int PMacSetVolume(int volume);
282 static void PMacPlay(void);
283 static void PMacRecord(void);
284 static irqreturn_t pmac_awacs_tx_intr(int irq, void *devid, struct pt_regs *regs);
285 static irqreturn_t pmac_awacs_rx_intr(int irq, void *devid, struct pt_regs *regs);
286 static irqreturn_t pmac_awacs_intr(int irq, void *devid, struct pt_regs *regs);
287 static void awacs_write(int val);
288 static int awacs_get_volume(int reg, int lshift);
289 static int awacs_volume_setter(int volume, int n, int mute, int lshift);
290
291
292 /*** Mid level stuff **********************************************************/
293
294 static int PMacMixerIoctl(u_int cmd, u_long arg);
295 static int PMacWriteSqSetup(void);
296 static int PMacReadSqSetup(void);
297 static void PMacAbortRead(void);
298
299 extern TRANS transAwacsNormal ;
300 extern TRANS transAwacsExpand ;
301 extern TRANS transAwacsNormalRead ;
302 extern TRANS transAwacsExpandRead ;
303
304 extern int daca_init(void);
305 extern void daca_cleanup(void);
306 extern int daca_set_volume(uint left_vol, uint right_vol);
307 extern void daca_get_volume(uint * left_vol, uint *right_vol);
308 extern int daca_enter_sleep(void);
309 extern int daca_leave_sleep(void);
310
311 #define TRY_LOCK() \
312 if ((rc = mutex_lock_interruptible(&dmasound_mutex)) != 0) \
313 return rc;
314 #define LOCK() mutex_lock(&dmasound_mutex);
315
316 #define UNLOCK() mutex_unlock(&dmasound_mutex);
317
318 /* We use different versions that the ones provided in dmasound.h
319 *
320 * FIXME: Use different names ;)
321 */
322 #undef IOCTL_IN
323 #undef IOCTL_OUT
324
325 #define IOCTL_IN(arg, ret) \
326 rc = get_user(ret, (int __user *)(arg)); \
327 if (rc) break;
328 #define IOCTL_OUT(arg, ret) \
329 ioctl_return2((int __user *)(arg), ret)
330
331 static inline int ioctl_return2(int __user *addr, int value)
332 {
333 return value < 0 ? value : put_user(value, addr);
334 }
335
336
337 /*** AE - TUMBLER / SNAPPER START ************************************************/
338
339
340 int gpio_audio_reset, gpio_audio_reset_pol;
341 int gpio_amp_mute, gpio_amp_mute_pol;
342 int gpio_headphone_mute, gpio_headphone_mute_pol;
343 int gpio_headphone_detect, gpio_headphone_detect_pol;
344 int gpio_headphone_irq;
345
346 int
347 setup_audio_gpio(const char *name, const char* compatible, int *gpio_addr, int* gpio_pol)
348 {
349 struct device_node *np;
350 u32* pp;
351
352 np = find_devices("gpio");
353 if (!np)
354 return -ENODEV;
355
356 np = np->child;
357 while(np != 0) {
358 if (name) {
359 char *property = get_property(np,"audio-gpio",NULL);
360 if (property != 0 && strcmp(property,name) == 0)
361 break;
362 } else if (compatible && device_is_compatible(np, compatible))
363 break;
364 np = np->sibling;
365 }
366 if (!np)
367 return -ENODEV;
368 pp = (u32 *)get_property(np, "AAPL,address", NULL);
369 if (!pp)
370 return -ENODEV;
371 *gpio_addr = (*pp) & 0x0000ffff;
372 pp = (u32 *)get_property(np, "audio-gpio-active-state", NULL);
373 if (pp)
374 *gpio_pol = *pp;
375 else
376 *gpio_pol = 1;
377 return irq_of_parse_and_map(np, 0);
378 }
379
380 static inline void
381 write_audio_gpio(int gpio_addr, int data)
382 {
383 if (!gpio_addr)
384 return;
385 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, gpio_addr, data ? 0x05 : 0x04);
386 }
387
388 static inline int
389 read_audio_gpio(int gpio_addr)
390 {
391 if (!gpio_addr)
392 return 0;
393 return ((pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio_addr, 0) & 0x02) !=0);
394 }
395
396 /*
397 * Headphone interrupt via GPIO (Tumbler, Snapper, DACA)
398 */
399 static irqreturn_t
400 headphone_intr(int irq, void *devid, struct pt_regs *regs)
401 {
402 unsigned long flags;
403
404 spin_lock_irqsave(&dmasound.lock, flags);
405 if (read_audio_gpio(gpio_headphone_detect) == gpio_headphone_detect_pol) {
406 printk(KERN_INFO "Audio jack plugged, muting speakers.\n");
407 write_audio_gpio(gpio_headphone_mute, !gpio_headphone_mute_pol);
408 write_audio_gpio(gpio_amp_mute, gpio_amp_mute_pol);
409 tas_output_device_change(sound_device_id,TAS_OUTPUT_HEADPHONES,0);
410 } else {
411 printk(KERN_INFO "Audio jack unplugged, enabling speakers.\n");
412 write_audio_gpio(gpio_amp_mute, !gpio_amp_mute_pol);
413 write_audio_gpio(gpio_headphone_mute, gpio_headphone_mute_pol);
414 tas_output_device_change(sound_device_id,TAS_OUTPUT_INTERNAL_SPKR,0);
415 }
416 spin_unlock_irqrestore(&dmasound.lock, flags);
417 return IRQ_HANDLED;
418 }
419
420
421 /* Initialize tumbler */
422
423 static int
424 tas_dmasound_init(void)
425 {
426 setup_audio_gpio(
427 "audio-hw-reset",
428 NULL,
429 &gpio_audio_reset,
430 &gpio_audio_reset_pol);
431 setup_audio_gpio(
432 "amp-mute",
433 NULL,
434 &gpio_amp_mute,
435 &gpio_amp_mute_pol);
436 setup_audio_gpio("headphone-mute",
437 NULL,
438 &gpio_headphone_mute,
439 &gpio_headphone_mute_pol);
440 gpio_headphone_irq = setup_audio_gpio(
441 "headphone-detect",
442 NULL,
443 &gpio_headphone_detect,
444 &gpio_headphone_detect_pol);
445 /* Fix some broken OF entries in desktop machines */
446 if (!gpio_headphone_irq)
447 gpio_headphone_irq = setup_audio_gpio(
448 NULL,
449 "keywest-gpio15",
450 &gpio_headphone_detect,
451 &gpio_headphone_detect_pol);
452
453 write_audio_gpio(gpio_audio_reset, gpio_audio_reset_pol);
454 msleep(100);
455 write_audio_gpio(gpio_audio_reset, !gpio_audio_reset_pol);
456 msleep(100);
457 if (gpio_headphone_irq) {
458 if (request_irq(gpio_headphone_irq,headphone_intr,0,"Headphone detect",NULL) < 0) {
459 printk(KERN_ERR "tumbler: Can't request headphone interrupt\n");
460 gpio_headphone_irq = 0;
461 } else {
462 u8 val;
463 /* Activate headphone status interrupts */
464 val = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio_headphone_detect, 0);
465 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, gpio_headphone_detect, val | 0x80);
466 /* Trigger it */
467 headphone_intr(0,NULL,NULL);
468 }
469 }
470 if (!gpio_headphone_irq) {
471 /* Some machine enter this case ? */
472 printk(KERN_WARNING "tumbler: Headphone detect IRQ not found, enabling all outputs !\n");
473 write_audio_gpio(gpio_amp_mute, !gpio_amp_mute_pol);
474 write_audio_gpio(gpio_headphone_mute, !gpio_headphone_mute_pol);
475 }
476 return 0;
477 }
478
479
480 static int
481 tas_dmasound_cleanup(void)
482 {
483 if (gpio_headphone_irq)
484 free_irq(gpio_headphone_irq, NULL);
485 return 0;
486 }
487
488 /* We don't support 48k yet */
489 static int tas_freqs[1] = { 44100 } ;
490 static int tas_freqs_ok[1] = { 1 } ;
491
492 /* don't know what to do really - just have to leave it where
493 * OF left things
494 */
495
496 static int
497 tas_set_frame_rate(void)
498 {
499 if (i2s) {
500 out_le32(i2s + (I2S_REG_SERIAL_FORMAT >> 2), 0x41190000);
501 out_le32(i2s + (I2S_REG_DATAWORD_SIZES >> 2), 0x02000200);
502 }
503 dmasound.hard.speed = 44100 ;
504 awacs_rate_index = 0 ;
505 return 44100 ;
506 }
507
508 static int
509 tas_mixer_ioctl(u_int cmd, u_long arg)
510 {
511 int __user *argp = (int __user *)arg;
512 int data;
513 int rc;
514
515 rc=tas_device_ioctl(cmd, arg);
516 if (rc != -EINVAL) {
517 return rc;
518 }
519
520 if ((cmd & ~0xff) == MIXER_WRITE(0) &&
521 tas_supported_mixers() & (1<<(cmd & 0xff))) {
522 rc = get_user(data, argp);
523 if (rc<0) return rc;
524 tas_set_mixer_level(cmd & 0xff, data);
525 tas_get_mixer_level(cmd & 0xff, &data);
526 return ioctl_return2(argp, data);
527 }
528 if ((cmd & ~0xff) == MIXER_READ(0) &&
529 tas_supported_mixers() & (1<<(cmd & 0xff))) {
530 tas_get_mixer_level(cmd & 0xff, &data);
531 return ioctl_return2(argp, data);
532 }
533
534 switch(cmd) {
535 case SOUND_MIXER_READ_DEVMASK:
536 data = tas_supported_mixers() | SOUND_MASK_SPEAKER;
537 rc = IOCTL_OUT(arg, data);
538 break;
539 case SOUND_MIXER_READ_STEREODEVS:
540 data = tas_stereo_mixers();
541 rc = IOCTL_OUT(arg, data);
542 break;
543 case SOUND_MIXER_READ_CAPS:
544 rc = IOCTL_OUT(arg, 0);
545 break;
546 case SOUND_MIXER_READ_RECMASK:
547 // XXX FIXME: find a way to check what is really available */
548 data = SOUND_MASK_LINE | SOUND_MASK_MIC;
549 rc = IOCTL_OUT(arg, data);
550 break;
551 case SOUND_MIXER_READ_RECSRC:
552 if (awacs_reg[0] & MASK_MUX_AUDIN)
553 data |= SOUND_MASK_LINE;
554 if (awacs_reg[0] & MASK_MUX_MIC)
555 data |= SOUND_MASK_MIC;
556 rc = IOCTL_OUT(arg, data);
557 break;
558 case SOUND_MIXER_WRITE_RECSRC:
559 IOCTL_IN(arg, data);
560 data =0;
561 rc = IOCTL_OUT(arg, data);
562 break;
563 case SOUND_MIXER_WRITE_SPEAKER: /* really bell volume */
564 IOCTL_IN(arg, data);
565 beep_vol = data & 0xff;
566 /* fall through */
567 case SOUND_MIXER_READ_SPEAKER:
568 rc = IOCTL_OUT(arg, (beep_vol<<8) | beep_vol);
569 break;
570 case SOUND_MIXER_OUTMASK:
571 case SOUND_MIXER_OUTSRC:
572 default:
573 rc = -EINVAL;
574 }
575
576 return rc;
577 }
578
579 static void __init
580 tas_init_frame_rates(unsigned int *prop, unsigned int l)
581 {
582 int i ;
583 if (prop) {
584 for (i=0; i<1; i++)
585 tas_freqs_ok[i] = 0;
586 for (l /= sizeof(int); l > 0; --l) {
587 unsigned int r = *prop++;
588 /* Apple 'Fixed' format */
589 if (r >= 0x10000)
590 r >>= 16;
591 for (i = 0; i < 1; ++i) {
592 if (r == tas_freqs[i]) {
593 tas_freqs_ok[i] = 1;
594 break;
595 }
596 }
597 }
598 }
599 /* else we assume that all the rates are available */
600 }
601
602
603 /*** AE - TUMBLER / SNAPPER END ************************************************/
604
605
606
607 /*** Low level stuff *********************************************************/
608
609 /*
610 * PCI PowerMac, with AWACS, Screamer, Burgundy, DACA or Tumbler and DBDMA.
611 */
612 static void *PMacAlloc(unsigned int size, gfp_t flags)
613 {
614 return kmalloc(size, flags);
615 }
616
617 static void PMacFree(void *ptr, unsigned int size)
618 {
619 kfree(ptr);
620 }
621
622 static int __init PMacIrqInit(void)
623 {
624 if (awacs)
625 if (request_irq(awacs_irq, pmac_awacs_intr, 0, "Built-in Sound misc", NULL))
626 return 0;
627 if (request_irq(awacs_tx_irq, pmac_awacs_tx_intr, 0, "Built-in Sound out", NULL)
628 || request_irq(awacs_rx_irq, pmac_awacs_rx_intr, 0, "Built-in Sound in", NULL))
629 return 0;
630 return 1;
631 }
632
633 #ifdef MODULE
634 static void PMacIrqCleanup(void)
635 {
636 /* turn off input & output dma */
637 DBDMA_DO_STOP(awacs_txdma);
638 DBDMA_DO_STOP(awacs_rxdma);
639
640 if (awacs)
641 /* disable interrupts from awacs interface */
642 out_le32(&awacs->control, in_le32(&awacs->control) & 0xfff);
643
644 /* Switch off the sound clock */
645 pmac_call_feature(PMAC_FTR_SOUND_CHIP_ENABLE, awacs_node, 0, 0);
646 /* Make sure proper bits are set on pismo & tipb */
647 if ((machine_is_compatible("PowerBook3,1") ||
648 machine_is_compatible("PowerBook3,2")) && awacs) {
649 awacs_reg[1] |= MASK_PAROUT0 | MASK_PAROUT1;
650 awacs_write(MASK_ADDR1 | awacs_reg[1]);
651 msleep(200);
652 }
653 if (awacs)
654 free_irq(awacs_irq, NULL);
655 free_irq(awacs_tx_irq, NULL);
656 free_irq(awacs_rx_irq, NULL);
657
658 if (awacs)
659 iounmap(awacs);
660 if (i2s)
661 iounmap(i2s);
662 iounmap(awacs_txdma);
663 iounmap(awacs_rxdma);
664
665 release_mem_region(awacs_rsrc[0].start,
666 awacs_rsrc[0].end - awacs_rsrc[0].start + 1);
667 release_mem_region(awacs_rsrc[1].start,
668 awacs_rsrc[1].end - awacs_rsrc[1].start + 1);
669 release_mem_region(awacs_rsrc[2].start,
670 awacs_rsrc[2].end - awacs_rsrc[2].start + 1);
671
672 kfree(awacs_tx_cmd_space);
673 kfree(awacs_rx_cmd_space);
674 kfree(beep_dbdma_cmd_space);
675 kfree(beep_buf);
676 #ifdef CONFIG_PM
677 pmu_unregister_sleep_notifier(&awacs_sleep_notifier);
678 #endif
679 }
680 #endif /* MODULE */
681
682 static void PMacSilence(void)
683 {
684 /* turn off output dma */
685 DBDMA_DO_STOP(awacs_txdma);
686 }
687
688 /* don't know what to do really - just have to leave it where
689 * OF left things
690 */
691
692 static int daca_set_frame_rate(void)
693 {
694 if (i2s) {
695 out_le32(i2s + (I2S_REG_SERIAL_FORMAT >> 2), 0x41190000);
696 out_le32(i2s + (I2S_REG_DATAWORD_SIZES >> 2), 0x02000200);
697 }
698 dmasound.hard.speed = 44100 ;
699 awacs_rate_index = 0 ;
700 return 44100 ;
701 }
702
703 static int awacs_freqs[8] = {
704 44100, 29400, 22050, 17640, 14700, 11025, 8820, 7350
705 };
706 static int awacs_freqs_ok[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
707
708 static int
709 awacs_set_frame_rate(int desired, int catch_r)
710 {
711 int tolerance, i = 8 ;
712 /*
713 * If we have a sample rate which is within catchRadius percent
714 * of the requested value, we don't have to expand the samples.
715 * Otherwise choose the next higher rate.
716 * N.B.: burgundy awacs only works at 44100 Hz.
717 */
718 do {
719 tolerance = catch_r * awacs_freqs[--i] / 100;
720 if (awacs_freqs_ok[i]
721 && dmasound.soft.speed <= awacs_freqs[i] + tolerance)
722 break;
723 } while (i > 0);
724 dmasound.hard.speed = awacs_freqs[i];
725 awacs_rate_index = i;
726
727 out_le32(&awacs->control, MASK_IEPC | (i << 8) | 0x11 );
728 awacs_reg[1] = (awacs_reg[1] & ~MASK_SAMPLERATE) | (i << 3);
729 awacs_write(awacs_reg[1] | MASK_ADDR1);
730 return dmasound.hard.speed;
731 }
732
733 static int
734 burgundy_set_frame_rate(void)
735 {
736 awacs_rate_index = 0 ;
737 awacs_reg[1] = (awacs_reg[1] & ~MASK_SAMPLERATE) ;
738 /* XXX disable error interrupt on burgundy for now */
739 out_le32(&awacs->control, MASK_IEPC | 0 | 0x11 | MASK_IEE);
740 return 44100 ;
741 }
742
743 static int
744 set_frame_rate(int desired, int catch_r)
745 {
746 switch (awacs_revision) {
747 case AWACS_BURGUNDY:
748 dmasound.hard.speed = burgundy_set_frame_rate();
749 break ;
750 case AWACS_TUMBLER:
751 case AWACS_SNAPPER:
752 dmasound.hard.speed = tas_set_frame_rate();
753 break ;
754 case AWACS_DACA:
755 dmasound.hard.speed =
756 daca_set_frame_rate();
757 break ;
758 default:
759 dmasound.hard.speed = awacs_set_frame_rate(desired,
760 catch_r);
761 break ;
762 }
763 return dmasound.hard.speed ;
764 }
765
766 static void
767 awacs_recalibrate(void)
768 {
769 /* Sorry for the horrible delays... I hope to get that improved
770 * by making the whole PM process asynchronous in a future version
771 */
772 msleep(750);
773 awacs_reg[1] |= MASK_CMUTE | MASK_AMUTE;
774 awacs_write(awacs_reg[1] | MASK_RECALIBRATE | MASK_ADDR1);
775 msleep(1000);
776 awacs_write(awacs_reg[1] | MASK_ADDR1);
777 }
778
779 static void PMacInit(void)
780 {
781 int tolerance;
782
783 switch (dmasound.soft.format) {
784 case AFMT_S16_LE:
785 case AFMT_U16_LE:
786 if (hw_can_byteswap)
787 dmasound.hard.format = AFMT_S16_LE;
788 else
789 dmasound.hard.format = AFMT_S16_BE;
790 break;
791 default:
792 dmasound.hard.format = AFMT_S16_BE;
793 break;
794 }
795 dmasound.hard.stereo = 1;
796 dmasound.hard.size = 16;
797
798 /* set dmasound.hard.speed - on the basis of what we want (soft)
799 * and the tolerance we'll allow.
800 */
801 set_frame_rate(dmasound.soft.speed, catchRadius) ;
802
803 tolerance = (catchRadius * dmasound.hard.speed) / 100;
804 if (dmasound.soft.speed >= dmasound.hard.speed - tolerance) {
805 dmasound.trans_write = &transAwacsNormal;
806 dmasound.trans_read = &transAwacsNormalRead;
807 } else {
808 dmasound.trans_write = &transAwacsExpand;
809 dmasound.trans_read = &transAwacsExpandRead;
810 }
811
812 if (awacs) {
813 if (hw_can_byteswap && (dmasound.hard.format == AFMT_S16_LE))
814 out_le32(&awacs->byteswap, BS_VAL);
815 else
816 out_le32(&awacs->byteswap, 0);
817 }
818
819 expand_bal = -dmasound.soft.speed;
820 expand_read_bal = -dmasound.soft.speed;
821 }
822
823 static int PMacSetFormat(int format)
824 {
825 int size;
826 int req_format = format;
827
828 switch (format) {
829 case AFMT_QUERY:
830 return dmasound.soft.format;
831 case AFMT_MU_LAW:
832 case AFMT_A_LAW:
833 case AFMT_U8:
834 case AFMT_S8:
835 size = 8;
836 break;
837 case AFMT_S16_LE:
838 if(!hw_can_byteswap)
839 format = AFMT_S16_BE;
840 case AFMT_S16_BE:
841 size = 16;
842 break;
843 case AFMT_U16_LE:
844 if(!hw_can_byteswap)
845 format = AFMT_U16_BE;
846 case AFMT_U16_BE:
847 size = 16;
848 break;
849 default: /* :-) */
850 printk(KERN_ERR "dmasound: unknown format 0x%x, using AFMT_U8\n",
851 format);
852 size = 8;
853 format = AFMT_U8;
854 }
855
856 if (req_format == format) {
857 dmasound.soft.format = format;
858 dmasound.soft.size = size;
859 if (dmasound.minDev == SND_DEV_DSP) {
860 dmasound.dsp.format = format;
861 dmasound.dsp.size = size;
862 }
863 }
864
865 return format;
866 }
867
868 #define AWACS_VOLUME_TO_MASK(x) (15 - ((((x) - 1) * 15) / 99))
869 #define AWACS_MASK_TO_VOLUME(y) (100 - ((y) * 99 / 15))
870
871 static int awacs_get_volume(int reg, int lshift)
872 {
873 int volume;
874
875 volume = AWACS_MASK_TO_VOLUME((reg >> lshift) & 0xf);
876 volume |= AWACS_MASK_TO_VOLUME(reg & 0xf) << 8;
877 return volume;
878 }
879
880 static int awacs_volume_setter(int volume, int n, int mute, int lshift)
881 {
882 int r1, rn;
883
884 if (mute && volume == 0) {
885 r1 = awacs_reg[1] | mute;
886 } else {
887 r1 = awacs_reg[1] & ~mute;
888 rn = awacs_reg[n] & ~(0xf | (0xf << lshift));
889 rn |= ((AWACS_VOLUME_TO_MASK(volume & 0xff) & 0xf) << lshift);
890 rn |= AWACS_VOLUME_TO_MASK((volume >> 8) & 0xff) & 0xf;
891 awacs_reg[n] = rn;
892 awacs_write((n << 12) | rn);
893 volume = awacs_get_volume(rn, lshift);
894 }
895 if (r1 != awacs_reg[1]) {
896 awacs_reg[1] = r1;
897 awacs_write(r1 | MASK_ADDR1);
898 }
899 return volume;
900 }
901
902 static int PMacSetVolume(int volume)
903 {
904 printk(KERN_WARNING "Bogus call to PMacSetVolume !\n");
905 return 0;
906 }
907
908 static void awacs_setup_for_beep(int speed)
909 {
910 out_le32(&awacs->control,
911 (in_le32(&awacs->control) & ~0x1f00)
912 | ((speed > 0 ? speed : awacs_rate_index) << 8));
913
914 if (hw_can_byteswap && (dmasound.hard.format == AFMT_S16_LE) && speed == -1)
915 out_le32(&awacs->byteswap, BS_VAL);
916 else
917 out_le32(&awacs->byteswap, 0);
918 }
919
920 /* CHECK: how much of this *really* needs IRQs masked? */
921 static void __PMacPlay(void)
922 {
923 volatile struct dbdma_cmd *cp;
924 int next_frg, count;
925
926 count = 300 ; /* > two cycles at the lowest sample rate */
927
928 /* what we want to send next */
929 next_frg = (write_sq.front + write_sq.active) % write_sq.max_count;
930
931 if (awacs_beep_state) {
932 /* sound takes precedence over beeps */
933 /* stop the dma channel */
934 out_le32(&awacs_txdma->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
935 while ( (in_le32(&awacs_txdma->status) & RUN) && count--)
936 udelay(1);
937 if (awacs)
938 awacs_setup_for_beep(-1);
939 out_le32(&awacs_txdma->cmdptr,
940 virt_to_bus(&(awacs_tx_cmds[next_frg])));
941
942 beep_playing = 0;
943 awacs_beep_state = 0;
944 }
945 /* this won't allow more than two frags to be in the output queue at
946 once. (or one, if the max frags is 2 - because count can't exceed
947 2 in that case)
948 */
949 while (write_sq.active < 2 && write_sq.active < write_sq.count) {
950 count = (write_sq.count == write_sq.active + 1) ?
951 write_sq.rear_size:write_sq.block_size ;
952 if (count < write_sq.block_size) {
953 if (!write_sq.syncing) /* last block not yet filled,*/
954 break; /* and we're not syncing or POST-ed */
955 else {
956 /* pretend the block is full to force a new
957 block to be started on the next write */
958 write_sq.rear_size = write_sq.block_size ;
959 write_sq.syncing &= ~2 ; /* clear POST */
960 }
961 }
962 cp = &awacs_tx_cmds[next_frg];
963 st_le16(&cp->req_count, count);
964 st_le16(&cp->xfer_status, 0);
965 st_le16(&cp->command, OUTPUT_MORE + INTR_ALWAYS);
966 /* put a STOP at the end of the queue - but only if we have
967 space for it. This means that, if we under-run and we only
968 have two fragments, we might re-play sound from an existing
969 queued frag. I guess the solution to that is not to set two
970 frags if you are likely to under-run...
971 */
972 if (write_sq.count < write_sq.max_count) {
973 if (++next_frg >= write_sq.max_count)
974 next_frg = 0 ; /* wrap */
975 /* if we get here then we've underrun so we will stop*/
976 st_le16(&awacs_tx_cmds[next_frg].command, DBDMA_STOP);
977 }
978 /* set the dbdma controller going, if it is not already */
979 if (write_sq.active == 0)
980 out_le32(&awacs_txdma->cmdptr, virt_to_bus(cp));
981 (void)in_le32(&awacs_txdma->status);
982 out_le32(&awacs_txdma->control, ((RUN|WAKE) << 16) + (RUN|WAKE));
983 ++write_sq.active;
984 }
985 }
986
987 static void PMacPlay(void)
988 {
989 LOCK();
990 if (!awacs_sleeping) {
991 unsigned long flags;
992
993 spin_lock_irqsave(&dmasound.lock, flags);
994 __PMacPlay();
995 spin_unlock_irqrestore(&dmasound.lock, flags);
996 }
997 UNLOCK();
998 }
999
1000 static void PMacRecord(void)
1001 {
1002 unsigned long flags;
1003
1004 if (read_sq.active)
1005 return;
1006
1007 spin_lock_irqsave(&dmasound.lock, flags);
1008
1009 /* This is all we have to do......Just start it up.
1010 */
1011 out_le32(&awacs_rxdma->control, ((RUN|WAKE) << 16) + (RUN|WAKE));
1012 read_sq.active = 1;
1013
1014 spin_unlock_irqrestore(&dmasound.lock, flags);
1015 }
1016
1017 /* if the TX status comes up "DEAD" - reported on some Power Computing machines
1018 we need to re-start the dbdma - but from a different physical start address
1019 and with a different transfer length. It would get very messy to do this
1020 with the normal dbdma_cmd blocks - we would have to re-write the buffer start
1021 addresses each time. So, we will keep a single dbdma_cmd block which can be
1022 fiddled with.
1023 When DEAD status is first reported the content of the faulted dbdma block is
1024 copied into the emergency buffer and we note that the buffer is in use.
1025 we then bump the start physical address by the amount that was successfully
1026 output before it died.
1027 On any subsequent DEAD result we just do the bump-ups (we know that we are
1028 already using the emergency dbdma_cmd).
1029 CHECK: this just tries to "do it". It is possible that we should abandon
1030 xfers when the number of residual bytes gets below a certain value - I can
1031 see that this might cause a loop-forever if too small a transfer causes
1032 DEAD status. However this is a TODO for now - we'll see what gets reported.
1033 When we get a successful transfer result with the emergency buffer we just
1034 pretend that it completed using the original dmdma_cmd and carry on. The
1035 'next_cmd' field will already point back to the original loop of blocks.
1036 */
1037
1038 static irqreturn_t
1039 pmac_awacs_tx_intr(int irq, void *devid, struct pt_regs *regs)
1040 {
1041 int i = write_sq.front;
1042 int stat;
1043 int i_nowrap = write_sq.front;
1044 volatile struct dbdma_cmd *cp;
1045 /* != 0 when we are dealing with a DEAD xfer */
1046 static int emergency_in_use;
1047
1048 spin_lock(&dmasound.lock);
1049 while (write_sq.active > 0) { /* we expect to have done something*/
1050 if (emergency_in_use) /* we are dealing with DEAD xfer */
1051 cp = emergency_dbdma_cmd ;
1052 else
1053 cp = &awacs_tx_cmds[i];
1054 stat = ld_le16(&cp->xfer_status);
1055 if (stat & DEAD) {
1056 unsigned short req, res ;
1057 unsigned int phy ;
1058 #ifdef DEBUG_DMASOUND
1059 printk("dmasound_pmac: tx-irq: xfer died - patching it up...\n") ;
1060 #endif
1061 /* to clear DEAD status we must first clear RUN
1062 set it to quiescent to be on the safe side */
1063 (void)in_le32(&awacs_txdma->status);
1064 out_le32(&awacs_txdma->control,
1065 (RUN|PAUSE|FLUSH|WAKE) << 16);
1066 write_sq.died++ ;
1067 if (!emergency_in_use) { /* new problem */
1068 memcpy((void *)emergency_dbdma_cmd, (void *)cp,
1069 sizeof(struct dbdma_cmd));
1070 emergency_in_use = 1;
1071 cp = emergency_dbdma_cmd;
1072 }
1073 /* now bump the values to reflect the amount
1074 we haven't yet shifted */
1075 req = ld_le16(&cp->req_count);
1076 res = ld_le16(&cp->res_count);
1077 phy = ld_le32(&cp->phy_addr);
1078 phy += (req - res);
1079 st_le16(&cp->req_count, res);
1080 st_le16(&cp->res_count, 0);
1081 st_le16(&cp->xfer_status, 0);
1082 st_le32(&cp->phy_addr, phy);
1083 st_le32(&cp->cmd_dep, virt_to_bus(&awacs_tx_cmds[(i+1)%write_sq.max_count]));
1084 st_le16(&cp->command, OUTPUT_MORE | BR_ALWAYS | INTR_ALWAYS);
1085
1086 /* point at our patched up command block */
1087 out_le32(&awacs_txdma->cmdptr, virt_to_bus(cp));
1088 /* we must re-start the controller */
1089 (void)in_le32(&awacs_txdma->status);
1090 /* should complete clearing the DEAD status */
1091 out_le32(&awacs_txdma->control,
1092 ((RUN|WAKE) << 16) + (RUN|WAKE));
1093 break; /* this block is still going */
1094 }
1095 if ((stat & ACTIVE) == 0)
1096 break; /* this frame is still going */
1097 if (emergency_in_use)
1098 emergency_in_use = 0 ; /* done that */
1099 --write_sq.count;
1100 --write_sq.active;
1101 i_nowrap++;
1102 if (++i >= write_sq.max_count)
1103 i = 0;
1104 }
1105
1106 /* if we stopped and we were not sync-ing - then we under-ran */
1107 if( write_sq.syncing == 0 ){
1108 stat = in_le32(&awacs_txdma->status) ;
1109 /* we hit the dbdma_stop */
1110 if( (stat & ACTIVE) == 0 ) write_sq.xruns++ ;
1111 }
1112
1113 /* if we used some data up then wake the writer to supply some more*/
1114 if (i_nowrap != write_sq.front)
1115 WAKE_UP(write_sq.action_queue);
1116 write_sq.front = i;
1117
1118 /* but make sure we funnel what we've already got */\
1119 if (!awacs_sleeping)
1120 __PMacPlay();
1121
1122 /* make the wake-on-empty conditional on syncing */
1123 if (!write_sq.active && (write_sq.syncing & 1))
1124 WAKE_UP(write_sq.sync_queue); /* any time we're empty */
1125 spin_unlock(&dmasound.lock);
1126 return IRQ_HANDLED;
1127 }
1128
1129
1130 static irqreturn_t
1131 pmac_awacs_rx_intr(int irq, void *devid, struct pt_regs *regs)
1132 {
1133 int stat ;
1134 /* For some reason on my PowerBook G3, I get one interrupt
1135 * when the interrupt vector is installed (like something is
1136 * pending). This happens before the dbdma is initialized by
1137 * us, so I just check the command pointer and if it is zero,
1138 * just blow it off.
1139 */
1140 if (in_le32(&awacs_rxdma->cmdptr) == 0)
1141 return IRQ_HANDLED;
1142
1143 /* We also want to blow 'em off when shutting down.
1144 */
1145 if (read_sq.active == 0)
1146 return IRQ_HANDLED;
1147
1148 spin_lock(&dmasound.lock);
1149 /* Check multiple buffers in case we were held off from
1150 * interrupt processing for a long time. Geeze, I really hope
1151 * this doesn't happen.
1152 */
1153 while ((stat=awacs_rx_cmds[read_sq.rear].xfer_status)) {
1154
1155 /* if we got a "DEAD" status then just log it for now.
1156 and try to restart dma.
1157 TODO: figure out how best to fix it up
1158 */
1159 if (stat & DEAD){
1160 #ifdef DEBUG_DMASOUND
1161 printk("dmasound_pmac: rx-irq: DIED - attempting resurection\n");
1162 #endif
1163 /* to clear DEAD status we must first clear RUN
1164 set it to quiescent to be on the safe side */
1165 (void)in_le32(&awacs_txdma->status);
1166 out_le32(&awacs_txdma->control,
1167 (RUN|PAUSE|FLUSH|WAKE) << 16);
1168 awacs_rx_cmds[read_sq.rear].xfer_status = 0;
1169 awacs_rx_cmds[read_sq.rear].res_count = 0;
1170 read_sq.died++ ;
1171 (void)in_le32(&awacs_txdma->status);
1172 /* re-start the same block */
1173 out_le32(&awacs_rxdma->cmdptr,
1174 virt_to_bus(&awacs_rx_cmds[read_sq.rear]));
1175 /* we must re-start the controller */
1176 (void)in_le32(&awacs_rxdma->status);
1177 /* should complete clearing the DEAD status */
1178 out_le32(&awacs_rxdma->control,
1179 ((RUN|WAKE) << 16) + (RUN|WAKE));
1180 spin_unlock(&dmasound.lock);
1181 return IRQ_HANDLED; /* try this block again */
1182 }
1183 /* Clear status and move on to next buffer.
1184 */
1185 awacs_rx_cmds[read_sq.rear].xfer_status = 0;
1186 read_sq.rear++;
1187
1188 /* Wrap the buffer ring.
1189 */
1190 if (read_sq.rear >= read_sq.max_active)
1191 read_sq.rear = 0;
1192
1193 /* If we have caught up to the front buffer, bump it.
1194 * This will cause weird (but not fatal) results if the
1195 * read loop is currently using this buffer. The user is
1196 * behind in this case anyway, so weird things are going
1197 * to happen.
1198 */
1199 if (read_sq.rear == read_sq.front) {
1200 read_sq.front++;
1201 read_sq.xruns++ ; /* we overan */
1202 if (read_sq.front >= read_sq.max_active)
1203 read_sq.front = 0;
1204 }
1205 }
1206
1207 WAKE_UP(read_sq.action_queue);
1208 spin_unlock(&dmasound.lock);
1209 return IRQ_HANDLED;
1210 }
1211
1212
1213 static irqreturn_t
1214 pmac_awacs_intr(int irq, void *devid, struct pt_regs *regs)
1215 {
1216 int ctrl;
1217 int status;
1218 int r1;
1219
1220 spin_lock(&dmasound.lock);
1221 ctrl = in_le32(&awacs->control);
1222 status = in_le32(&awacs->codec_stat);
1223
1224 if (ctrl & MASK_PORTCHG) {
1225 /* tested on Screamer, should work on others too */
1226 if (awacs_revision == AWACS_SCREAMER) {
1227 if (((status & MASK_HDPCONN) >> 3) && (hdp_connected == 0)) {
1228 hdp_connected = 1;
1229
1230 r1 = awacs_reg[1] | MASK_SPKMUTE;
1231 awacs_reg[1] = r1;
1232 awacs_write(r1 | MASK_ADDR_MUTE);
1233 } else if (((status & MASK_HDPCONN) >> 3 == 0) && (hdp_connected == 1)) {
1234 hdp_connected = 0;
1235
1236 r1 = awacs_reg[1] & ~MASK_SPKMUTE;
1237 awacs_reg[1] = r1;
1238 awacs_write(r1 | MASK_ADDR_MUTE);
1239 }
1240 }
1241 }
1242 if (ctrl & MASK_CNTLERR) {
1243 int err = (in_le32(&awacs->codec_stat) & MASK_ERRCODE) >> 16;
1244 /* CHECK: we just swallow burgundy errors at the moment..*/
1245 if (err != 0 && awacs_revision != AWACS_BURGUNDY)
1246 printk(KERN_ERR "dmasound_pmac: error %x\n", err);
1247 }
1248 /* Writing 1s to the CNTLERR and PORTCHG bits clears them... */
1249 out_le32(&awacs->control, ctrl);
1250 spin_unlock(&dmasound.lock);
1251 return IRQ_HANDLED;
1252 }
1253
1254 static void
1255 awacs_write(int val)
1256 {
1257 int count = 300 ;
1258 if (awacs_revision >= AWACS_DACA || !awacs)
1259 return ;
1260
1261 while ((in_le32(&awacs->codec_ctrl) & MASK_NEWECMD) && count--)
1262 udelay(1) ; /* timeout is > 2 samples at lowest rate */
1263 out_le32(&awacs->codec_ctrl, val | (awacs_subframe << 22));
1264 (void)in_le32(&awacs->byteswap);
1265 }
1266
1267 /* this is called when the beep timer expires... it will be called even
1268 if the beep has been overidden by other sound output.
1269 */
1270 static void awacs_nosound(unsigned long xx)
1271 {
1272 unsigned long flags;
1273 int count = 600 ; /* > four samples at lowest rate */
1274
1275 spin_lock_irqsave(&dmasound.lock, flags);
1276 if (beep_playing) {
1277 st_le16(&beep_dbdma_cmd->command, DBDMA_STOP);
1278 out_le32(&awacs_txdma->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
1279 while ((in_le32(&awacs_txdma->status) & RUN) && count--)
1280 udelay(1);
1281 if (awacs)
1282 awacs_setup_for_beep(-1);
1283 beep_playing = 0;
1284 }
1285 spin_unlock_irqrestore(&dmasound.lock, flags);
1286 }
1287
1288 /*
1289 * We generate the beep with a single dbdma command that loops a buffer
1290 * forever - without generating interrupts.
1291 *
1292 * So, to stop it you have to stop dma output as per awacs_nosound.
1293 */
1294 static int awacs_beep_event(struct input_dev *dev, unsigned int type,
1295 unsigned int code, int hz)
1296 {
1297 unsigned long flags;
1298 int beep_speed = 0;
1299 int srate;
1300 int period, ncycles, nsamples;
1301 int i, j, f;
1302 short *p;
1303 static int beep_hz_cache;
1304 static int beep_nsamples_cache;
1305 static int beep_volume_cache;
1306
1307 if (type != EV_SND)
1308 return -1;
1309 switch (code) {
1310 case SND_BELL:
1311 if (hz)
1312 hz = 1000;
1313 break;
1314 case SND_TONE:
1315 break;
1316 default:
1317 return -1;
1318 }
1319
1320 if (beep_buf == NULL)
1321 return -1;
1322
1323 /* quick-hack fix for DACA, Burgundy & Tumbler */
1324
1325 if (awacs_revision >= AWACS_DACA){
1326 srate = 44100 ;
1327 } else {
1328 for (i = 0; i < 8 && awacs_freqs[i] >= BEEP_SRATE; ++i)
1329 if (awacs_freqs_ok[i])
1330 beep_speed = i;
1331 srate = awacs_freqs[beep_speed];
1332 }
1333
1334 if (hz <= srate / BEEP_BUFLEN || hz > srate / 2) {
1335 /* cancel beep currently playing */
1336 awacs_nosound(0);
1337 return 0;
1338 }
1339
1340 spin_lock_irqsave(&dmasound.lock, flags);
1341 if (beep_playing || write_sq.active || beep_buf == NULL) {
1342 spin_unlock_irqrestore(&dmasound.lock, flags);
1343 return -1; /* too hard, sorry :-( */
1344 }
1345 beep_playing = 1;
1346 st_le16(&beep_dbdma_cmd->command, OUTPUT_MORE + BR_ALWAYS);
1347 spin_unlock_irqrestore(&dmasound.lock, flags);
1348
1349 if (hz == beep_hz_cache && beep_vol == beep_volume_cache) {
1350 nsamples = beep_nsamples_cache;
1351 } else {
1352 period = srate * 256 / hz; /* fixed point */
1353 ncycles = BEEP_BUFLEN * 256 / period;
1354 nsamples = (period * ncycles) >> 8;
1355 f = ncycles * 65536 / nsamples;
1356 j = 0;
1357 p = beep_buf;
1358 for (i = 0; i < nsamples; ++i, p += 2) {
1359 p[0] = p[1] = beep_wform[j >> 8] * beep_vol;
1360 j = (j + f) & 0xffff;
1361 }
1362 beep_hz_cache = hz;
1363 beep_volume_cache = beep_vol;
1364 beep_nsamples_cache = nsamples;
1365 }
1366
1367 st_le16(&beep_dbdma_cmd->req_count, nsamples*4);
1368 st_le16(&beep_dbdma_cmd->xfer_status, 0);
1369 st_le32(&beep_dbdma_cmd->cmd_dep, virt_to_bus(beep_dbdma_cmd));
1370 st_le32(&beep_dbdma_cmd->phy_addr, virt_to_bus(beep_buf));
1371 awacs_beep_state = 1;
1372
1373 spin_lock_irqsave(&dmasound.lock, flags);
1374 if (beep_playing) { /* i.e. haven't been terminated already */
1375 int count = 300 ;
1376 out_le32(&awacs_txdma->control, (RUN|WAKE|FLUSH|PAUSE) << 16);
1377 while ((in_le32(&awacs_txdma->status) & RUN) && count--)
1378 udelay(1); /* timeout > 2 samples at lowest rate*/
1379 if (awacs)
1380 awacs_setup_for_beep(beep_speed);
1381 out_le32(&awacs_txdma->cmdptr, virt_to_bus(beep_dbdma_cmd));
1382 (void)in_le32(&awacs_txdma->status);
1383 out_le32(&awacs_txdma->control, RUN | (RUN << 16));
1384 }
1385 spin_unlock_irqrestore(&dmasound.lock, flags);
1386
1387 return 0;
1388 }
1389
1390 /* used in init and for wake-up */
1391
1392 static void
1393 load_awacs(void)
1394 {
1395 awacs_write(awacs_reg[0] + MASK_ADDR0);
1396 awacs_write(awacs_reg[1] + MASK_ADDR1);
1397 awacs_write(awacs_reg[2] + MASK_ADDR2);
1398 awacs_write(awacs_reg[4] + MASK_ADDR4);
1399
1400 if (awacs_revision == AWACS_SCREAMER) {
1401 awacs_write(awacs_reg[5] + MASK_ADDR5);
1402 msleep(100);
1403 awacs_write(awacs_reg[6] + MASK_ADDR6);
1404 msleep(2);
1405 awacs_write(awacs_reg[1] + MASK_ADDR1);
1406 awacs_write(awacs_reg[7] + MASK_ADDR7);
1407 }
1408 if (awacs) {
1409 if (hw_can_byteswap && (dmasound.hard.format == AFMT_S16_LE))
1410 out_le32(&awacs->byteswap, BS_VAL);
1411 else
1412 out_le32(&awacs->byteswap, 0);
1413 }
1414 }
1415
1416 #ifdef CONFIG_PM
1417 /*
1418 * Save state when going to sleep, restore it afterwards.
1419 */
1420 /* FIXME: sort out disabling/re-enabling of read stuff as well */
1421 static int awacs_sleep_notify(struct pmu_sleep_notifier *self, int when)
1422 {
1423 unsigned long flags;
1424
1425 switch (when) {
1426 case PBOOK_SLEEP_NOW:
1427 LOCK();
1428 awacs_sleeping = 1;
1429 /* Tell the rest of the driver we are now going to sleep */
1430 mb();
1431 if (awacs_revision == AWACS_SCREAMER ||
1432 awacs_revision == AWACS_AWACS) {
1433 awacs_reg1_save = awacs_reg[1];
1434 awacs_reg[1] |= MASK_AMUTE | MASK_CMUTE;
1435 awacs_write(MASK_ADDR1 | awacs_reg[1]);
1436 }
1437
1438 PMacSilence();
1439 /* stop rx - if going - a bit of a daft user... but */
1440 out_le32(&awacs_rxdma->control, (RUN|WAKE|FLUSH << 16));
1441 /* deny interrupts */
1442 if (awacs)
1443 disable_irq(awacs_irq);
1444 disable_irq(awacs_tx_irq);
1445 disable_irq(awacs_rx_irq);
1446 /* Chip specific sleep code */
1447 switch (awacs_revision) {
1448 case AWACS_TUMBLER:
1449 case AWACS_SNAPPER:
1450 write_audio_gpio(gpio_headphone_mute, gpio_headphone_mute_pol);
1451 write_audio_gpio(gpio_amp_mute, gpio_amp_mute_pol);
1452 tas_enter_sleep();
1453 write_audio_gpio(gpio_audio_reset, gpio_audio_reset_pol);
1454 break ;
1455 case AWACS_DACA:
1456 daca_enter_sleep();
1457 break ;
1458 case AWACS_BURGUNDY:
1459 break ;
1460 case AWACS_SCREAMER:
1461 case AWACS_AWACS:
1462 default:
1463 out_le32(&awacs->control, 0x11) ;
1464 break ;
1465 }
1466 /* Disable sound clock */
1467 pmac_call_feature(PMAC_FTR_SOUND_CHIP_ENABLE, awacs_node, 0, 0);
1468 /* According to Darwin, we do that after turning off the sound
1469 * chip clock. All this will have to be cleaned up once we properly
1470 * parse the OF sound-objects
1471 */
1472 if ((machine_is_compatible("PowerBook3,1") ||
1473 machine_is_compatible("PowerBook3,2")) && awacs) {
1474 awacs_reg[1] |= MASK_PAROUT0 | MASK_PAROUT1;
1475 awacs_write(MASK_ADDR1 | awacs_reg[1]);
1476 msleep(200);
1477 }
1478 break;
1479 case PBOOK_WAKE:
1480 /* Enable sound clock */
1481 pmac_call_feature(PMAC_FTR_SOUND_CHIP_ENABLE, awacs_node, 0, 1);
1482 if ((machine_is_compatible("PowerBook3,1") ||
1483 machine_is_compatible("PowerBook3,2")) && awacs) {
1484 msleep(100);
1485 awacs_reg[1] &= ~(MASK_PAROUT0 | MASK_PAROUT1);
1486 awacs_write(MASK_ADDR1 | awacs_reg[1]);
1487 msleep(300);
1488 } else
1489 msleep(1000);
1490 /* restore settings */
1491 switch (awacs_revision) {
1492 case AWACS_TUMBLER:
1493 case AWACS_SNAPPER:
1494 write_audio_gpio(gpio_headphone_mute, gpio_headphone_mute_pol);
1495 write_audio_gpio(gpio_amp_mute, gpio_amp_mute_pol);
1496 write_audio_gpio(gpio_audio_reset, gpio_audio_reset_pol);
1497 msleep(100);
1498 write_audio_gpio(gpio_audio_reset, !gpio_audio_reset_pol);
1499 msleep(150);
1500 tas_leave_sleep(); /* Stub for now */
1501 headphone_intr(0,NULL,NULL);
1502 break;
1503 case AWACS_DACA:
1504 msleep(10); /* Check this !!! */
1505 daca_leave_sleep();
1506 break ; /* dont know how yet */
1507 case AWACS_BURGUNDY:
1508 break ;
1509 case AWACS_SCREAMER:
1510 case AWACS_AWACS:
1511 default:
1512 load_awacs() ;
1513 break ;
1514 }
1515 /* Recalibrate chip */
1516 if (awacs_revision == AWACS_SCREAMER && awacs)
1517 awacs_recalibrate();
1518 /* Make sure dma is stopped */
1519 PMacSilence();
1520 if (awacs)
1521 enable_irq(awacs_irq);
1522 enable_irq(awacs_tx_irq);
1523 enable_irq(awacs_rx_irq);
1524 if (awacs) {
1525 /* OK, allow ints back again */
1526 out_le32(&awacs->control, MASK_IEPC
1527 | (awacs_rate_index << 8) | 0x11
1528 | (awacs_revision < AWACS_DACA ? MASK_IEE: 0));
1529 }
1530 if (macio_base && is_pbook_g3) {
1531 /* FIXME: should restore the setup we had...*/
1532 out_8(macio_base + 0x37, 3);
1533 } else if (is_pbook_3X00) {
1534 in_8(latch_base + 0x190);
1535 }
1536 /* Remove mute */
1537 if (awacs_revision == AWACS_SCREAMER ||
1538 awacs_revision == AWACS_AWACS) {
1539 awacs_reg[1] = awacs_reg1_save;
1540 awacs_write(MASK_ADDR1 | awacs_reg[1]);
1541 }
1542 awacs_sleeping = 0;
1543 /* Resume pending sounds. */
1544 /* we don't try to restart input... */
1545 spin_lock_irqsave(&dmasound.lock, flags);
1546 __PMacPlay();
1547 spin_unlock_irqrestore(&dmasound.lock, flags);
1548 UNLOCK();
1549 }
1550 return PBOOK_SLEEP_OK;
1551 }
1552 #endif /* CONFIG_PM */
1553
1554
1555 /* All the burgundy functions: */
1556
1557 /* Waits for busy flag to clear */
1558 static inline void
1559 awacs_burgundy_busy_wait(void)
1560 {
1561 int count = 50; /* > 2 samples at 44k1 */
1562 while ((in_le32(&awacs->codec_ctrl) & MASK_NEWECMD) && count--)
1563 udelay(1) ;
1564 }
1565
1566 static inline void
1567 awacs_burgundy_extend_wait(void)
1568 {
1569 int count = 50 ; /* > 2 samples at 44k1 */
1570 while ((!(in_le32(&awacs->codec_stat) & MASK_EXTEND)) && count--)
1571 udelay(1) ;
1572 count = 50;
1573 while ((in_le32(&awacs->codec_stat) & MASK_EXTEND) && count--)
1574 udelay(1);
1575 }
1576
1577 static void
1578 awacs_burgundy_wcw(unsigned addr, unsigned val)
1579 {
1580 out_le32(&awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff));
1581 awacs_burgundy_busy_wait();
1582 out_le32(&awacs->codec_ctrl, addr + 0x200d00 +((val>>8) & 0xff));
1583 awacs_burgundy_busy_wait();
1584 out_le32(&awacs->codec_ctrl, addr + 0x200e00 +((val>>16) & 0xff));
1585 awacs_burgundy_busy_wait();
1586 out_le32(&awacs->codec_ctrl, addr + 0x200f00 +((val>>24) & 0xff));
1587 awacs_burgundy_busy_wait();
1588 }
1589
1590 static unsigned
1591 awacs_burgundy_rcw(unsigned addr)
1592 {
1593 unsigned val = 0;
1594 unsigned long flags;
1595
1596 /* should have timeouts here */
1597 spin_lock_irqsave(&dmasound.lock, flags);
1598
1599 out_le32(&awacs->codec_ctrl, addr + 0x100000);
1600 awacs_burgundy_busy_wait();
1601 awacs_burgundy_extend_wait();
1602 val += (in_le32(&awacs->codec_stat) >> 4) & 0xff;
1603
1604 out_le32(&awacs->codec_ctrl, addr + 0x100100);
1605 awacs_burgundy_busy_wait();
1606 awacs_burgundy_extend_wait();
1607 val += ((in_le32(&awacs->codec_stat)>>4) & 0xff) <<8;
1608
1609 out_le32(&awacs->codec_ctrl, addr + 0x100200);
1610 awacs_burgundy_busy_wait();
1611 awacs_burgundy_extend_wait();
1612 val += ((in_le32(&awacs->codec_stat)>>4) & 0xff) <<16;
1613
1614 out_le32(&awacs->codec_ctrl, addr + 0x100300);
1615 awacs_burgundy_busy_wait();
1616 awacs_burgundy_extend_wait();
1617 val += ((in_le32(&awacs->codec_stat)>>4) & 0xff) <<24;
1618
1619 spin_unlock_irqrestore(&dmasound.lock, flags);
1620
1621 return val;
1622 }
1623
1624
1625 static void
1626 awacs_burgundy_wcb(unsigned addr, unsigned val)
1627 {
1628 out_le32(&awacs->codec_ctrl, addr + 0x300000 + (val & 0xff));
1629 awacs_burgundy_busy_wait();
1630 }
1631
1632 static unsigned
1633 awacs_burgundy_rcb(unsigned addr)
1634 {
1635 unsigned val = 0;
1636 unsigned long flags;
1637
1638 /* should have timeouts here */
1639 spin_lock_irqsave(&dmasound.lock, flags);
1640
1641 out_le32(&awacs->codec_ctrl, addr + 0x100000);
1642 awacs_burgundy_busy_wait();
1643 awacs_burgundy_extend_wait();
1644 val += (in_le32(&awacs->codec_stat) >> 4) & 0xff;
1645
1646 spin_unlock_irqrestore(&dmasound.lock, flags);
1647
1648 return val;
1649 }
1650
1651 static int
1652 awacs_burgundy_check(void)
1653 {
1654 /* Checks to see the chip is alive and kicking */
1655 int error = in_le32(&awacs->codec_ctrl) & MASK_ERRCODE;
1656
1657 return error == 0xf0000;
1658 }
1659
1660 static int
1661 awacs_burgundy_init(void)
1662 {
1663 if (awacs_burgundy_check()) {
1664 printk(KERN_WARNING "dmasound_pmac: burgundy not working :-(\n");
1665 return 1;
1666 }
1667
1668 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_OUTPUTENABLES,
1669 DEF_BURGUNDY_OUTPUTENABLES);
1670 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
1671 DEF_BURGUNDY_MORE_OUTPUTENABLES);
1672 awacs_burgundy_wcw(MASK_ADDR_BURGUNDY_OUTPUTSELECTS,
1673 DEF_BURGUNDY_OUTPUTSELECTS);
1674
1675 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_INPSEL21,
1676 DEF_BURGUNDY_INPSEL21);
1677 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_INPSEL3,
1678 DEF_BURGUNDY_INPSEL3);
1679 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_GAINCD,
1680 DEF_BURGUNDY_GAINCD);
1681 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_GAINLINE,
1682 DEF_BURGUNDY_GAINLINE);
1683 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_GAINMIC,
1684 DEF_BURGUNDY_GAINMIC);
1685 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_GAINMODEM,
1686 DEF_BURGUNDY_GAINMODEM);
1687
1688 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_ATTENSPEAKER,
1689 DEF_BURGUNDY_ATTENSPEAKER);
1690 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_ATTENLINEOUT,
1691 DEF_BURGUNDY_ATTENLINEOUT);
1692 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_ATTENHP,
1693 DEF_BURGUNDY_ATTENHP);
1694
1695 awacs_burgundy_wcw(MASK_ADDR_BURGUNDY_MASTER_VOLUME,
1696 DEF_BURGUNDY_MASTER_VOLUME);
1697 awacs_burgundy_wcw(MASK_ADDR_BURGUNDY_VOLCD,
1698 DEF_BURGUNDY_VOLCD);
1699 awacs_burgundy_wcw(MASK_ADDR_BURGUNDY_VOLLINE,
1700 DEF_BURGUNDY_VOLLINE);
1701 awacs_burgundy_wcw(MASK_ADDR_BURGUNDY_VOLMIC,
1702 DEF_BURGUNDY_VOLMIC);
1703 return 0;
1704 }
1705
1706 static void
1707 awacs_burgundy_write_volume(unsigned address, int volume)
1708 {
1709 int hardvolume,lvolume,rvolume;
1710
1711 lvolume = (volume & 0xff) ? (volume & 0xff) + 155 : 0;
1712 rvolume = ((volume >>8)&0xff) ? ((volume >> 8)&0xff ) + 155 : 0;
1713
1714 hardvolume = lvolume + (rvolume << 16);
1715
1716 awacs_burgundy_wcw(address, hardvolume);
1717 }
1718
1719 static int
1720 awacs_burgundy_read_volume(unsigned address)
1721 {
1722 int softvolume,wvolume;
1723
1724 wvolume = awacs_burgundy_rcw(address);
1725
1726 softvolume = (wvolume & 0xff) - 155;
1727 softvolume += (((wvolume >> 16) & 0xff) - 155)<<8;
1728
1729 return softvolume > 0 ? softvolume : 0;
1730 }
1731
1732 static int
1733 awacs_burgundy_read_mvolume(unsigned address)
1734 {
1735 int lvolume,rvolume,wvolume;
1736
1737 wvolume = awacs_burgundy_rcw(address);
1738
1739 wvolume &= 0xffff;
1740
1741 rvolume = (wvolume & 0xff) - 155;
1742 lvolume = ((wvolume & 0xff00)>>8) - 155;
1743
1744 return lvolume + (rvolume << 8);
1745 }
1746
1747 static void
1748 awacs_burgundy_write_mvolume(unsigned address, int volume)
1749 {
1750 int lvolume,rvolume,hardvolume;
1751
1752 lvolume = (volume &0xff) ? (volume & 0xff) + 155 :0;
1753 rvolume = ((volume >>8) & 0xff) ? (volume >> 8) + 155 :0;
1754
1755 hardvolume = lvolume + (rvolume << 8);
1756 hardvolume += (hardvolume << 16);
1757
1758 awacs_burgundy_wcw(address, hardvolume);
1759 }
1760
1761 /* End burgundy functions */
1762
1763 /* Set up output volumes on machines with the 'perch/whisper' extension card.
1764 * this has an SGS i2c chip (7433) which is accessed using the cuda.
1765 *
1766 * TODO: split this out and make use of the other parts of the SGS chip to
1767 * do Bass, Treble etc.
1768 */
1769
1770 static void
1771 awacs_enable_amp(int spkr_vol)
1772 {
1773 #ifdef CONFIG_ADB_CUDA
1774 struct adb_request req;
1775
1776 if (sys_ctrler != SYS_CTRLER_CUDA)
1777 return;
1778
1779 /* turn on headphones */
1780 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC,
1781 0x8a, 4, 0);
1782 while (!req.complete) cuda_poll();
1783 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC,
1784 0x8a, 6, 0);
1785 while (!req.complete) cuda_poll();
1786
1787 /* turn on speaker */
1788 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC,
1789 0x8a, 3, (100 - (spkr_vol & 0xff)) * 32 / 100);
1790 while (!req.complete) cuda_poll();
1791 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC,
1792 0x8a, 5, (100 - ((spkr_vol >> 8) & 0xff)) * 32 / 100);
1793 while (!req.complete) cuda_poll();
1794
1795 cuda_request(&req, NULL, 5, CUDA_PACKET,
1796 CUDA_GET_SET_IIC, 0x8a, 1, 0x29);
1797 while (!req.complete) cuda_poll();
1798 #endif /* CONFIG_ADB_CUDA */
1799 }
1800
1801
1802 /*** Mid level stuff *********************************************************/
1803
1804
1805 /*
1806 * /dev/mixer abstraction
1807 */
1808
1809 static void do_line_lev(int data)
1810 {
1811 line_lev = data ;
1812 awacs_reg[0] &= ~MASK_MUX_AUDIN;
1813 if ((data & 0xff) >= 50)
1814 awacs_reg[0] |= MASK_MUX_AUDIN;
1815 awacs_write(MASK_ADDR0 | awacs_reg[0]);
1816 }
1817
1818 static void do_ip_gain(int data)
1819 {
1820 ip_gain = data ;
1821 data &= 0xff;
1822 awacs_reg[0] &= ~MASK_GAINLINE;
1823 if (awacs_revision == AWACS_SCREAMER) {
1824 awacs_reg[6] &= ~MASK_MIC_BOOST ;
1825 if (data >= 33) {
1826 awacs_reg[0] |= MASK_GAINLINE;
1827 if( data >= 66)
1828 awacs_reg[6] |= MASK_MIC_BOOST ;
1829 }
1830 awacs_write(MASK_ADDR6 | awacs_reg[6]) ;
1831 } else {
1832 if (data >= 50)
1833 awacs_reg[0] |= MASK_GAINLINE;
1834 }
1835 awacs_write(MASK_ADDR0 | awacs_reg[0]);
1836 }
1837
1838 static void do_mic_lev(int data)
1839 {
1840 mic_lev = data ;
1841 data &= 0xff;
1842 awacs_reg[0] &= ~MASK_MUX_MIC;
1843 if (data >= 50)
1844 awacs_reg[0] |= MASK_MUX_MIC;
1845 awacs_write(MASK_ADDR0 | awacs_reg[0]);
1846 }
1847
1848 static void do_cd_lev(int data)
1849 {
1850 cd_lev = data ;
1851 awacs_reg[0] &= ~MASK_MUX_CD;
1852 if ((data & 0xff) >= 50)
1853 awacs_reg[0] |= MASK_MUX_CD;
1854 awacs_write(MASK_ADDR0 | awacs_reg[0]);
1855 }
1856
1857 static void do_rec_lev(int data)
1858 {
1859 int left, right ;
1860 rec_lev = data ;
1861 /* need to fudge this to use the volume setter routine */
1862 left = 100 - (data & 0xff) ; if( left < 0 ) left = 0 ;
1863 right = 100 - ((data >> 8) & 0xff) ; if( right < 0 ) right = 0 ;
1864 left |= (right << 8 );
1865 left = awacs_volume_setter(left, 0, 0, 4);
1866 }
1867
1868 static void do_passthru_vol(int data)
1869 {
1870 passthru_vol = data ;
1871 awacs_reg[1] &= ~MASK_LOOPTHRU;
1872 if (awacs_revision == AWACS_SCREAMER) {
1873 if( data ) { /* switch it on for non-zero */
1874 awacs_reg[1] |= MASK_LOOPTHRU;
1875 awacs_write(MASK_ADDR1 | awacs_reg[1]);
1876 }
1877 data = awacs_volume_setter(data, 5, 0, 6) ;
1878 } else {
1879 if ((data & 0xff) >= 50)
1880 awacs_reg[1] |= MASK_LOOPTHRU;
1881 awacs_write(MASK_ADDR1 | awacs_reg[1]);
1882 data = (awacs_reg[1] & MASK_LOOPTHRU)? 100: 0;
1883 }
1884 }
1885
1886 static int awacs_mixer_ioctl(u_int cmd, u_long arg)
1887 {
1888 int data;
1889 int rc;
1890
1891 switch (cmd) {
1892 case SOUND_MIXER_READ_CAPS:
1893 /* say we will allow multiple inputs? prob. wrong
1894 so I'm switching it to single */
1895 return IOCTL_OUT(arg, 1);
1896 case SOUND_MIXER_READ_DEVMASK:
1897 data = SOUND_MASK_VOLUME | SOUND_MASK_SPEAKER
1898 | SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD
1899 | SOUND_MASK_IGAIN | SOUND_MASK_RECLEV
1900 | SOUND_MASK_ALTPCM
1901 | SOUND_MASK_MONITOR;
1902 rc = IOCTL_OUT(arg, data);
1903 break;
1904 case SOUND_MIXER_READ_RECMASK:
1905 data = SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD;
1906 rc = IOCTL_OUT(arg, data);
1907 break;
1908 case SOUND_MIXER_READ_RECSRC:
1909 data = 0;
1910 if (awacs_reg[0] & MASK_MUX_AUDIN)
1911 data |= SOUND_MASK_LINE;
1912 if (awacs_reg[0] & MASK_MUX_MIC)
1913 data |= SOUND_MASK_MIC;
1914 if (awacs_reg[0] & MASK_MUX_CD)
1915 data |= SOUND_MASK_CD;
1916 rc = IOCTL_OUT(arg, data);
1917 break;
1918 case SOUND_MIXER_WRITE_RECSRC:
1919 IOCTL_IN(arg, data);
1920 data &= (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD);
1921 awacs_reg[0] &= ~(MASK_MUX_CD | MASK_MUX_MIC
1922 | MASK_MUX_AUDIN);
1923 if (data & SOUND_MASK_LINE)
1924 awacs_reg[0] |= MASK_MUX_AUDIN;
1925 if (data & SOUND_MASK_MIC)
1926 awacs_reg[0] |= MASK_MUX_MIC;
1927 if (data & SOUND_MASK_CD)
1928 awacs_reg[0] |= MASK_MUX_CD;
1929 awacs_write(awacs_reg[0] | MASK_ADDR0);
1930 rc = IOCTL_OUT(arg, data);
1931 break;
1932 case SOUND_MIXER_READ_STEREODEVS:
1933 data = SOUND_MASK_VOLUME | SOUND_MASK_SPEAKER| SOUND_MASK_RECLEV ;
1934 if (awacs_revision == AWACS_SCREAMER)
1935 data |= SOUND_MASK_MONITOR ;
1936 rc = IOCTL_OUT(arg, data);
1937 break;
1938 case SOUND_MIXER_WRITE_VOLUME:
1939 IOCTL_IN(arg, data);
1940 line_vol = data ;
1941 awacs_volume_setter(data, 2, 0, 6);
1942 /* fall through */
1943 case SOUND_MIXER_READ_VOLUME:
1944 rc = IOCTL_OUT(arg, line_vol);
1945 break;
1946 case SOUND_MIXER_WRITE_SPEAKER:
1947 IOCTL_IN(arg, data);
1948 spk_vol = data ;
1949 if (has_perch)
1950 awacs_enable_amp(data);
1951 else
1952 (void)awacs_volume_setter(data, 4, MASK_CMUTE, 6);
1953 /* fall though */
1954 case SOUND_MIXER_READ_SPEAKER:
1955 rc = IOCTL_OUT(arg, spk_vol);
1956 break;
1957 case SOUND_MIXER_WRITE_ALTPCM: /* really bell volume */
1958 IOCTL_IN(arg, data);
1959 beep_vol = data & 0xff;
1960 /* fall through */
1961 case SOUND_MIXER_READ_ALTPCM:
1962 rc = IOCTL_OUT(arg, beep_vol);
1963 break;
1964 case SOUND_MIXER_WRITE_LINE:
1965 IOCTL_IN(arg, data);
1966 do_line_lev(data) ;
1967 /* fall through */
1968 case SOUND_MIXER_READ_LINE:
1969 rc = IOCTL_OUT(arg, line_lev);
1970 break;
1971 case SOUND_MIXER_WRITE_IGAIN:
1972 IOCTL_IN(arg, data);
1973 do_ip_gain(data) ;
1974 /* fall through */
1975 case SOUND_MIXER_READ_IGAIN:
1976 rc = IOCTL_OUT(arg, ip_gain);
1977 break;
1978 case SOUND_MIXER_WRITE_MIC:
1979 IOCTL_IN(arg, data);
1980 do_mic_lev(data);
1981 /* fall through */
1982 case SOUND_MIXER_READ_MIC:
1983 rc = IOCTL_OUT(arg, mic_lev);
1984 break;
1985 case SOUND_MIXER_WRITE_CD:
1986 IOCTL_IN(arg, data);
1987 do_cd_lev(data);
1988 /* fall through */
1989 case SOUND_MIXER_READ_CD:
1990 rc = IOCTL_OUT(arg, cd_lev);
1991 break;
1992 case SOUND_MIXER_WRITE_RECLEV:
1993 IOCTL_IN(arg, data);
1994 do_rec_lev(data) ;
1995 /* fall through */
1996 case SOUND_MIXER_READ_RECLEV:
1997 rc = IOCTL_OUT(arg, rec_lev);
1998 break;
1999 case MIXER_WRITE(SOUND_MIXER_MONITOR):
2000 IOCTL_IN(arg, data);
2001 do_passthru_vol(data) ;
2002 /* fall through */
2003 case MIXER_READ(SOUND_MIXER_MONITOR):
2004 rc = IOCTL_OUT(arg, passthru_vol);
2005 break;
2006 default:
2007 rc = -EINVAL;
2008 }
2009
2010 return rc;
2011 }
2012
2013 static void awacs_mixer_init(void)
2014 {
2015 awacs_volume_setter(line_vol, 2, 0, 6);
2016 if (has_perch)
2017 awacs_enable_amp(spk_vol);
2018 else
2019 (void)awacs_volume_setter(spk_vol, 4, MASK_CMUTE, 6);
2020 do_line_lev(line_lev) ;
2021 do_ip_gain(ip_gain) ;
2022 do_mic_lev(mic_lev) ;
2023 do_cd_lev(cd_lev) ;
2024 do_rec_lev(rec_lev) ;
2025 do_passthru_vol(passthru_vol) ;
2026 }
2027
2028 static int burgundy_mixer_ioctl(u_int cmd, u_long arg)
2029 {
2030 int data;
2031 int rc;
2032
2033 /* We are, we are, we are... Burgundy or better */
2034 switch(cmd) {
2035 case SOUND_MIXER_READ_DEVMASK:
2036 data = SOUND_MASK_VOLUME | SOUND_MASK_CD |
2037 SOUND_MASK_LINE | SOUND_MASK_MIC |
2038 SOUND_MASK_SPEAKER | SOUND_MASK_ALTPCM;
2039 rc = IOCTL_OUT(arg, data);
2040 break;
2041 case SOUND_MIXER_READ_RECMASK:
2042 data = SOUND_MASK_LINE | SOUND_MASK_MIC
2043 | SOUND_MASK_CD;
2044 rc = IOCTL_OUT(arg, data);
2045 break;
2046 case SOUND_MIXER_READ_RECSRC:
2047 data = 0;
2048 if (awacs_reg[0] & MASK_MUX_AUDIN)
2049 data |= SOUND_MASK_LINE;
2050 if (awacs_reg[0] & MASK_MUX_MIC)
2051 data |= SOUND_MASK_MIC;
2052 if (awacs_reg[0] & MASK_MUX_CD)
2053 data |= SOUND_MASK_CD;
2054 rc = IOCTL_OUT(arg, data);
2055 break;
2056 case SOUND_MIXER_WRITE_RECSRC:
2057 IOCTL_IN(arg, data);
2058 data &= (SOUND_MASK_LINE
2059 | SOUND_MASK_MIC | SOUND_MASK_CD);
2060 awacs_reg[0] &= ~(MASK_MUX_CD | MASK_MUX_MIC
2061 | MASK_MUX_AUDIN);
2062 if (data & SOUND_MASK_LINE)
2063 awacs_reg[0] |= MASK_MUX_AUDIN;
2064 if (data & SOUND_MASK_MIC)
2065 awacs_reg[0] |= MASK_MUX_MIC;
2066 if (data & SOUND_MASK_CD)
2067 awacs_reg[0] |= MASK_MUX_CD;
2068 awacs_write(awacs_reg[0] | MASK_ADDR0);
2069 rc = IOCTL_OUT(arg, data);
2070 break;
2071 case SOUND_MIXER_READ_STEREODEVS:
2072 data = SOUND_MASK_VOLUME | SOUND_MASK_SPEAKER
2073 | SOUND_MASK_RECLEV | SOUND_MASK_CD
2074 | SOUND_MASK_LINE;
2075 rc = IOCTL_OUT(arg, data);
2076 break;
2077 case SOUND_MIXER_READ_CAPS:
2078 rc = IOCTL_OUT(arg, 0);
2079 break;
2080 case SOUND_MIXER_WRITE_VOLUME:
2081 IOCTL_IN(arg, data);
2082 awacs_burgundy_write_mvolume(MASK_ADDR_BURGUNDY_MASTER_VOLUME, data);
2083 /* Fall through */
2084 case SOUND_MIXER_READ_VOLUME:
2085 rc = IOCTL_OUT(arg, awacs_burgundy_read_mvolume(MASK_ADDR_BURGUNDY_MASTER_VOLUME));
2086 break;
2087 case SOUND_MIXER_WRITE_SPEAKER:
2088 IOCTL_IN(arg, data);
2089 if (!(data & 0xff)) {
2090 /* Mute the left speaker */
2091 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
2092 awacs_burgundy_rcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES) & ~0x2);
2093 } else {
2094 /* Unmute the left speaker */
2095 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
2096 awacs_burgundy_rcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES) | 0x2);
2097 }
2098 if (!(data & 0xff00)) {
2099 /* Mute the right speaker */
2100 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
2101 awacs_burgundy_rcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES) & ~0x4);
2102 } else {
2103 /* Unmute the right speaker */
2104 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
2105 awacs_burgundy_rcb(MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES) | 0x4);
2106 }
2107
2108 data = (((data&0xff)*16)/100 > 0xf ? 0xf :
2109 (((data&0xff)*16)/100)) +
2110 ((((data>>8)*16)/100 > 0xf ? 0xf :
2111 ((((data>>8)*16)/100)))<<4);
2112
2113 awacs_burgundy_wcb(MASK_ADDR_BURGUNDY_ATTENSPEAKER, ~data);
2114 /* Fall through */
2115 case SOUND_MIXER_READ_SPEAKER:
2116 data = awacs_burgundy_rcb(MASK_ADDR_BURGUNDY_ATTENSPEAKER);
2117 data = (((data & 0xf)*100)/16) + ((((data>>4)*100)/16)<<8);
2118 rc = IOCTL_OUT(arg, (~data) & 0x0000ffff);
2119 break;
2120 case SOUND_MIXER_WRITE_ALTPCM: /* really bell volume */
2121 IOCTL_IN(arg, data);
2122 beep_vol = data & 0xff;
2123 /* fall through */
2124 case SOUND_MIXER_READ_ALTPCM:
2125 rc = IOCTL_OUT(arg, beep_vol);
2126 break;
2127 case SOUND_MIXER_WRITE_LINE:
2128 IOCTL_IN(arg, data);
2129 awacs_burgundy_write_volume(MASK_ADDR_BURGUNDY_VOLLINE, data);
2130
2131 /* fall through */
2132 case SOUND_MIXER_READ_LINE:
2133 data = awacs_burgundy_read_volume(MASK_ADDR_BURGUNDY_VOLLINE);
2134 rc = IOCTL_OUT(arg, data);
2135 break;
2136 case SOUND_MIXER_WRITE_MIC:
2137 IOCTL_IN(arg, data);
2138 /* Mic is mono device */
2139 data = (data << 8) + (data << 24);
2140 awacs_burgundy_write_volume(MASK_ADDR_BURGUNDY_VOLMIC, data);
2141 /* fall through */
2142 case SOUND_MIXER_READ_MIC:
2143 data = awacs_burgundy_read_volume(MASK_ADDR_BURGUNDY_VOLMIC);
2144 data <<= 24;
2145 rc = IOCTL_OUT(arg, data);
2146 break;
2147 case SOUND_MIXER_WRITE_CD:
2148 IOCTL_IN(arg, data);
2149 awacs_burgundy_write_volume(MASK_ADDR_BURGUNDY_VOLCD, data);
2150 /* fall through */
2151 case SOUND_MIXER_READ_CD:
2152 data = awacs_burgundy_read_volume(MASK_ADDR_BURGUNDY_VOLCD);
2153 rc = IOCTL_OUT(arg, data);
2154 break;
2155 case SOUND_MIXER_WRITE_RECLEV:
2156 IOCTL_IN(arg, data);
2157 data = awacs_volume_setter(data, 0, 0, 4);
2158 rc = IOCTL_OUT(arg, data);
2159 break;
2160 case SOUND_MIXER_READ_RECLEV:
2161 data = awacs_get_volume(awacs_reg[0], 4);
2162 rc = IOCTL_OUT(arg, data);
2163 break;
2164 case SOUND_MIXER_OUTMASK:
2165 case SOUND_MIXER_OUTSRC:
2166 default:
2167 rc = -EINVAL;
2168 }
2169
2170 return rc;
2171 }
2172
2173 static int daca_mixer_ioctl(u_int cmd, u_long arg)
2174 {
2175 int data;
2176 int rc;
2177
2178 /* And the DACA's no genius either! */
2179
2180 switch(cmd) {
2181 case SOUND_MIXER_READ_DEVMASK:
2182 data = SOUND_MASK_VOLUME;
2183 rc = IOCTL_OUT(arg, data);
2184 break;
2185 case SOUND_MIXER_READ_RECMASK:
2186 data = 0;
2187 rc = IOCTL_OUT(arg, data);
2188 break;
2189 case SOUND_MIXER_READ_RECSRC:
2190 data = 0;
2191 rc = IOCTL_OUT(arg, data);
2192 break;
2193 case SOUND_MIXER_WRITE_RECSRC:
2194 IOCTL_IN(arg, data);
2195 data =0;
2196 rc = IOCTL_OUT(arg, data);
2197 break;
2198 case SOUND_MIXER_READ_STEREODEVS:
2199 data = SOUND_MASK_VOLUME;
2200 rc = IOCTL_OUT(arg, data);
2201 break;
2202 case SOUND_MIXER_READ_CAPS:
2203 rc = IOCTL_OUT(arg, 0);
2204 break;
2205 case SOUND_MIXER_WRITE_VOLUME:
2206 IOCTL_IN(arg, data);
2207 daca_set_volume(data, data);
2208 /* Fall through */
2209 case SOUND_MIXER_READ_VOLUME:
2210 daca_get_volume(& data, &data);
2211 rc = IOCTL_OUT(arg, data);
2212 break;
2213 case SOUND_MIXER_OUTMASK:
2214 case SOUND_MIXER_OUTSRC:
2215 default:
2216 rc = -EINVAL;
2217 }
2218 return rc;
2219 }
2220
2221 static int PMacMixerIoctl(u_int cmd, u_long arg)
2222 {
2223 int rc;
2224
2225 /* Different IOCTLS for burgundy and, eventually, DACA & Tumbler */
2226
2227 TRY_LOCK();
2228
2229 switch (awacs_revision){
2230 case AWACS_BURGUNDY:
2231 rc = burgundy_mixer_ioctl(cmd, arg);
2232 break ;
2233 case AWACS_DACA:
2234 rc = daca_mixer_ioctl(cmd, arg);
2235 break;
2236 case AWACS_TUMBLER:
2237 case AWACS_SNAPPER:
2238 rc = tas_mixer_ioctl(cmd, arg);
2239 break ;
2240 default: /* ;-)) */
2241 rc = awacs_mixer_ioctl(cmd, arg);
2242 }
2243
2244 UNLOCK();
2245
2246 return rc;
2247 }
2248
2249 static void PMacMixerInit(void)
2250 {
2251 switch (awacs_revision) {
2252 case AWACS_TUMBLER:
2253 printk("AE-Init tumbler mixer\n");
2254 break ;
2255 case AWACS_SNAPPER:
2256 printk("AE-Init snapper mixer\n");
2257 break ;
2258 case AWACS_DACA:
2259 case AWACS_BURGUNDY:
2260 break ; /* don't know yet */
2261 case AWACS_AWACS:
2262 case AWACS_SCREAMER:
2263 default:
2264 awacs_mixer_init() ;
2265 break ;
2266 }
2267 }
2268
2269 /* Write/Read sq setup functions:
2270 Check to see if we have enough (or any) dbdma cmd buffers for the
2271 user's fragment settings. If not, allocate some. If this fails we will
2272 point at the beep buffer - as an emergency provision - to stop dma tromping
2273 on some random bit of memory (if someone lets it go anyway).
2274 The command buffers are then set up to point to the fragment buffers
2275 (allocated elsewhere). We need n+1 commands the last of which holds
2276 a NOP + loop to start.
2277 */
2278
2279 static int PMacWriteSqSetup(void)
2280 {
2281 int i, count = 600 ;
2282 volatile struct dbdma_cmd *cp;
2283
2284 LOCK();
2285
2286 /* stop the controller from doing any output - if it isn't already.
2287 it _should_ be before this is called anyway */
2288
2289 out_le32(&awacs_txdma->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
2290 while ((in_le32(&awacs_txdma->status) & RUN) && count--)
2291 udelay(1);
2292 #ifdef DEBUG_DMASOUND
2293 if (count <= 0)
2294 printk("dmasound_pmac: write sq setup: timeout waiting for dma to stop\n");
2295 #endif
2296
2297 if ((write_sq.max_count + 1) > number_of_tx_cmd_buffers) {
2298 kfree(awacs_tx_cmd_space);
2299 number_of_tx_cmd_buffers = 0;
2300
2301 /* we need nbufs + 1 (for the loop) and we should request + 1
2302 again because the DBDMA_ALIGN might pull the start up by up
2303 to sizeof(struct dbdma_cmd) - 4.
2304 */
2305
2306 awacs_tx_cmd_space = kmalloc
2307 ((write_sq.max_count + 1 + 1) * sizeof(struct dbdma_cmd),
2308 GFP_KERNEL);
2309 if (awacs_tx_cmd_space == NULL) {
2310 /* don't leave it dangling - nasty but better than a
2311 random address */
2312 out_le32(&awacs_txdma->cmdptr, virt_to_bus(beep_dbdma_cmd));
2313 printk(KERN_ERR
2314 "dmasound_pmac: can't allocate dbdma cmd buffers"
2315 ", driver disabled\n");
2316 UNLOCK();
2317 return -ENOMEM;
2318 }
2319 awacs_tx_cmds = (volatile struct dbdma_cmd *)
2320 DBDMA_ALIGN(awacs_tx_cmd_space);
2321 number_of_tx_cmd_buffers = write_sq.max_count + 1;
2322 }
2323
2324 cp = awacs_tx_cmds;
2325 memset((void *)cp, 0, (write_sq.max_count+1) * sizeof(struct dbdma_cmd));
2326 for (i = 0; i < write_sq.max_count; ++i, ++cp) {
2327 st_le32(&cp->phy_addr, virt_to_bus(write_sq.buffers[i]));
2328 }
2329 st_le16(&cp->command, DBDMA_NOP + BR_ALWAYS);
2330 st_le32(&cp->cmd_dep, virt_to_bus(awacs_tx_cmds));
2331 /* point the controller at the command stack - ready to go */
2332 out_le32(&awacs_txdma->cmdptr, virt_to_bus(awacs_tx_cmds));
2333 UNLOCK();
2334 return 0;
2335 }
2336
2337 static int PMacReadSqSetup(void)
2338 {
2339 int i, count = 600;
2340 volatile struct dbdma_cmd *cp;
2341
2342 LOCK();
2343
2344 /* stop the controller from doing any input - if it isn't already.
2345 it _should_ be before this is called anyway */
2346
2347 out_le32(&awacs_rxdma->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
2348 while ((in_le32(&awacs_rxdma->status) & RUN) && count--)
2349 udelay(1);
2350 #ifdef DEBUG_DMASOUND
2351 if (count <= 0)
2352 printk("dmasound_pmac: read sq setup: timeout waiting for dma to stop\n");
2353 #endif
2354
2355 if ((read_sq.max_count+1) > number_of_rx_cmd_buffers ) {
2356 kfree(awacs_rx_cmd_space);
2357 number_of_rx_cmd_buffers = 0;
2358
2359 /* we need nbufs + 1 (for the loop) and we should request + 1 again
2360 because the DBDMA_ALIGN might pull the start up by up to
2361 sizeof(struct dbdma_cmd) - 4 (assuming kmalloc aligns 32 bits).
2362 */
2363
2364 awacs_rx_cmd_space = kmalloc
2365 ((read_sq.max_count + 1 + 1) * sizeof(struct dbdma_cmd),
2366 GFP_KERNEL);
2367 if (awacs_rx_cmd_space == NULL) {
2368 /* don't leave it dangling - nasty but better than a
2369 random address */
2370 out_le32(&awacs_rxdma->cmdptr, virt_to_bus(beep_dbdma_cmd));
2371 printk(KERN_ERR
2372 "dmasound_pmac: can't allocate dbdma cmd buffers"
2373 ", driver disabled\n");
2374 UNLOCK();
2375 return -ENOMEM;
2376 }
2377 awacs_rx_cmds = (volatile struct dbdma_cmd *)
2378 DBDMA_ALIGN(awacs_rx_cmd_space);
2379 number_of_rx_cmd_buffers = read_sq.max_count + 1 ;
2380 }
2381 cp = awacs_rx_cmds;
2382 memset((void *)cp, 0, (read_sq.max_count+1) * sizeof(struct dbdma_cmd));
2383
2384 /* Set dma buffers up in a loop */
2385 for (i = 0; i < read_sq.max_count; i++,cp++) {
2386 st_le32(&cp->phy_addr, virt_to_bus(read_sq.buffers[i]));
2387 st_le16(&cp->command, INPUT_MORE + INTR_ALWAYS);
2388 st_le16(&cp->req_count, read_sq.block_size);
2389 st_le16(&cp->xfer_status, 0);
2390 }
2391
2392 /* The next two lines make the thing loop around.
2393 */
2394 st_le16(&cp->command, DBDMA_NOP + BR_ALWAYS);
2395 st_le32(&cp->cmd_dep, virt_to_bus(awacs_rx_cmds));
2396 /* point the controller at the command stack - ready to go */
2397 out_le32(&awacs_rxdma->cmdptr, virt_to_bus(awacs_rx_cmds));
2398
2399 UNLOCK();
2400 return 0;
2401 }
2402
2403 /* TODO: this needs work to guarantee that when it returns DMA has stopped
2404 but in a more elegant way than is done here....
2405 */
2406
2407 static void PMacAbortRead(void)
2408 {
2409 int i;
2410 volatile struct dbdma_cmd *cp;
2411
2412 LOCK();
2413 /* give it a chance to update the output and provide the IRQ
2414 that is expected.
2415 */
2416
2417 out_le32(&awacs_rxdma->control, ((FLUSH) << 16) + FLUSH );
2418
2419 cp = awacs_rx_cmds;
2420 for (i = 0; i < read_sq.max_count; i++,cp++)
2421 st_le16(&cp->command, DBDMA_STOP);
2422 /*
2423 * We should probably wait for the thing to stop before we
2424 * release the memory.
2425 */
2426
2427 msleep(100) ; /* give it a (small) chance to act */
2428
2429 /* apply the sledgehammer approach - just stop it now */
2430
2431 out_le32(&awacs_rxdma->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
2432 UNLOCK();
2433 }
2434
2435 extern char *get_afmt_string(int);
2436 static int PMacStateInfo(char *b, size_t sp)
2437 {
2438 int i, len = 0;
2439 len = sprintf(b,"HW rates: ");
2440 switch (awacs_revision){
2441 case AWACS_DACA:
2442 case AWACS_BURGUNDY:
2443 len += sprintf(b,"44100 ") ;
2444 break ;
2445 case AWACS_TUMBLER:
2446 case AWACS_SNAPPER:
2447 for (i=0; i<1; i++){
2448 if (tas_freqs_ok[i])
2449 len += sprintf(b+len,"%d ", tas_freqs[i]) ;
2450 }
2451 break ;
2452 case AWACS_AWACS:
2453 case AWACS_SCREAMER:
2454 default:
2455 for (i=0; i<8; i++){
2456 if (awacs_freqs_ok[i])
2457 len += sprintf(b+len,"%d ", awacs_freqs[i]) ;
2458 }
2459 break ;
2460 }
2461 len += sprintf(b+len,"s/sec\n") ;
2462 if (len < sp) {
2463 len += sprintf(b+len,"HW AFMTS: ");
2464 i = AFMT_U16_BE ;
2465 while (i) {
2466 if (i & dmasound.mach.hardware_afmts)
2467 len += sprintf(b+len,"%s ",
2468 get_afmt_string(i & dmasound.mach.hardware_afmts));
2469 i >>= 1 ;
2470 }
2471 len += sprintf(b+len,"\n") ;
2472 }
2473 return len ;
2474 }
2475
2476 /*** Machine definitions *****************************************************/
2477
2478 static SETTINGS def_hard = {
2479 .format = AFMT_S16_BE,
2480 .stereo = 1,
2481 .size = 16,
2482 .speed = 44100
2483 } ;
2484
2485 static SETTINGS def_soft = {
2486 .format = AFMT_S16_BE,
2487 .stereo = 1,
2488 .size = 16,
2489 .speed = 44100
2490 } ;
2491
2492 static MACHINE machPMac = {
2493 .name = awacs_name,
2494 .name2 = "PowerMac Built-in Sound",
2495 .owner = THIS_MODULE,
2496 .dma_alloc = PMacAlloc,
2497 .dma_free = PMacFree,
2498 .irqinit = PMacIrqInit,
2499 #ifdef MODULE
2500 .irqcleanup = PMacIrqCleanup,
2501 #endif /* MODULE */
2502 .init = PMacInit,
2503 .silence = PMacSilence,
2504 .setFormat = PMacSetFormat,
2505 .setVolume = PMacSetVolume,
2506 .play = PMacPlay,
2507 .record = NULL, /* default to no record */
2508 .mixer_init = PMacMixerInit,
2509 .mixer_ioctl = PMacMixerIoctl,
2510 .write_sq_setup = PMacWriteSqSetup,
2511 .read_sq_setup = PMacReadSqSetup,
2512 .state_info = PMacStateInfo,
2513 .abort_read = PMacAbortRead,
2514 .min_dsp_speed = 7350,
2515 .max_dsp_speed = 44100,
2516 .version = ((DMASOUND_AWACS_REVISION<<8) + DMASOUND_AWACS_EDITION)
2517 };
2518
2519
2520 /*** Config & Setup **********************************************************/
2521
2522 /* Check for pmac models that we care about in terms of special actions.
2523 */
2524
2525 void __init
2526 set_model(void)
2527 {
2528 /* portables/lap-tops */
2529
2530 if (machine_is_compatible("AAPL,3400/2400") ||
2531 machine_is_compatible("AAPL,3500")) {
2532 is_pbook_3X00 = 1 ;
2533 }
2534 if (machine_is_compatible("PowerBook1,1") || /* lombard */
2535 machine_is_compatible("AAPL,PowerBook1998")){ /* wallstreet */
2536 is_pbook_g3 = 1 ;
2537 return ;
2538 }
2539 }
2540
2541 /* Get the OF node that tells us about the registers, interrupts etc. to use
2542 for sound IO.
2543
2544 On most machines the sound IO OF node is the 'davbus' node. On newer pmacs
2545 with DACA (& Tumbler) the node to use is i2s-a. On much older machines i.e.
2546 before 9500 there is no davbus node and we have to use the 'awacs' property.
2547
2548 In the latter case we signal this by setting the codec value - so that the
2549 code that looks for chip properties knows how to go about it.
2550 */
2551
2552 static struct device_node* __init
2553 get_snd_io_node(void)
2554 {
2555 struct device_node *np = NULL;
2556
2557 /* set up awacs_node for early OF which doesn't have a full set of
2558 * properties on davbus
2559 */
2560
2561 awacs_node = find_devices("awacs");
2562 if (awacs_node)
2563 awacs_revision = AWACS_AWACS;
2564
2565 /* powermac models after 9500 (other than those which use DACA or
2566 * Tumbler) have a node called "davbus".
2567 */
2568 np = find_devices("davbus");
2569 /*
2570 * if we didn't find a davbus device, try 'i2s-a' since
2571 * this seems to be what iBooks (& Tumbler) have.
2572 */
2573 if (np == NULL)
2574 np = i2s_node = find_devices("i2s-a");
2575
2576 /* if we didn't find this - perhaps we are on an early model
2577 * which _only_ has an 'awacs' node
2578 */
2579 if (np == NULL && awacs_node)
2580 np = awacs_node ;
2581
2582 /* if we failed all these return null - this will cause the
2583 * driver to give up...
2584 */
2585 return np ;
2586 }
2587
2588 /* Get the OF node that contains the info about the sound chip, inputs s-rates
2589 etc.
2590 This node does not exist (or contains much reduced info) on earlier machines
2591 we have to deduce the info other ways for these.
2592 */
2593
2594 static struct device_node* __init
2595 get_snd_info_node(struct device_node *io)
2596 {
2597 struct device_node *info;
2598
2599 info = find_devices("sound");
2600 while (info && info->parent != io)
2601 info = info->next;
2602 return info;
2603 }
2604
2605 /* Find out what type of codec we have.
2606 */
2607
2608 static int __init
2609 get_codec_type(struct device_node *info)
2610 {
2611 /* already set if pre-davbus model and info will be NULL */
2612 int codec = awacs_revision ;
2613
2614 if (info) {
2615 /* must do awacs first to allow screamer to overide it */
2616 if (device_is_compatible(info, "awacs"))
2617 codec = AWACS_AWACS ;
2618 if (device_is_compatible(info, "screamer"))
2619 codec = AWACS_SCREAMER;
2620 if (device_is_compatible(info, "burgundy"))
2621 codec = AWACS_BURGUNDY ;
2622 if (device_is_compatible(info, "daca"))
2623 codec = AWACS_DACA;
2624 if (device_is_compatible(info, "tumbler"))
2625 codec = AWACS_TUMBLER;
2626 if (device_is_compatible(info, "snapper"))
2627 codec = AWACS_SNAPPER;
2628 }
2629 return codec ;
2630 }
2631
2632 /* find out what type, if any, of expansion card we have
2633 */
2634 static void __init
2635 get_expansion_type(void)
2636 {
2637 if (find_devices("perch") != NULL)
2638 has_perch = 1;
2639
2640 if (find_devices("pb-ziva-pc") != NULL)
2641 has_ziva = 1;
2642 /* need to work out how we deal with iMac SRS module */
2643 }
2644
2645 /* set up frame rates.
2646 * I suspect that these routines don't quite go about it the right way:
2647 * - where there is more than one rate - I think that the first property
2648 * value is the number of rates.
2649 * TODO: check some more device trees and modify accordingly
2650 * Set dmasound.mach.max_dsp_rate on the basis of these routines.
2651 */
2652
2653 static void __init
2654 awacs_init_frame_rates(unsigned int *prop, unsigned int l)
2655 {
2656 int i ;
2657 if (prop) {
2658 for (i=0; i<8; i++)
2659 awacs_freqs_ok[i] = 0 ;
2660 for (l /= sizeof(int); l > 0; --l) {
2661 unsigned int r = *prop++;
2662 /* Apple 'Fixed' format */
2663 if (r >= 0x10000)
2664 r >>= 16;
2665 for (i = 0; i < 8; ++i) {
2666 if (r == awacs_freqs[i]) {
2667 awacs_freqs_ok[i] = 1;
2668 break;
2669 }
2670 }
2671 }
2672 }
2673 /* else we assume that all the rates are available */
2674 }
2675
2676 static void __init
2677 burgundy_init_frame_rates(unsigned int *prop, unsigned int l)
2678 {
2679 int temp[9] ;
2680 int i = 0 ;
2681 if (prop) {
2682 for (l /= sizeof(int); l > 0; --l) {
2683 unsigned int r = *prop++;
2684 /* Apple 'Fixed' format */
2685 if (r >= 0x10000)
2686 r >>= 16;
2687 temp[i] = r ;
2688 i++ ; if(i>=9) i=8;
2689 }
2690 }
2691 #ifdef DEBUG_DMASOUND
2692 if (i > 1){
2693 int j;
2694 printk("dmasound_pmac: burgundy with multiple frame rates\n");
2695 for(j=0; j<i; j++)
2696 printk("%d ", temp[j]) ;
2697 printk("\n") ;
2698 }
2699 #endif
2700 }
2701
2702 static void __init
2703 daca_init_frame_rates(unsigned int *prop, unsigned int l)
2704 {
2705 int temp[9] ;
2706 int i = 0 ;
2707 if (prop) {
2708 for (l /= sizeof(int); l > 0; --l) {
2709 unsigned int r = *prop++;
2710 /* Apple 'Fixed' format */
2711 if (r >= 0x10000)
2712 r >>= 16;
2713 temp[i] = r ;
2714 i++ ; if(i>=9) i=8;
2715
2716 }
2717 }
2718 #ifdef DEBUG_DMASOUND
2719 if (i > 1){
2720 int j;
2721 printk("dmasound_pmac: DACA with multiple frame rates\n");
2722 for(j=0; j<i; j++)
2723 printk("%d ", temp[j]) ;
2724 printk("\n") ;
2725 }
2726 #endif
2727 }
2728
2729 static void __init
2730 init_frame_rates(unsigned int *prop, unsigned int l)
2731 {
2732 switch (awacs_revision) {
2733 case AWACS_TUMBLER:
2734 case AWACS_SNAPPER:
2735 tas_init_frame_rates(prop, l);
2736 break ;
2737 case AWACS_DACA:
2738 daca_init_frame_rates(prop, l);
2739 break ;
2740 case AWACS_BURGUNDY:
2741 burgundy_init_frame_rates(prop, l);
2742 break ;
2743 default:
2744 awacs_init_frame_rates(prop, l);
2745 break ;
2746 }
2747 }
2748
2749 /* find things/machines that can't do mac-io byteswap
2750 */
2751
2752 static void __init
2753 set_hw_byteswap(struct device_node *io)
2754 {
2755 struct device_node *mio ;
2756 unsigned int kl = 0 ;
2757
2758 /* if seems that Keylargo can't byte-swap */
2759
2760 for (mio = io->parent; mio ; mio = mio->parent) {
2761 if (strcmp(mio->name, "mac-io") == 0) {
2762 if (device_is_compatible(mio, "Keylargo"))
2763 kl = 1;
2764 break;
2765 }
2766 }
2767 hw_can_byteswap = !kl;
2768 }
2769
2770 /* Allocate the resources necessary for beep generation. This cannot be (quite)
2771 done statically (yet) because we cannot do virt_to_bus() on static vars when
2772 the code is loaded as a module.
2773
2774 for the sake of saving the possibility that two allocations will incur the
2775 overhead of two pull-ups in DBDMA_ALIGN() we allocate the 'emergency' dmdma
2776 command here as well... even tho' it is not part of the beep process.
2777 */
2778
2779 int32_t
2780 __init setup_beep(void)
2781 {
2782 /* Initialize beep stuff */
2783 /* want one cmd buffer for beeps, and a second one for emergencies
2784 - i.e. dbdma error conditions.
2785 ask for three to allow for pull up in DBDMA_ALIGN().
2786 */
2787 beep_dbdma_cmd_space =
2788 kmalloc((2 + 1) * sizeof(struct dbdma_cmd), GFP_KERNEL);
2789 if(beep_dbdma_cmd_space == NULL) {
2790 printk(KERN_ERR "dmasound_pmac: no beep dbdma cmd space\n") ;
2791 return -ENOMEM ;
2792 }
2793 beep_dbdma_cmd = (volatile struct dbdma_cmd *)
2794 DBDMA_ALIGN(beep_dbdma_cmd_space);
2795 /* set up emergency dbdma cmd */
2796 emergency_dbdma_cmd = beep_dbdma_cmd+1 ;
2797 beep_buf = kmalloc(BEEP_BUFLEN * 4, GFP_KERNEL);
2798 if (beep_buf == NULL) {
2799 printk(KERN_ERR "dmasound_pmac: no memory for beep buffer\n");
2800 kfree(beep_dbdma_cmd_space) ;
2801 return -ENOMEM ;
2802 }
2803 return 0 ;
2804 }
2805
2806 static struct input_dev *awacs_beep_dev;
2807
2808 int __init dmasound_awacs_init(void)
2809 {
2810 struct device_node *io = NULL, *info = NULL;
2811 int vol, res;
2812
2813 if (!machine_is(powermac))
2814 return -ENODEV;
2815
2816 awacs_subframe = 0;
2817 awacs_revision = 0;
2818 hw_can_byteswap = 1 ; /* most can */
2819
2820 /* look for models we need to handle specially */
2821 set_model() ;
2822
2823 /* find the OF node that tells us about the dbdma stuff
2824 */
2825 io = get_snd_io_node();
2826 if (io == NULL) {
2827 #ifdef DEBUG_DMASOUND
2828 printk("dmasound_pmac: couldn't find sound io OF node\n");
2829 #endif
2830 return -ENODEV ;
2831 }
2832
2833 /* find the OF node that tells us about the sound sub-system
2834 * this doesn't exist on pre-davbus machines (earlier than 9500)
2835 */
2836 if (awacs_revision != AWACS_AWACS) { /* set for pre-davbus */
2837 info = get_snd_info_node(io) ;
2838 if (info == NULL){
2839 #ifdef DEBUG_DMASOUND
2840 printk("dmasound_pmac: couldn't find 'sound' OF node\n");
2841 #endif
2842 return -ENODEV ;
2843 }
2844 }
2845
2846 awacs_revision = get_codec_type(info) ;
2847 if (awacs_revision == 0) {
2848 #ifdef DEBUG_DMASOUND
2849 printk("dmasound_pmac: couldn't find a Codec we can handle\n");
2850 #endif
2851 return -ENODEV ; /* we don't know this type of h/w */
2852 }
2853
2854 /* set up perch, ziva, SRS or whatever else we have as sound
2855 * expansion.
2856 */
2857 get_expansion_type();
2858
2859 /* we've now got enough information to make up the audio topology.
2860 * we will map the sound part of mac-io now so that we can probe for
2861 * other info if necessary (early AWACS we want to read chip ids)
2862 */
2863
2864 if (of_get_address(io, 2, NULL, NULL) == NULL) {
2865 /* OK - maybe we need to use the 'awacs' node (on earlier
2866 * machines).
2867 */
2868 if (awacs_node) {
2869 io = awacs_node ;
2870 if (of_get_address(io, 2, NULL, NULL) == NULL) {
2871 printk("dmasound_pmac: can't use %s\n",
2872 io->full_name);
2873 return -ENODEV;
2874 }
2875 } else
2876 printk("dmasound_pmac: can't use %s\n", io->full_name);
2877 }
2878
2879 if (of_address_to_resource(io, 0, &awacs_rsrc[0]) ||
2880 request_mem_region(awacs_rsrc[0].start,
2881 awacs_rsrc[0].end - awacs_rsrc[0].start + 1,
2882 " (IO)") == NULL) {
2883 printk(KERN_ERR "dmasound: can't request IO resource !\n");
2884 return -ENODEV;
2885 }
2886 if (of_address_to_resource(io, 1, &awacs_rsrc[1]) ||
2887 request_mem_region(awacs_rsrc[1].start,
2888 awacs_rsrc[1].end - awacs_rsrc[1].start + 1,
2889 " (tx dma)") == NULL) {
2890 release_mem_region(awacs_rsrc[0].start,
2891 awacs_rsrc[0].end - awacs_rsrc[0].start + 1);
2892 printk(KERN_ERR "dmasound: can't request Tx DMA resource !\n");
2893 return -ENODEV;
2894 }
2895 if (of_address_to_resource(io, 2, &awacs_rsrc[2]) ||
2896 request_mem_region(awacs_rsrc[2].start,
2897 awacs_rsrc[2].end - awacs_rsrc[2].start + 1,
2898 " (rx dma)") == NULL) {
2899 release_mem_region(awacs_rsrc[0].start,
2900 awacs_rsrc[0].end - awacs_rsrc[0].start + 1);
2901 release_mem_region(awacs_rsrc[1].start,
2902 awacs_rsrc[1].end - awacs_rsrc[1].start + 1);
2903 printk(KERN_ERR "dmasound: can't request Rx DMA resource !\n");
2904 return -ENODEV;
2905 }
2906
2907 awacs_beep_dev = input_allocate_device();
2908 if (!awacs_beep_dev) {
2909 release_mem_region(awacs_rsrc[0].start,
2910 awacs_rsrc[0].end - awacs_rsrc[0].start + 1);
2911 release_mem_region(awacs_rsrc[1].start,
2912 awacs_rsrc[1].end - awacs_rsrc[1].start + 1);
2913 release_mem_region(awacs_rsrc[2].start,
2914 awacs_rsrc[2].end - awacs_rsrc[2].start + 1);
2915 printk(KERN_ERR "dmasound: can't allocate input device !\n");
2916 return -ENOMEM;
2917 }
2918
2919 awacs_beep_dev->name = "dmasound beeper";
2920 awacs_beep_dev->phys = "macio/input0";
2921 awacs_beep_dev->id.bustype = BUS_HOST;
2922 awacs_beep_dev->event = awacs_beep_event;
2923 awacs_beep_dev->sndbit[0] = BIT(SND_BELL) | BIT(SND_TONE);
2924 awacs_beep_dev->evbit[0] = BIT(EV_SND);
2925
2926 /* all OF versions I've seen use this value */
2927 if (i2s_node)
2928 i2s = ioremap(awacs_rsrc[0].start, 0x1000);
2929 else
2930 awacs = ioremap(awacs_rsrc[0].start, 0x1000);
2931 awacs_txdma = ioremap(awacs_rsrc[1].start, 0x100);
2932 awacs_rxdma = ioremap(awacs_rsrc[2].start, 0x100);
2933
2934 /* first of all make sure that the chip is powered up....*/
2935 pmac_call_feature(PMAC_FTR_SOUND_CHIP_ENABLE, io, 0, 1);
2936 if (awacs_revision == AWACS_SCREAMER && awacs)
2937 awacs_recalibrate();
2938
2939 awacs_irq = irq_of_parse_and_map(io, 0);
2940 awacs_tx_irq = irq_of_parse_and_map(io, 1);
2941 awacs_rx_irq = irq_of_parse_and_map(io, 2);
2942
2943 /* Hack for legacy crap that will be killed someday */
2944 awacs_node = io;
2945
2946 /* if we have an awacs or screamer - probe the chip to make
2947 * sure we have the right revision.
2948 */
2949
2950 if (awacs_revision <= AWACS_SCREAMER){
2951 uint32_t temp, rev, mfg ;
2952 /* find out the awacs revision from the chip */
2953 temp = in_le32(&awacs->codec_stat);
2954 rev = (temp >> 12) & 0xf;
2955 mfg = (temp >> 8) & 0xf;
2956 #ifdef DEBUG_DMASOUND
2957 printk("dmasound_pmac: Awacs/Screamer Codec Mfct: %d Rev %d\n", mfg, rev);
2958 #endif
2959 if (rev >= AWACS_SCREAMER)
2960 awacs_revision = AWACS_SCREAMER ;
2961 else
2962 awacs_revision = rev ;
2963 }
2964
2965 dmasound.mach = machPMac;
2966
2967 /* find out other bits & pieces from OF, these may be present
2968 only on some models ... so be careful.
2969 */
2970
2971 /* in the absence of a frame rates property we will use the defaults
2972 */
2973
2974 if (info) {
2975 unsigned int *prop, l;
2976
2977 sound_device_id = 0;
2978 /* device ID appears post g3 b&w */
2979 prop = (unsigned int *)get_property(info, "device-id", NULL);
2980 if (prop != 0)
2981 sound_device_id = *prop;
2982
2983 /* look for a property saying what sample rates
2984 are available */
2985
2986 prop = (unsigned int *)get_property(info, "sample-rates", &l);
2987 if (prop == 0)
2988 prop = (unsigned int *) get_property
2989 (info, "output-frame-rates", &l);
2990
2991 /* if it's there use it to set up frame rates */
2992 init_frame_rates(prop, l) ;
2993 }
2994
2995 if (awacs)
2996 out_le32(&awacs->control, 0x11); /* set everything quiesent */
2997
2998 set_hw_byteswap(io) ; /* figure out if the h/w can do it */
2999
3000 #ifdef CONFIG_NVRAM
3001 /* get default volume from nvram */
3002 vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
3003 #else
3004 vol = 0;
3005 #endif
3006
3007 /* set up tracking values */
3008 spk_vol = vol * 100 ;
3009 spk_vol /= 7 ; /* get set value to a percentage */
3010 spk_vol |= (spk_vol << 8) ; /* equal left & right */
3011 line_vol = passthru_vol = spk_vol ;
3012
3013 /* fill regs that are shared between AWACS & Burgundy */
3014
3015 awacs_reg[2] = vol + (vol << 6);
3016 awacs_reg[4] = vol + (vol << 6);
3017 awacs_reg[5] = vol + (vol << 6); /* screamer has loopthru vol control */
3018 awacs_reg[6] = 0; /* maybe should be vol << 3 for PCMCIA speaker */
3019 awacs_reg[7] = 0;
3020
3021 awacs_reg[0] = MASK_MUX_CD;
3022 awacs_reg[1] = MASK_LOOPTHRU;
3023
3024 /* FIXME: Only machines with external SRS module need MASK_PAROUT */
3025 if (has_perch || sound_device_id == 0x5
3026 || /*sound_device_id == 0x8 ||*/ sound_device_id == 0xb)
3027 awacs_reg[1] |= MASK_PAROUT0 | MASK_PAROUT1;
3028
3029 switch (awacs_revision) {
3030 case AWACS_TUMBLER:
3031 tas_register_driver(&tas3001c_hooks);
3032 tas_init(I2C_DRIVERID_TAS3001C, I2C_DRIVERNAME_TAS3001C);
3033 tas_dmasound_init();
3034 tas_post_init();
3035 break ;
3036 case AWACS_SNAPPER:
3037 tas_register_driver(&tas3004_hooks);
3038 tas_init(I2C_DRIVERID_TAS3004,I2C_DRIVERNAME_TAS3004);
3039 tas_dmasound_init();
3040 tas_post_init();
3041 break;
3042 case AWACS_DACA:
3043 daca_init();
3044 break;
3045 case AWACS_BURGUNDY:
3046 awacs_burgundy_init();
3047 break ;
3048 case AWACS_SCREAMER:
3049 case AWACS_AWACS:
3050 default:
3051 load_awacs();
3052 break ;
3053 }
3054
3055 /* enable/set-up external modules - when we know how */
3056
3057 if (has_perch)
3058 awacs_enable_amp(100 * 0x101);
3059
3060 /* Reset dbdma channels */
3061 out_le32(&awacs_txdma->control, (RUN|PAUSE|FLUSH|WAKE|DEAD) << 16);
3062 while (in_le32(&awacs_txdma->status) & RUN)
3063 udelay(1);
3064 out_le32(&awacs_rxdma->control, (RUN|PAUSE|FLUSH|WAKE|DEAD) << 16);
3065 while (in_le32(&awacs_rxdma->status) & RUN)
3066 udelay(1);
3067
3068 /* Initialize beep stuff */
3069 if ((res=setup_beep()))
3070 return res ;
3071
3072 #ifdef CONFIG_PM
3073 pmu_register_sleep_notifier(&awacs_sleep_notifier);
3074 #endif /* CONFIG_PM */
3075
3076 /* Powerbooks have odd ways of enabling inputs such as
3077 an expansion-bay CD or sound from an internal modem
3078 or a PC-card modem. */
3079 if (is_pbook_3X00) {
3080 /*
3081 * Enable CD and PC-card sound inputs.
3082 * This is done by reading from address
3083 * f301a000, + 0x10 to enable the expansion-bay
3084 * CD sound input, + 0x80 to enable the PC-card
3085 * sound input. The 0x100 enables the SCSI bus
3086 * terminator power.
3087 */
3088 latch_base = ioremap (0xf301a000, 0x1000);
3089 in_8(latch_base + 0x190);
3090
3091 } else if (is_pbook_g3) {
3092 struct device_node* mio;
3093 macio_base = NULL;
3094 for (mio = io->parent; mio; mio = mio->parent) {
3095 if (strcmp(mio->name, "mac-io") == 0) {
3096 struct resource r;
3097 if (of_address_to_resource(mio, 0, &r) == 0)
3098 macio_base = ioremap(r.start, 0x40);
3099 break;
3100 }
3101 }
3102 /*
3103 * Enable CD sound input.
3104 * The relevant bits for writing to this byte are 0x8f.
3105 * I haven't found out what the 0x80 bit does.
3106 * For the 0xf bits, writing 3 or 7 enables the CD
3107 * input, any other value disables it. Values
3108 * 1, 3, 5, 7 enable the microphone. Values 0, 2,
3109 * 4, 6, 8 - f enable the input from the modem.
3110 * -- paulus.
3111 */
3112 if (macio_base)
3113 out_8(macio_base + 0x37, 3);
3114 }
3115
3116 if (hw_can_byteswap)
3117 dmasound.mach.hardware_afmts = (AFMT_S16_BE | AFMT_S16_LE) ;
3118 else
3119 dmasound.mach.hardware_afmts = AFMT_S16_BE ;
3120
3121 /* shut out chips that do output only.
3122 * may need to extend this to machines which have no inputs - even tho'
3123 * they use screamer - IIRC one of the powerbooks is like this.
3124 */
3125
3126 if (awacs_revision != AWACS_DACA) {
3127 dmasound.mach.capabilities = DSP_CAP_DUPLEX ;
3128 dmasound.mach.record = PMacRecord ;
3129 }
3130
3131 dmasound.mach.default_hard = def_hard ;
3132 dmasound.mach.default_soft = def_soft ;
3133
3134 switch (awacs_revision) {
3135 case AWACS_BURGUNDY:
3136 sprintf(awacs_name, "PowerMac Burgundy ") ;
3137 break ;
3138 case AWACS_DACA:
3139 sprintf(awacs_name, "PowerMac DACA ") ;
3140 break ;
3141 case AWACS_TUMBLER:
3142 sprintf(awacs_name, "PowerMac Tumbler ") ;
3143 break ;
3144 case AWACS_SNAPPER:
3145 sprintf(awacs_name, "PowerMac Snapper ") ;
3146 break ;
3147 case AWACS_SCREAMER:
3148 sprintf(awacs_name, "PowerMac Screamer ") ;
3149 break ;
3150 case AWACS_AWACS:
3151 default:
3152 sprintf(awacs_name, "PowerMac AWACS rev %d ", awacs_revision) ;
3153 break ;
3154 }
3155
3156 /*
3157 * XXX: we should handle errors here, but that would mean
3158 * rewriting the whole init code. later..
3159 */
3160 input_register_device(awacs_beep_dev);
3161
3162 return dmasound_init();
3163 }
3164
3165 static void __exit dmasound_awacs_cleanup(void)
3166 {
3167 input_unregister_device(awacs_beep_dev);
3168
3169 switch (awacs_revision) {
3170 case AWACS_TUMBLER:
3171 case AWACS_SNAPPER:
3172 tas_dmasound_cleanup();
3173 tas_cleanup();
3174 break ;
3175 case AWACS_DACA:
3176 daca_cleanup();
3177 break;
3178 }
3179 dmasound_deinit();
3180
3181 }
3182
3183 MODULE_DESCRIPTION("PowerMac built-in audio driver.");
3184 MODULE_LICENSE("GPL");
3185
3186 module_init(dmasound_awacs_init);
3187 module_exit(dmasound_awacs_cleanup);
Linux kernel - Deliverables
This page took 0.145968 seconds and 5 git commands to generate.