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