← Back to branch summary

~ubuntu-branches/ubuntu/vivid/oss4/vivid

« back to all changes in this revision

Viewing changes to attic/drv/oss_allegro/allegro_util.inc

  • Committer: Bazaar Package Importer
  • Author(s): Romain Beauxis, Samuel Thibault, Romain Beauxis, Sebastien NOEL
  • Date: 2011-06-14 10:06:56 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20110614100656-cx4oc7u426zn812z
Tags: 4.2-build2004-1
http://bugs.debian.org/589127
http://bugs.debian.org/604679
http://bugs.debian.org/595298
http://bugs.debian.org/619272
http://bugs.debian.org/627149
http://bugs.debian.org/628879
[ Samuel Thibault ]
* debian/control: Add liboss4-salsa2, liboss4-salsa-dev and
  liboss4-salsa-asound2 packages, equivalent to (and will replace) those from
  the oss-libsalsa package (Closes: #589127).
* debian/patches/liboss4-salsa.patch: New patch to rename libsalsa into
  liboss4-salsa to avoid conflicts in the archive for no good reason.
* debian/rules: Make in libOSSlib and libsalsa.
* debian/liboss4-salsa-dev.install, debian/liboss4-salsa2.install,
  debian/liboss4-salsa-asound2.links, debian/liboss4-salsa-dev.links:
  Install liboss4-salsa libraries like was done in the oss-libsalsa package.
* include-alsa: Add a copy of ALSA 1.0.5 headers: Cf ALSA_1.0.* symbols in
  libsalsa, this is the roughly supported version.
* debian/copyright: Update for new include-alsa files.
* alsa.pc: New file for compatibility with libasound-dev.
* debian/control:
  - Add Vcs-Browser and Vcs-Svn fields.
  - Use linux-any instead of the list of Linux archs (Closes: #604679).
  - Make dkms dependency linux-any only.
* debian/patches/hurd_iot.patch: New patch to fix soundcard.h usage in
  libsalsa on hurd-i386.
* debian/patches/libsalsa_fixes.patch: New patch to fix some printf usages
  and ioctl declaration in libsalsa.
* debian/patches/no_EBADE.patch: New patch to cope with hurd-i386 not having
  EBADE.
* debian/patches/CFLAGS.patch: New patch to make oss4 take debian/rules
  CFLAGS into account.
* debian/patches/snd_asoundlib_version.patch: New patch to add
  snd_asoundlib_version().
* debian/patches/generic_srccconf.patch: New patch to fix source
  configuration on unknown archs.

[ Romain Beauxis ]
* Fixed README.Debian to only mention dkms' modules.
* Switch to dpkg-source 3.0 (quilt) format
* Added DM-Upload-Allowed: yes

[ Sebastien NOEL ]
* New upstream release (Closes: #595298, #619272).
* Fix typo in initscript (Closes: #627149).
* debian/control: adjust linux-headers dependencies (Closes: #628879).

Show diffs side-by-side

added added

removed removed

Lines of Context:
attic/drv/oss_allegro/allegro_util.inc
 
1
/*
 
2
 *      allegro_util.inc  --  ESS Technology allegro audio driver.
 
3
 *
 
4
 *      Copyright (C) 1992-2000  Don Kim (don.kim@esstech.com)
 
5
 *
 
6
 */
 
7
 
 
8
#define  DOCKF_DOCKED            0x00000001     /* Default Un-Docked */
 
9
#define  DOCKF_DEST_CODEC2       0x00000008     /* Tells VxD CODEC2 active */
 
10
#define  HW_INIT_SET_ACTIVE_ACRW    0x00000003  /* Sets the active AC Read/Write */
 
11
#define  HW_INIT_SET_ACTIVE_ACINTF  0x00000004  /* ... AC Intf (Local or Remote) */
 
12
 
 
13
VOID CodecReset (void);
 
14
void Set2Use36Mhz (void);
 
15
void HWMGR_EnableRemoteCodec (allegro_devc * devc, BOOLEAN enable);
 
16
 
 
17
#ifdef later
 
18
VOID CloseModem ();
 
19
#endif
 
20
extern PHWI gphwi;
 
21
extern oss_device_t *allegro_osdev;
 
22
 
 
23
#define CODEC_TYPE_AC97   1
 
24
#define CODEC_TYPE_ESS    2
 
25
 
 
26
#define DSP33MHZ 0
 
27
#define DSP36MHZ 1
 
28
#define DSP49MHZ 2
 
29
 
 
30
static unsigned char bChipType;
 
31
static unsigned char fRemoteCodec;
 
32
static unsigned char bCodec;
 
33
static unsigned char gbHwVolEnabled = TRUE;
 
34
static unsigned char bEapdSupportMode;
 
35
static unsigned int wEapdGPOPolarity_Port;
 
36
static unsigned char bEnable4Speaker;
 
37
BOOL IsAC3Format = FALSE;
 
38
BOOL g4Speaker = FALSE;
 
39
 
 
40
/*
 
41
 * DOCK
 
42
 */
 
43
static WORD gwDockVal;
 
44
UCHAR bEnableDockDetect = TRUE;
 
45
UCHAR bDockingDetectGPIPort = 0;        /* TODO: What is the right value */
 
46
static WORD wDockedMask;
 
47
static WORD wDockedValue;
 
48
UCHAR bMonoOutputSelect = 0;
 
49
static WORD gwDefaultMonoOutVol;
 
50
int bHwVolCtrlMode = -1;
 
51
static ULONG ulCodec;
 
52
#define NEC_VENDOR_ID3  0x80F11033
 
53
void HwRelease (allegro_devc * devc);
 
54
#define WriteLego HWMGR_WriteCodecData
 
55
PCLIENT_INST pClient_SPDIFIN = NULL;
 
56
BOOL fSPDIFOUT = FALSE;
 
57
 
 
58
 
 
59
#if 0
 
60
void
 
61
dDbgOut (char *sz, ...)
 
62
{
 
63
  char buf[256];
 
64
  va_list va;
 
65
  va_start (va, sz);
 
66
  vsprintf (buf, sz, va);
 
67
  va_end (va);
 
68
  printk (buf);
 
69
  printk ("\n");
 
70
}
 
71
#endif
 
72
 
 
73
void
 
74
HwSetSystemParameter (allegro_devc * devc, DWORD dwValue)
 
75
{
 
76
  switch (dwValue >> 16)
 
77
    {
 
78
    case HW_INIT_SET_ACTIVE_ACRW:       /*3 */
 
79
      {
 
80
        dprintf1 (("ACRW %x", dwValue & DOCKF_DEST_CODEC2));
 
81
 
 
82
        /*
 
83
         * Set the active AC out direction
 
84
         */
 
85
        if ((WORD) dwValue & DOCKF_DEST_CODEC2) /* In/Out AC2 */
 
86
          HWMGR_EnableRemoteCodec (devc, TRUE);
 
87
        else
 
88
          HWMGR_EnableRemoteCodec (devc, FALSE);
 
89
      }
 
90
      break;
 
91
 
 
92
    case HW_INIT_SET_ACTIVE_ACINTF:     /*4 */
 
93
      {
 
94
        WORD wTmp;
 
95
 
 
96
        dprintf1 (("ACINTF %x", dwValue));
 
97
        if (!(dwValue & DOCKF_DOCKED))  /* Nothing there */
 
98
          {
 
99
            /* CODEC DAC I/F set to local only */
 
100
            wTmp = inpw (devc->osdev, devc->base + 0x3a);
 
101
            wTmp &= 0xFFF3;     /* [3:2] = "00" */
 
102
            outpw (devc->osdev, devc->base + 0x3a, wTmp);
 
103
 
 
104
            /* CODEC ADC I/F set to local only */
 
105
            wTmp = inpw (devc->osdev, devc->base + 0x3c);
 
106
            wTmp &= 0xFFF3;     /* [3:2] = "00" */
 
107
            outpw (devc->osdev, devc->base + 0x3c, wTmp);
 
108
          }
 
109
        else
 
110
          {                     /* DOCKED */
 
111
            /* CODEC DAC I/F set to local + remote */
 
112
            wTmp = inpw (devc->osdev, devc->base + 0x3a);
 
113
            wTmp &= 0xFFF3;
 
114
            wTmp |= 0x000C;     /* [3:2] = "11" */
 
115
            outpw (devc->osdev, devc->base + 0x3a, wTmp);
 
116
 
 
117
            /* CODEC ADC I/F set to remote AC2 (or both??) */
 
118
            wTmp = inpw (devc->osdev, devc->base + 0x3c);
 
119
            wTmp &= 0xFFF3;
 
120
            wTmp |= 0x000C;     /* [3:2] = "11" */
 
121
            outpw (devc->osdev, devc->base + 0x3c, wTmp);
 
122
          }
 
123
      }
 
124
      break;
 
125
    }
 
126
}
 
127
 
 
128
VOID
 
129
PCIWrite (allegro_devc * devc, WORD address, ULONG value)
 
130
{
 
131
 
 
132
  pci_write_config_dword (devc->osdev, address, value);
 
133
 
 
134
}
 
135
 
 
136
ULONG
 
137
PCIRead (allegro_devc * devc, WORD address)
 
138
{
 
139
  unsigned int dw;
 
140
  pci_read_config_dword (devc->osdev, address, &dw);
 
141
  return dw;
 
142
}
 
143
 
 
144
#ifdef DEBUGINTERFACE
 
145
void
 
146
dumpreg (WORD programid, WORD index, WORD value, WORD * out)
 
147
{
 
148
  ULONG dwData;
 
149
 
 
150
  switch (programid)
 
151
    {
 
152
    case 1:                     /* aggr */
 
153
      *out = inpw (devc->osdev, devc->base + index);
 
154
      break;
 
155
 
 
156
    case 2:                     /* aggw */
 
157
      outpw (devc->osdev, devc->base + index, value);
 
158
      break;
 
159
 
 
160
    case 3:                     /* legor */
 
161
      HWMGR_ReadCodecData (devc, devc->osdev, index, out);
 
162
      break;
 
163
 
 
164
    case 4:                     /* legow */
 
165
      HWMGR_WriteCodecData (devc, (UCHAR) index, value);
 
166
      break;
 
167
 
 
168
    case 5:                     /* pciar */
 
169
      index &= ~0x1;            /* make sure it's even address */
 
170
      dwData = PCIRead (devcv, index & ~0x3);
 
171
      if ((index % 4) == 0)
 
172
        *out = (WORD) dwData;
 
173
      else
 
174
        *out = (WORD) (dwData >> 16);
 
175
      break;
 
176
 
 
177
    case 6:                     /* pciaw */
 
178
      index &= ~0x1;            /* make sure it's even address */
 
179
      dwData = PCIRead (devc, index & ~0x3);
 
180
      if ((index % 4) == 0)
 
181
        {
 
182
          dwData &= ~0xffff;
 
183
          dwData |= value;
 
184
        }
 
185
      else
 
186
        {
 
187
          dwData &= 0xffff;
 
188
          dwData |= (value << 16);
 
189
        }
 
190
      PCIWrite (devc, (index & ~0x3), dwData);
 
191
      break;
 
192
    }
 
193
}
 
194
#endif /* DEBUGINTERFACE */
 
195
 
 
196
void
 
197
DelayMillisec (int millisec)
 
198
{
 
199
  int count;
 
200
 
 
201
  millisec = millisec * 1000 / 50;
 
202
  for (count = 0; count < millisec; count++)
 
203
    KeStallExecutionProcessor (50);
 
204
}                               /* DelayMillisec */
 
205
 
 
206
/* -------------------------------------------------------------------------- */
 
207
 
 
208
UCHAR
 
209
HWMGR_ReadDataByte (allegro_devc * devc, UCHAR Index)
 
210
{
 
211
  return READ_PORT_UCHAR (devc->osdev, devc->base + Index);
 
212
}                               /* HWMGR_ReadDataByte */
 
213
 
 
214
 
 
215
USHORT
 
216
HWMGR_ReadDataWord (allegro_devc * devc, UCHAR Index)
 
217
{
 
218
  return READ_PORT_USHORT (devc->osdev, devc->base + Index);
 
219
}                               /* HWMGR_ReadDataWord */
 
220
 
 
221
 
 
222
void
 
223
HWMGR_WriteDataByte (allegro_devc * devc, UCHAR Index, UCHAR Value)
 
224
{
 
225
  WRITE_PORT_UCHAR (devc->osdev, devc->base + Index, Value);
 
226
}                               /* HWMGR_WriteDataByte */
 
227
 
 
228
 
 
229
void
 
230
HWMGR_WriteDataWord (allegro_devc * devc, UCHAR Index, USHORT Value)
 
231
{
 
232
  WRITE_PORT_USHORT (devc->osdev, devc->base + Index, Value);
 
233
}                               /* HWMGR_WriteDataWord */
 
234
 
 
235
 
 
236
void
 
237
HWMGR_RestoreACLink (allegro_devc * devc)
 
238
{
 
239
  int i;
 
240
  USHORT wDataCodec;
 
241
  USHORT wDataIn;
 
242
  USHORT wDataOut;
 
243
  USHORT wControl = HWMGR_ReadDataWord (devc, RING_BUS_CTRL_A);
 
244
 
 
245
  HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, (USHORT) (wControl &
 
246
                                                        ~SERIAL_AC_LINK_ENABLE));
 
247
  KeStallExecutionProcessor (50);
 
248
  HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, wControl);
 
249
 
 
250
  wDataCodec = HWMGR_ReadDataWord (devc, RING_BUS_CTRL_B);
 
251
  wDataIn = HWMGR_ReadDataWord (devc, SDO_IN_DEST_CTRL);
 
252
  wDataOut = HWMGR_ReadDataWord (devc, SDO_OUT_DEST_CTRL);
 
253
 
 
254
  HWMGR_WriteDataWord (devc, SDO_OUT_DEST_CTRL, (USHORT) (wDataOut &
 
255
                                                          ~COMMAND_ADDR_OUT));
 
256
  HWMGR_WriteDataWord (devc, SDO_IN_DEST_CTRL, (USHORT) (wDataIn &
 
257
                                                         ~STATUS_ADDR_IN));
 
258
  HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B, (USHORT) (wDataCodec &
 
259
                                                        ~SECOND_CODEC_ID_MASK));
 
260
 
 
261
  /* power down DAC to resynchronize after AC-link change */
 
262
  HWMGR_WriteDataWord (devc, CODEC_DATA, AC97_PR1);
 
263
  HWMGR_WriteDataByte (devc, CODEC_COMMAND, AC97_POWER_DOWN_CTRL);
 
264
  for (i = 0; i < 1000; i++)
 
265
    if (!(HWMGR_ReadDataByte (devc, CODEC_STATUS) & CODEC_BUSY_B))
 
266
      break;
 
267
  KeStallExecutionProcessor (1);
 
268
  HWMGR_WriteDataWord (devc, CODEC_DATA, 0);
 
269
  HWMGR_WriteDataByte (devc, CODEC_COMMAND, AC97_POWER_DOWN_CTRL);
 
270
  for (i = 0; i < 1000; i++)
 
271
    if (!(HWMGR_ReadDataByte (devc, CODEC_STATUS) & CODEC_BUSY_B))
 
272
      break;
 
273
  HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B, wDataCodec);
 
274
  HWMGR_WriteDataWord (devc, SDO_IN_DEST_CTRL, wDataIn);
 
275
  HWMGR_WriteDataWord (devc, SDO_OUT_DEST_CTRL, wDataOut);
 
276
}                               /* HWMGR_RestoreACLink */
 
277
 
 
278
BOOLEAN
 
279
HWMGR_ReadCodecData (allegro_devc * devc, UCHAR Index, PUSHORT Value)
 
280
{
 
281
  int i;
 
282
 
 
283
  *Value = 0;
 
284
  HWMGR_WriteDataByte (devc, CODEC_COMMAND, (UCHAR) (CODEC_READ_B | Index));
 
285
  for (i = 0; i < 1000; i++)
 
286
    {
 
287
      if (!(HWMGR_ReadDataByte (devc, CODEC_STATUS) & CODEC_BUSY_B))
 
288
        {
 
289
          *Value = HWMGR_ReadDataWord (devc, CODEC_DATA);
 
290
          return TRUE;
 
291
        }
 
292
    }
 
293
  if (CODEC_TYPE_ESS == bCodec)
 
294
    HWMGR_RestoreACLink (devc);
 
295
 
 
296
  return FALSE;
 
297
}                               /* HWMGR_ReadCodecData */
 
298
 
 
299
 
 
300
BOOLEAN
 
301
HWMGR_WriteCodecData (allegro_devc * devc, UCHAR Index, USHORT Value)
 
302
{
 
303
  int i;
 
304
 
 
305
  HWMGR_WriteDataWord (devc, CODEC_DATA, Value);
 
306
  HWMGR_WriteDataByte (devc, CODEC_COMMAND, Index);
 
307
  for (i = 0; i < 1000; i++)
 
308
    {
 
309
      if (!(HWMGR_ReadDataByte (devc, CODEC_STATUS) & CODEC_BUSY_B))
 
310
        {
 
311
          return TRUE;
 
312
        }
 
313
    }
 
314
  if (CODEC_TYPE_ESS == bCodec)
 
315
    HWMGR_RestoreACLink (devc);
 
316
  return FALSE;
 
317
}                               /* HWMGR_WriteCodecData */
 
318
 
 
319
void
 
320
HWMGR_EnableExternalAmp (allegro_devc * devc, BOOLEAN enable)
 
321
{
 
322
  USHORT wDirection;
 
323
  USHORT wGPO;
 
324
  USHORT wGPO2;
 
325
  USHORT wPolarity;
 
326
  USHORT wPolarity2;
 
327
 
 
328
  /*
 
329
   * by default, setup for reference board
 
330
   */
 
331
  if (bEapdSupportMode == 0)
 
332
    {
 
333
      bEapdSupportMode = 1;
 
334
      if (bChipType >= M3_1998)
 
335
        wEapdGPOPolarity_Port = 0x1100;
 
336
      else
 
337
        {
 
338
          wEapdGPOPolarity_Port = 0x1800;
 
339
          if (bChipType == 2)
 
340
            wEapdGPOPolarity_Port = 0x1c00;
 
341
          if (bEnable4Speaker)
 
342
            wEapdGPOPolarity_Port = 0x1600;
 
343
        }
 
344
    }
 
345
 
 
346
  dprintf3 (("Mode=%x PPort=%x", bEapdSupportMode, wEapdGPOPolarity_Port));
 
347
  wGPO2 = wPolarity2 = 0;
 
348
  switch (bEapdSupportMode)
 
349
    {
 
350
    case 0:
 
351
      break;
 
352
    case 2:
 
353
      wGPO2 = wEapdGPOPolarity_Port & 0x0F;
 
354
      wPolarity2 = wEapdGPOPolarity_Port >> 4 & 0x0F;
 
355
      if (enable)
 
356
        wPolarity2 = !wPolarity2;
 
357
      wPolarity2 = wPolarity2 << wGPO2;
 
358
      wGPO2 = 1 << wGPO2;
 
359
      wGPO = wEapdGPOPolarity_Port >> 8 & 0x0F;
 
360
      wPolarity = wEapdGPOPolarity_Port >> 12;
 
361
      if (enable)
 
362
        wPolarity = !wPolarity;
 
363
      wPolarity = wPolarity << wGPO;
 
364
      wGPO = 1 << wGPO;
 
365
      wGPO |= wGPO2;
 
366
      wPolarity |= wPolarity2;
 
367
      HWMGR_WriteDataWord (devc, GPIO_MASK, (USHORT) ~ wGPO);
 
368
      wDirection = HWMGR_ReadDataWord (devc, GPIO_DIRECTION) | wGPO;
 
369
      HWMGR_WriteDataWord (devc, GPIO_DIRECTION, wDirection);
 
370
      HWMGR_WriteDataWord (devc, GPIO_DATA, (USHORT) (GPO_SECONDARY_AC97 |
 
371
                                                      GPO_PRIMARY_AC97 |
 
372
                                                      wPolarity));
 
373
      HWMGR_WriteDataWord (devc, GPIO_MASK, 0xFFFF);
 
374
      break;
 
375
 
 
376
    case 1:
 
377
      wGPO = wEapdGPOPolarity_Port >> 8 & 0x0F;
 
378
      wPolarity = wEapdGPOPolarity_Port >> 12;
 
379
      if (enable)
 
380
        wPolarity = !wPolarity;
 
381
      wPolarity = wPolarity << wGPO;
 
382
      wGPO = 1 << wGPO;
 
383
      wGPO |= wGPO2;
 
384
      wPolarity |= wPolarity2;
 
385
      HWMGR_WriteDataWord (devc, GPIO_MASK, (USHORT) ~ wGPO);
 
386
      wDirection = HWMGR_ReadDataWord (devc, GPIO_DIRECTION) | wGPO;
 
387
      HWMGR_WriteDataWord (devc, GPIO_DIRECTION, wDirection);
 
388
      HWMGR_WriteDataWord (devc, GPIO_DATA, (USHORT) (GPO_SECONDARY_AC97 |
 
389
                                                      GPO_PRIMARY_AC97 |
 
390
                                                      wPolarity));
 
391
      HWMGR_WriteDataWord (devc, GPIO_MASK, 0xFFFF);
 
392
      break;
 
393
    }
 
394
}                               /* HWMGR_EnableExternalAmp */
 
395
 
 
396
 
 
397
void
 
398
HWMGR_EnableRemoteCodec (allegro_devc * devc, BOOLEAN enable)
 
399
{
 
400
  USHORT wData;
 
401
 
 
402
/* This function MUST be in a non-paged segment */
 
403
/*    PAGED_CODE(); */
 
404
  if (enable == fRemoteCodec)
 
405
    return;
 
406
  fRemoteCodec = enable;
 
407
  if (enable)
 
408
    {
 
409
 
 
410
      /* enable remote codec */
 
411
      wData = HWMGR_ReadDataWord (devc, RING_BUS_CTRL_B);
 
412
      wData = (wData & ~SECOND_CODEC_ID_MASK) | 1;
 
413
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B, wData);
 
414
      wData = HWMGR_ReadDataWord (devc, SDO_OUT_DEST_CTRL);
 
415
      wData = (wData & ~COMMAND_ADDR_OUT) | 1;
 
416
      HWMGR_WriteDataWord (devc, SDO_OUT_DEST_CTRL, wData);
 
417
      wData = HWMGR_ReadDataWord (devc, SDO_IN_DEST_CTRL);
 
418
      wData = (wData & ~STATUS_ADDR_IN) | 1;
 
419
      HWMGR_WriteDataWord (devc, SDO_IN_DEST_CTRL, wData);
 
420
    }
 
421
  else
 
422
    {
 
423
 
 
424
      /* disable remote codec */
 
425
      wData = HWMGR_ReadDataWord (devc, RING_BUS_CTRL_B);
 
426
      wData = wData & ~SECOND_CODEC_ID_MASK;
 
427
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B, wData);
 
428
      wData = HWMGR_ReadDataWord (devc, SDO_OUT_DEST_CTRL);
 
429
      wData = wData & ~COMMAND_ADDR_OUT;
 
430
      HWMGR_WriteDataWord (devc, SDO_OUT_DEST_CTRL, wData);
 
431
      wData = HWMGR_ReadDataWord (devc, SDO_IN_DEST_CTRL);
 
432
      wData = wData & ~STATUS_ADDR_IN;
 
433
      HWMGR_WriteDataWord (devc, SDO_IN_DEST_CTRL, wData);
 
434
    }
 
435
}                               /* HWMGR_EnableRemoteCodec */
 
436
 
 
437
#define AKM_CODEC       0x414B4D
 
438
#define TRA_CODEC       0x545241
 
439
#define ESS_CODEC       0x458383
 
440
#define STAC9721_CODEC  0x838476
 
441
#define STAC9721_REV_C  0x09
 
442
#define STAC9721_REV_D  0x44
 
443
 
 
444
BOOLEAN
 
445
HWMGR_ReadVendorId (allegro_devc * devc, OUT PULONG pulData, OUT PBYTE pbRev)
 
446
{
 
447
  USHORT wData;
 
448
 
 
449
  *pulData = 0;
 
450
  if (HWMGR_ReadCodecData (devc, AC97_VENDOR_ID1, &wData))
 
451
    {
 
452
      *pulData = (ULONG) wData << 16;
 
453
      if (HWMGR_ReadCodecData (devc, AC97_VENDOR_ID2, &wData))
 
454
        {
 
455
          *pulData |= wData;
 
456
          *pbRev = (UCHAR) * pulData;
 
457
          *pulData >>= 8;
 
458
          return TRUE;
 
459
        }
 
460
      *pulData = 0;
 
461
    }
 
462
  return FALSE;
 
463
}                               /* HWMGR_ReadVendorId */
 
464
 
 
465
void
 
466
HWMGR_ResetCodec (allegro_devc * devc)
 
467
{
 
468
  ULONG ulData;
 
469
  USHORT wData;
 
470
  USHORT wDirection;
 
471
  int delay_count;
 
472
  int reset_count;
 
473
  int wait_count;
 
474
  int DoReset = TRUE;
 
475
  BYTE bSaveCodec;
 
476
  BYTE bRev;
 
477
 
 
478
  delay_count = reset_count = wait_count = 0;
 
479
  wDirection = HWMGR_ReadDataWord (devc, GPIO_DIRECTION);
 
480
 
 
481
  /* not sure if this applies for Allegro-1/Maestro-3 */
 
482
  if (PCIRead (devc, PCI_USER_CONFIG) & EXT_PCI_MASTER_ENABLE)
 
483
    {
 
484
 
 
485
      /* GPIO4 = output */
 
486
      wDirection |= 0x10;
 
487
    }
 
488
 
 
489
  HWMGR_EnableRemoteCodec (devc, FALSE);
 
490
 
 
491
  /* set bCodec to undefined so that ReadCodecData will not try to restore */
 
492
  /* AC-link */
 
493
  bSaveCodec = bCodec;
 
494
  bCodec = 0;
 
495
 
 
496
  /* If we can read codec, skip codec reset to avoid pop sound. */
 
497
  /* HP Omnibook M3 does not setup AC-link correctly */
 
498
  HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, IO_SRAM_ENABLE);
 
499
 
 
500
  /* delay at least 20 us if disabling AC-link */
 
501
  KeStallExecutionProcessor (20);
 
502
  HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A,
 
503
                       IO_SRAM_ENABLE | SERIAL_AC_LINK_ENABLE);
 
504
  KeStallExecutionProcessor (1);
 
505
  if (HWMGR_ReadVendorId (devc, &ulData, &bRev))
 
506
    {
 
507
 
 
508
      dprintf1 (("codec1 id = %x", ulData));
 
509
      /* do not need to reset */
 
510
      DoReset = FALSE;
 
511
    }
 
512
  if (ulData != 0 && ulData != 0xFFFFFF)
 
513
    {
 
514
      ulCodec = ulData;
 
515
      bCodec = CODEC_TYPE_AC97;
 
516
      if (TRA_CODEC == ulCodec)
 
517
        {
 
518
 
 
519
          /* fix for tritech 2.0a codec */
 
520
          HWMGR_WriteCodecData (devc, 0x2A, 0x0001);
 
521
          HWMGR_WriteCodecData (devc, 0x2C, 0x0000);
 
522
          HWMGR_WriteCodecData (devc, 0x2C, 0xFFFF);
 
523
        }
 
524
      else if (ESS_CODEC == ulCodec)
 
525
        {
 
526
          bCodec = CODEC_TYPE_ESS;
 
527
        }
 
528
    }
 
529
  else
 
530
    {
 
531
      if (bChipType >= M3_1998)
 
532
        bCodec = CODEC_TYPE_AC97;
 
533
      else
 
534
        bCodec = CODEC_TYPE_ESS;
 
535
    }
 
536
  if (bSaveCodec)
 
537
    {
 
538
      bCodec = bSaveCodec;
 
539
    }
 
540
 
 
541
  dprintf1 (("reset codec1 bCodec=%d DoReset=%d", bCodec, DoReset));
 
542
  /* reset primary codec */
 
543
  if (DoReset)
 
544
    {
 
545
 
 
546
      /* regular AC97 codec */
 
547
      if (bChipType >= M3_1998)
 
548
        {
 
549
          delay_count = 20;
 
550
#if CRYSTAL_CODEC_FIX
 
551
          if (!ulCodec || CRY_CODEC == ulCodec)
 
552
            {
 
553
              wait_count = 500;
 
554
            }
 
555
          else
 
556
            {
 
557
              wait_count = 20;
 
558
            }
 
559
#else
 
560
          wait_count = 20;
 
561
#endif
 
562
        }
 
563
      else
 
564
        {
 
565
          delay_count = 50;
 
566
 
 
567
          /* delay 800 ms!? */
 
568
          wait_count = 800;
 
569
        }
 
570
      reset_count = 0;
 
571
 
 
572
    RESET_CODEC:
 
573
 
 
574
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, IO_SRAM_ENABLE);
 
575
 
 
576
      /* delay at least 20 us if disabling AC-link */
 
577
      KeStallExecutionProcessor (20);
 
578
 
 
579
      /* write GPO0 */
 
580
      HWMGR_WriteDataWord (devc, GPIO_DIRECTION,
 
581
                           wDirection & ~GPO_PRIMARY_AC97);
 
582
      HWMGR_WriteDataWord (devc, GPIO_MASK, (USHORT) ~ GPO_PRIMARY_AC97);
 
583
      HWMGR_WriteDataWord (devc, GPIO_DATA, 0x000);
 
584
      wDirection |= GPO_PRIMARY_AC97;
 
585
      HWMGR_WriteDataWord (devc, GPIO_DIRECTION, wDirection);
 
586
 
 
587
      /* delay 20 ms */
 
588
      DelayMillisec (delay_count);
 
589
      HWMGR_WriteDataWord (devc, GPIO_DATA, GPO_PRIMARY_AC97);
 
590
      KeStallExecutionProcessor (5);
 
591
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A,
 
592
                           IO_SRAM_ENABLE | SERIAL_AC_LINK_ENABLE);
 
593
      HWMGR_WriteDataWord (devc, GPIO_MASK, 0xFFFF);
 
594
 
 
595
      /* wait for codec to be ready */
 
596
      DelayMillisec (wait_count);
 
597
 
 
598
#if defined( AC97_RESETFIX )
 
599
      /* If unable to read from Codec, perform special reset */
 
600
      if (!HWMGR_ReadCodecData (devc, AC97_VENDOR_ID1, &wData))
 
601
        {
 
602
          /* Save Serial Link Configuration */
 
603
          HWMGR_ReadDataWord (devc, RING_BUS_CTRL_A, &wRingBusReg);
 
604
 
 
605
          /* Disable Serial AC Link and Cold Reset Codec */
 
606
          HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, _AC_SDFS_ENABLE);
 
607
 
 
608
          /* Delay 20mS */
 
609
          for (count = 0; count < 400; count++)
 
610
            KeStallExecutionProcessor (50);
 
611
 
 
612
          /* Enable AC Serial Link */
 
613
          HWMGR_WriteDataWord (devc, RING_BUG_CTRL_A, wRingBusReg);
 
614
 
 
615
          if (!HWMGR_ReadCodecData (devc, AC97_VENDOR_ID1, &wData))
 
616
            {
 
617
              /* Disable Serial AC Link and Cold Reset Codec */
 
618
              HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, _AC_SDFS_ENABLE);
 
619
 
 
620
              /* Warm Reset Codec */
 
621
              HWMGR_WriteDataByte (devc, CODEC_COMMAND, 0x00);
 
622
              /* Delay 20mS */
 
623
              for (count = 0; count < 400; count++)
 
624
                KeStallExecutionProcessor (50);
 
625
 
 
626
              /* Enable AC Serial Link */
 
627
              HWMGR_WriteDataWord (devc, RING_BUG_CTRL_A, wRingBusReg);
 
628
 
 
629
              /* Set AC97 PR4 26h[12] */
 
630
              HWMGR_ReadCodecData (devc, AC97_POWER_DOWN_CTRL, &wData);
 
631
              HWMGR_WriteCodecData (devc, AC97_POWER_DOWN_CTRL,
 
632
                                    wData | AC97_PR4);
 
633
 
 
634
              /* Warm Reset Codec */
 
635
              HWMGR_WriteDataByte (devc, CODEC_COMMAND, 0x00);
 
636
              /* Delay 20mS */
 
637
              for (count = 0; count < 400; count++)
 
638
                KeStallExecutionProcessor (50);
 
639
            }
 
640
        }
 
641
#endif
 
642
 
 
643
      if (!bCodec)
 
644
        {
 
645
          if (HWMGR_ReadVendorId (devc, &ulData, &bRev))
 
646
            {
 
647
              if (ulData != 0 && ulData != 0xFFFFFF)
 
648
                {
 
649
                  ulCodec = ulData;
 
650
                  bCodec = CODEC_TYPE_AC97;
 
651
                  if (TRA_CODEC == ulCodec)
 
652
                    {
 
653
 
 
654
                      /* fix for tritech 2.0a codec */
 
655
                      HWMGR_WriteCodecData (devc, 0x2A, 0x0001);
 
656
                      HWMGR_WriteCodecData (devc, 0x2C, 0x0000);
 
657
                      HWMGR_WriteCodecData (devc, 0x2C, 0xFFFF);
 
658
                    }
 
659
                  else if (ESS_CODEC == ulCodec)
 
660
                    {
 
661
                      bCodec = CODEC_TYPE_ESS;
 
662
                    }
 
663
                }
 
664
            }
 
665
          else
 
666
            {
 
667
              if (++reset_count < 20)
 
668
                {
 
669
                  delay_count += 10;
 
670
                  wait_count += 100;
 
671
                  goto RESET_CODEC;
 
672
                }
 
673
            }
 
674
          if (!bCodec)
 
675
            {
 
676
              if (bChipType >= M3_1998)
 
677
                bCodec = CODEC_TYPE_AC97;
 
678
              else
 
679
                bCodec = CODEC_TYPE_ESS;
 
680
            }
 
681
        }
 
682
    }
 
683
  else if ((wDirection & GPO_PRIMARY_AC97) == 0)
 
684
    {
 
685
      HWMGR_WriteDataWord (devc, GPIO_MASK, (USHORT) ~ GPO_PRIMARY_AC97);
 
686
      HWMGR_WriteDataWord (devc, GPIO_DATA, GPO_PRIMARY_AC97);
 
687
      wDirection |= GPO_PRIMARY_AC97;
 
688
      HWMGR_WriteDataWord (devc, GPIO_DIRECTION, wDirection);
 
689
      HWMGR_WriteDataWord (devc, GPIO_MASK, 0xFFFF);
 
690
    }
 
691
 
 
692
  dprintf1 (("Codec:%d\n", bCodec));
 
693
 
 
694
  if (CODEC_TYPE_ESS == bCodec)
 
695
    {
 
696
      if (HWMGR_ReadCodecData (devc, AC97_CLOCK_DELAY, &wData))
 
697
        {
 
698
          wData &= ~(AC97_CLOCK_DELAY_SEL << AC97_ADC_CDS_SHIFT);
 
699
          wData |= 18 << AC97_ADC_CDS_SHIFT;
 
700
          HWMGR_WriteCodecData (devc, AC97_CLOCK_DELAY, wData);
 
701
        }
 
702
      else
 
703
        {
 
704
          if (++reset_count < 20)
 
705
            {
 
706
              delay_count += 10;
 
707
              wait_count += 100;
 
708
              goto RESET_CODEC;
 
709
            }
 
710
        }
 
711
    }
 
712
 
 
713
  if (gwDockVal)
 
714
    {
 
715
      HWMGR_EnableRemoteCodec (devc, TRUE);
 
716
 
 
717
      wData = HWMGR_ReadDataWord (devc, RING_BUS_CTRL_B);
 
718
      wData &= ~(SECOND_AC_ENABLE | SECOND_CODEC_ID_MASK);
 
719
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B,
 
720
                           (USHORT) (wData | SECOND_AC_ENABLE | 1));
 
721
 
 
722
      /* If we can read codec, skip codec reset to avoid pop sound. */
 
723
      DoReset = TRUE;
 
724
      if (HWMGR_ReadVendorId (devc, &ulData, &bRev))
 
725
        {
 
726
 
 
727
          dprintf1 (("Read:%x,%x\n", ulData, bRev));
 
728
 
 
729
          /* do not need to reset */
 
730
          DoReset = FALSE;
 
731
        }
 
732
 
 
733
      /* reset secondary codec */
 
734
      if (DoReset)
 
735
        {
 
736
          HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A, IO_SRAM_ENABLE);
 
737
 
 
738
          /* delay at least 20 us if disabling AC-link */
 
739
          KeStallExecutionProcessor (20);
 
740
 
 
741
          /* write GPO3 */
 
742
          HWMGR_WriteDataWord (devc, GPIO_DIRECTION,
 
743
                               wDirection & ~GPO_SECONDARY_AC97);
 
744
          HWMGR_WriteDataWord (devc, GPIO_MASK,
 
745
                               (USHORT) ~ GPO_SECONDARY_AC97);
 
746
          HWMGR_WriteDataWord (devc, GPIO_DATA, 0x000);
 
747
          wDirection |= GPO_SECONDARY_AC97;
 
748
          HWMGR_WriteDataWord (devc, GPIO_DIRECTION, wDirection);
 
749
 
 
750
          /* delay 20 ms */
 
751
          DelayMillisec (20);
 
752
          HWMGR_WriteDataWord (devc, GPIO_DATA, GPO_SECONDARY_AC97);
 
753
 
 
754
          /* delay 20 ms */
 
755
          DelayMillisec (20);
 
756
          HWMGR_WriteDataWord (devc, GPIO_MASK, 0xFFFF);
 
757
 
 
758
          HWMGR_WriteDataWord (devc, RING_BUS_CTRL_A,
 
759
                               IO_SRAM_ENABLE | SERIAL_AC_LINK_ENABLE);
 
760
          KeStallExecutionProcessor (1);
 
761
 
 
762
          /* read vendor id */
 
763
          (void) HWMGR_ReadVendorId (devc, &ulData, &bRev);
 
764
 
 
765
          dprintf1 (("Reset:%x,%x\n", ulData, bRev));
 
766
        }
 
767
      else if ((wDirection & GPO_SECONDARY_AC97) == 0)
 
768
        {
 
769
          HWMGR_WriteDataWord (devc, GPIO_MASK,
 
770
                               (USHORT) ~ GPO_SECONDARY_AC97);
 
771
          HWMGR_WriteDataWord (devc, GPIO_DATA, GPO_SECONDARY_AC97);
 
772
          wDirection |= GPO_SECONDARY_AC97;
 
773
          HWMGR_WriteDataWord (devc, GPIO_DIRECTION, wDirection);
 
774
          HWMGR_WriteDataWord (devc, GPIO_MASK, 0xFFFF);
 
775
        }
 
776
      if (ulData != 0 && ulData != 0xFFFFFF)
 
777
        {
 
778
          if (TRA_CODEC == ulData)
 
779
            {
 
780
 
 
781
              /* fix for tritech 2.0a codec */
 
782
              HWMGR_WriteCodecData (devc, 0x2A, 0x0001);
 
783
              HWMGR_WriteCodecData (devc, 0x2C, 0x0000);
 
784
              HWMGR_WriteCodecData (devc, 0x2C, 0xFFFF);
 
785
            }
 
786
          else if (STAC9721_CODEC == ulData)
 
787
            {
 
788
              USHORT wStatus;
 
789
 
 
790
              if (!HWMGR_ReadCodecData
 
791
                  (devc, AC97_POWER_DOWN_CTRL, &wStatus) || 0 == wStatus)
 
792
                {
 
793
                  HWMGR_WriteCodecData (devc, 0x76, 0xABBA);
 
794
                  if (STAC9721_REV_D == bRev)
 
795
                    {
 
796
                      HWMGR_WriteCodecData (devc, 0x78, 0x2002);
 
797
                      KeStallExecutionProcessor (20);
 
798
                      HWMGR_WriteCodecData (devc, 0x78, 0x2802);
 
799
                    }
 
800
                  else
 
801
                    {
 
802
                      HWMGR_WriteCodecData (devc, 0x78, 0x3002);
 
803
                      KeStallExecutionProcessor (20);
 
804
                      HWMGR_WriteCodecData (devc, 0x78, 0x3802);
 
805
                    }
 
806
                }
 
807
            }
 
808
        }
 
809
      HWMGR_EnableRemoteCodec (devc, FALSE);
 
810
 
 
811
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B, wData);
 
812
    }
 
813
}                               /* HWMGR_ResetCodec */
 
814
 
 
815
#if 0
 
816
#define DSP33MHZ  0
 
817
#define DSP36MHZ  1
 
818
#define DSP49MHZ  2
 
819
#endif
 
820
 
 
821
 
 
822
UCHAR bGray_Code[32] = {
 
823
  0x00, 0x01, 0x03, 0x02, 0x07, 0x06, 0x04, 0x05,
 
824
  0x0F, 0x0E, 0x0C, 0x0D, 0x08, 0x09, 0x0B, 0x0A,
 
825
  0x1F, 0x1E, 0x1C, 0x1D, 0x18, 0x19, 0x1B, 0x1A,
 
826
  0x10, 0x11, 0x13, 0x12, 0x17, 0x16, 0x14, 0x15
 
827
};
 
828
 
 
829
void
 
830
HWMGR_SetClockSpeed (allegro_devc * devc, UCHAR speed)
 
831
{
 
832
  ULONG ulData;
 
833
  int choice;
 
834
  int mode;
 
835
  UCHAR bModeValue[8];
 
836
  UCHAR bData;
 
837
  UCHAR bDelta;
 
838
 
 
839
  HWMGR_WriteDataByte (devc, ASSP_CONTROL_B, RESET_ASSP);
 
840
 
 
841
  ulData = PCIRead (devc, PCI_ALLEGRO_CONFIG);
 
842
  ulData &= ~INT_CLK_SELECT;
 
843
  ulData &= ~(CLK_MULT_MODE_SELECT | CLK_MULT_MODE_SELECT_2);
 
844
  PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
845
 
 
846
  if (DSP36MHZ == speed)
 
847
    {
 
848
      ulData = PCIRead (devc, PCI_USER_CONFIG);
 
849
      ulData &= ~IN_CLK_12MHZ_SELECT;
 
850
      PCIWrite (devc, PCI_USER_CONFIG, ulData);
 
851
 
 
852
      for (mode = 0; mode < 4; mode++)
 
853
        {
 
854
          ulData |= INT_CLK_MULT_RESET;
 
855
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
856
          ulData &= ~CLK_MULT_MODE_SELECT;
 
857
          ulData |= mode << CLK_MULT_MODE_SHIFT;
 
858
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
859
          ulData &= ~INT_CLK_MULT_RESET;
 
860
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
861
 
 
862
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
863
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
864
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
865
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
866
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
867
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
868
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
869
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
870
          bModeValue[mode] =
 
871
            bGray_Code[HWMGR_ReadDataWord (devc, CLK_MULT_DATA_PORT) >> 5
 
872
                       & 0x1F];
 
873
        }
 
874
      ulData |= CLK_MULT_MODE_SELECT_2;
 
875
      for (mode = 0; mode < 4; mode++)
 
876
        {
 
877
          ulData |= INT_CLK_MULT_RESET;
 
878
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
879
          ulData &= ~CLK_MULT_MODE_SELECT;
 
880
          ulData |= mode << CLK_MULT_MODE_SHIFT;
 
881
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
882
          ulData &= ~INT_CLK_MULT_RESET;
 
883
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
884
 
 
885
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
886
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
887
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
888
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
889
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
890
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
891
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
892
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
893
          bModeValue[mode + 4] =
 
894
            bGray_Code[HWMGR_ReadDataWord (devc, CLK_MULT_DATA_PORT) >> 5
 
895
                       & 0x1F];
 
896
        }
 
897
#define Abs(x) ((x)<0) ? -(x) : (x)
 
898
      bDelta = Abs (bModeValue[0] - 0x10);
 
899
      choice = 0;
 
900
      for (mode = 1; mode < 8; mode++)
 
901
        {
 
902
          if (bDelta > Abs (bModeValue[mode] - 0x10))
 
903
            {
 
904
              bDelta = Abs (bModeValue[mode] - 0x10);
 
905
              choice = mode;
 
906
            }
 
907
        }
 
908
 
 
909
#if 0
 
910
      _Debug_Printf_Service ("mode:%d\n", choice);
 
911
#endif
 
912
      ulData &= ~(CLK_MULT_MODE_SELECT | CLK_MULT_MODE_SELECT_2);
 
913
      if (choice > 3)
 
914
        {
 
915
          ulData |= CLK_MULT_MODE_SELECT_2;
 
916
          choice -= 4;
 
917
        }
 
918
      ulData |= INT_CLK_MULT_RESET;
 
919
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
920
      ulData |= choice << CLK_MULT_MODE_SHIFT;
 
921
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
922
      ulData &= ~INT_CLK_MULT_RESET;
 
923
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
924
 
 
925
      ulData |= INT_CLK_SELECT;
 
926
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
927
      READ_PORT_UCHAR (devc->osdev, 0x80);
 
928
      READ_PORT_UCHAR (devc->osdev, 0x80);
 
929
    }
 
930
  else
 
931
    {
 
932
      ulData = PCIRead (devc, PCI_USER_CONFIG);
 
933
      ulData |= IN_CLK_12MHZ_SELECT;
 
934
      PCIWrite (devc, PCI_USER_CONFIG, ulData);
 
935
    }
 
936
 
 
937
  bData = HWMGR_ReadDataByte (devc, ASSP_CONTROL_A);
 
938
  bData &= ~(DSP_CLK_36MHZ_SELECT | ASSP_CLK_49MHZ_SELECT);
 
939
  bData |= ASSP_0_WS_ENABLE;
 
940
  switch (speed)
 
941
    {
 
942
    case DSP36MHZ:
 
943
      bData |= DSP_CLK_36MHZ_SELECT;
 
944
      break;
 
945
    case DSP49MHZ:
 
946
      bData |= ASSP_CLK_49MHZ_SELECT;
 
947
      break;
 
948
    }
 
949
  HWMGR_WriteDataByte (devc, ASSP_CONTROL_A, bData);
 
950
 
 
951
  HWMGR_WriteDataByte (devc, ASSP_CONTROL_B, RUN_ASSP);
 
952
}                               /* HWMGR_SetClockSpeed */
 
953
 
 
954
void
 
955
HWMGR_SetM3ClockSpeed (allegro_devc * devc, UCHAR speed)
 
956
{
 
957
  ULONG ulData;
 
958
  int choice;
 
959
  int mode;
 
960
  UCHAR bModeValue[8];
 
961
  UCHAR bData;
 
962
  UCHAR bDelta;
 
963
 
 
964
  HWMGR_WriteDataByte (devc, ASSP_CONTROL_B, RESET_ASSP);
 
965
 
 
966
  ulData = PCIRead (devc, PCI_ALLEGRO_CONFIG);
 
967
  if (DSP33MHZ == speed)
 
968
    ulData &= ~INT_CLK_SRC_NOT_PCI;
 
969
  else
 
970
    ulData |= INT_CLK_SRC_NOT_PCI;
 
971
  ulData &= ~(INT_CLK_MULT_ENABLE | INT_CLK_SELECT);
 
972
  ulData &= ~(CLK_MULT_MODE_SELECT | CLK_MULT_MODE_SELECT_2);
 
973
  PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
974
 
 
975
  if (DSP36MHZ == speed)
 
976
    {
 
977
      ulData = PCIRead (devc, PCI_USER_CONFIG);
 
978
      ulData |= IN_CLK_12MHZ_SELECT;
 
979
      PCIWrite (devc, PCI_USER_CONFIG, ulData);
 
980
 
 
981
      for (mode = 0; mode < 4; mode++)
 
982
        {
 
983
          ulData &= ~INT_CLK_MULT_ENABLE;
 
984
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
985
          ulData &= ~CLK_MULT_MODE_SELECT;
 
986
          ulData |= mode << CLK_MULT_MODE_SHIFT;
 
987
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
988
          ulData |= INT_CLK_MULT_ENABLE;
 
989
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
990
 
 
991
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
992
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
993
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
994
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
995
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
996
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
997
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
998
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
999
          bModeValue[mode] =
 
1000
            bGray_Code[HWMGR_ReadDataWord (devc, CLK_MULT_DATA_PORT) >> 5
 
1001
                       & 0x1F];
 
1002
        }
 
1003
      ulData |= CLK_MULT_MODE_SELECT_2;
 
1004
      for (mode = 0; mode < 4; mode++)
 
1005
        {
 
1006
          ulData &= ~INT_CLK_MULT_ENABLE;
 
1007
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1008
          ulData &= ~CLK_MULT_MODE_SELECT;
 
1009
          ulData |= mode << CLK_MULT_MODE_SHIFT;
 
1010
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1011
          ulData |= INT_CLK_MULT_ENABLE;
 
1012
          PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1013
 
 
1014
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1015
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1016
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1017
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1018
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1019
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1020
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1021
          READ_PORT_UCHAR (devc->osdev, 0x80);
 
1022
          bModeValue[mode + 4] =
 
1023
            bGray_Code[HWMGR_ReadDataWord (devc, CLK_MULT_DATA_PORT) >> 5
 
1024
                       & 0x1F];
 
1025
        }
 
1026
      bDelta = Abs (bModeValue[0] - 0x10);
 
1027
      choice = 0;
 
1028
      for (mode = 1; mode < 8; mode++)
 
1029
        {
 
1030
          if (bDelta > Abs (bModeValue[mode] - 0x10))
 
1031
            {
 
1032
              bDelta = Abs (bModeValue[mode] - 0x10);
 
1033
              choice = mode;
 
1034
            }
 
1035
        }
 
1036
 
 
1037
#if 0
 
1038
      _Debug_Printf_Service ("mode:%d\n", choice);
 
1039
#endif
 
1040
      ulData &= ~(INT_CLK_MULT_ENABLE | CLK_MULT_MODE_SELECT |
 
1041
                  CLK_MULT_MODE_SELECT_2);
 
1042
      if (choice > 3)
 
1043
        {
 
1044
          ulData |= CLK_MULT_MODE_SELECT_2;
 
1045
          choice -= 4;
 
1046
        }
 
1047
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1048
      ulData |= choice << CLK_MULT_MODE_SHIFT;
 
1049
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1050
      ulData |= INT_CLK_MULT_ENABLE;
 
1051
      PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1052
    }
 
1053
 
 
1054
  bData = HWMGR_ReadDataByte (devc, ASSP_CONTROL_A);
 
1055
  bData &= ~(DSP_CLK_36MHZ_SELECT | ASSP_CLK_49MHZ_SELECT);
 
1056
  bData |= ASSP_0_WS_ENABLE;
 
1057
  switch (speed)
 
1058
    {
 
1059
    case DSP36MHZ:
 
1060
      bData |= DSP_CLK_36MHZ_SELECT;
 
1061
      break;
 
1062
    case DSP49MHZ:
 
1063
      bData |= ASSP_CLK_49MHZ_SELECT;
 
1064
      break;
 
1065
    }
 
1066
  HWMGR_WriteDataByte (devc, ASSP_CONTROL_A, bData);
 
1067
 
 
1068
  HWMGR_WriteDataByte (devc, ASSP_CONTROL_B, RUN_ASSP);
 
1069
}                               /* HWMGR_SetM3ClockSpeed */
 
1070
 
 
1071
 
 
1072
BOOLEAN
 
1073
HWMGR_InitKernel (allegro_devc * devc)
 
1074
{
 
1075
  ULONG ulData;
 
1076
 
 
1077
  ulData = PCIRead (devc, PCI_ALLEGRO_CONFIG);
 
1078
  ulData &= REDUCED_DEBOUNCE;
 
1079
 
 
1080
  if (gbHwVolEnabled)
 
1081
    {
 
1082
      ulData |= HV_CTRL_ENABLE;
 
1083
 
 
1084
      if (bHwVolCtrlMode == -1)
 
1085
        {
 
1086
          bHwVolCtrlMode = 0;
 
1087
          if (bChipType < M3_1998)
 
1088
            bHwVolCtrlMode = 1;
 
1089
        }
 
1090
 
 
1091
      if (PCIRead (devc, 0x2c) == NEC_VENDOR_ID3)
 
1092
        {
 
1093
          bHwVolCtrlMode |= (0x80 | 0x40);
 
1094
        }
 
1095
 
 
1096
      if (bHwVolCtrlMode & 0x80)
 
1097
        {
 
1098
          bHwVolCtrlMode &= ~0x80;
 
1099
          ulData |= REDUCED_DEBOUNCE;
 
1100
        }
 
1101
 
 
1102
      if (bHwVolCtrlMode & 0x40)
 
1103
        {
 
1104
          bHwVolCtrlMode &= ~0x40;
 
1105
          PCIWrite (devc, PCI_USER_CONFIG,
 
1106
                    PCIRead (devc, PCI_USER_CONFIG) | HV_CTRL_TEST);
 
1107
        }
 
1108
 
 
1109
      dprintf1 (("bHwVolCtrlMode=%x", bHwVolCtrlMode));
 
1110
 
 
1111
      /* default 53/54 pin */
 
1112
      switch (bHwVolCtrlMode)
 
1113
        {
 
1114
 
 
1115
          /* 44/45 pin */
 
1116
        case 0x01:
 
1117
          ulData |= HV_BUTTON_FROM_GD;
 
1118
          break;
 
1119
 
 
1120
#if 0
 
1121
          /* M3E */
 
1122
        case 0x02:
 
1123
          break;
 
1124
          /* M3E */
 
1125
        case 0x03:
 
1126
          break;
 
1127
          /* M3E */
 
1128
        case 0x04:
 
1129
          break;
 
1130
#endif
 
1131
        }
 
1132
    }
 
1133
 
 
1134
  ulData |= PM_CTRL_ENABLE | CLK_DIV_BY_49 | USE_PCI_TIMING;
 
1135
  PCIWrite (devc, PCI_ALLEGRO_CONFIG, ulData);
 
1136
 
 
1137
  ulData = PCIRead (devc, PCI_USER_CONFIG);
 
1138
  ulData |= MIDI_1_ENABLE;
 
1139
  PCIWrite (devc, PCI_USER_CONFIG, ulData);
 
1140
 
 
1141
  if (bChipType >= M3_1998)
 
1142
    HWMGR_SetM3ClockSpeed (devc, DSP49MHZ);
 
1143
  else
 
1144
    /* new Allegro board only works with external 49 Mhz clock */
 
1145
    HWMGR_SetClockSpeed (devc, DSP49MHZ);
 
1146
  /*ulDSPConnectIn = KCONNECT_ADC1; */
 
1147
 
 
1148
  /* initialize the DSP kernel */
 
1149
  if (kInitKernel (devc, &gphwi, 0x1978, 0x10, devc->base, 0) !=
 
1150
      KRETURN_SUCCESS)
 
1151
    return FALSE;
 
1152
 
 
1153
#ifdef later
 
1154
  InitModem ();
 
1155
#endif
 
1156
 
 
1157
#ifdef FIXED_MODEM
 
1158
  {
 
1159
    extern DWORD gdwESModem;
 
1160
    extern DWORD DisableModemClient (VOID);
 
1161
    if (gdwESModem)
 
1162
      {
 
1163
        if (kOpenInstance
 
1164
            (gphwi, CLIENT_MODEM, 0, 0x180 * 2,
 
1165
             &pClient_Modem) != KRETURN_SUCCESS)
 
1166
          return FALSE;
 
1167
        DisableModemClient ();
 
1168
      }
 
1169
  }
 
1170
#endif
 
1171
 
 
1172
  return TRUE;
 
1173
}                               /* HWMGR_InitKernel */
 
1174
 
 
1175
/* -------------------------------------------------------------------------- */
 
1176
 
 
1177
void
 
1178
HWMGR_InitSystem (allegro_devc * devc)
 
1179
{
 
1180
  WORD wData;
 
1181
  DWORD dwVal;
 
1182
 
 
1183
#if 0                           /* this cause zip sound for Compaq. Code here is for problems for older */
 
1184
  /* allegro chip, new one does not need this any more. */
 
1185
  /* prevent AC-link deadlocking */
 
1186
  HWMGR_WriteDataWord (devc, HOST_INT_CTRL, SOFTWARE_RESET_ENABLE);
 
1187
  KeStallExecutionProcessor (5);
 
1188
  HWMGR_WriteDataWord (devc, HOST_INT_CTRL, 0x0);
 
1189
#endif
 
1190
 
 
1191
  HWMGR_InitKernel (devc);
 
1192
 
 
1193
  if (bEnableDockDetect)
 
1194
    {
 
1195
      wDockedMask = bDockingDetectGPIPort & 0x0F;
 
1196
      wDockedValue = (bDockingDetectGPIPort >> 4 & 0x0F) << wDockedMask;
 
1197
      wDockedMask = 1 << wDockedMask;
 
1198
      gwDockVal =
 
1199
        (HWMGR_ReadDataWord (devc, GPIO_DATA) & wDockedMask) == wDockedValue;
 
1200
    }
 
1201
  else
 
1202
    {
 
1203
      wDockedMask = wDockedValue = 0;
 
1204
    }
 
1205
 
 
1206
  /* force to set correct codec */
 
1207
  fRemoteCodec = 0xFF;
 
1208
 
 
1209
  HWMGR_ResetCodec (devc);
 
1210
 
 
1211
  /* allegro codec proble from cold boot so one more resetcodec */
 
1212
  HWMGR_ResetCodec (devc);
 
1213
 
 
1214
  if (CODEC_TYPE_ESS == bCodec)
 
1215
    {
 
1216
 
 
1217
      /* power down DAC to resynchronize after AC-link change */
 
1218
      HWMGR_WriteCodecData (devc, AC97_POWER_DOWN_CTRL, AC97_PR1);
 
1219
      KeStallExecutionProcessor (1);
 
1220
    }
 
1221
 
 
1222
  /* codec not reset every time */
 
1223
  HWMGR_WriteCodecData (devc, AC97_POWER_DOWN_CTRL, 0);
 
1224
  HWMGR_EnableExternalAmp (devc, TRUE);
 
1225
  if (gwDockVal)
 
1226
    {
 
1227
      wData = HWMGR_ReadDataWord (devc, RING_BUS_CTRL_B);
 
1228
      wData |= SECOND_AC_ENABLE;
 
1229
      HWMGR_WriteDataWord (devc, RING_BUS_CTRL_B, wData);
 
1230
    }
 
1231
 
 
1232
  HWMGR_ReadCodecData (devc, AC97_GENERAL_PURPOSE, &wData);
 
1233
  if (bMonoOutputSelect)
 
1234
    {
 
1235
      wData |= 0x300;
 
1236
 
 
1237
      HWMGR_WriteCodecData (devc, AC97_MASTER_MONO_VOL, gwDefaultMonoOutVol);
 
1238
      KeStallExecutionProcessor (100);
 
1239
      HWMGR_WriteCodecData (devc, AC97_MASTER_MONO_VOL, gwDefaultMonoOutVol);
 
1240
    }
 
1241
  else
 
1242
    wData &= ~0x300;
 
1243
  HWMGR_WriteCodecData (devc, AC97_GENERAL_PURPOSE, wData);
 
1244
 
 
1245
  /* fix DAC volume at 0x0808 */
 
1246
  HWMGR_WriteCodecData (devc, AC97_MASTER_VOL, 0x0404);
 
1247
  HWMGR_WriteCodecData (devc, AC97_PCM_OUT_VOL, 0x0404);
 
1248
 
 
1249
  /* Mute the ADC */
 
1250
  if (!g4Speaker)
 
1251
    HWMGR_WriteCodecData (devc, AC97_RECORD_GAIN, 0x8000);
 
1252
 
 
1253
  gwDSPConnectIn = KCONNECT_ADC1;
 
1254
 
 
1255
  /*
 
1256
   * Undock it first
 
1257
   */
 
1258
  dwVal = HW_INIT_SET_ACTIVE_ACINTF;
 
1259
  dwVal <<= 16;
 
1260
  HwSetSystemParameter (devc, dwVal);
 
1261
 
 
1262
  /*
 
1263
   * Setup active I/F
 
1264
   */
 
1265
  dwVal = HW_INIT_SET_ACTIVE_ACINTF;
 
1266
  dwVal <<= 16;
 
1267
 
 
1268
  HwSetSystemParameter (devc, dwVal);
 
1269
}                               /* HWMGR_InitSystem */
 
1270
 
 
1271
 
 
1272
void
 
1273
HwRelease (allegro_devc * devc)
 
1274
{
 
1275
#ifdef later
 
1276
  CloseModem ();
 
1277
#endif
 
1278
 
 
1279
  kTermKernel (devc, gphwi, devc->base);
 
1280
 
 
1281
  HWMGR_EnableExternalAmp (devc, FALSE);
 
1282
 
 
1283
  /* MUTE THE DAMN THING FIRST */
 
1284
  WriteLego (devc, 0x02, 0x3F3F);       /* LOUT1 Master Attenuation (-1.5dB steps: 0000 = 0dB, 3F3F = -94dB, ) */
 
1285
 
 
1286
  WriteLego (devc, 0x04, 0x9F1F);       /* Headphone */
 
1287
  WriteLego (devc, 0x06, 0x9F1F);       /* MonoOut */
 
1288
  WriteLego (devc, 0x12, 0x9F1F);       /* CD to Mixer Level (80=mute; 00=+12.0dB, 08=0.0dB, 0F = -33dB) */
 
1289
  WriteLego (devc, 0x16, 0x9F1F);       /* AUX to Mixer Level (80=mute; 00=+12.0dB, 08=0.0dB, 0F = -33dB) */
 
1290
  WriteLego (devc, 0x0E, 0x9F1F);       /* Mic         to Mixer Level (80=mute; 00=+12.0dB, 08=0.0dB, 0F = -33dB) */
 
1291
  WriteLego (devc, 0x18, 0x9F1F);       /* DAC         to Mixer Level (80=mute; 00=+12.0dB, 08=0.0dB, 0F = -33dB) */
 
1292
  WriteLego (devc, 0x10, 0x9F1F);       /* Line in     to Mixer Level (80=mute; 00=+12.0dB, 08=0.0dB, 0F = -33dB) */
 
1293
  WriteLego (devc, 0x1A, 0);    /* Rec Gain */
 
1294
  WriteLego (devc, 0x1C, 0x8F0F);       /* Rec Gain */
 
1295
}