SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/oss/dmasound/dmasound_awacs.c

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