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