root/sound/pci/riptide/riptide.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. atoh
  2. senddata
  3. loadfirmware
  4. alloclbuspath
  5. freelbuspath
  6. writearm
  7. sendcmd
  8. setmixer
  9. getpaths
  10. getsourcesink
  11. getsamplerate
  12. setsampleformat
  13. setsamplerate
  14. getmixer
  15. riptide_handleirq
  16. riptide_suspend
  17. riptide_resume
  18. try_to_load_firmware
  19. riptide_reset
  20. snd_riptide_pointer
  21. snd_riptide_trigger
  22. snd_riptide_prepare
  23. snd_riptide_hw_params
  24. snd_riptide_hw_free
  25. snd_riptide_playback_open
  26. snd_riptide_capture_open
  27. snd_riptide_playback_close
  28. snd_riptide_capture_close
  29. snd_riptide_pcm
  30. snd_riptide_interrupt
  31. snd_riptide_codec_write
  32. snd_riptide_codec_read
  33. snd_riptide_initialize
  34. snd_riptide_free
  35. snd_riptide_dev_free
  36. snd_riptide_create
  37. snd_riptide_proc_read
  38. snd_riptide_proc_init
  39. snd_riptide_mixer
  40. snd_riptide_joystick_probe
  41. snd_riptide_joystick_remove
  42. snd_card_riptide_probe
  43. snd_card_riptide_remove
  44. alsa_card_riptide_init
  45. alsa_card_riptide_exit

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Driver for the Conexant Riptide Soundchip
   4  *
   5  *      Copyright (c) 2004 Peter Gruber <nokos@gmx.net>
   6  */
   7 /*
   8   History:
   9    - 02/15/2004 first release
  10    
  11   This Driver is based on the OSS Driver version from Linuxant (riptide-0.6lnxtbeta03111100)
  12   credits from the original files:
  13   
  14   MODULE NAME:        cnxt_rt.h                       
  15   AUTHOR:             K. Lazarev  (Transcribed by KNL)
  16   HISTORY:         Major Revision               Date        By
  17             -----------------------------     --------     -----
  18             Created                           02/1/2000     KNL
  19 
  20   MODULE NAME:     int_mdl.c                       
  21   AUTHOR:          Konstantin Lazarev    (Transcribed by KNL)
  22   HISTORY:         Major Revision               Date        By
  23             -----------------------------     --------     -----
  24             Created                           10/01/99      KNL
  25             
  26   MODULE NAME:        riptide.h                       
  27   AUTHOR:             O. Druzhinin  (Transcribed by OLD)
  28   HISTORY:         Major Revision               Date        By
  29             -----------------------------     --------     -----
  30             Created                           10/16/97      OLD
  31 
  32   MODULE NAME:        Rp_Cmdif.cpp                       
  33   AUTHOR:             O. Druzhinin  (Transcribed by OLD)
  34                       K. Lazarev    (Transcribed by KNL)
  35   HISTORY:         Major Revision               Date        By
  36             -----------------------------     --------     -----
  37             Adopted from NT4 driver            6/22/99      OLD
  38             Ported to Linux                    9/01/99      KNL
  39 
  40   MODULE NAME:        rt_hw.c                       
  41   AUTHOR:             O. Druzhinin  (Transcribed by OLD)
  42                       C. Lazarev    (Transcribed by CNL)
  43   HISTORY:         Major Revision               Date        By
  44             -----------------------------     --------     -----
  45             Created                           11/18/97      OLD
  46             Hardware functions for RipTide    11/24/97      CNL
  47             (ES1) are coded
  48             Hardware functions for RipTide    12/24/97      CNL
  49             (A0) are coded
  50             Hardware functions for RipTide    03/20/98      CNL
  51             (A1) are coded
  52             Boot loader is included           05/07/98      CNL
  53             Redesigned for WDM                07/27/98      CNL
  54             Redesigned for Linux              09/01/99      CNL
  55 
  56   MODULE NAME:        rt_hw.h
  57   AUTHOR:             C. Lazarev    (Transcribed by CNL)
  58   HISTORY:         Major Revision               Date        By
  59             -----------------------------     --------     -----
  60             Created                           11/18/97      CNL
  61 
  62   MODULE NAME:     rt_mdl.c                       
  63   AUTHOR:          Konstantin Lazarev    (Transcribed by KNL)
  64   HISTORY:         Major Revision               Date        By
  65             -----------------------------     --------     -----
  66             Created                           10/01/99      KNL
  67 
  68   MODULE NAME:        mixer.h                        
  69   AUTHOR:             K. Kenney
  70   HISTORY:         Major Revision                   Date          By
  71             -----------------------------          --------     -----
  72             Created from MS W95 Sample             11/28/95      KRS
  73             RipTide                                10/15/97      KRS
  74             Adopted for Windows NT driver          01/20/98      CNL
  75 */
  76 
  77 #include <linux/delay.h>
  78 #include <linux/init.h>
  79 #include <linux/interrupt.h>
  80 #include <linux/pci.h>
  81 #include <linux/slab.h>
  82 #include <linux/wait.h>
  83 #include <linux/gameport.h>
  84 #include <linux/device.h>
  85 #include <linux/firmware.h>
  86 #include <linux/kernel.h>
  87 #include <linux/module.h>
  88 #include <linux/io.h>
  89 #include <sound/core.h>
  90 #include <sound/info.h>
  91 #include <sound/control.h>
  92 #include <sound/pcm.h>
  93 #include <sound/pcm_params.h>
  94 #include <sound/ac97_codec.h>
  95 #include <sound/mpu401.h>
  96 #include <sound/opl3.h>
  97 #include <sound/initval.h>
  98 
  99 #if IS_REACHABLE(CONFIG_GAMEPORT)
 100 #define SUPPORT_JOYSTICK 1
 101 #endif
 102 
 103 MODULE_AUTHOR("Peter Gruber <nokos@gmx.net>");
 104 MODULE_DESCRIPTION("riptide");
 105 MODULE_LICENSE("GPL");
 106 MODULE_SUPPORTED_DEVICE("{{Conexant,Riptide}}");
 107 MODULE_FIRMWARE("riptide.hex");
 108 
 109 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
 110 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
 111 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;
 112 
 113 #ifdef SUPPORT_JOYSTICK
 114 static int joystick_port[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS - 1)] = 0x200 };
 115 #endif
 116 static int mpu_port[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS - 1)] = 0x330 };
 117 static int opl3_port[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS - 1)] = 0x388 };
 118 
 119 module_param_array(index, int, NULL, 0444);
 120 MODULE_PARM_DESC(index, "Index value for Riptide soundcard.");
 121 module_param_array(id, charp, NULL, 0444);
 122 MODULE_PARM_DESC(id, "ID string for Riptide soundcard.");
 123 module_param_array(enable, bool, NULL, 0444);
 124 MODULE_PARM_DESC(enable, "Enable Riptide soundcard.");
 125 #ifdef SUPPORT_JOYSTICK
 126 module_param_hw_array(joystick_port, int, ioport, NULL, 0444);
 127 MODULE_PARM_DESC(joystick_port, "Joystick port # for Riptide soundcard.");
 128 #endif
 129 module_param_hw_array(mpu_port, int, ioport, NULL, 0444);
 130 MODULE_PARM_DESC(mpu_port, "MPU401 port # for Riptide driver.");
 131 module_param_hw_array(opl3_port, int, ioport, NULL, 0444);
 132 MODULE_PARM_DESC(opl3_port, "OPL3 port # for Riptide driver.");
 133 
 134 /*
 135  */
 136 
 137 #define MPU401_HW_RIPTIDE MPU401_HW_MPU401
 138 #define OPL3_HW_RIPTIDE   OPL3_HW_OPL3
 139 
 140 #define PCI_EXT_CapId       0x40
 141 #define PCI_EXT_NextCapPrt  0x41
 142 #define PCI_EXT_PWMC        0x42
 143 #define PCI_EXT_PWSCR       0x44
 144 #define PCI_EXT_Data00      0x46
 145 #define PCI_EXT_PMSCR_BSE   0x47
 146 #define PCI_EXT_SB_Base     0x48
 147 #define PCI_EXT_FM_Base     0x4a
 148 #define PCI_EXT_MPU_Base    0x4C
 149 #define PCI_EXT_Game_Base   0x4E
 150 #define PCI_EXT_Legacy_Mask 0x50
 151 #define PCI_EXT_AsicRev     0x52
 152 #define PCI_EXT_Reserved3   0x53
 153 
 154 #define LEGACY_ENABLE_ALL      0x8000   /* legacy device options */
 155 #define LEGACY_ENABLE_SB       0x4000
 156 #define LEGACY_ENABLE_FM       0x2000
 157 #define LEGACY_ENABLE_MPU_INT  0x1000
 158 #define LEGACY_ENABLE_MPU      0x0800
 159 #define LEGACY_ENABLE_GAMEPORT 0x0400
 160 
 161 #define MAX_WRITE_RETRY  10     /* cmd interface limits */
 162 #define MAX_ERROR_COUNT  10
 163 #define CMDIF_TIMEOUT    50000
 164 #define RESET_TRIES      5
 165 
 166 #define READ_PORT_ULONG(p)     inl((unsigned long)&(p))
 167 #define WRITE_PORT_ULONG(p,x)  outl(x,(unsigned long)&(p))
 168 
 169 #define READ_AUDIO_CONTROL(p)     READ_PORT_ULONG(p->audio_control)
 170 #define WRITE_AUDIO_CONTROL(p,x)  WRITE_PORT_ULONG(p->audio_control,x)
 171 #define UMASK_AUDIO_CONTROL(p,x)  WRITE_PORT_ULONG(p->audio_control,READ_PORT_ULONG(p->audio_control)|x)
 172 #define MASK_AUDIO_CONTROL(p,x)   WRITE_PORT_ULONG(p->audio_control,READ_PORT_ULONG(p->audio_control)&x)
 173 #define READ_AUDIO_STATUS(p)      READ_PORT_ULONG(p->audio_status)
 174 
 175 #define SET_GRESET(p)     UMASK_AUDIO_CONTROL(p,0x0001) /* global reset switch */
 176 #define UNSET_GRESET(p)   MASK_AUDIO_CONTROL(p,~0x0001)
 177 #define SET_AIE(p)        UMASK_AUDIO_CONTROL(p,0x0004) /* interrupt enable */
 178 #define UNSET_AIE(p)      MASK_AUDIO_CONTROL(p,~0x0004)
 179 #define SET_AIACK(p)      UMASK_AUDIO_CONTROL(p,0x0008) /* interrupt acknowledge */
 180 #define UNSET_AIACKT(p)   MASKAUDIO_CONTROL(p,~0x0008)
 181 #define SET_ECMDAE(p)     UMASK_AUDIO_CONTROL(p,0x0010)
 182 #define UNSET_ECMDAE(p)   MASK_AUDIO_CONTROL(p,~0x0010)
 183 #define SET_ECMDBE(p)     UMASK_AUDIO_CONTROL(p,0x0020)
 184 #define UNSET_ECMDBE(p)   MASK_AUDIO_CONTROL(p,~0x0020)
 185 #define SET_EDATAF(p)     UMASK_AUDIO_CONTROL(p,0x0040)
 186 #define UNSET_EDATAF(p)   MASK_AUDIO_CONTROL(p,~0x0040)
 187 #define SET_EDATBF(p)     UMASK_AUDIO_CONTROL(p,0x0080)
 188 #define UNSET_EDATBF(p)   MASK_AUDIO_CONTROL(p,~0x0080)
 189 #define SET_ESBIRQON(p)   UMASK_AUDIO_CONTROL(p,0x0100)
 190 #define UNSET_ESBIRQON(p) MASK_AUDIO_CONTROL(p,~0x0100)
 191 #define SET_EMPUIRQ(p)    UMASK_AUDIO_CONTROL(p,0x0200)
 192 #define UNSET_EMPUIRQ(p)  MASK_AUDIO_CONTROL(p,~0x0200)
 193 #define IS_CMDE(a)        (READ_PORT_ULONG(a->stat)&0x1)        /* cmd empty */
 194 #define IS_DATF(a)        (READ_PORT_ULONG(a->stat)&0x2)        /* data filled */
 195 #define IS_READY(p)       (READ_AUDIO_STATUS(p)&0x0001)
 196 #define IS_DLREADY(p)     (READ_AUDIO_STATUS(p)&0x0002)
 197 #define IS_DLERR(p)       (READ_AUDIO_STATUS(p)&0x0004)
 198 #define IS_GERR(p)        (READ_AUDIO_STATUS(p)&0x0008) /* error ! */
 199 #define IS_CMDAEIRQ(p)    (READ_AUDIO_STATUS(p)&0x0010)
 200 #define IS_CMDBEIRQ(p)    (READ_AUDIO_STATUS(p)&0x0020)
 201 #define IS_DATAFIRQ(p)    (READ_AUDIO_STATUS(p)&0x0040)
 202 #define IS_DATBFIRQ(p)    (READ_AUDIO_STATUS(p)&0x0080)
 203 #define IS_EOBIRQ(p)      (READ_AUDIO_STATUS(p)&0x0100) /* interrupt status */
 204 #define IS_EOSIRQ(p)      (READ_AUDIO_STATUS(p)&0x0200)
 205 #define IS_EOCIRQ(p)      (READ_AUDIO_STATUS(p)&0x0400)
 206 #define IS_UNSLIRQ(p)     (READ_AUDIO_STATUS(p)&0x0800)
 207 #define IS_SBIRQ(p)       (READ_AUDIO_STATUS(p)&0x1000)
 208 #define IS_MPUIRQ(p)      (READ_AUDIO_STATUS(p)&0x2000)
 209 
 210 #define RESP 0x00000001         /* command flags */
 211 #define PARM 0x00000002
 212 #define CMDA 0x00000004
 213 #define CMDB 0x00000008
 214 #define NILL 0x00000000
 215 
 216 #define LONG0(a)   ((u32)a)     /* shifts and masks */
 217 #define BYTE0(a)   (LONG0(a)&0xff)
 218 #define BYTE1(a)   (BYTE0(a)<<8)
 219 #define BYTE2(a)   (BYTE0(a)<<16)
 220 #define BYTE3(a)   (BYTE0(a)<<24)
 221 #define WORD0(a)   (LONG0(a)&0xffff)
 222 #define WORD1(a)   (WORD0(a)<<8)
 223 #define WORD2(a)   (WORD0(a)<<16)
 224 #define TRINIB0(a) (LONG0(a)&0xffffff)
 225 #define TRINIB1(a) (TRINIB0(a)<<8)
 226 
 227 #define RET(a)     ((union cmdret *)(a))
 228 
 229 #define SEND_GETV(p,b)             sendcmd(p,RESP,GETV,0,RET(b))        /* get version */
 230 #define SEND_GETC(p,b,c)           sendcmd(p,PARM|RESP,GETC,c,RET(b))
 231 #define SEND_GUNS(p,b)             sendcmd(p,RESP,GUNS,0,RET(b))
 232 #define SEND_SCID(p,b)             sendcmd(p,RESP,SCID,0,RET(b))
 233 #define SEND_RMEM(p,b,c,d)         sendcmd(p,PARM|RESP,RMEM|BYTE1(b),LONG0(c),RET(d))   /* memory access for firmware write */
 234 #define SEND_SMEM(p,b,c)           sendcmd(p,PARM,SMEM|BYTE1(b),LONG0(c),RET(0))        /* memory access for firmware write */
 235 #define SEND_WMEM(p,b,c)           sendcmd(p,PARM,WMEM|BYTE1(b),LONG0(c),RET(0))        /* memory access for firmware write */
 236 #define SEND_SDTM(p,b,c)           sendcmd(p,PARM|RESP,SDTM|TRINIB1(b),0,RET(c))        /* memory access for firmware write */
 237 #define SEND_GOTO(p,b)             sendcmd(p,PARM,GOTO,LONG0(b),RET(0)) /* memory access for firmware write */
 238 #define SEND_SETDPLL(p)            sendcmd(p,0,ARM_SETDPLL,0,RET(0))
 239 #define SEND_SSTR(p,b,c)           sendcmd(p,PARM,SSTR|BYTE3(b),LONG0(c),RET(0))        /* start stream */
 240 #define SEND_PSTR(p,b)             sendcmd(p,PARM,PSTR,BYTE3(b),RET(0)) /* pause stream */
 241 #define SEND_KSTR(p,b)             sendcmd(p,PARM,KSTR,BYTE3(b),RET(0)) /* stop stream */
 242 #define SEND_KDMA(p)               sendcmd(p,0,KDMA,0,RET(0))   /* stop all dma */
 243 #define SEND_GPOS(p,b,c,d)         sendcmd(p,PARM|RESP,GPOS,BYTE3(c)|BYTE2(b),RET(d))   /* get position in dma */
 244 #define SEND_SETF(p,b,c,d,e,f,g)   sendcmd(p,PARM,SETF|WORD1(b)|BYTE3(c),d|BYTE1(e)|BYTE2(f)|BYTE3(g),RET(0))   /* set sample format at mixer */
 245 #define SEND_GSTS(p,b,c,d)         sendcmd(p,PARM|RESP,GSTS,BYTE3(c)|BYTE2(b),RET(d))
 246 #define SEND_NGPOS(p,b,c,d)        sendcmd(p,PARM|RESP,NGPOS,BYTE3(c)|BYTE2(b),RET(d))
 247 #define SEND_PSEL(p,b,c)           sendcmd(p,PARM,PSEL,BYTE2(b)|BYTE3(c),RET(0))        /* activate lbus path */
 248 #define SEND_PCLR(p,b,c)           sendcmd(p,PARM,PCLR,BYTE2(b)|BYTE3(c),RET(0))        /* deactivate lbus path */
 249 #define SEND_PLST(p,b)             sendcmd(p,PARM,PLST,BYTE3(b),RET(0))
 250 #define SEND_RSSV(p,b,c,d)         sendcmd(p,PARM|RESP,RSSV,BYTE2(b)|BYTE3(c),RET(d))
 251 #define SEND_LSEL(p,b,c,d,e,f,g,h) sendcmd(p,PARM,LSEL|BYTE1(b)|BYTE2(c)|BYTE3(d),BYTE0(e)|BYTE1(f)|BYTE2(g)|BYTE3(h),RET(0))   /* select paths for internal connections */
 252 #define SEND_SSRC(p,b,c,d,e)       sendcmd(p,PARM,SSRC|BYTE1(b)|WORD2(c),WORD0(d)|WORD2(e),RET(0))      /* configure source */
 253 #define SEND_SLST(p,b)             sendcmd(p,PARM,SLST,BYTE3(b),RET(0))
 254 #define SEND_RSRC(p,b,c)           sendcmd(p,RESP,RSRC|BYTE1(b),0,RET(c))       /* read source config */
 255 #define SEND_SSRB(p,b,c)           sendcmd(p,PARM,SSRB|BYTE1(b),WORD2(c),RET(0))
 256 #define SEND_SDGV(p,b,c,d,e)       sendcmd(p,PARM,SDGV|BYTE2(b)|BYTE3(c),WORD0(d)|WORD2(e),RET(0))      /* set digital mixer */
 257 #define SEND_RDGV(p,b,c,d)         sendcmd(p,PARM|RESP,RDGV|BYTE2(b)|BYTE3(c),0,RET(d)) /* read digital mixer */
 258 #define SEND_DLST(p,b)             sendcmd(p,PARM,DLST,BYTE3(b),RET(0))
 259 #define SEND_SACR(p,b,c)           sendcmd(p,PARM,SACR,WORD0(b)|WORD2(c),RET(0))        /* set AC97 register */
 260 #define SEND_RACR(p,b,c)           sendcmd(p,PARM|RESP,RACR,WORD2(b),RET(c))    /* get AC97 register */
 261 #define SEND_ALST(p,b)             sendcmd(p,PARM,ALST,BYTE3(b),RET(0))
 262 #define SEND_TXAC(p,b,c,d,e,f)     sendcmd(p,PARM,TXAC|BYTE1(b)|WORD2(c),WORD0(d)|BYTE2(e)|BYTE3(f),RET(0))
 263 #define SEND_RXAC(p,b,c,d)         sendcmd(p,PARM|RESP,RXAC,BYTE2(b)|BYTE3(c),RET(d))
 264 #define SEND_SI2S(p,b)             sendcmd(p,PARM,SI2S,WORD2(b),RET(0))
 265 
 266 #define EOB_STATUS         0x80000000   /* status flags : block boundary */
 267 #define EOS_STATUS         0x40000000   /*              : stoppped */
 268 #define EOC_STATUS         0x20000000   /*              : stream end */
 269 #define ERR_STATUS         0x10000000
 270 #define EMPTY_STATUS       0x08000000
 271 
 272 #define IEOB_ENABLE        0x1  /* enable interrupts for status notification above */
 273 #define IEOS_ENABLE        0x2
 274 #define IEOC_ENABLE        0x4
 275 #define RDONCE             0x8
 276 #define DESC_MAX_MASK      0xff
 277 
 278 #define ST_PLAY  0x1            /* stream states */
 279 #define ST_STOP  0x2
 280 #define ST_PAUSE 0x4
 281 
 282 #define I2S_INTDEC     3        /* config for I2S link */
 283 #define I2S_MERGER     0
 284 #define I2S_SPLITTER   0
 285 #define I2S_MIXER      7
 286 #define I2S_RATE       44100
 287 
 288 #define MODEM_INTDEC   4        /* config for modem link */
 289 #define MODEM_MERGER   3
 290 #define MODEM_SPLITTER 0
 291 #define MODEM_MIXER    11
 292 
 293 #define FM_INTDEC      3        /* config for FM/OPL3 link */
 294 #define FM_MERGER      0
 295 #define FM_SPLITTER    0
 296 #define FM_MIXER       9
 297 
 298 #define SPLIT_PATH  0x80        /* path splitting flag */
 299 
 300 enum FIRMWARE {
 301         DATA_REC = 0, EXT_END_OF_FILE, EXT_SEG_ADDR_REC, EXT_GOTO_CMD_REC,
 302         EXT_LIN_ADDR_REC,
 303 };
 304 
 305 enum CMDS {
 306         GETV = 0x00, GETC, GUNS, SCID, RMEM =
 307             0x10, SMEM, WMEM, SDTM, GOTO, SSTR =
 308             0x20, PSTR, KSTR, KDMA, GPOS, SETF, GSTS, NGPOS, PSEL =
 309             0x30, PCLR, PLST, RSSV, LSEL, SSRC = 0x40, SLST, RSRC, SSRB, SDGV =
 310             0x50, RDGV, DLST, SACR = 0x60, RACR, ALST, TXAC, RXAC, SI2S =
 311             0x70, ARM_SETDPLL = 0x72,
 312 };
 313 
 314 enum E1SOURCE {
 315         ARM2LBUS_FIFO0 = 0, ARM2LBUS_FIFO1, ARM2LBUS_FIFO2, ARM2LBUS_FIFO3,
 316         ARM2LBUS_FIFO4, ARM2LBUS_FIFO5, ARM2LBUS_FIFO6, ARM2LBUS_FIFO7,
 317         ARM2LBUS_FIFO8, ARM2LBUS_FIFO9, ARM2LBUS_FIFO10, ARM2LBUS_FIFO11,
 318         ARM2LBUS_FIFO12, ARM2LBUS_FIFO13, ARM2LBUS_FIFO14, ARM2LBUS_FIFO15,
 319         INTER0_OUT, INTER1_OUT, INTER2_OUT, INTER3_OUT, INTER4_OUT,
 320         INTERM0_OUT, INTERM1_OUT, INTERM2_OUT, INTERM3_OUT, INTERM4_OUT,
 321         INTERM5_OUT, INTERM6_OUT, DECIMM0_OUT, DECIMM1_OUT, DECIMM2_OUT,
 322         DECIMM3_OUT, DECIM0_OUT, SR3_4_OUT, OPL3_SAMPLE, ASRC0, ASRC1,
 323         ACLNK2PADC, ACLNK2MODEM0RX, ACLNK2MIC, ACLNK2MODEM1RX, ACLNK2HNDMIC,
 324         DIGITAL_MIXER_OUT0, GAINFUNC0_OUT, GAINFUNC1_OUT, GAINFUNC2_OUT,
 325         GAINFUNC3_OUT, GAINFUNC4_OUT, SOFTMODEMTX, SPLITTER0_OUTL,
 326         SPLITTER0_OUTR, SPLITTER1_OUTL, SPLITTER1_OUTR, SPLITTER2_OUTL,
 327         SPLITTER2_OUTR, SPLITTER3_OUTL, SPLITTER3_OUTR, MERGER0_OUT,
 328         MERGER1_OUT, MERGER2_OUT, MERGER3_OUT, ARM2LBUS_FIFO_DIRECT, NO_OUT
 329 };
 330 
 331 enum E2SINK {
 332         LBUS2ARM_FIFO0 = 0, LBUS2ARM_FIFO1, LBUS2ARM_FIFO2, LBUS2ARM_FIFO3,
 333         LBUS2ARM_FIFO4, LBUS2ARM_FIFO5, LBUS2ARM_FIFO6, LBUS2ARM_FIFO7,
 334         INTER0_IN, INTER1_IN, INTER2_IN, INTER3_IN, INTER4_IN, INTERM0_IN,
 335         INTERM1_IN, INTERM2_IN, INTERM3_IN, INTERM4_IN, INTERM5_IN, INTERM6_IN,
 336         DECIMM0_IN, DECIMM1_IN, DECIMM2_IN, DECIMM3_IN, DECIM0_IN, SR3_4_IN,
 337         PDAC2ACLNK, MODEM0TX2ACLNK, MODEM1TX2ACLNK, HNDSPK2ACLNK,
 338         DIGITAL_MIXER_IN0, DIGITAL_MIXER_IN1, DIGITAL_MIXER_IN2,
 339         DIGITAL_MIXER_IN3, DIGITAL_MIXER_IN4, DIGITAL_MIXER_IN5,
 340         DIGITAL_MIXER_IN6, DIGITAL_MIXER_IN7, DIGITAL_MIXER_IN8,
 341         DIGITAL_MIXER_IN9, DIGITAL_MIXER_IN10, DIGITAL_MIXER_IN11,
 342         GAINFUNC0_IN, GAINFUNC1_IN, GAINFUNC2_IN, GAINFUNC3_IN, GAINFUNC4_IN,
 343         SOFTMODEMRX, SPLITTER0_IN, SPLITTER1_IN, SPLITTER2_IN, SPLITTER3_IN,
 344         MERGER0_INL, MERGER0_INR, MERGER1_INL, MERGER1_INR, MERGER2_INL,
 345         MERGER2_INR, MERGER3_INL, MERGER3_INR, E2SINK_MAX
 346 };
 347 
 348 enum LBUS_SINK {
 349         LS_SRC_INTERPOLATOR = 0, LS_SRC_INTERPOLATORM, LS_SRC_DECIMATOR,
 350         LS_SRC_DECIMATORM, LS_MIXER_IN, LS_MIXER_GAIN_FUNCTION,
 351         LS_SRC_SPLITTER, LS_SRC_MERGER, LS_NONE1, LS_NONE2,
 352 };
 353 
 354 enum RT_CHANNEL_IDS {
 355         M0TX = 0, M1TX, TAMTX, HSSPKR, PDAC, DSNDTX0, DSNDTX1, DSNDTX2,
 356         DSNDTX3, DSNDTX4, DSNDTX5, DSNDTX6, DSNDTX7, WVSTRTX, COP3DTX, SPARE,
 357         M0RX, HSMIC, M1RX, CLEANRX, MICADC, PADC, COPRX1, COPRX2,
 358         CHANNEL_ID_COUNTER
 359 };
 360 
 361 enum { SB_CMD = 0, MODEM_CMD, I2S_CMD0, I2S_CMD1, FM_CMD, MAX_CMD };
 362 
 363 struct lbuspath {
 364         unsigned char *noconv;
 365         unsigned char *stereo;
 366         unsigned char *mono;
 367 };
 368 
 369 struct cmdport {
 370         u32 data1;              /* cmd,param */
 371         u32 data2;              /* param */
 372         u32 stat;               /* status */
 373         u32 pad[5];
 374 };
 375 
 376 struct riptideport {
 377         u32 audio_control;      /* status registers */
 378         u32 audio_status;
 379         u32 pad[2];
 380         struct cmdport port[2]; /* command ports */
 381 };
 382 
 383 struct cmdif {
 384         struct riptideport *hwport;
 385         spinlock_t lock;
 386         unsigned int cmdcnt;    /* cmd statistics */
 387         unsigned int cmdtime;
 388         unsigned int cmdtimemax;
 389         unsigned int cmdtimemin;
 390         unsigned int errcnt;
 391         int is_reset;
 392 };
 393 
 394 struct riptide_firmware {
 395         u16 ASIC;
 396         u16 CODEC;
 397         u16 AUXDSP;
 398         u16 PROG;
 399 };
 400 
 401 union cmdret {
 402         u8 retbytes[8];
 403         u16 retwords[4];
 404         u32 retlongs[2];
 405 };
 406 
 407 union firmware_version {
 408         union cmdret ret;
 409         struct riptide_firmware firmware;
 410 };
 411 
 412 #define get_pcmhwdev(substream) (struct pcmhw *)(substream->runtime->private_data)
 413 
 414 #define PLAYBACK_SUBSTREAMS 3
 415 struct snd_riptide {
 416         struct snd_card *card;
 417         struct pci_dev *pci;
 418         const struct firmware *fw_entry;
 419 
 420         struct cmdif *cif;
 421 
 422         struct snd_pcm *pcm;
 423         struct snd_pcm *pcm_i2s;
 424         struct snd_rawmidi *rmidi;
 425         struct snd_opl3 *opl3;
 426         struct snd_ac97 *ac97;
 427         struct snd_ac97_bus *ac97_bus;
 428 
 429         struct snd_pcm_substream *playback_substream[PLAYBACK_SUBSTREAMS];
 430         struct snd_pcm_substream *capture_substream;
 431 
 432         int openstreams;
 433 
 434         int irq;
 435         unsigned long port;
 436         unsigned short mpuaddr;
 437         unsigned short opladdr;
 438 #ifdef SUPPORT_JOYSTICK
 439         unsigned short gameaddr;
 440 #endif
 441         struct resource *res_port;
 442 
 443         unsigned short device_id;
 444 
 445         union firmware_version firmware;
 446 
 447         spinlock_t lock;
 448         struct tasklet_struct riptide_tq;
 449         struct snd_info_entry *proc_entry;
 450 
 451         unsigned long received_irqs;
 452         unsigned long handled_irqs;
 453 #ifdef CONFIG_PM_SLEEP
 454         int in_suspend;
 455 #endif
 456 };
 457 
 458 struct sgd {                    /* scatter gather desriptor */
 459         __le32 dwNextLink;
 460         __le32 dwSegPtrPhys;
 461         __le32 dwSegLen;
 462         __le32 dwStat_Ctl;
 463 };
 464 
 465 struct pcmhw {                  /* pcm descriptor */
 466         struct lbuspath paths;
 467         unsigned char *lbuspath;
 468         unsigned char source;
 469         unsigned char intdec[2];
 470         unsigned char mixer;
 471         unsigned char id;
 472         unsigned char state;
 473         unsigned int rate;
 474         unsigned int channels;
 475         snd_pcm_format_t format;
 476         struct snd_dma_buffer sgdlist;
 477         struct sgd *sgdbuf;
 478         unsigned int size;
 479         unsigned int pages;
 480         unsigned int oldpos;
 481         unsigned int pointer;
 482 };
 483 
 484 #define CMDRET_ZERO (union cmdret){{(u32)0, (u32) 0}}
 485 
 486 static int sendcmd(struct cmdif *cif, u32 flags, u32 cmd, u32 parm,
 487                    union cmdret *ret);
 488 static int getsourcesink(struct cmdif *cif, unsigned char source,
 489                          unsigned char sink, unsigned char *a,
 490                          unsigned char *b);
 491 static int snd_riptide_initialize(struct snd_riptide *chip);
 492 static int riptide_reset(struct cmdif *cif, struct snd_riptide *chip);
 493 
 494 /*
 495  */
 496 
 497 static const struct pci_device_id snd_riptide_ids[] = {
 498         { PCI_DEVICE(0x127a, 0x4310) },
 499         { PCI_DEVICE(0x127a, 0x4320) },
 500         { PCI_DEVICE(0x127a, 0x4330) },
 501         { PCI_DEVICE(0x127a, 0x4340) },
 502         {0,},
 503 };
 504 
 505 #ifdef SUPPORT_JOYSTICK
 506 static const struct pci_device_id snd_riptide_joystick_ids[] = {
 507         { PCI_DEVICE(0x127a, 0x4312) },
 508         { PCI_DEVICE(0x127a, 0x4322) },
 509         { PCI_DEVICE(0x127a, 0x4332) },
 510         { PCI_DEVICE(0x127a, 0x4342) },
 511         {0,},
 512 };
 513 #endif
 514 
 515 MODULE_DEVICE_TABLE(pci, snd_riptide_ids);
 516 
 517 /*
 518  */
 519 
 520 static unsigned char lbusin2out[E2SINK_MAX + 1][2] = {
 521         {NO_OUT, LS_NONE1}, {NO_OUT, LS_NONE2}, {NO_OUT, LS_NONE1}, {NO_OUT,
 522                                                                      LS_NONE2},
 523         {NO_OUT, LS_NONE1}, {NO_OUT, LS_NONE2}, {NO_OUT, LS_NONE1}, {NO_OUT,
 524                                                                      LS_NONE2},
 525         {INTER0_OUT, LS_SRC_INTERPOLATOR}, {INTER1_OUT, LS_SRC_INTERPOLATOR},
 526         {INTER2_OUT, LS_SRC_INTERPOLATOR}, {INTER3_OUT, LS_SRC_INTERPOLATOR},
 527         {INTER4_OUT, LS_SRC_INTERPOLATOR}, {INTERM0_OUT, LS_SRC_INTERPOLATORM},
 528         {INTERM1_OUT, LS_SRC_INTERPOLATORM}, {INTERM2_OUT,
 529                                               LS_SRC_INTERPOLATORM},
 530         {INTERM3_OUT, LS_SRC_INTERPOLATORM}, {INTERM4_OUT,
 531                                               LS_SRC_INTERPOLATORM},
 532         {INTERM5_OUT, LS_SRC_INTERPOLATORM}, {INTERM6_OUT,
 533                                               LS_SRC_INTERPOLATORM},
 534         {DECIMM0_OUT, LS_SRC_DECIMATORM}, {DECIMM1_OUT, LS_SRC_DECIMATORM},
 535         {DECIMM2_OUT, LS_SRC_DECIMATORM}, {DECIMM3_OUT, LS_SRC_DECIMATORM},
 536         {DECIM0_OUT, LS_SRC_DECIMATOR}, {SR3_4_OUT, LS_NONE1}, {NO_OUT,
 537                                                                 LS_NONE2},
 538         {NO_OUT, LS_NONE1}, {NO_OUT, LS_NONE2}, {NO_OUT, LS_NONE1},
 539         {DIGITAL_MIXER_OUT0, LS_MIXER_IN}, {DIGITAL_MIXER_OUT0, LS_MIXER_IN},
 540         {DIGITAL_MIXER_OUT0, LS_MIXER_IN}, {DIGITAL_MIXER_OUT0, LS_MIXER_IN},
 541         {DIGITAL_MIXER_OUT0, LS_MIXER_IN}, {DIGITAL_MIXER_OUT0, LS_MIXER_IN},
 542         {DIGITAL_MIXER_OUT0, LS_MIXER_IN}, {DIGITAL_MIXER_OUT0, LS_MIXER_IN},
 543         {DIGITAL_MIXER_OUT0, LS_MIXER_IN}, {DIGITAL_MIXER_OUT0, LS_MIXER_IN},
 544         {DIGITAL_MIXER_OUT0, LS_MIXER_IN}, {DIGITAL_MIXER_OUT0, LS_MIXER_IN},
 545         {GAINFUNC0_OUT, LS_MIXER_GAIN_FUNCTION}, {GAINFUNC1_OUT,
 546                                                   LS_MIXER_GAIN_FUNCTION},
 547         {GAINFUNC2_OUT, LS_MIXER_GAIN_FUNCTION}, {GAINFUNC3_OUT,
 548                                                   LS_MIXER_GAIN_FUNCTION},
 549         {GAINFUNC4_OUT, LS_MIXER_GAIN_FUNCTION}, {SOFTMODEMTX, LS_NONE1},
 550         {SPLITTER0_OUTL, LS_SRC_SPLITTER}, {SPLITTER1_OUTL, LS_SRC_SPLITTER},
 551         {SPLITTER2_OUTL, LS_SRC_SPLITTER}, {SPLITTER3_OUTL, LS_SRC_SPLITTER},
 552         {MERGER0_OUT, LS_SRC_MERGER}, {MERGER0_OUT, LS_SRC_MERGER},
 553         {MERGER1_OUT, LS_SRC_MERGER},
 554         {MERGER1_OUT, LS_SRC_MERGER}, {MERGER2_OUT, LS_SRC_MERGER},
 555         {MERGER2_OUT, LS_SRC_MERGER},
 556         {MERGER3_OUT, LS_SRC_MERGER}, {MERGER3_OUT, LS_SRC_MERGER}, {NO_OUT,
 557                                                                      LS_NONE2},
 558 };
 559 
 560 static unsigned char lbus_play_opl3[] = {
 561         DIGITAL_MIXER_IN0 + FM_MIXER, 0xff
 562 };
 563 static unsigned char lbus_play_modem[] = {
 564         DIGITAL_MIXER_IN0 + MODEM_MIXER, 0xff
 565 };
 566 static unsigned char lbus_play_i2s[] = {
 567         INTER0_IN + I2S_INTDEC, DIGITAL_MIXER_IN0 + I2S_MIXER, 0xff
 568 };
 569 static unsigned char lbus_play_out[] = {
 570         PDAC2ACLNK, 0xff
 571 };
 572 static unsigned char lbus_play_outhp[] = {
 573         HNDSPK2ACLNK, 0xff
 574 };
 575 static unsigned char lbus_play_noconv1[] = {
 576         DIGITAL_MIXER_IN0, 0xff
 577 };
 578 static unsigned char lbus_play_stereo1[] = {
 579         INTER0_IN, DIGITAL_MIXER_IN0, 0xff
 580 };
 581 static unsigned char lbus_play_mono1[] = {
 582         INTERM0_IN, DIGITAL_MIXER_IN0, 0xff
 583 };
 584 static unsigned char lbus_play_noconv2[] = {
 585         DIGITAL_MIXER_IN1, 0xff
 586 };
 587 static unsigned char lbus_play_stereo2[] = {
 588         INTER1_IN, DIGITAL_MIXER_IN1, 0xff
 589 };
 590 static unsigned char lbus_play_mono2[] = {
 591         INTERM1_IN, DIGITAL_MIXER_IN1, 0xff
 592 };
 593 static unsigned char lbus_play_noconv3[] = {
 594         DIGITAL_MIXER_IN2, 0xff
 595 };
 596 static unsigned char lbus_play_stereo3[] = {
 597         INTER2_IN, DIGITAL_MIXER_IN2, 0xff
 598 };
 599 static unsigned char lbus_play_mono3[] = {
 600         INTERM2_IN, DIGITAL_MIXER_IN2, 0xff
 601 };
 602 static unsigned char lbus_rec_noconv1[] = {
 603         LBUS2ARM_FIFO5, 0xff
 604 };
 605 static unsigned char lbus_rec_stereo1[] = {
 606         DECIM0_IN, LBUS2ARM_FIFO5, 0xff
 607 };
 608 static unsigned char lbus_rec_mono1[] = {
 609         DECIMM3_IN, LBUS2ARM_FIFO5, 0xff
 610 };
 611 
 612 static unsigned char play_ids[] = { 4, 1, 2, };
 613 static unsigned char play_sources[] = {
 614         ARM2LBUS_FIFO4, ARM2LBUS_FIFO1, ARM2LBUS_FIFO2,
 615 };
 616 static struct lbuspath lbus_play_paths[] = {
 617         {
 618          .noconv = lbus_play_noconv1,
 619          .stereo = lbus_play_stereo1,
 620          .mono = lbus_play_mono1,
 621          },
 622         {
 623          .noconv = lbus_play_noconv2,
 624          .stereo = lbus_play_stereo2,
 625          .mono = lbus_play_mono2,
 626          },
 627         {
 628          .noconv = lbus_play_noconv3,
 629          .stereo = lbus_play_stereo3,
 630          .mono = lbus_play_mono3,
 631          },
 632 };
 633 static const struct lbuspath lbus_rec_path = {
 634         .noconv = lbus_rec_noconv1,
 635         .stereo = lbus_rec_stereo1,
 636         .mono = lbus_rec_mono1,
 637 };
 638 
 639 #define FIRMWARE_VERSIONS 1
 640 static union firmware_version firmware_versions[] = {
 641         {
 642                 .firmware = {
 643                         .ASIC = 3,
 644                         .CODEC = 2,
 645                         .AUXDSP = 3,
 646                         .PROG = 773,
 647                 },
 648         },
 649 };
 650 
 651 static u32 atoh(const unsigned char *in, unsigned int len)
 652 {
 653         u32 sum = 0;
 654         unsigned int mult = 1;
 655         unsigned char c;
 656 
 657         while (len) {
 658                 int value;
 659 
 660                 c = in[len - 1];
 661                 value = hex_to_bin(c);
 662                 if (value >= 0)
 663                         sum += mult * value;
 664                 mult *= 16;
 665                 --len;
 666         }
 667         return sum;
 668 }
 669 
 670 static int senddata(struct cmdif *cif, const unsigned char *in, u32 offset)
 671 {
 672         u32 addr;
 673         u32 data;
 674         u32 i;
 675         const unsigned char *p;
 676 
 677         i = atoh(&in[1], 2);
 678         addr = offset + atoh(&in[3], 4);
 679         if (SEND_SMEM(cif, 0, addr) != 0)
 680                 return -EACCES;
 681         p = in + 9;
 682         while (i) {
 683                 data = atoh(p, 8);
 684                 if (SEND_WMEM(cif, 2,
 685                               ((data & 0x0f0f0f0f) << 4) | ((data & 0xf0f0f0f0)
 686                                                             >> 4)))
 687                         return -EACCES;
 688                 i -= 4;
 689                 p += 8;
 690         }
 691         return 0;
 692 }
 693 
 694 static int loadfirmware(struct cmdif *cif, const unsigned char *img,
 695                         unsigned int size)
 696 {
 697         const unsigned char *in;
 698         u32 laddr, saddr, t, val;
 699         int err = 0;
 700 
 701         laddr = saddr = 0;
 702         while (size > 0 && err == 0) {
 703                 in = img;
 704                 if (in[0] == ':') {
 705                         t = atoh(&in[7], 2);
 706                         switch (t) {
 707                         case DATA_REC:
 708                                 err = senddata(cif, in, laddr + saddr);
 709                                 break;
 710                         case EXT_SEG_ADDR_REC:
 711                                 saddr = atoh(&in[9], 4) << 4;
 712                                 break;
 713                         case EXT_LIN_ADDR_REC:
 714                                 laddr = atoh(&in[9], 4) << 16;
 715                                 break;
 716                         case EXT_GOTO_CMD_REC:
 717                                 val = atoh(&in[9], 8);
 718                                 if (SEND_GOTO(cif, val) != 0)
 719                                         err = -EACCES;
 720                                 break;
 721                         case EXT_END_OF_FILE:
 722                                 size = 0;
 723                                 break;
 724                         default:
 725                                 break;
 726                         }
 727                         while (size > 0) {
 728                                 size--;
 729                                 if (*img++ == '\n')
 730                                         break;
 731                         }
 732                 }
 733         }
 734         snd_printdd("load firmware return %d\n", err);
 735         return err;
 736 }
 737 
 738 static void
 739 alloclbuspath(struct cmdif *cif, unsigned char source,
 740               unsigned char *path, unsigned char *mixer, unsigned char *s)
 741 {
 742         while (*path != 0xff) {
 743                 unsigned char sink, type;
 744 
 745                 sink = *path & (~SPLIT_PATH);
 746                 if (sink != E2SINK_MAX) {
 747                         snd_printdd("alloc path 0x%x->0x%x\n", source, sink);
 748                         SEND_PSEL(cif, source, sink);
 749                         source = lbusin2out[sink][0];
 750                         type = lbusin2out[sink][1];
 751                         if (type == LS_MIXER_IN) {
 752                                 if (mixer)
 753                                         *mixer = sink - DIGITAL_MIXER_IN0;
 754                         }
 755                         if (type == LS_SRC_DECIMATORM ||
 756                             type == LS_SRC_DECIMATOR ||
 757                             type == LS_SRC_INTERPOLATORM ||
 758                             type == LS_SRC_INTERPOLATOR) {
 759                                 if (s) {
 760                                         if (s[0] != 0xff)
 761                                                 s[1] = sink;
 762                                         else
 763                                                 s[0] = sink;
 764                                 }
 765                         }
 766                 }
 767                 if (*path++ & SPLIT_PATH) {
 768                         unsigned char *npath = path;
 769 
 770                         while (*npath != 0xff)
 771                                 npath++;
 772                         alloclbuspath(cif, source + 1, ++npath, mixer, s);
 773                 }
 774         }
 775 }
 776 
 777 static void
 778 freelbuspath(struct cmdif *cif, unsigned char source, unsigned char *path)
 779 {
 780         while (*path != 0xff) {
 781                 unsigned char sink;
 782 
 783                 sink = *path & (~SPLIT_PATH);
 784                 if (sink != E2SINK_MAX) {
 785                         snd_printdd("free path 0x%x->0x%x\n", source, sink);
 786                         SEND_PCLR(cif, source, sink);
 787                         source = lbusin2out[sink][0];
 788                 }
 789                 if (*path++ & SPLIT_PATH) {
 790                         unsigned char *npath = path;
 791 
 792                         while (*npath != 0xff)
 793                                 npath++;
 794                         freelbuspath(cif, source + 1, ++npath);
 795                 }
 796         }
 797 }
 798 
 799 static int writearm(struct cmdif *cif, u32 addr, u32 data, u32 mask)
 800 {
 801         union cmdret rptr = CMDRET_ZERO;
 802         unsigned int i = MAX_WRITE_RETRY;
 803         int flag = 1;
 804 
 805         SEND_RMEM(cif, 0x02, addr, &rptr);
 806         rptr.retlongs[0] &= (~mask);
 807 
 808         while (--i) {
 809                 SEND_SMEM(cif, 0x01, addr);
 810                 SEND_WMEM(cif, 0x02, (rptr.retlongs[0] | data));
 811                 SEND_RMEM(cif, 0x02, addr, &rptr);
 812                 if ((rptr.retlongs[0] & data) == data) {
 813                         flag = 0;
 814                         break;
 815                 } else
 816                         rptr.retlongs[0] &= ~mask;
 817         }
 818         snd_printdd("send arm 0x%x 0x%x 0x%x return %d\n", addr, data, mask,
 819                     flag);
 820         return flag;
 821 }
 822 
 823 static int sendcmd(struct cmdif *cif, u32 flags, u32 cmd, u32 parm,
 824                    union cmdret *ret)
 825 {
 826         int i, j;
 827         int err;
 828         unsigned int time = 0;
 829         unsigned long irqflags;
 830         struct riptideport *hwport;
 831         struct cmdport *cmdport = NULL;
 832 
 833         if (snd_BUG_ON(!cif))
 834                 return -EINVAL;
 835 
 836         hwport = cif->hwport;
 837         if (cif->errcnt > MAX_ERROR_COUNT) {
 838                 if (cif->is_reset) {
 839                         snd_printk(KERN_ERR
 840                                    "Riptide: Too many failed cmds, reinitializing\n");
 841                         if (riptide_reset(cif, NULL) == 0) {
 842                                 cif->errcnt = 0;
 843                                 return -EIO;
 844                         }
 845                 }
 846                 snd_printk(KERN_ERR "Riptide: Initialization failed.\n");
 847                 return -EINVAL;
 848         }
 849         if (ret) {
 850                 ret->retlongs[0] = 0;
 851                 ret->retlongs[1] = 0;
 852         }
 853         i = 0;
 854         spin_lock_irqsave(&cif->lock, irqflags);
 855         while (i++ < CMDIF_TIMEOUT && !IS_READY(cif->hwport))
 856                 udelay(10);
 857         if (i > CMDIF_TIMEOUT) {
 858                 err = -EBUSY;
 859                 goto errout;
 860         }
 861 
 862         err = 0;
 863         for (j = 0, time = 0; time < CMDIF_TIMEOUT; j++, time += 2) {
 864                 cmdport = &(hwport->port[j % 2]);
 865                 if (IS_DATF(cmdport)) { /* free pending data */
 866                         READ_PORT_ULONG(cmdport->data1);
 867                         READ_PORT_ULONG(cmdport->data2);
 868                 }
 869                 if (IS_CMDE(cmdport)) {
 870                         if (flags & PARM)       /* put data */
 871                                 WRITE_PORT_ULONG(cmdport->data2, parm);
 872                         WRITE_PORT_ULONG(cmdport->data1, cmd);  /* write cmd */
 873                         if ((flags & RESP) && ret) {
 874                                 while (!IS_DATF(cmdport) &&
 875                                        time < CMDIF_TIMEOUT) {
 876                                         udelay(10);
 877                                         time++;
 878                                 }
 879                                 if (time < CMDIF_TIMEOUT) {     /* read response */
 880                                         ret->retlongs[0] =
 881                                             READ_PORT_ULONG(cmdport->data1);
 882                                         ret->retlongs[1] =
 883                                             READ_PORT_ULONG(cmdport->data2);
 884                                 } else {
 885                                         err = -ENOSYS;
 886                                         goto errout;
 887                                 }
 888                         }
 889                         break;
 890                 }
 891                 udelay(20);
 892         }
 893         if (time == CMDIF_TIMEOUT) {
 894                 err = -ENODATA;
 895                 goto errout;
 896         }
 897         spin_unlock_irqrestore(&cif->lock, irqflags);
 898 
 899         cif->cmdcnt++;          /* update command statistics */
 900         cif->cmdtime += time;
 901         if (time > cif->cmdtimemax)
 902                 cif->cmdtimemax = time;
 903         if (time < cif->cmdtimemin)
 904                 cif->cmdtimemin = time;
 905         if ((cif->cmdcnt) % 1000 == 0)
 906                 snd_printdd
 907                     ("send cmd %d time: %d mintime: %d maxtime %d err: %d\n",
 908                      cif->cmdcnt, cif->cmdtime, cif->cmdtimemin,
 909                      cif->cmdtimemax, cif->errcnt);
 910         return 0;
 911 
 912       errout:
 913         cif->errcnt++;
 914         spin_unlock_irqrestore(&cif->lock, irqflags);
 915         snd_printdd
 916             ("send cmd %d hw: 0x%x flag: 0x%x cmd: 0x%x parm: 0x%x ret: 0x%x 0x%x CMDE: %d DATF: %d failed %d\n",
 917              cif->cmdcnt, (int)((void *)&(cmdport->stat) - (void *)hwport),
 918              flags, cmd, parm, ret ? ret->retlongs[0] : 0,
 919              ret ? ret->retlongs[1] : 0, IS_CMDE(cmdport), IS_DATF(cmdport),
 920              err);
 921         return err;
 922 }
 923 
 924 static int
 925 setmixer(struct cmdif *cif, short num, unsigned short rval, unsigned short lval)
 926 {
 927         union cmdret rptr = CMDRET_ZERO;
 928         int i = 0;
 929 
 930         snd_printdd("sent mixer %d: 0x%x 0x%x\n", num, rval, lval);
 931         do {
 932                 SEND_SDGV(cif, num, num, rval, lval);
 933                 SEND_RDGV(cif, num, num, &rptr);
 934                 if (rptr.retwords[0] == lval && rptr.retwords[1] == rval)
 935                         return 0;
 936         } while (i++ < MAX_WRITE_RETRY);
 937         snd_printdd("sent mixer failed\n");
 938         return -EIO;
 939 }
 940 
 941 static int getpaths(struct cmdif *cif, unsigned char *o)
 942 {
 943         unsigned char src[E2SINK_MAX];
 944         unsigned char sink[E2SINK_MAX];
 945         int i, j = 0;
 946 
 947         for (i = 0; i < E2SINK_MAX; i++) {
 948                 getsourcesink(cif, i, i, &src[i], &sink[i]);
 949                 if (sink[i] < E2SINK_MAX) {
 950                         o[j++] = sink[i];
 951                         o[j++] = i;
 952                 }
 953         }
 954         return j;
 955 }
 956 
 957 static int
 958 getsourcesink(struct cmdif *cif, unsigned char source, unsigned char sink,
 959               unsigned char *a, unsigned char *b)
 960 {
 961         union cmdret rptr = CMDRET_ZERO;
 962 
 963         if (SEND_RSSV(cif, source, sink, &rptr) &&
 964             SEND_RSSV(cif, source, sink, &rptr))
 965                 return -EIO;
 966         *a = rptr.retbytes[0];
 967         *b = rptr.retbytes[1];
 968         snd_printdd("getsourcesink 0x%x 0x%x\n", *a, *b);
 969         return 0;
 970 }
 971 
 972 static int
 973 getsamplerate(struct cmdif *cif, unsigned char *intdec, unsigned int *rate)
 974 {
 975         unsigned char *s;
 976         unsigned int p[2] = { 0, 0 };
 977         int i;
 978         union cmdret rptr = CMDRET_ZERO;
 979 
 980         s = intdec;
 981         for (i = 0; i < 2; i++) {
 982                 if (*s != 0xff) {
 983                         if (SEND_RSRC(cif, *s, &rptr) &&
 984                             SEND_RSRC(cif, *s, &rptr))
 985                                 return -EIO;
 986                         p[i] += rptr.retwords[1];
 987                         p[i] *= rptr.retwords[2];
 988                         p[i] += rptr.retwords[3];
 989                         p[i] /= 65536;
 990                 }
 991                 s++;
 992         }
 993         if (p[0]) {
 994                 if (p[1] != p[0])
 995                         snd_printdd("rates differ %d %d\n", p[0], p[1]);
 996                 *rate = (unsigned int)p[0];
 997         } else
 998                 *rate = (unsigned int)p[1];
 999         snd_printdd("getsampleformat %d %d %d\n", intdec[0], intdec[1], *rate);
1000         return 0;
1001 }
1002 
1003 static int
1004 setsampleformat(struct cmdif *cif,
1005                 unsigned char mixer, unsigned char id,
1006                 unsigned char channels, snd_pcm_format_t format)
1007 {
1008         unsigned char w, ch, sig, order;
1009 
1010         snd_printdd
1011             ("setsampleformat mixer: %d id: %d channels: %d format: %d\n",
1012              mixer, id, channels, format);
1013         ch = channels == 1;
1014         w = snd_pcm_format_width(format) == 8;
1015         sig = snd_pcm_format_unsigned(format) != 0;
1016         order = snd_pcm_format_big_endian(format) != 0;
1017 
1018         if (SEND_SETF(cif, mixer, w, ch, order, sig, id) &&
1019             SEND_SETF(cif, mixer, w, ch, order, sig, id)) {
1020                 snd_printdd("setsampleformat failed\n");
1021                 return -EIO;
1022         }
1023         return 0;
1024 }
1025 
1026 static int
1027 setsamplerate(struct cmdif *cif, unsigned char *intdec, unsigned int rate)
1028 {
1029         u32 D, M, N;
1030         union cmdret rptr = CMDRET_ZERO;
1031         int i;
1032 
1033         snd_printdd("setsamplerate intdec: %d,%d rate: %d\n", intdec[0],
1034                     intdec[1], rate);
1035         D = 48000;
1036         M = ((rate == 48000) ? 47999 : rate) * 65536;
1037         N = M % D;
1038         M /= D;
1039         for (i = 0; i < 2; i++) {
1040                 if (*intdec != 0xff) {
1041                         do {
1042                                 SEND_SSRC(cif, *intdec, D, M, N);
1043                                 SEND_RSRC(cif, *intdec, &rptr);
1044                         } while (rptr.retwords[1] != D &&
1045                                  rptr.retwords[2] != M &&
1046                                  rptr.retwords[3] != N &&
1047                                  i++ < MAX_WRITE_RETRY);
1048                         if (i > MAX_WRITE_RETRY) {
1049                                 snd_printdd("sent samplerate %d: %d failed\n",
1050                                             *intdec, rate);
1051                                 return -EIO;
1052                         }
1053                 }
1054                 intdec++;
1055         }
1056         return 0;
1057 }
1058 
1059 static int
1060 getmixer(struct cmdif *cif, short num, unsigned short *rval,
1061          unsigned short *lval)
1062 {
1063         union cmdret rptr = CMDRET_ZERO;
1064 
1065         if (SEND_RDGV(cif, num, num, &rptr) && SEND_RDGV(cif, num, num, &rptr))
1066                 return -EIO;
1067         *rval = rptr.retwords[0];
1068         *lval = rptr.retwords[1];
1069         snd_printdd("got mixer %d: 0x%x 0x%x\n", num, *rval, *lval);
1070         return 0;
1071 }
1072 
1073 static void riptide_handleirq(unsigned long dev_id)
1074 {
1075         struct snd_riptide *chip = (void *)dev_id;
1076         struct cmdif *cif = chip->cif;
1077         struct snd_pcm_substream *substream[PLAYBACK_SUBSTREAMS + 1];
1078         struct snd_pcm_runtime *runtime;
1079         struct pcmhw *data = NULL;
1080         unsigned int pos, period_bytes;
1081         struct sgd *c;
1082         int i, j;
1083         unsigned int flag;
1084 
1085         if (!cif)
1086                 return;
1087 
1088         for (i = 0; i < PLAYBACK_SUBSTREAMS; i++)
1089                 substream[i] = chip->playback_substream[i];
1090         substream[i] = chip->capture_substream;
1091         for (i = 0; i < PLAYBACK_SUBSTREAMS + 1; i++) {
1092                 if (substream[i] &&
1093                     (runtime = substream[i]->runtime) &&
1094                     (data = runtime->private_data) && data->state != ST_STOP) {
1095                         pos = 0;
1096                         for (j = 0; j < data->pages; j++) {
1097                                 c = &data->sgdbuf[j];
1098                                 flag = le32_to_cpu(c->dwStat_Ctl);
1099                                 if (flag & EOB_STATUS)
1100                                         pos += le32_to_cpu(c->dwSegLen);
1101                                 if (flag & EOC_STATUS)
1102                                         pos += le32_to_cpu(c->dwSegLen);
1103                                 if ((flag & EOS_STATUS)
1104                                     && (data->state == ST_PLAY)) {
1105                                         data->state = ST_STOP;
1106                                         snd_printk(KERN_ERR
1107                                                    "Riptide: DMA stopped unexpectedly\n");
1108                                 }
1109                                 c->dwStat_Ctl =
1110                                     cpu_to_le32(flag &
1111                                                 ~(EOS_STATUS | EOB_STATUS |
1112                                                   EOC_STATUS));
1113                         }
1114                         data->pointer += pos;
1115                         pos += data->oldpos;
1116                         if (data->state != ST_STOP) {
1117                                 period_bytes =
1118                                     frames_to_bytes(runtime,
1119                                                     runtime->period_size);
1120                                 snd_printdd
1121                                     ("interrupt 0x%x after 0x%lx of 0x%lx frames in period\n",
1122                                      READ_AUDIO_STATUS(cif->hwport),
1123                                      bytes_to_frames(runtime, pos),
1124                                      runtime->period_size);
1125                                 j = 0;
1126                                 if (pos >= period_bytes) {
1127                                         j++;
1128                                         while (pos >= period_bytes)
1129                                                 pos -= period_bytes;
1130                                 }
1131                                 data->oldpos = pos;
1132                                 if (j > 0)
1133                                         snd_pcm_period_elapsed(substream[i]);
1134                         }
1135                 }
1136         }
1137 }
1138 
1139 #ifdef CONFIG_PM_SLEEP
1140 static int riptide_suspend(struct device *dev)
1141 {
1142         struct snd_card *card = dev_get_drvdata(dev);
1143         struct snd_riptide *chip = card->private_data;
1144 
1145         chip->in_suspend = 1;
1146         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1147         snd_ac97_suspend(chip->ac97);
1148         return 0;
1149 }
1150 
1151 static int riptide_resume(struct device *dev)
1152 {
1153         struct snd_card *card = dev_get_drvdata(dev);
1154         struct snd_riptide *chip = card->private_data;
1155 
1156         snd_riptide_initialize(chip);
1157         snd_ac97_resume(chip->ac97);
1158         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1159         chip->in_suspend = 0;
1160         return 0;
1161 }
1162 
1163 static SIMPLE_DEV_PM_OPS(riptide_pm, riptide_suspend, riptide_resume);
1164 #define RIPTIDE_PM_OPS  &riptide_pm
1165 #else
1166 #define RIPTIDE_PM_OPS  NULL
1167 #endif /* CONFIG_PM_SLEEP */
1168 
1169 static int try_to_load_firmware(struct cmdif *cif, struct snd_riptide *chip)
1170 {
1171         union firmware_version firmware = { .ret = CMDRET_ZERO };
1172         int i, timeout, err;
1173 
1174         for (i = 0; i < 2; i++) {
1175                 WRITE_PORT_ULONG(cif->hwport->port[i].data1, 0);
1176                 WRITE_PORT_ULONG(cif->hwport->port[i].data2, 0);
1177         }
1178         SET_GRESET(cif->hwport);
1179         udelay(100);
1180         UNSET_GRESET(cif->hwport);
1181         udelay(100);
1182 
1183         for (timeout = 100000; --timeout; udelay(10)) {
1184                 if (IS_READY(cif->hwport) && !IS_GERR(cif->hwport))
1185                         break;
1186         }
1187         if (!timeout) {
1188                 snd_printk(KERN_ERR
1189                            "Riptide: device not ready, audio status: 0x%x "
1190                            "ready: %d gerr: %d\n",
1191                            READ_AUDIO_STATUS(cif->hwport),
1192                            IS_READY(cif->hwport), IS_GERR(cif->hwport));
1193                 return -EIO;
1194         } else {
1195                 snd_printdd
1196                         ("Riptide: audio status: 0x%x ready: %d gerr: %d\n",
1197                          READ_AUDIO_STATUS(cif->hwport),
1198                          IS_READY(cif->hwport), IS_GERR(cif->hwport));
1199         }
1200 
1201         SEND_GETV(cif, &firmware.ret);
1202         snd_printdd("Firmware version: ASIC: %d CODEC %d AUXDSP %d PROG %d\n",
1203                     firmware.firmware.ASIC, firmware.firmware.CODEC,
1204                     firmware.firmware.AUXDSP, firmware.firmware.PROG);
1205 
1206         if (!chip)
1207                 return 1;
1208 
1209         for (i = 0; i < FIRMWARE_VERSIONS; i++) {
1210                 if (!memcmp(&firmware_versions[i], &firmware, sizeof(firmware)))
1211                         return 1; /* OK */
1212 
1213         }
1214 
1215         snd_printdd("Writing Firmware\n");
1216         if (!chip->fw_entry) {
1217                 err = request_firmware(&chip->fw_entry, "riptide.hex",
1218                                        &chip->pci->dev);
1219                 if (err) {
1220                         snd_printk(KERN_ERR
1221                                    "Riptide: Firmware not available %d\n", err);
1222                         return -EIO;
1223                 }
1224         }
1225         err = loadfirmware(cif, chip->fw_entry->data, chip->fw_entry->size);
1226         if (err) {
1227                 snd_printk(KERN_ERR
1228                            "Riptide: Could not load firmware %d\n", err);
1229                 return err;
1230         }
1231 
1232         chip->firmware = firmware;
1233 
1234         return 1; /* OK */
1235 }
1236 
1237 static int riptide_reset(struct cmdif *cif, struct snd_riptide *chip)
1238 {
1239         union cmdret rptr = CMDRET_ZERO;
1240         int err, tries;
1241 
1242         if (!cif)
1243                 return -EINVAL;
1244 
1245         cif->cmdcnt = 0;
1246         cif->cmdtime = 0;
1247         cif->cmdtimemax = 0;
1248         cif->cmdtimemin = 0xffffffff;
1249         cif->errcnt = 0;
1250         cif->is_reset = 0;
1251 
1252         tries = RESET_TRIES;
1253         do {
1254                 err = try_to_load_firmware(cif, chip);
1255                 if (err < 0)
1256                         return err;
1257         } while (!err && --tries);
1258 
1259         SEND_SACR(cif, 0, AC97_RESET);
1260         SEND_RACR(cif, AC97_RESET, &rptr);
1261         snd_printdd("AC97: 0x%x 0x%x\n", rptr.retlongs[0], rptr.retlongs[1]);
1262 
1263         SEND_PLST(cif, 0);
1264         SEND_SLST(cif, 0);
1265         SEND_DLST(cif, 0);
1266         SEND_ALST(cif, 0);
1267         SEND_KDMA(cif);
1268 
1269         writearm(cif, 0x301F8, 1, 1);
1270         writearm(cif, 0x301F4, 1, 1);
1271 
1272         SEND_LSEL(cif, MODEM_CMD, 0, 0, MODEM_INTDEC, MODEM_MERGER,
1273                   MODEM_SPLITTER, MODEM_MIXER);
1274         setmixer(cif, MODEM_MIXER, 0x7fff, 0x7fff);
1275         alloclbuspath(cif, ARM2LBUS_FIFO13, lbus_play_modem, NULL, NULL);
1276 
1277         SEND_LSEL(cif, FM_CMD, 0, 0, FM_INTDEC, FM_MERGER, FM_SPLITTER,
1278                   FM_MIXER);
1279         setmixer(cif, FM_MIXER, 0x7fff, 0x7fff);
1280         writearm(cif, 0x30648 + FM_MIXER * 4, 0x01, 0x00000005);
1281         writearm(cif, 0x301A8, 0x02, 0x00000002);
1282         writearm(cif, 0x30264, 0x08, 0xffffffff);
1283         alloclbuspath(cif, OPL3_SAMPLE, lbus_play_opl3, NULL, NULL);
1284 
1285         SEND_SSRC(cif, I2S_INTDEC, 48000,
1286                   ((u32) I2S_RATE * 65536) / 48000,
1287                   ((u32) I2S_RATE * 65536) % 48000);
1288         SEND_LSEL(cif, I2S_CMD0, 0, 0, I2S_INTDEC, I2S_MERGER, I2S_SPLITTER,
1289                   I2S_MIXER);
1290         SEND_SI2S(cif, 1);
1291         alloclbuspath(cif, ARM2LBUS_FIFO0, lbus_play_i2s, NULL, NULL);
1292         alloclbuspath(cif, DIGITAL_MIXER_OUT0, lbus_play_out, NULL, NULL);
1293         alloclbuspath(cif, DIGITAL_MIXER_OUT0, lbus_play_outhp, NULL, NULL);
1294 
1295         SET_AIACK(cif->hwport);
1296         SET_AIE(cif->hwport);
1297         SET_AIACK(cif->hwport);
1298         cif->is_reset = 1;
1299 
1300         return 0;
1301 }
1302 
1303 static const struct snd_pcm_hardware snd_riptide_playback = {
1304         .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1305                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1306                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID),
1307         .formats =
1308             SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8
1309             | SNDRV_PCM_FMTBIT_U16_LE,
1310         .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000,
1311         .rate_min = 5500,
1312         .rate_max = 48000,
1313         .channels_min = 1,
1314         .channels_max = 2,
1315         .buffer_bytes_max = (64 * 1024),
1316         .period_bytes_min = PAGE_SIZE >> 1,
1317         .period_bytes_max = PAGE_SIZE << 8,
1318         .periods_min = 2,
1319         .periods_max = 64,
1320         .fifo_size = 0,
1321 };
1322 static const struct snd_pcm_hardware snd_riptide_capture = {
1323         .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1324                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
1325                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID),
1326         .formats =
1327             SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8
1328             | SNDRV_PCM_FMTBIT_U16_LE,
1329         .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000,
1330         .rate_min = 5500,
1331         .rate_max = 48000,
1332         .channels_min = 1,
1333         .channels_max = 2,
1334         .buffer_bytes_max = (64 * 1024),
1335         .period_bytes_min = PAGE_SIZE >> 1,
1336         .period_bytes_max = PAGE_SIZE << 3,
1337         .periods_min = 2,
1338         .periods_max = 64,
1339         .fifo_size = 0,
1340 };
1341 
1342 static snd_pcm_uframes_t snd_riptide_pointer(struct snd_pcm_substream
1343                                              *substream)
1344 {
1345         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1346         struct snd_pcm_runtime *runtime = substream->runtime;
1347         struct pcmhw *data = get_pcmhwdev(substream);
1348         struct cmdif *cif = chip->cif;
1349         union cmdret rptr = CMDRET_ZERO;
1350         snd_pcm_uframes_t ret;
1351 
1352         SEND_GPOS(cif, 0, data->id, &rptr);
1353         if (data->size && runtime->period_size) {
1354                 snd_printdd
1355                     ("pointer stream %d position 0x%x(0x%x in buffer) bytes 0x%lx(0x%lx in period) frames\n",
1356                      data->id, rptr.retlongs[1], rptr.retlongs[1] % data->size,
1357                      bytes_to_frames(runtime, rptr.retlongs[1]),
1358                      bytes_to_frames(runtime,
1359                                      rptr.retlongs[1]) % runtime->period_size);
1360                 if (rptr.retlongs[1] > data->pointer)
1361                         ret =
1362                             bytes_to_frames(runtime,
1363                                             rptr.retlongs[1] % data->size);
1364                 else
1365                         ret =
1366                             bytes_to_frames(runtime,
1367                                             data->pointer % data->size);
1368         } else {
1369                 snd_printdd("stream not started or strange parms (%d %ld)\n",
1370                             data->size, runtime->period_size);
1371                 ret = bytes_to_frames(runtime, 0);
1372         }
1373         return ret;
1374 }
1375 
1376 static int snd_riptide_trigger(struct snd_pcm_substream *substream, int cmd)
1377 {
1378         int i, j;
1379         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1380         struct pcmhw *data = get_pcmhwdev(substream);
1381         struct cmdif *cif = chip->cif;
1382         union cmdret rptr = CMDRET_ZERO;
1383 
1384         spin_lock(&chip->lock);
1385         switch (cmd) {
1386         case SNDRV_PCM_TRIGGER_START:
1387         case SNDRV_PCM_TRIGGER_RESUME:
1388                 if (!(data->state & ST_PLAY)) {
1389                         SEND_SSTR(cif, data->id, data->sgdlist.addr);
1390                         SET_AIE(cif->hwport);
1391                         data->state = ST_PLAY;
1392                         if (data->mixer != 0xff)
1393                                 setmixer(cif, data->mixer, 0x7fff, 0x7fff);
1394                         chip->openstreams++;
1395                         data->oldpos = 0;
1396                         data->pointer = 0;
1397                 }
1398                 break;
1399         case SNDRV_PCM_TRIGGER_STOP:
1400         case SNDRV_PCM_TRIGGER_SUSPEND:
1401                 if (data->mixer != 0xff)
1402                         setmixer(cif, data->mixer, 0, 0);
1403                 setmixer(cif, data->mixer, 0, 0);
1404                 SEND_KSTR(cif, data->id);
1405                 data->state = ST_STOP;
1406                 chip->openstreams--;
1407                 j = 0;
1408                 do {
1409                         i = rptr.retlongs[1];
1410                         SEND_GPOS(cif, 0, data->id, &rptr);
1411                         udelay(1);
1412                 } while (i != rptr.retlongs[1] && j++ < MAX_WRITE_RETRY);
1413                 if (j > MAX_WRITE_RETRY)
1414                         snd_printk(KERN_ERR "Riptide: Could not stop stream!");
1415                 break;
1416         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1417                 if (!(data->state & ST_PAUSE)) {
1418                         SEND_PSTR(cif, data->id);
1419                         data->state |= ST_PAUSE;
1420                         chip->openstreams--;
1421                 }
1422                 break;
1423         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1424                 if (data->state & ST_PAUSE) {
1425                         SEND_SSTR(cif, data->id, data->sgdlist.addr);
1426                         data->state &= ~ST_PAUSE;
1427                         chip->openstreams++;
1428                 }
1429                 break;
1430         default:
1431                 spin_unlock(&chip->lock);
1432                 return -EINVAL;
1433         }
1434         spin_unlock(&chip->lock);
1435         return 0;
1436 }
1437 
1438 static int snd_riptide_prepare(struct snd_pcm_substream *substream)
1439 {
1440         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1441         struct snd_pcm_runtime *runtime = substream->runtime;
1442         struct pcmhw *data = get_pcmhwdev(substream);
1443         struct cmdif *cif = chip->cif;
1444         unsigned char *lbuspath = NULL;
1445         unsigned int rate, channels;
1446         int err = 0;
1447         snd_pcm_format_t format;
1448 
1449         if (snd_BUG_ON(!cif || !data))
1450                 return -EINVAL;
1451 
1452         snd_printdd("prepare id %d ch: %d f:0x%x r:%d\n", data->id,
1453                     runtime->channels, runtime->format, runtime->rate);
1454 
1455         spin_lock_irq(&chip->lock);
1456         channels = runtime->channels;
1457         format = runtime->format;
1458         rate = runtime->rate;
1459         switch (channels) {
1460         case 1:
1461                 if (rate == 48000 && format == SNDRV_PCM_FORMAT_S16_LE)
1462                         lbuspath = data->paths.noconv;
1463                 else
1464                         lbuspath = data->paths.mono;
1465                 break;
1466         case 2:
1467                 if (rate == 48000 && format == SNDRV_PCM_FORMAT_S16_LE)
1468                         lbuspath = data->paths.noconv;
1469                 else
1470                         lbuspath = data->paths.stereo;
1471                 break;
1472         }
1473         snd_printdd("use sgdlist at 0x%p\n",
1474                     data->sgdlist.area);
1475         if (data->sgdlist.area) {
1476                 unsigned int i, j, size, pages, f, pt, period;
1477                 struct sgd *c, *p = NULL;
1478 
1479                 size = frames_to_bytes(runtime, runtime->buffer_size);
1480                 period = frames_to_bytes(runtime, runtime->period_size);
1481                 f = PAGE_SIZE;
1482                 while ((size + (f >> 1) - 1) <= (f << 7) && (f << 1) > period)
1483                         f = f >> 1;
1484                 pages = DIV_ROUND_UP(size, f);
1485                 data->size = size;
1486                 data->pages = pages;
1487                 snd_printdd
1488                     ("create sgd size: 0x%x pages %d of size 0x%x for period 0x%x\n",
1489                      size, pages, f, period);
1490                 pt = 0;
1491                 j = 0;
1492                 for (i = 0; i < pages; i++) {
1493                         unsigned int ofs, addr;
1494                         c = &data->sgdbuf[i];
1495                         if (p)
1496                                 p->dwNextLink = cpu_to_le32(data->sgdlist.addr +
1497                                                             (i *
1498                                                              sizeof(struct
1499                                                                     sgd)));
1500                         c->dwNextLink = cpu_to_le32(data->sgdlist.addr);
1501                         ofs = j << PAGE_SHIFT;
1502                         addr = snd_pcm_sgbuf_get_addr(substream, ofs) + pt;
1503                         c->dwSegPtrPhys = cpu_to_le32(addr);
1504                         pt = (pt + f) % PAGE_SIZE;
1505                         if (pt == 0)
1506                                 j++;
1507                         c->dwSegLen = cpu_to_le32(f);
1508                         c->dwStat_Ctl =
1509                             cpu_to_le32(IEOB_ENABLE | IEOS_ENABLE |
1510                                         IEOC_ENABLE);
1511                         p = c;
1512                         size -= f;
1513                 }
1514                 data->sgdbuf[i].dwSegLen = cpu_to_le32(size);
1515         }
1516         if (lbuspath && lbuspath != data->lbuspath) {
1517                 if (data->lbuspath)
1518                         freelbuspath(cif, data->source, data->lbuspath);
1519                 alloclbuspath(cif, data->source, lbuspath,
1520                               &data->mixer, data->intdec);
1521                 data->lbuspath = lbuspath;
1522                 data->rate = 0;
1523         }
1524         if (data->rate != rate || data->format != format ||
1525             data->channels != channels) {
1526                 data->rate = rate;
1527                 data->format = format;
1528                 data->channels = channels;
1529                 if (setsampleformat
1530                     (cif, data->mixer, data->id, channels, format)
1531                     || setsamplerate(cif, data->intdec, rate))
1532                         err = -EIO;
1533         }
1534         spin_unlock_irq(&chip->lock);
1535         return err;
1536 }
1537 
1538 static int
1539 snd_riptide_hw_params(struct snd_pcm_substream *substream,
1540                       struct snd_pcm_hw_params *hw_params)
1541 {
1542         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1543         struct pcmhw *data = get_pcmhwdev(substream);
1544         struct snd_dma_buffer *sgdlist = &data->sgdlist;
1545         int err;
1546 
1547         snd_printdd("hw params id %d (sgdlist: 0x%p 0x%lx %d)\n", data->id,
1548                     sgdlist->area, (unsigned long)sgdlist->addr,
1549                     (int)sgdlist->bytes);
1550         if (sgdlist->area)
1551                 snd_dma_free_pages(sgdlist);
1552         if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
1553                                        snd_dma_pci_data(chip->pci),
1554                                        sizeof(struct sgd) * (DESC_MAX_MASK + 1),
1555                                        sgdlist)) < 0) {
1556                 snd_printk(KERN_ERR "Riptide: failed to alloc %d dma bytes\n",
1557                            (int)sizeof(struct sgd) * (DESC_MAX_MASK + 1));
1558                 return err;
1559         }
1560         data->sgdbuf = (struct sgd *)sgdlist->area;
1561         return snd_pcm_lib_malloc_pages(substream,
1562                                         params_buffer_bytes(hw_params));
1563 }
1564 
1565 static int snd_riptide_hw_free(struct snd_pcm_substream *substream)
1566 {
1567         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1568         struct pcmhw *data = get_pcmhwdev(substream);
1569         struct cmdif *cif = chip->cif;
1570 
1571         if (cif && data) {
1572                 if (data->lbuspath)
1573                         freelbuspath(cif, data->source, data->lbuspath);
1574                 data->lbuspath = NULL;
1575                 data->source = 0xff;
1576                 data->intdec[0] = 0xff;
1577                 data->intdec[1] = 0xff;
1578 
1579                 if (data->sgdlist.area) {
1580                         snd_dma_free_pages(&data->sgdlist);
1581                         data->sgdlist.area = NULL;
1582                 }
1583         }
1584         return snd_pcm_lib_free_pages(substream);
1585 }
1586 
1587 static int snd_riptide_playback_open(struct snd_pcm_substream *substream)
1588 {
1589         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1590         struct snd_pcm_runtime *runtime = substream->runtime;
1591         struct pcmhw *data;
1592         int sub_num = substream->number;
1593 
1594         chip->playback_substream[sub_num] = substream;
1595         runtime->hw = snd_riptide_playback;
1596 
1597         data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
1598         if (data == NULL)
1599                 return -ENOMEM;
1600         data->paths = lbus_play_paths[sub_num];
1601         data->id = play_ids[sub_num];
1602         data->source = play_sources[sub_num];
1603         data->intdec[0] = 0xff;
1604         data->intdec[1] = 0xff;
1605         data->state = ST_STOP;
1606         runtime->private_data = data;
1607         return snd_pcm_hw_constraint_integer(runtime,
1608                                              SNDRV_PCM_HW_PARAM_PERIODS);
1609 }
1610 
1611 static int snd_riptide_capture_open(struct snd_pcm_substream *substream)
1612 {
1613         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1614         struct snd_pcm_runtime *runtime = substream->runtime;
1615         struct pcmhw *data;
1616 
1617         chip->capture_substream = substream;
1618         runtime->hw = snd_riptide_capture;
1619 
1620         data = kzalloc(sizeof(struct pcmhw), GFP_KERNEL);
1621         if (data == NULL)
1622                 return -ENOMEM;
1623         data->paths = lbus_rec_path;
1624         data->id = PADC;
1625         data->source = ACLNK2PADC;
1626         data->intdec[0] = 0xff;
1627         data->intdec[1] = 0xff;
1628         data->state = ST_STOP;
1629         runtime->private_data = data;
1630         return snd_pcm_hw_constraint_integer(runtime,
1631                                              SNDRV_PCM_HW_PARAM_PERIODS);
1632 }
1633 
1634 static int snd_riptide_playback_close(struct snd_pcm_substream *substream)
1635 {
1636         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1637         struct pcmhw *data = get_pcmhwdev(substream);
1638         int sub_num = substream->number;
1639 
1640         substream->runtime->private_data = NULL;
1641         chip->playback_substream[sub_num] = NULL;
1642         kfree(data);
1643         return 0;
1644 }
1645 
1646 static int snd_riptide_capture_close(struct snd_pcm_substream *substream)
1647 {
1648         struct snd_riptide *chip = snd_pcm_substream_chip(substream);
1649         struct pcmhw *data = get_pcmhwdev(substream);
1650 
1651         substream->runtime->private_data = NULL;
1652         chip->capture_substream = NULL;
1653         kfree(data);
1654         return 0;
1655 }
1656 
1657 static const struct snd_pcm_ops snd_riptide_playback_ops = {
1658         .open = snd_riptide_playback_open,
1659         .close = snd_riptide_playback_close,
1660         .ioctl = snd_pcm_lib_ioctl,
1661         .hw_params = snd_riptide_hw_params,
1662         .hw_free = snd_riptide_hw_free,
1663         .prepare = snd_riptide_prepare,
1664         .page = snd_pcm_sgbuf_ops_page,
1665         .trigger = snd_riptide_trigger,
1666         .pointer = snd_riptide_pointer,
1667 };
1668 static const struct snd_pcm_ops snd_riptide_capture_ops = {
1669         .open = snd_riptide_capture_open,
1670         .close = snd_riptide_capture_close,
1671         .ioctl = snd_pcm_lib_ioctl,
1672         .hw_params = snd_riptide_hw_params,
1673         .hw_free = snd_riptide_hw_free,
1674         .prepare = snd_riptide_prepare,
1675         .page = snd_pcm_sgbuf_ops_page,
1676         .trigger = snd_riptide_trigger,
1677         .pointer = snd_riptide_pointer,
1678 };
1679 
1680 static int snd_riptide_pcm(struct snd_riptide *chip, int device)
1681 {
1682         struct snd_pcm *pcm;
1683         int err;
1684 
1685         if ((err =
1686              snd_pcm_new(chip->card, "RIPTIDE", device, PLAYBACK_SUBSTREAMS, 1,
1687                          &pcm)) < 0)
1688                 return err;
1689         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1690                         &snd_riptide_playback_ops);
1691         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1692                         &snd_riptide_capture_ops);
1693         pcm->private_data = chip;
1694         pcm->info_flags = 0;
1695         strcpy(pcm->name, "RIPTIDE");
1696         chip->pcm = pcm;
1697         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
1698                                               snd_dma_pci_data(chip->pci),
1699                                               64 * 1024, 128 * 1024);
1700         return 0;
1701 }
1702 
1703 static irqreturn_t
1704 snd_riptide_interrupt(int irq, void *dev_id)
1705 {
1706         struct snd_riptide *chip = dev_id;
1707         struct cmdif *cif = chip->cif;
1708 
1709         if (cif) {
1710                 chip->received_irqs++;
1711                 if (IS_EOBIRQ(cif->hwport) || IS_EOSIRQ(cif->hwport) ||
1712                     IS_EOCIRQ(cif->hwport)) {
1713                         chip->handled_irqs++;
1714                         tasklet_schedule(&chip->riptide_tq);
1715                 }
1716                 if (chip->rmidi && IS_MPUIRQ(cif->hwport)) {
1717                         chip->handled_irqs++;
1718                         snd_mpu401_uart_interrupt(irq,
1719                                                   chip->rmidi->private_data);
1720                 }
1721                 SET_AIACK(cif->hwport);
1722         }
1723         return IRQ_HANDLED;
1724 }
1725 
1726 static void
1727 snd_riptide_codec_write(struct snd_ac97 *ac97, unsigned short reg,
1728                         unsigned short val)
1729 {
1730         struct snd_riptide *chip = ac97->private_data;
1731         struct cmdif *cif = chip->cif;
1732         union cmdret rptr = CMDRET_ZERO;
1733         int i = 0;
1734 
1735         if (snd_BUG_ON(!cif))
1736                 return;
1737 
1738         snd_printdd("Write AC97 reg 0x%x 0x%x\n", reg, val);
1739         do {
1740                 SEND_SACR(cif, val, reg);
1741                 SEND_RACR(cif, reg, &rptr);
1742         } while (rptr.retwords[1] != val && i++ < MAX_WRITE_RETRY);
1743         if (i > MAX_WRITE_RETRY)
1744                 snd_printdd("Write AC97 reg failed\n");
1745 }
1746 
1747 static unsigned short snd_riptide_codec_read(struct snd_ac97 *ac97,
1748                                              unsigned short reg)
1749 {
1750         struct snd_riptide *chip = ac97->private_data;
1751         struct cmdif *cif = chip->cif;
1752         union cmdret rptr = CMDRET_ZERO;
1753 
1754         if (snd_BUG_ON(!cif))
1755                 return 0;
1756 
1757         if (SEND_RACR(cif, reg, &rptr) != 0)
1758                 SEND_RACR(cif, reg, &rptr);
1759         snd_printdd("Read AC97 reg 0x%x got 0x%x\n", reg, rptr.retwords[1]);
1760         return rptr.retwords[1];
1761 }
1762 
1763 static int snd_riptide_initialize(struct snd_riptide *chip)
1764 {
1765         struct cmdif *cif;
1766         unsigned int device_id;
1767         int err;
1768 
1769         if (snd_BUG_ON(!chip))
1770                 return -EINVAL;
1771 
1772         cif = chip->cif;
1773         if (!cif) {
1774                 if ((cif = kzalloc(sizeof(struct cmdif), GFP_KERNEL)) == NULL)
1775                         return -ENOMEM;
1776                 cif->hwport = (struct riptideport *)chip->port;
1777                 spin_lock_init(&cif->lock);
1778                 chip->cif = cif;
1779         }
1780         cif->is_reset = 0;
1781         if ((err = riptide_reset(cif, chip)) != 0)
1782                 return err;
1783         device_id = chip->device_id;
1784         switch (device_id) {
1785         case 0x4310:
1786         case 0x4320:
1787         case 0x4330:
1788                 snd_printdd("Modem enable?\n");
1789                 SEND_SETDPLL(cif);
1790                 break;
1791         }
1792         snd_printdd("Enabling MPU IRQs\n");
1793         if (chip->rmidi)
1794                 SET_EMPUIRQ(cif->hwport);
1795         return err;
1796 }
1797 
1798 static int snd_riptide_free(struct snd_riptide *chip)
1799 {
1800         struct cmdif *cif;
1801 
1802         if (!chip)
1803                 return 0;
1804 
1805         if ((cif = chip->cif)) {
1806                 SET_GRESET(cif->hwport);
1807                 udelay(100);
1808                 UNSET_GRESET(cif->hwport);
1809                 kfree(chip->cif);
1810         }
1811         if (chip->irq >= 0)
1812                 free_irq(chip->irq, chip);
1813         release_firmware(chip->fw_entry);
1814         release_and_free_resource(chip->res_port);
1815         kfree(chip);
1816         return 0;
1817 }
1818 
1819 static int snd_riptide_dev_free(struct snd_device *device)
1820 {
1821         struct snd_riptide *chip = device->device_data;
1822 
1823         return snd_riptide_free(chip);
1824 }
1825 
1826 static int
1827 snd_riptide_create(struct snd_card *card, struct pci_dev *pci,
1828                    struct snd_riptide **rchip)
1829 {
1830         struct snd_riptide *chip;
1831         struct riptideport *hwport;
1832         int err;
1833         static struct snd_device_ops ops = {
1834                 .dev_free = snd_riptide_dev_free,
1835         };
1836 
1837         *rchip = NULL;
1838         if ((err = pci_enable_device(pci)) < 0)
1839                 return err;
1840         if (!(chip = kzalloc(sizeof(struct snd_riptide), GFP_KERNEL)))
1841                 return -ENOMEM;
1842 
1843         spin_lock_init(&chip->lock);
1844         chip->card = card;
1845         chip->pci = pci;
1846         chip->irq = -1;
1847         chip->openstreams = 0;
1848         chip->port = pci_resource_start(pci, 0);
1849         chip->received_irqs = 0;
1850         chip->handled_irqs = 0;
1851         chip->cif = NULL;
1852         tasklet_init(&chip->riptide_tq, riptide_handleirq, (unsigned long)chip);
1853 
1854         if ((chip->res_port =
1855              request_region(chip->port, 64, "RIPTIDE")) == NULL) {
1856                 snd_printk(KERN_ERR
1857                            "Riptide: unable to grab region 0x%lx-0x%lx\n",
1858                            chip->port, chip->port + 64 - 1);
1859                 snd_riptide_free(chip);
1860                 return -EBUSY;
1861         }
1862         hwport = (struct riptideport *)chip->port;
1863         UNSET_AIE(hwport);
1864 
1865         if (request_irq(pci->irq, snd_riptide_interrupt, IRQF_SHARED,
1866                         KBUILD_MODNAME, chip)) {
1867                 snd_printk(KERN_ERR "Riptide: unable to grab IRQ %d\n",
1868                            pci->irq);
1869                 snd_riptide_free(chip);
1870                 return -EBUSY;
1871         }
1872         chip->irq = pci->irq;
1873         chip->device_id = pci->device;
1874         pci_set_master(pci);
1875         if ((err = snd_riptide_initialize(chip)) < 0) {
1876                 snd_riptide_free(chip);
1877                 return err;
1878         }
1879 
1880         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1881                 snd_riptide_free(chip);
1882                 return err;
1883         }
1884 
1885         *rchip = chip;
1886         return 0;
1887 }
1888 
1889 static void
1890 snd_riptide_proc_read(struct snd_info_entry *entry,
1891                       struct snd_info_buffer *buffer)
1892 {
1893         struct snd_riptide *chip = entry->private_data;
1894         struct pcmhw *data;
1895         int i;
1896         struct cmdif *cif = NULL;
1897         unsigned char p[256];
1898         unsigned short rval = 0, lval = 0;
1899         unsigned int rate;
1900 
1901         if (!chip)
1902                 return;
1903 
1904         snd_iprintf(buffer, "%s\n\n", chip->card->longname);
1905         snd_iprintf(buffer, "Device ID: 0x%x\nReceived IRQs: (%ld)%ld\nPorts:",
1906                     chip->device_id, chip->handled_irqs, chip->received_irqs);
1907         for (i = 0; i < 64; i += 4)
1908                 snd_iprintf(buffer, "%c%02x: %08x",
1909                             (i % 16) ? ' ' : '\n', i, inl(chip->port + i));
1910         if ((cif = chip->cif)) {
1911                 snd_iprintf(buffer,
1912                             "\nVersion: ASIC: %d CODEC: %d AUXDSP: %d PROG: %d",
1913                             chip->firmware.firmware.ASIC,
1914                             chip->firmware.firmware.CODEC,
1915                             chip->firmware.firmware.AUXDSP,
1916                             chip->firmware.firmware.PROG);
1917                 snd_iprintf(buffer, "\nDigital mixer:");
1918                 for (i = 0; i < 12; i++) {
1919                         getmixer(cif, i, &rval, &lval);
1920                         snd_iprintf(buffer, "\n %d: %d %d", i, rval, lval);
1921                 }
1922                 snd_iprintf(buffer,
1923                             "\nARM Commands num: %d failed: %d time: %d max: %d min: %d",
1924                             cif->cmdcnt, cif->errcnt,
1925                             cif->cmdtime, cif->cmdtimemax, cif->cmdtimemin);
1926         }
1927         snd_iprintf(buffer, "\nOpen streams %d:\n", chip->openstreams);
1928         for (i = 0; i < PLAYBACK_SUBSTREAMS; i++) {
1929                 if (chip->playback_substream[i]
1930                     && chip->playback_substream[i]->runtime
1931                     && (data =
1932                         chip->playback_substream[i]->runtime->private_data)) {
1933                         snd_iprintf(buffer,
1934                                     "stream: %d mixer: %d source: %d (%d,%d)\n",
1935                                     data->id, data->mixer, data->source,
1936                                     data->intdec[0], data->intdec[1]);
1937                         if (!(getsamplerate(cif, data->intdec, &rate)))
1938                                 snd_iprintf(buffer, "rate: %d\n", rate);
1939                 }
1940         }
1941         if (chip->capture_substream
1942             && chip->capture_substream->runtime
1943             && (data = chip->capture_substream->runtime->private_data)) {
1944                 snd_iprintf(buffer,
1945                             "stream: %d mixer: %d source: %d (%d,%d)\n",
1946                             data->id, data->mixer,
1947                             data->source, data->intdec[0], data->intdec[1]);
1948                 if (!(getsamplerate(cif, data->intdec, &rate)))
1949                         snd_iprintf(buffer, "rate: %d\n", rate);
1950         }
1951         snd_iprintf(buffer, "Paths:\n");
1952         i = getpaths(cif, p);
1953         while (i >= 2) {
1954                 i -= 2;
1955                 snd_iprintf(buffer, "%x->%x ", p[i], p[i + 1]);
1956         }
1957         snd_iprintf(buffer, "\n");
1958 }
1959 
1960 static void snd_riptide_proc_init(struct snd_riptide *chip)
1961 {
1962         snd_card_ro_proc_new(chip->card, "riptide", chip,
1963                              snd_riptide_proc_read);
1964 }
1965 
1966 static int snd_riptide_mixer(struct snd_riptide *chip)
1967 {
1968         struct snd_ac97_bus *pbus;
1969         struct snd_ac97_template ac97;
1970         int err = 0;
1971         static struct snd_ac97_bus_ops ops = {
1972                 .write = snd_riptide_codec_write,
1973                 .read = snd_riptide_codec_read,
1974         };
1975 
1976         memset(&ac97, 0, sizeof(ac97));
1977         ac97.private_data = chip;
1978         ac97.scaps = AC97_SCAP_SKIP_MODEM;
1979 
1980         if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus)) < 0)
1981                 return err;
1982 
1983         chip->ac97_bus = pbus;
1984         ac97.pci = chip->pci;
1985         if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97)) < 0)
1986                 return err;
1987         return err;
1988 }
1989 
1990 #ifdef SUPPORT_JOYSTICK
1991 
1992 static int
1993 snd_riptide_joystick_probe(struct pci_dev *pci, const struct pci_device_id *id)
1994 {
1995         static int dev;
1996         struct gameport *gameport;
1997         int ret;
1998 
1999         if (dev >= SNDRV_CARDS)
2000                 return -ENODEV;
2001 
2002         if (!enable[dev]) {
2003                 ret = -ENOENT;
2004                 goto inc_dev;
2005         }
2006 
2007         if (!joystick_port[dev]) {
2008                 ret = 0;
2009                 goto inc_dev;
2010         }
2011 
2012         gameport = gameport_allocate_port();
2013         if (!gameport) {
2014                 ret = -ENOMEM;
2015                 goto inc_dev;
2016         }
2017         if (!request_region(joystick_port[dev], 8, "Riptide gameport")) {
2018                 snd_printk(KERN_WARNING
2019                            "Riptide: cannot grab gameport 0x%x\n",
2020                            joystick_port[dev]);
2021                 gameport_free_port(gameport);
2022                 ret = -EBUSY;
2023                 goto inc_dev;
2024         }
2025 
2026         gameport->io = joystick_port[dev];
2027         gameport_register_port(gameport);
2028         pci_set_drvdata(pci, gameport);
2029 
2030         ret = 0;
2031 inc_dev:
2032         dev++;
2033         return ret;
2034 }
2035 
2036 static void snd_riptide_joystick_remove(struct pci_dev *pci)
2037 {
2038         struct gameport *gameport = pci_get_drvdata(pci);
2039         if (gameport) {
2040                 release_region(gameport->io, 8);
2041                 gameport_unregister_port(gameport);
2042         }
2043 }
2044 #endif
2045 
2046 static int
2047 snd_card_riptide_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
2048 {
2049         static int dev;
2050         struct snd_card *card;
2051         struct snd_riptide *chip;
2052         unsigned short val;
2053         int err;
2054 
2055         if (dev >= SNDRV_CARDS)
2056                 return -ENODEV;
2057         if (!enable[dev]) {
2058                 dev++;
2059                 return -ENOENT;
2060         }
2061 
2062         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
2063                            0, &card);
2064         if (err < 0)
2065                 return err;
2066         err = snd_riptide_create(card, pci, &chip);
2067         if (err < 0)
2068                 goto error;
2069         card->private_data = chip;
2070         err = snd_riptide_pcm(chip, 0);
2071         if (err < 0)
2072                 goto error;
2073         err = snd_riptide_mixer(chip);
2074         if (err < 0)
2075                 goto error;
2076 
2077         val = LEGACY_ENABLE_ALL;
2078         if (opl3_port[dev])
2079                 val |= LEGACY_ENABLE_FM;
2080 #ifdef SUPPORT_JOYSTICK
2081         if (joystick_port[dev])
2082                 val |= LEGACY_ENABLE_GAMEPORT;
2083 #endif
2084         if (mpu_port[dev])
2085                 val |= LEGACY_ENABLE_MPU_INT | LEGACY_ENABLE_MPU;
2086         val |= (chip->irq << 4) & 0xf0;
2087         pci_write_config_word(chip->pci, PCI_EXT_Legacy_Mask, val);
2088         if (mpu_port[dev]) {
2089                 val = mpu_port[dev];
2090                 pci_write_config_word(chip->pci, PCI_EXT_MPU_Base, val);
2091                 err = snd_mpu401_uart_new(card, 0, MPU401_HW_RIPTIDE,
2092                                           val, MPU401_INFO_IRQ_HOOK, -1,
2093                                           &chip->rmidi);
2094                 if (err < 0)
2095                         snd_printk(KERN_WARNING
2096                                    "Riptide: Can't Allocate MPU at 0x%x\n",
2097                                    val);
2098                 else
2099                         chip->mpuaddr = val;
2100         }
2101         if (opl3_port[dev]) {
2102                 val = opl3_port[dev];
2103                 pci_write_config_word(chip->pci, PCI_EXT_FM_Base, val);
2104                 err = snd_opl3_create(card, val, val + 2,
2105                                       OPL3_HW_RIPTIDE, 0, &chip->opl3);
2106                 if (err < 0)
2107                         snd_printk(KERN_WARNING
2108                                    "Riptide: Can't Allocate OPL3 at 0x%x\n",
2109                                    val);
2110                 else {
2111                         chip->opladdr = val;
2112                         err = snd_opl3_hwdep_new(chip->opl3, 0, 1, NULL);
2113                         if (err < 0)
2114                                 snd_printk(KERN_WARNING
2115                                            "Riptide: Can't Allocate OPL3-HWDEP\n");
2116                 }
2117         }
2118 #ifdef SUPPORT_JOYSTICK
2119         if (joystick_port[dev]) {
2120                 val = joystick_port[dev];
2121                 pci_write_config_word(chip->pci, PCI_EXT_Game_Base, val);
2122                 chip->gameaddr = val;
2123         }
2124 #endif
2125 
2126         strcpy(card->driver, "RIPTIDE");
2127         strcpy(card->shortname, "Riptide");
2128 #ifdef SUPPORT_JOYSTICK
2129         snprintf(card->longname, sizeof(card->longname),
2130                  "%s at 0x%lx, irq %i mpu 0x%x opl3 0x%x gameport 0x%x",
2131                  card->shortname, chip->port, chip->irq, chip->mpuaddr,
2132                  chip->opladdr, chip->gameaddr);
2133 #else
2134         snprintf(card->longname, sizeof(card->longname),
2135                  "%s at 0x%lx, irq %i mpu 0x%x opl3 0x%x",
2136                  card->shortname, chip->port, chip->irq, chip->mpuaddr,
2137                  chip->opladdr);
2138 #endif
2139         snd_riptide_proc_init(chip);
2140         err = snd_card_register(card);
2141         if (err < 0)
2142                 goto error;
2143         pci_set_drvdata(pci, card);
2144         dev++;
2145         return 0;
2146 
2147  error:
2148         snd_card_free(card);
2149         return err;
2150 }
2151 
2152 static void snd_card_riptide_remove(struct pci_dev *pci)
2153 {
2154         snd_card_free(pci_get_drvdata(pci));
2155 }
2156 
2157 static struct pci_driver driver = {
2158         .name = KBUILD_MODNAME,
2159         .id_table = snd_riptide_ids,
2160         .probe = snd_card_riptide_probe,
2161         .remove = snd_card_riptide_remove,
2162         .driver = {
2163                 .pm = RIPTIDE_PM_OPS,
2164         },
2165 };
2166 
2167 #ifdef SUPPORT_JOYSTICK
2168 static struct pci_driver joystick_driver = {
2169         .name = KBUILD_MODNAME "-joystick",
2170         .id_table = snd_riptide_joystick_ids,
2171         .probe = snd_riptide_joystick_probe,
2172         .remove = snd_riptide_joystick_remove,
2173 };
2174 #endif
2175 
2176 static int __init alsa_card_riptide_init(void)
2177 {
2178         int err;
2179         err = pci_register_driver(&driver);
2180         if (err < 0)
2181                 return err;
2182 #if defined(SUPPORT_JOYSTICK)
2183         err = pci_register_driver(&joystick_driver);
2184         /* On failure unregister formerly registered audio driver */
2185         if (err < 0)
2186                 pci_unregister_driver(&driver);
2187 #endif
2188         return err;
2189 }
2190 
2191 static void __exit alsa_card_riptide_exit(void)
2192 {
2193         pci_unregister_driver(&driver);
2194 #if defined(SUPPORT_JOYSTICK)
2195         pci_unregister_driver(&joystick_driver);
2196 #endif
2197 }
2198 
2199 module_init(alsa_card_riptide_init);
2200 module_exit(alsa_card_riptide_exit);

/* [<][>][^][v][top][bottom][index][help] */