开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
hwctxt.cpp
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：54k
源码类别：

Windows CE

开发平台：

Windows_Unix

hwctxt.cpp：源码内容
  1. //
  2. // Copyright (c) Microsoft Corporation.  All rights reserved.
  3. //
  4. //
  5. // Use of this source code is subject to the terms of the Microsoft end-user
  6. // license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
  7. // If you did not accept the terms of the EULA, you are not authorized to use
  8. // this source code. For a copy of the EULA, please see the LICENSE.RTF on your
  9. // install media.
  10. //
  11. /*++
  12. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  13. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  14. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  15. PARTICULAR PURPOSE.
  17.    
  18. Module Name: HWCTXT.CPP
  20. Abstract: Platform dependent code for the mixing audio driver.
  22. Notes: The following file contains all the hardware specific code
  23. for the mixing audio driver.  This code's primary responsibilities
  24. are:
  26. * Initialize audio hardware (including codec chip)
  27. * Schedule DMA operations (move data from/to buffers)
  28. * Handle audio interrupts
  30. All other tasks (mixing, volume control, etc.) are handled by the "upper"
  31. layers of this driver.
  33. ****** IMPORTANT ******
  34. Presently, audio input (i.e. RECORD functionality) IS NOT implemented.  On 
  35. this platform, in order to record the TLV320AIC codec chip needs to be 
  36. configured as MASTER and the CPU's I2S controller configured as SLAVE.  
  37. Unfortunately, a hardware bug in the current Samsung CPU samples prevents 
  38. SLAVE mode from working properly.  As a result, only audio playback is 
  39. supported by configuring the CPU I2S controller as MASTER and the audio
  40. codec chip as SLAVE.  
  42. The final revision of the Samsung SC2440 CPU is expected to fix this 
  43. hardware bug.  Once this issue is resolved, the CPU's I2S controller 
  44. (look at I2S.CPP) should be configured in SLAVE mode and the audio codec 
  45. chip (see InitCodec() below) should be configured as MASTER.  With these
  46. changes, the following routines need to be implemented:
  48. InitInputDMA() - initialize the input DMA channel
  49. StartInputDMA() - starts DMA operations on the input DMA channel
  50. StopInputDMA() - stops any current DMA operations on the input DMA channel
  52. For the SC2440 CPU, DMA channel 2 can be used for both input and output.  In this,
  53. configuration, however, only one type operation (input or output) can execute.  In 
  54. order to implement simultaneous playback and recording, two things must be done:
  55.  
  56. 1) Input DMA should be moved to DMA Channel 1; Output DMA still uses DMA Channel 2.
  57. 2) Step #3 in InterruptThread() needs to be implemented so that the DMA interrupt
  58.    source (input DMA or output DMA?) can be determined.  The interrupt source needs
  59.    to be determined so that the appropriate buffers can be copied (Steps #4,#5...etc.).
  61. Lastly, the m_OutputDMAStatus and m_InputDMAStatus variables shouldn't need to be modified.  
  62. The logic surrounding these drivers is simply used to determine which buffer (A or B) needs
  63. processing.
  65. Environment: PocketPC SMDK2440 Reference Platform:
  67. Hardware - Samsung SC2440 CPU
  68.    TI TLV320AIC audio codec chip where: 
  69. 1) SPI bus is used for control 
  70. 2) I2S bus is used for data (CPU is master
  71.    and codec chip is slave)
  73. Software - Windows CE 3.0 and later.    
  74. -*/
  76. #include "wavemain.h"
  77. #include <p2.h>
  78. #include "s2440.h"
  79. #include "dma.h"
  80. #include "hwctxt.h"
  82. #define DMA_FLAG 1
  85. #define AC97_DEBUG 0
  86. #define AC97MSG(a,b) RETAILMSG(AC97_DEBUG,b)
  88. #define DMA_CH_MIC 2
  89. #define DMA_CH_OUT 1
  91. #define WAIT_DMA_END 0
  93. #define DELAY_COUNT 0x1000
  96. int rec_mode=0;
  98. //-------------------------------- Global Variables --------------------------------------
  99. volatile AC97reg *v_pAC97regs = NULL; // AC97 control registers
  100. volatile IOPreg *v_pIOPregs = NULL; // GPIO registers (needed to enable I2S and SPI)
  101. volatile DMAreg *v_pDMAregs = NULL; // DMA registers (needed for I/O on I2S bus)
  102. volatile CLKPWRreg *g_pCLKPWRreg = NULL; // Clock power registers (needed to enable I2S and SPI clocks)
  103. volatile INTreg  *s2440INT  = NULL;
  105. HANDLE          g_hUTLObject = INVALID_HANDLE_VALUE;
  107. HardwareContext *g_pHWContext = NULL;
  109. void AC97_GPIO_Init();
  111. unsigned int delay_count;
  112. //----------------------------------------------------------------------------------------
  114. /*#ifdef DEBUG
  115. DBGPARAM dpCurSettings = {
  116.     TEXT("CONSOLE"), {
  117.         TEXT("0"),TEXT("1"),TEXT("2"),TEXT("3"),
  118.         TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),
  119.         TEXT("8"),TEXT("9"),TEXT("10"),TEXT("11"),
  120.         TEXT("12"),TEXT("Function"),TEXT("Init"),TEXT("Error")},
  121.     0x8000  // Errors only, by default
  122. }; 
  123. #endif
  124. */
  126. // Static Functions
  127. volatile static int loop = S2440FCLK/100000;
  129. static void Delay(USHORT count)
  130. {
  131. volatile int i, j;
  133. for(;count > 0;count--)
  134. for(i=0;i < loop; i++) { j++; }
  135. }
  137. static void WriteCodecRegister(UCHAR Reg, USHORT Val)
  138. {
  139. v_pAC97regs->rAC_CODEC_CMD = (Reg << AC97_CMD_ADDR_SHIFT) | (Val << AC97_CMD_DATA_SHIFT);
  140. Delay(100);
  141. //Sleep(5);
  142. v_pAC97regs->rAC_CODEC_CMD |= (AC97_READ_COMMAND); //To receive SLOTREQ bits when VRA is '1'.
  143. }
  145. static USHORT ReadCodecRegister(UCHAR Reg)
  146. {
  147. USHORT retval;
  149. v_pAC97regs->rAC_CODEC_CMD = AC97_READ_COMMAND | (Reg << AC97_CMD_ADDR_SHIFT);
  151. Delay(100);
  152. //Sleep(5);
  154. retval = v_pAC97regs->rAC_CODEC_STAT & AC97_STAT_DATA_READ_MASK;
  156. return retval;
  157. }
  160. BOOL HardwareContext::CreateHWContext(DWORD Index)
  161. {
  162.     if (g_pHWContext)
  163.     {
  164.         return TRUE;
  165.     }
  167.     g_pHWContext = new HardwareContext;
  168.     if (!g_pHWContext)
  169.     {
  170.         return FALSE;
  171.     }
  173.     return g_pHWContext->Init(Index);
  174. }
  176. HardwareContext::HardwareContext()
  177. : m_InputDeviceContext(), m_OutputDeviceContext()
  178. {
  179.     InitializeCriticalSection(&m_Lock);
  180. }
  182. HardwareContext::~HardwareContext()
  183. {
  184.     DeleteCriticalSection(&m_Lock);
  185. }
  187. BOOL HardwareContext::Init(DWORD Index)
  188. {
  189. BOOL bRet = TRUE;
  191. //----- 1. Initialize the state/status variables -----
  192.     m_DriverIndex = Index;
  193.     m_IntrAudio         = SYSINTR_AUDIO;
  194.     m_InPowerHandler    = FALSE;
  195.     m_InputDMARunning   = FALSE;
  196.     m_OutputDMARunning  = FALSE;
  197. m_InputDMAStatus = DMA_CLEAR;
  198. m_OutputDMAStatus = DMA_CLEAR;
  200.     //----- 2. Map the necessary descriptory channel and control registers into the driver's virtual address space -----
  201. if(!MapRegisters())
  202. {
  203. DEBUGMSG(ZONE_ERROR, (TEXT("WAVEDEV.DLL:HardwareContext::Init() - Failed to map config registers.rn")));
  204. bRet = FALSE;
  205.         goto Exit;
  206. }
  208.     //----- 3. Map the DMA buffers into driver's virtual address space -----
  209.     if(!MapDMABuffers())
  210.     {
  211. DEBUGMSG(ZONE_ERROR, (TEXT("WAVEDEV.DLL:HardwareContext::Init() - Failed to map DMA buffers.rn")));
  212. bRet = FALSE;
  213.         goto Exit;
  214.     }
  216. //---- Configure the AC97 Controller
  217. AC97_Init();
  219.     //----- 4. Configure the Codec -----
  220.     InitCodec();
  221.     
  222. //----- 5. Initialize the interrupt thread -----
  223.     if (!InitInterruptThread())
  224.     {
  225. DEBUGMSG(ZONE_ERROR, (TEXT("WAVEDEV.DLL:HardwareContext::Init() - Failed to initialize interrupt thread.rn")));
  226. bRet = FALSE;
  227.         goto Exit;
  228.     }
  230.     //
  231.     // Power Manager expects us to init in D0.
  232.     // We are normally in D4 unless we are opened for play.
  233.     // Inform the PM.
  234.     //
  235.     m_Dx = D0;
  236.     //DevicePowerNotify(_T("WAV1:"),(_CEDEVICE_POWER_STATE)D4, POWER_NAME);
  238.     RETAILMSG(1,(_T("AC97AUDIO::Init.rn")));    
  239.     
  240. Exit:
  241.     return bRet;
  242. }
  245. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  246. Function: MapRegisters()
  248. Description: Maps the config registers used by both the SPI and
  249. I2S controllers.
  251. Notes: The SPI and I2S controllers both use the GPIO config
  252. registers, so these MUST be initialized FIRST.
  254. Returns: Boolean indicating success
  255. -------------------------------------------------------------------*/
  256. BOOL HardwareContext::MapRegisters()
  257. {
  258.     v_pAC97regs = (volatile AC97reg *)VirtualAlloc(0, sizeof(AC97reg), MEM_RESERVE, PAGE_NOACCESS);
  259. if (!v_pAC97regs)
  260. {
  261. AC97MSG(1, (TEXT("AC97reg: VirtualAlloc failed!rn")));
  262. return(FALSE);
  263. }
  264. if (!VirtualCopy((PVOID)v_pAC97regs, (PVOID)(AC97_BASE), sizeof(AC97reg), PAGE_READWRITE | PAGE_NOCACHE))
  265. {
  266. AC97MSG(1, (TEXT("AC97reg: VirtualCopy failed!rn")));
  267. return(FALSE);
  268. }
  270. v_pIOPregs = (volatile IOPreg *)VirtualAlloc(0,sizeof(IOPreg),MEM_RESERVE, PAGE_NOACCESS);
  271. if (!v_pIOPregs)
  272. {
  273. AC97MSG(1,(TEXT("IOPreg: VirtualAlloc failed!rn")));
  274. return FALSE;
  275. }
  276. if (!VirtualCopy((PVOID)v_pIOPregs,(PVOID)(IOP_BASE),sizeof(IOPreg), PAGE_READWRITE | PAGE_NOCACHE ))
  277. {
  278. AC97MSG(1,(TEXT("IOPreg: VirtualCopy failed!rn")));
  279. return FALSE;
  280. }
  282. v_pDMAregs = (volatile DMAreg *)VirtualAlloc(0,sizeof(DMAreg),MEM_RESERVE, PAGE_NOACCESS);
  283. if (!v_pDMAregs)
  284. {
  285. AC97MSG(1,(TEXT("DMAreg: VirtualAlloc failed!rn")));
  286. return FALSE;
  287. }
  288. if (!VirtualCopy((PVOID)v_pDMAregs,(PVOID)(DMA_BASE),sizeof(DMAreg), PAGE_READWRITE | PAGE_NOCACHE ))
  289. {
  290. AC97MSG(1,(TEXT("DMAreg: VirtualCopy failed!rn")));
  291. return FALSE;
  292. }
  294. s2440INT = (volatile INTreg *)VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
  295. if (!v_pDMAregs)
  296. {
  297. AC97MSG(1,(TEXT("INTreg: VirtualAlloc failed!rn")));
  298. return FALSE;
  299. }
  300. if (!VirtualCopy((PVOID)s2440INT,(PVOID)(INT_BASE),sizeof(INTreg), PAGE_READWRITE | PAGE_NOCACHE ))
  301. {
  302. AC97MSG(1,(TEXT("INTreg: VirtualCopy failed!rn")));
  303. return FALSE;
  304. }
  306. g_pCLKPWRreg = (volatile CLKPWRreg *)VirtualAlloc(0,sizeof(CLKPWRreg),MEM_RESERVE, PAGE_NOACCESS);
  307. if (!g_pCLKPWRreg)
  308. {
  309. AC97MSG(1,(TEXT("DMAreg: VirtualAlloc failed!rn")));
  310. return FALSE;
  311. }
  312. if (!VirtualCopy((PVOID)g_pCLKPWRreg,(PVOID)(CLKPWR_BASE),sizeof(CLKPWRreg), PAGE_READWRITE | PAGE_NOCACHE ))
  313. {
  314. AC97MSG(1,(TEXT("DMAreg: VirtualCopy failed!rn")));
  315. return FALSE;
  316. }
  317.    
  318. return TRUE;
  319. }
  322. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  323. Function: Deinit()
  325. Description: Deinitializest the hardware: disables DMA channel(s), 
  326. clears any pending interrupts, powers down the audio
  327. codec chip, etc.
  329. Returns: Boolean indicating success
  330. -------------------------------------------------------------------*/
  331. BOOL HardwareContext::Deinit()
  332. {
  333. //----- 1. Disable the input/output channels -----
  334. // AUDIO_IN_DMA_DISABLE();
  335. AUDIO_OUT_DMA_DISABLE();
  337. //----- 2. Disable/clear DMA input/output interrupts -----
  338. AUDIO_IN_CLEAR_INTERRUPTS();
  339. AUDIO_OUT_CLEAR_INTERRUPTS();
  341. //----- 3. Turn the audio hardware off -----
  342.     AudioMute(DMA_CH_OUT | DMA_CH_MIC, TRUE);
  344.     //----- 4. Unmap the control registers and DMA buffers -----
  345.     UnmapRegisters();
  346. UnmapDMABuffers();
  348.     return TRUE;
  349. }
  352. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  353. Function: UnmapRegisters()
  355. Description: Unmaps the config registers used by both the SPI and
  356. I2S controllers.
  358. Notes: The SPI and I2S controllers both use the GPIO config
  359. registers, so these MUST be deinitialized LAST.
  361. Returns: Boolean indicating success
  362. -------------------------------------------------------------------*/
  363. BOOL HardwareContext::UnmapRegisters()
  364. {
  365. //----- 1. Free the fast driver-->driver calling mechanism object -----
  366. if(g_hUTLObject) 
  367. {
  368.         CloseHandle(g_hUTLObject);
  369. }
  371. return TRUE;
  372. }
  375. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  376. Function: MapDMABuffers()
  378. Description: Maps the DMA buffers used for audio input/output
  379. on the I2S bus.
  381. Returns: Boolean indicating success
  382. -------------------------------------------------------------------*/
  383. BOOL HardwareContext::MapDMABuffers()
  384. {
  385.     BOOL bSuccess=FALSE;
  387. PBYTE pTemp;
  389.     //----- 1. Allocate a block of virtual memory big enough to hold the DMA buffers -----
  390.     if(!(pTemp = (PBYTE)VirtualAlloc(0, AUDIO_DMA_PAGE_SIZE * 4, MEM_RESERVE, PAGE_NOACCESS)))
  391. {
  392. DEBUGMSG(ZONE_ERROR, (TEXT("WAVEDEV.DLL:HardwareContext::MapDMABuffers() - Unable to allocate memory for DMA buffers!rn")));
  393. goto MAP_ERROR;
  394. }
  396.     //----- 2. Map the physical DMA buffer to the virtual address we just allocated -----
  397. if(!VirtualCopy((LPVOID)pTemp, (LPVOID)AUDIO_DMA_BUFFER_BASE, (AUDIO_DMA_PAGE_SIZE * 4), 
  398. PAGE_READWRITE | PAGE_NOCACHE))
  399. {
  400. DEBUGMSG(ZONE_ERROR, (TEXT("WAVEDEV.DLL:HardwareContext::MapDMABuffers() - VirtualCopy() failed when binding DMA buffers.rn")));
  401. goto MAP_ERROR;
  402.     }
  404. //----- 3. Setup the DMA page pointers -----
  405. //    NOTE: Currently, input and output each have two DMA pages; these pages are used in a round-robin
  406. //  fashion so that the OS can read/write one buffer while the audio codec chip read/writes the
  407. //  other buffer.
  408.     m_Output_pbDMA_PAGES[0] = pTemp;
  409.     m_Output_pbDMA_PAGES[1] = pTemp + AUDIO_DMA_PAGE_SIZE;
  410.     m_Input_pbDMA_PAGES[0]  = pTemp + 2*AUDIO_DMA_PAGE_SIZE;
  411.     m_Input_pbDMA_PAGES[1]  = pTemp + 3*AUDIO_DMA_PAGE_SIZE;
  413.     return TRUE;
  415. MAP_ERROR:
  416. if(pTemp)
  417. VirtualFree(pTemp, 0, MEM_RELEASE);
  419. return FALSE;
  420. }
  424. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  425. Function: UnmapDMABuffers()
  427. Description: Unmaps the DMA buffers used for audio input/output
  428. on the I2S bus.
  430. Returns: Boolean indicating success
  431. -------------------------------------------------------------------*/
  432. BOOL HardwareContext::UnmapDMABuffers()
  433. {
  434. if(m_Output_pbDMA_PAGES[0])
  435. {
  436. VirtualFree((PVOID)m_Output_pbDMA_PAGES[0], 0, MEM_RELEASE);
  437. }
  439. return TRUE;
  440. }
  442. void AC97_GPIO_Init()
  443. {
  444. //----- 2. Configure the GPIO pins for AC97 mode -----
  445. //    
  446. //    AC_SDATA_OUT - GPE4
  447. //    AC_SDATA_IN - GPE3
  448. //    AC_nRESET - GPE2
  449. //    AC_BIT_CLK - GPE1
  450. //    AC_SYNC - GPE0
  451. //
  452. // Port Init for AC97
  453. //PG[4:0]=AC_SDATA_OUT:AC_SDATA_IN:AC_nRESET:AC_BIT_CLK:AC_SYNC
  454. v_pIOPregs->rGPECON = ((v_pIOPregs->rGPECON & 0xfffffc00) | 0x3ff);
  455. v_pIOPregs->rGPEUP = (v_pIOPregs->rGPEUP & ~(0x1f)) | 0x1f;
  456. //Delay(10);
  457. //Sleep(5);
  458. }
  460. BOOL HardwareContext::AC97_Init()
  461. {
  463. RETAILMSG(AC97_DEBUG,(_T("WAVDEV_AC97::AC97_Init()++rn")));
  465. //----- 1. IMPORTANT: By default, the internal clock is disabled.  To configure the controller ------
  466. //   we must first enable it.
  467. g_pCLKPWRreg->rCLKCON |= AC97_INTERNAL_CLOCK_ENABLE; // Enable the CPU clock to the AC97 controller
  469. AC97_GPIO_Init();
  471. v_pAC97regs->rAC_GLBCTRL = 0;
  472. Delay(10); //Sleep(5);
  474. // Write into the AC97 Global Control Register
  476. //Cold Reset 
  477. v_pAC97regs->rAC_GLBCTRL = 0x1; 
  478. Delay(10); //Sleep(5);
  479. v_pAC97regs->rAC_GLBCTRL = 0x0;
  480. Delay(10); //Sleep(5);
  482. //AC-link On
  483. v_pAC97regs->rAC_GLBCTRL = (1<<2);
  484. Delay(10); //Sleep(5);
  486. //Transfer data enable using AC-link
  487. v_pAC97regs->rAC_GLBCTRL = v_pAC97regs->rAC_GLBCTRL | (1<<3);
  488. Delay(10); //Sleep(5);
  491. // Disable the Codec ready Interrupt
  492. v_pAC97regs->rAC_GLBCTRL = v_pAC97regs->rAC_GLBCTRL | (1<<22);
  493. Delay(10); //Sleep(5);
  495. //while (!(v_pAC97regs->rAC_GLBSTAT& 0x400000));
  497. RETAILMSG(AC97_DEBUG,(_T("WAVEDEV_AC97::AC97 Codec Ready!rn")));
  499. v_pAC97regs->rAC_GLBCTRL &= ~(0x400000); // codec ready interrupt disable
  501. Delay(10); //Sleep(5);
  503. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3f<<8)) | 0x0000; // PCM_OUT=OFF,PCM_IN=OFF,MIC=OFF;
  504. //v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3f<<8)) | 0x2200; // PCM_OUT=DMA,PCM_IN=OFF,MIC=DMA;
  506. RETAILMSG(AC97_DEBUG,(_T("WAVDEV_AC97::AC97_Init()--rn")));
  508. return TRUE;
  510. }
  513. BOOL HardwareContext::Codec_channel()
  514. {
  515. if( m_InputDMARunning & m_OutputDMARunning )
  516. {
  517. RETAILMSG(AC97_DEBUG,(_T("Codec_channel() - In & Outrn")));
  518.     WriteCodecRegister(AC97_POWER_CONTROL, AC97_PWR_D0); // ADC, DAC power up
  519. }    
  520. else if( m_InputDMARunning )
  521. {
  522. RETAILMSG(AC97_DEBUG,(_T("Codec_channel() - Inrn")));
  523.     WriteCodecRegister(AC97_POWER_CONTROL, AC97_PWR_PR1); // DAC power down
  524. }
  525. else if( m_OutputDMARunning )
  526. {
  527. RETAILMSG(AC97_DEBUG,(_T("Codec_channel() - Outrn")));
  528.     WriteCodecRegister(AC97_POWER_CONTROL, AC97_PWR_PR0); // ADC power down
  529. }
  530. else
  531. {
  532. RETAILMSG(AC97_DEBUG,(_T("Codec_channel() - nonern")));
  533.     WriteCodecRegister(AC97_POWER_CONTROL, AC97_PWR_PR1|AC97_PWR_PR0); // ADC/DAC power down
  534. }
  535.     return(TRUE);
  536. }
  538. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  539. Function: InitCodec()
  541. Description: Initializes the audio codec chip.
  543. Notes: The audio codec chip is intialized for output mode
  544. but powered down.  To conserve battery life, the chip
  545. is only powered up when the user starts playing a 
  546. file.
  548. Specifically, the power_up/down logic is done 
  549. in the AudioMute() function.  If either of the 
  550. audio channels are unmuted, then the chip is powered
  551. up; otherwise the chip is powered own.
  553. Returns: Boolean indicating success
  554. -------------------------------------------------------------------*/
  555. BOOL HardwareContext::InitCodec()
  556. {
  557. USHORT CodecRead;                             
  558. ULONG CodecVendorID, CodecRevision;           
  560. AC97MSG(1, (TEXT("+++InitCodecrn")));
  561.                                                
  562. // write the Codec software reset
  563. // 00h
  564. WriteCodecRegister(AC97_RESET, 0x683F);   
  566. // Enable the VRA
  567. // 2Ah
  568. WriteCodecRegister(AC97_EXT_AUDIO_CONTROL, AC97_ENABLE_VRA);
  570. WriteCodecRegister(AC97_PCM_DAC_RATE, 44100); // Write default Sample rate for DAC
  571. WriteCodecRegister(AC97_PCM_ADC_RATE, 44100); // Write default Sample rate for DAC
  572.   
  573. // get the Vendor ID and revision 
  574. // 7Ch            
  575. CodecVendorID = ULONG(ReadCodecRegister( AC97_VENDOR_ID1 )) << 16;
  577. // 7E
  578. CodecRead = ReadCodecRegister( AC97_VENDOR_ID2 );
  580. CodecVendorID |= ULONG(CodecRead) & 0x0000ff00;
  581. CodecRevision = ULONG(CodecRead) & 0x000000ff;
  583. /*
  584. RETAILMSG(AC97_DEBUG, (TEXT("STAC9766 Codec Vendor ID: %08x rn"), CodecVendorID));
  585. RETAILMSG(AC97_DEBUG, (TEXT("STAC9766 Codec Revision:  %02xrn"), CodecRevision));
  587. if ( !( CodecVendorID == AC97_VENDOR_SIGMATEL && CodecRevision == 0x66)) 
  588. {
  589. // now power down the Analog section of the AC97
  590. // and power it back up.  This forces the Sigmatel
  591. // to calibrate it's analog levels
  592. // 26h 
  593. WriteCodecRegister(AC97_POWER_CONTROL, AC97_PWR_ANLOFF );
  594. Delay(10); //Sleep(5);
  595. RETAILMSG(AC97_DEBUG,(_T("WriteCodecRegister(AC97_POWER_CONTROL, AC97_PWR_ANLOFF)rn")));
  596. }
  597. */
  598. // Turn Power on for sections
  599. // 26h
  600. WriteCodecRegister( AC97_POWER_CONTROL, AC97_PWR_D0 );
  602. // Write the Analog reg
  603. // 6Eh
  604. //WriteCodecRegister( AC97_ANALOG_SPEC, 0x0000 );
  606. // write HP Out Value
  607. // 04h
  608. WriteCodecRegister( AC97_HEADPHONE_VOL, 0x0404 ); //0x0202); //0x0404 );
  611. // Mute unusing analog source except -------------------------------
  612. // PCBEEP_VOL - 0ah
  613. WriteCodecRegister( AC97_PCBEEP_VOL, 0x8000 );
  614. // PHONE_VOL - 0ch
  615. WriteCodecRegister( AC97_PHONE_VOL, 0x8000 );
  616. // LINEIN_VOL - 10h
  617. WriteCodecRegister( AC97_LINEIN_VOL, 0x8000 );
  618. // CD_VOL - 12h
  619. WriteCodecRegister( AC97_CD_VOL, 0x8000 );
  620. // VIDEO_VOL - 14h
  621. WriteCodecRegister( AC97_VIDEO_VOL, 0x8000 );
  622. // AUX_VOL - 16h
  623. WriteCodecRegister( AC97_AUX_VOL, 0x8000 );
  625. // write the wave out volume
  626. // 18h
  627. WriteCodecRegister( AC97_PCMOUT_VOL, 0x0505 ); //0x0000 ); //0x0606 );
  630. // Init MIC-IN configurations
  632. // 20h
  633. WriteCodecRegister( AC97_GENERAL_PURPOSE, 0x0000 ); //MIC1 Selected
  635. // ADC Gain Control, 30dB
  636. //BOOSTEN =1
  637. // tmp = ReadCodecRegister(AC97_MIC_VOL) & ~(0x1<<6);
  638. // WriteCodecRegister(AC97_MIC_VOL, tmp | (0x1<<6));
  639. WriteCodecRegister( AC97_MIC_VOL, (1<<15)|(1<<6) ); // Mute & BOOTEN
  641. //ADC Input Slot => left slot6, right slot9, MIC GAIN VAL=1
  642. WriteCodecRegister( AC97_INTR_PAGE, 0x0 );
  643. WriteCodecRegister( AC97_ANALOG_SPEC, 0x0024 );
  645. //Left, Right => MIC
  646. WriteCodecRegister( AC97_RECORD_SELECT, AC97_RECMUX_MIC );
  648. // set up a default record gain
  649. // 1Ch
  650. WriteCodecRegister( AC97_RECORD_GAIN, AC97_RECORD_GAIN_VAL );
  652. // Now write High Pass Filter Bypass Control Register
  653. // 78h
  654. WriteCodecRegister( AC97_HPF_BYPASS, AC97_HIPASS_DISABLE );
  656. AC97MSG(1, (TEXT("---InitCodecrn")));
  658. return(TRUE);
  659. }
  663. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  664. Function: InitOutputDMA()
  666. Description: Initializes the DMA channel for output.
  668. Notes: DMA Channel 2 is used for transmitting output sound
  669. data from system memory to the I2S controller.
  671. Returns: Boolean indicating success
  672. -------------------------------------------------------------------*/
  673. BOOL HardwareContext::InitOutputDMA()
  674. {
  676. //----- 1. Initialize the DMA channel for output mode and use the first output DMA buffer -----
  677.     v_pDMAregs->rDISRC1 = (int)(PLAY_DMA_BUFFER_PHYS); 
  678.     v_pDMAregs->rDISRCC1 &= ~(SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS); // Source is system bus, increment addr
  680.     //----- 2. Initialize the DMA channel to send data over the I2S bus -----
  681.     v_pDMAregs->rDIDST1 = (int)AC_PCMDATA_PHYS; 
  682.     //v_pDMAregs->rDIDSTC1 |= (DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS); // Dest is  periperal bus, fixed addr
  683.     v_pDMAregs->rDIDSTC1 = (DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS); // Dest is  periperal bus, fixed addr
  685. //----- 3. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
  686. //    single tx, single service, I2SSDO, I2S request, no auto-reload, half-word, tx count
  687. v_pDMAregs->rDCON1 = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | AC97PCMOUT_DMA1 | DMA_TRIGGERED_BY_HARDWARE 
  688. #if DMA_FLAG
  689. // | TRANSFER_HALF_WORD | (AUDIO_DMA_PAGE_SIZE / 2 ) );
  690. | TRANSFER_WORD | (AUDIO_DMA_PAGE_SIZE / 4 ) );
  691. #else    
  692. // | NO_DMA_AUTO_RELOAD | TRANSFER_HALF_WORD | (AUDIO_DMA_PAGE_SIZE / 2) );
  693. | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | (AUDIO_DMA_PAGE_SIZE / 4 ) );
  694. #endif    
  695.      
  696. //----- 4. Reset the playback pointers -----
  697. AUDIO_RESET_PLAYBACK_POINTER();
  699. AC97MSG(1,(TEXT("---InitOutputDMAn")));
  701. return TRUE;
  702. }
  705. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  706. Function: StartOutputDMA()
  708. Description: Starts outputting the sound data to the audio codec
  709. chip via DMA.
  711. Notes: Currently, both playback and record share the same
  712. DMA channel.  Consequently, we can only start this
  713. operation if the input channel isn't using DMA.
  715. Returns: Boolean indicating success
  716. -------------------------------------------------------------------*/
  717. BOOL HardwareContext::StartOutputDMA()
  718. {
  719. ULONG OutputTransferred;
  720. AC97MSG(1,(TEXT("+++StartOutputDMAn")));
  722. if(!m_OutputDMARunning && (m_Dx == D0) )
  723. // if(!m_OutputDMARunning)
  724.     {
  725.         //----- 1. Initialize our buffer counters -----
  726.         m_OutputDMARunning=TRUE;
  727.         m_OutBytes[OUT_BUFFER_A]=m_OutBytes[OUT_BUFFER_B]=0;
  729.         //----- 2. Prime the output buffer with sound data -----
  730. //m_OutputDMAStatus = (DMA_DONEA | DMA_DONEB) & ~DMA_BIU;
  731. //RETAILMSG(1,(_T("dmastat = %xrn"), m_OutputDMAStatus));
  732. m_OutputDMAStatus = (DMA_DONEA | DMA_DONEB) & ~DMA_BIU;
  733. OutputTransferred = TransferOutputBuffers(m_OutputDMAStatus);
  734.         
  735. //----- 3. If we did transfer any data to the DMA buffers, go ahead and enable DMA -----
  736. if(OutputTransferred)
  737.         {
  738. //----- 4. Configure the DMA channel for playback -----
  739. if(!InitOutputDMA())
  740. {
  741. DEBUGMSG(ZONE_ERROR, (TEXT("HardwareContext::StartOutputDMA() - Unable to initialize output DMA channel!rn")));
  742. goto START_ERROR;
  743. }
  745. #if DMA_FLAG
  746. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<12)) | (0x2<<12); // 0x2 = DMA
  747. #else
  748. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<12)) | (0x1<<12); // 0x1 = PIO
  749. #endif
  751. //----- 5. Make sure the audio isn't muted -----
  752. AudioMute(DMA_CH_OUT, FALSE);
  754. //----- 6. Start the DMA controller -----
  755. AUDIO_RESET_PLAYBACK_POINTER();
  756. SELECT_AUDIO_DMA_OUTPUT_BUFFER_A();
  757. Codec_channel(); // Turn ON output channel
  758. // charlie, start A buffer
  759. AUDIO_OUT_DMA_ENABLE();
  760. #if DMA_FLAG
  761.         // wait for DMA to start.
  762.         delay_count = 0;
  763.         while((v_pDMAregs->rDSTAT1&0xfffff)==0){
  764.          RETAILMSG(1,(_T("1")));
  765. #if WAIT_DMA_END
  766. Sleep(1);
  767. #else
  768.     if( delay_count++ > DELAY_COUNT ) break;
  769. #endif
  770.         }        
  771.         // change the buffer pointer
  772.         SELECT_AUDIO_DMA_OUTPUT_BUFFER_B();
  773.         // Set DMA for B Buffer
  774. #endif         
  775.         }
  776.         else    // We didn't transfer any data, so DMA wasn't enabled
  777.         {
  778.             m_OutputDMARunning=FALSE;
  779.         }
  780.     }
  781.     
  782.     AC97MSG(1,(TEXT("---StartOutputDMAn")));
  784. return TRUE;
  786. START_ERROR:
  787. return FALSE;
  788. }
  790. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  791. Function: StopOutputDMA()
  793. Description: Stops any DMA activity on the output channel.
  795. Returns: Boolean indicating success
  796. -------------------------------------------------------------------*/
  797. void HardwareContext::StopOutputDMA()
  798. {
  799. AC97MSG(1,(_T("StopOutputDMA()++rn")));
  801. // jylee,040220
  802. // you should do this sleep operation for AC-Link operation.
  803. Sleep(1);
  805. //----- 1. If the output DMA is running, stop it -----
  806.     if (m_OutputDMARunning)
  807. {
  808. m_OutputDMAStatus = DMA_CLEAR;
  809. AUDIO_OUT_DMA_DISABLE();
  810. AUDIO_OUT_CLEAR_INTERRUPTS();
  812. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<12)) | (0x0<<12); // 0x0 = OFF
  814. AudioMute(DMA_CH_OUT, TRUE);
  815.     }
  817. m_OutputDMARunning = FALSE;
  819. Codec_channel();
  821. /*
  822. // jylee, 040220
  823. // Clear AC97 PCMDATA FIFO.
  824. for (int i=0; i<AC97_PCMDATA_FIFO_LENGTH;i++)
  825. {
  826. v_pAC97regs->rAC_PCMDATA = 0x00000000;
  827. }
  828. */
  829. AC97MSG(1,(_T("StopOutputDMA()--rn")));
  830. }
  833. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  834. Function: InitInputDMA()
  836. Description: Initializes the DMA channel for input.
  838. Notes: ***** NOT IMPLEMENTED *****
  840. The following routine is not implemented due to a
  841. hardware bug in the revision of the Samsung SC2440
  842. CPU this driver was developed on.  See the header
  843. at the top of this file for details.
  845. Returns: Boolean indicating success
  846. -------------------------------------------------------------------*/
  847. BOOL HardwareContext::InitInputDMA()
  848. {
  850. //goto INIT_ERROR;
  851. AC97MSG(1,(TEXT("+++InitInputDMAn")));
  852. //============================ Configure DMA Channel 1 ===========================
  853. //------ On platforms with the revsion of the Samsung SC2440 CPU with the IIS SLAVE bug fix, this -----
  854. //  code can be used to configure DMA channel 1 for input.
  856. //----- 1. Initialize the DMA channel for input mode and use the first input DMA buffer -----
  857. v_pDMAregs->rDISRC2 = (int)AC_MICDATA_PHYS;
  858. v_pDMAregs->rDISRCC2 = (SOURCE_PERIPHERAL_BUS | FIXED_SOURCE_ADDRESS); // Source is periperal bus, fixed addr
  859.     
  860.     //----- 2. Initialize the DMA channel to receive data over the I2S bus -----
  861.     v_pDMAregs->rDIDST2 = (int)(RECORD_DMA_BUFFER_PHYS); //(AUDIO_DMA_BUFFER_PHYS); 
  862.     v_pDMAregs->rDIDSTC2 &= ~(DESTINATION_PERIPHERAL_BUS | FIXED_DESTINATION_ADDRESS); // Destination is system bus, increment addr
  864. //----- 3. Configure the DMA channel's transfer characteristics: handshake, sync PCLK, interrupt, -----
  865. //    single tx, single service, I2SSDI, I2S request, no auto-reload, half-word, tx count
  866. v_pDMAregs->rDCON2 = (  HANDSHAKE_MODE | GENERATE_INTERRUPT | AC97MICIN_DMA2 | DMA_TRIGGERED_BY_HARDWARE 
  867. #if DMA_FLAG
  868. #if (INCHANNELS==2)
  869.    | TRANSFER_WORD | (AUDIO_DMA_PAGE_SIZE / 4) );
  870. #else    
  871.    | TRANSFER_HALF_WORD | (AUDIO_DMA_PAGE_SIZE / 2) );
  872. #endif
  873. #else /* DMA_FLAG */
  874.    | NO_DMA_AUTO_RELOAD | TRANSFER_WORD | (AUDIO_DMA_PAGE_SIZE / 4) );
  875.    //| NO_DMA_AUTO_RELOAD | TRANSFER_HALF_WORD | (AUDIO_DMA_PAGE_SIZE / 2) );
  876. #endif /* DMA_FLAG */
  878. return TRUE;
  879. }
  882. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  883. Function: StartInputDMA()
  885. Description: Starts inputting the recorded sound data from the 
  886. audio codec chip via DMA.
  888. Notes: ***** NOT IMPLEMENTED *****
  890. The following routine is not implemented due to a
  891. hardware bug in the revision of the Samsung SC2440
  892. CPU this driver was developed on.  See the header
  893. at the top of this file for details.
  895. Returns: Boolean indicating success
  896. -------------------------------------------------------------------*/
  897. BOOL HardwareContext::StartInputDMA()
  898. {
  899. //------ On platforms with the revsion of the Samsung SC2440 CPU with the IIS SLAVE bug fix, this -----
  900. //  code can be used to configure DMA channel 1 for input.
  902. AC97MSG(1,(TEXT("+++StartInputDMAn")));
  904. if(!m_InputDMARunning)
  905.     {
  906.         //----- 1. Initialize our buffer counters -----
  907.         m_InputDMARunning=TRUE;
  908. Codec_channel();        // Turn On Input channel
  909.         m_InBytes[IN_BUFFER_A]=m_InBytes[IN_BUFFER_B]=0;
  911.         //----- 2. Prime the output buffer with sound data -----
  912. m_InputDMAStatus = (DMA_DONEA | DMA_DONEB) & ~DMA_BIU;
  914. //----- 3. Configure the DMA channel for record -----
  915. if(!InitInputDMA())
  916. {
  917. DEBUGMSG(ZONE_ERROR, (TEXT("HardwareContext::StartInputDMA() - Unable to initialize input DMA channel!rn")));
  918. goto START_ERROR;
  919. }
  921. #if DMA_FLAG
  922. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<8)) | (0x2<<8); // 0x2 = DMA
  923. #else
  924. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<8)) | (0x1<<8); // 0x1 = PIO
  925. #endif
  927. //----- 4. Make sure the audio isn't muted -----
  928. AudioMute(DMA_CH_MIC, FALSE);
  930. //----- 5. Start the input DMA -----
  931. AUDIO_RESET_RECORD_POINTER();
  932. SELECT_AUDIO_DMA_INPUT_BUFFER_A();
  934. Codec_channel();        // Turn On Input channel
  935. v_pDMAregs->rDMASKTRIG2 = ENABLE_DMA_CHANNEL;
  937. #if DMA_FLAG
  938.         // wait for DMA to start.
  939.         delay_count = 0;
  940.         while((v_pDMAregs->rDSTAT2&0xfffff)==0){
  941.          RETAILMSG(1,(_T("2")));
  943. #if WAIT_DMA_END
  944. Sleep(1);
  945. #else
  946.          if( delay_count++ > DELAY_COUNT ) break;
  947. #endif
  948.         } 
  949.         // change the buffer pointer
  950.         SELECT_AUDIO_DMA_INPUT_BUFFER_B();
  951. #endif         
  953.     }
  954.     AC97MSG(1,(TEXT("---StartInputDMAn")));
  955. return TRUE;
  957. START_ERROR:
  958. return FALSE;
  959. }
  961. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  962. Function: StopInputDMA()
  964. Description: Stops any DMA activity on the input channel.
  966. Notes: ***** NOT IMPLEMENTED *****
  968. The following routine is not implemented due to a
  969. hardware bug in the revision of the Samsung SC2440
  970. CPU this driver was developed on.  See the header
  971. at the top of this file for details.
  973. Returns: Boolean indicating success
  974. -------------------------------------------------------------------*/
  975. void HardwareContext::StopInputDMA()
  976. {
  978. //------ On platforms with the revsion of the Samsung SC2440 CPU with the IIS SLAVE bug fix, this -----
  979. //  code can be used to configure DMA channel 1 for input.
  981. //----- 1. If the output DMA is running, stop it -----
  982.     if (m_InputDMARunning)
  983. {
  984. AUDIO_IN_DMA_DISABLE(); // jylee
  985. AUDIO_IN_CLEAR_INTERRUPTS();
  987. m_InputDMAStatus = DMA_CLEAR;
  989. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<8)) | (0x0<<8); // 0x0 = OFF
  991. AudioMute(DMA_CH_MIC, TRUE);
  992.     }
  994. m_InputDMARunning = FALSE;
  995. Codec_channel();
  996. }
  999. DWORD HardwareContext::GetInterruptThreadPriority()
  1000. {
  1001.     HKEY hDevKey;
  1002.     DWORD dwValType;
  1003.     DWORD dwValLen;
  1004.     DWORD dwPrio = 249; // Default priority
  1006.     hDevKey = OpenDeviceKey((LPWSTR)m_DriverIndex);
  1007.     if (hDevKey)
  1008.     {
  1009.         dwValLen = sizeof(DWORD);
  1010.         RegQueryValueEx(
  1011.             hDevKey,
  1012.             TEXT("Priority256"),
  1013.             NULL,
  1014.             &dwValType,
  1015.             (PUCHAR)&dwPrio,
  1016.             &dwValLen);
  1017.         RegCloseKey(hDevKey);
  1018.     }
  1020.     return dwPrio;
  1021. }
  1023. /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  1024. // SetForceSpeaker is called from the device context to update the state of the
  1025. // m_bForceSpeaker variable.
  1026. /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  1028. DWORD HardwareContext::ForceSpeaker( BOOL bForceSpeaker )
  1029. {
  1030.     // If m_NumForcedSpeaker is non-zero, audio should be routed to an
  1031.     // external speaker (if hw permits).
  1032.     if (bForceSpeaker)
  1033.     {
  1034.         m_NumForcedSpeaker++;
  1035.         if (m_NumForcedSpeaker==1)
  1036.         {
  1037.             RecalcSpeakerEnable();
  1038.         }
  1039.     }
  1040.     else
  1041.     {
  1042.         m_NumForcedSpeaker--;
  1043.         if (m_NumForcedSpeaker==0)
  1044.         {
  1045.             RecalcSpeakerEnable();
  1046.         }
  1047.     }
  1049.     return MMSYSERR_NOERROR;
  1050. }
  1052. // Control the hardware speaker enable
  1053. void HardwareContext::SetSpeakerEnable(BOOL bEnable)
  1054. {
  1055.     // Code to turn speaker on/off here
  1056.     return;
  1057. }
  1059. /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  1060. // RecalcSpeakerEnable decides whether to enable the speaker or not.
  1061. // For now, it only looks at the m_bForceSpeaker variable, but it could
  1062. // also look at whether the headset is plugged in
  1063. // and/or whether we're in a voice call. Some mechanism would
  1064. // need to be implemented to inform the wave driver of changes in the state of
  1065. // these variables however.
  1066. /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
  1068. void HardwareContext::RecalcSpeakerEnable()
  1069. {
  1070.     SetSpeakerEnable(m_NumForcedSpeaker);
  1071. }
  1073. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1074. Function: InitInterruptThread()
  1076. Description: Initializes the IST for handling DMA interrupts.
  1078. Returns: Boolean indicating success
  1079. -------------------------------------------------------------------*/
  1080. BOOL HardwareContext::InitInterruptThread()
  1081. {
  1082.     BOOL bSuccess;
  1083.     
  1084.     m_hAudioInterrupt = CreateEvent( NULL, FALSE, FALSE, NULL);
  1086.     if (!m_hAudioInterrupt)
  1087.     {
  1088.         return FALSE;
  1089.     }
  1091.     bSuccess = InterruptInitialize(m_IntrAudio, m_hAudioInterrupt, NULL, 0);
  1093.     m_hAudioInterruptThread  = CreateThread((LPSECURITY_ATTRIBUTES)NULL,
  1094.                                             0,
  1095.                                             (LPTHREAD_START_ROUTINE)CallInterruptThread,
  1096.                                             this,
  1097.                                             0,
  1098.                                             NULL);
  1099.     if (!m_hAudioInterruptThread)
  1100.     {
  1101.         return FALSE;
  1102.     }
  1104.     // Bump up the priority since the interrupt must be serviced immediately.
  1105. CeSetThreadPriority(m_hAudioInterruptThread, GetInterruptThreadPriority());
  1107.     return TRUE;
  1108. }
  1111. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1112. Function: PowerUp()
  1114. Description: Powers up the audio codec chip.
  1116. Notes: Currently, this function is unimplemented because
  1117. the audio codec chip is ONLY powered up when the 
  1118. user wishes to play or record.  The AudioMute() function
  1119. handles the powerup sequence.
  1121. Returns: Boolean indicating success
  1122. -------------------------------------------------------------------*/
  1123. void HardwareContext::PowerUp()
  1124. {
  1125.     RETAILMSG(1,(_T("AC97:PowerUP()rn")));
  1127.     AC97_Init();
  1128.     //AC97_GPIO_Init();
  1129.     
  1130.     InitCodec();
  1131.     
  1132.     //AudioMute(DMA_CH_OUT, FALSE); // 030711
  1134.     // setup DMA output
  1135.     //InitOutputDMA();
  1137.     //AudioMute((DMA_CH_OUT | DMA_CH_MIC), FALSE);
  1138.     AudioMute(DMA_CH_OUT, FALSE);
  1139. }
  1142. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1143. Function: PowerDown()
  1145. Description: Powers down the audio codec chip.
  1147. Notes: Even if the input/output channels are muted, this
  1148. function powers down the audio codec chip in order
  1149. to conserve battery power.
  1151. Returns: Boolean indicating success
  1152. -------------------------------------------------------------------*/
  1153. void HardwareContext::PowerDown()
  1154. {
  1155.     RETAILMSG(1,(_T("AC97:PowerDown()rn")));
  1156.     //StopOutputDMA();
  1158. m_OutputDMAStatus = DMA_CLEAR;
  1159. AUDIO_OUT_DMA_DISABLE();
  1160. AUDIO_OUT_CLEAR_INTERRUPTS();
  1162. v_pAC97regs->rAC_GLBCTRL = (v_pAC97regs->rAC_GLBCTRL & ~(0x3<<12)) | (0x0<<12); // 0x0 = OFF
  1164. //AudioMute(DMA_CH_OUT, TRUE);
  1167. m_OutputDMARunning = FALSE;
  1168. m_InputDMARunning = FALSE;
  1170. AudioMute((DMA_CH_OUT | DMA_CH_MIC), TRUE);
  1171. }
  1174. //############################################ Helper Functions #############################################
  1176. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1177. Function: TransferOutputBuffer()
  1179. Description: Retrieves the next "mixed" audio buffer of data to
  1180. DMA into the output channel.
  1182. Returns: Number of bytes needing to be transferred.
  1183. -------------------------------------------------------------------*/
  1184. ULONG HardwareContext::TransferOutputBuffer(ULONG NumBuf)
  1185. {
  1186.     ULONG BytesTransferred = 0;
  1188.     PBYTE pBufferStart = m_Output_pbDMA_PAGES[NumBuf];
  1189.     PBYTE pBufferEnd = pBufferStart + AUDIO_DMA_PAGE_SIZE;
  1190.     PBYTE pBufferLast;
  1192. __try
  1193. {
  1194. pBufferLast = m_OutputDeviceContext.TransferBuffer(pBufferStart, pBufferEnd,NULL);
  1195. BytesTransferred = m_OutBytes[NumBuf] = pBufferLast-pBufferStart;
  1197. // Enable if you need to clear the rest of the DMA buffer
  1198. StreamContext::ClearBuffer(pBufferLast,pBufferEnd);
  1199. //memset(pBufferStart, 0, AUDIO_DMA_PAGE_SIZE);
  1201. if(NumBuf == OUT_BUFFER_A) // Output Buffer A
  1202. {
  1203. m_OutputDMAStatus &= ~DMA_DONEA;
  1204. m_OutputDMAStatus |= DMA_STRTA;
  1205. }
  1206. else // Output Buffer B
  1207. {
  1208. m_OutputDMAStatus &= ~DMA_DONEB;
  1209. m_OutputDMAStatus |= DMA_STRTB;
  1210. }
  1211. }
  1212. __except(EXCEPTION_EXECUTE_HANDLER) 
  1213. {
  1214. DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:TransferOutputBuffer() - EXCEPTION: %d"), GetExceptionCode()));
  1215. }
  1217.     return BytesTransferred;
  1218. }
  1221. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1222. Function: TransferOutputBuffers()
  1224. Description: Determines which output buffer (A or B) needs to 
  1225. be filled with sound data.  The correct buffer is
  1226. then populated with data and ready to DMA to the 
  1227. output channel.
  1229. Returns: Boolean indicating success
  1230. -------------------------------------------------------------------*/
  1231. ULONG HardwareContext::TransferOutputBuffers(DWORD dwDCSR)
  1232. {
  1233.     ULONG BytesTransferred = 0;
  1235.     ULONG BytesTotal;
  1236.     DWORD Bits = dwDCSR & (DMA_DONEA|DMA_DONEB|DMA_BIU);
  1238. switch (Bits)
  1239.     {
  1240.     case 0:
  1241.     case DMA_BIU:
  1242.         // No done bits set- must not be my interrupt
  1243.         return 0;
  1244.     case DMA_DONEA|DMA_DONEB|DMA_BIU:
  1245.         // Load B, then A
  1246.         BytesTransferred = TransferOutputBuffer(OUT_BUFFER_B);
  1247.         // fall through
  1248.     case DMA_DONEA: // This should never happen!
  1249.     case DMA_DONEA|DMA_BIU:
  1250. BytesTransferred += TransferOutputBuffer(OUT_BUFFER_A); // charlie, A => B
  1251.         break;
  1252.     case DMA_DONEA|DMA_DONEB:
  1253.         // Load A, then B
  1254.         BytesTransferred = TransferOutputBuffer(OUT_BUFFER_A);
  1255. #if DMA_FLAG        
  1256.         // charlie
  1257.         BytesTransferred += TransferOutputBuffer(OUT_BUFFER_B);
  1258.         break; // charlie
  1259. #endif        
  1260.         // fall through
  1261.     case DMA_DONEB|DMA_BIU: // This should never happen!
  1262.     case DMA_DONEB:
  1263.         // Load B
  1264.         BytesTransferred += TransferOutputBuffer(OUT_BUFFER_B); // charlie, B => A
  1265.         break;
  1266.     }
  1268.     // If it was our interrupt, but we weren't able to transfer any bytes
  1269.     // (e.g. no full buffers ready to be emptied)
  1270.     // and all the output DMA buffers are now empty, then stop the output DMA
  1271.     BytesTotal = m_OutBytes[OUT_BUFFER_A]+m_OutBytes[OUT_BUFFER_B];
  1273. if (BytesTotal==0)
  1274.     {
  1275. StopOutputDMA();
  1276.     }
  1277.     return BytesTransferred;
  1278. }
  1281. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1282. Function: TransferInputBuffer()
  1284. Description: Retrieves the chunk of recorded sound data and inputs
  1285. it into an audio buffer for potential "mixing".
  1287. Returns: Number of bytes needing to be transferred.
  1288. -------------------------------------------------------------------*/
  1289. ULONG HardwareContext::TransferInputBuffer(ULONG NumBuf)
  1290. {
  1291.     ULONG BytesTransferred = 0;
  1293.     PBYTE pBufferStart = m_Input_pbDMA_PAGES[NumBuf];
  1294.     PBYTE pBufferEnd = pBufferStart + AUDIO_DMA_PAGE_SIZE;
  1295.     PBYTE pBufferLast;
  1297. __try
  1298. {
  1299. pBufferLast = m_InputDeviceContext.TransferBuffer(pBufferStart, pBufferEnd,NULL);
  1300. BytesTransferred = m_InBytes[NumBuf] = pBufferLast-pBufferStart;
  1302. if(NumBuf == IN_BUFFER_A) // Input Buffer A
  1303. {
  1304. m_InputDMAStatus &= ~DMA_DONEA;
  1305. m_InputDMAStatus |= DMA_STRTA;
  1306. }
  1307. else // Input Buffer B
  1308. {
  1309. m_InputDMAStatus &= ~DMA_DONEB;
  1310. m_InputDMAStatus |= DMA_STRTB;
  1311. }
  1313. }
  1314. __except(EXCEPTION_EXECUTE_HANDLER) 
  1315. {
  1316. DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:TransferInputBuffer() - EXCEPTION: %d"), GetExceptionCode()));
  1317. }
  1319.     return BytesTransferred;
  1320. }
  1323. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1324. Function: TransferInputBuffers()
  1326. Description: Determines which input buffer (A or B) needs to 
  1327. be filled with recorded sound data.  The correct 
  1328. buffer is then populated with recorded sound data
  1329. from the input channel.
  1331. Returns: Boolean indicating success
  1332. -------------------------------------------------------------------*/
  1333. ULONG HardwareContext::TransferInputBuffers(DWORD dwDCSR)
  1334. {
  1335.     ULONG BytesTransferred=0;
  1336.     DWORD Bits = dwDCSR & (DMA_DONEA|DMA_DONEB|DMA_BIU);
  1338.     switch (Bits)
  1339.     {
  1340.     case 0:
  1341.     case DMA_BIU:
  1342.         // No done bits set- must not be my interrupt
  1343.         return 0;
  1344.     case DMA_DONEA|DMA_DONEB|DMA_BIU:
  1345.         // Load B, then A
  1346.         BytesTransferred = TransferInputBuffer(IN_BUFFER_B);
  1347.         // fall through
  1348.     case DMA_DONEA: // This should never happen!
  1349.     case DMA_DONEA|DMA_BIU:
  1350.         // Load A
  1351.         BytesTransferred += TransferInputBuffer(IN_BUFFER_A);
  1352.         break;
  1353.     case DMA_DONEA|DMA_DONEB:
  1354.         // Load A, then B
  1355.         BytesTransferred = TransferInputBuffer(IN_BUFFER_A);
  1356. #if 0 //DMA_FLAG        
  1357. BytesTransferred += TransferInputBuffer(IN_BUFFER_B);
  1358. break;
  1359. #endif
  1360.         // fall through
  1361.     case DMA_DONEB|DMA_BIU: // This should never happen!
  1362.     case DMA_DONEB:
  1363.         // Load B
  1364.         BytesTransferred += TransferInputBuffer(IN_BUFFER_B);
  1365.         break;
  1366.     }
  1368.     // If it was our interrupt, but we weren't able to transfer any bytes
  1369.     // (e.g. no empty buffers ready to be filled)
  1370.     // Then stop the input DMA
  1371.     if (BytesTransferred==0)
  1372.     {
  1373.         StopInputDMA();
  1374.     }
  1375.     return BytesTransferred;
  1376. }
  1379. void HardwareContext::InterruptThread()
  1380. {
  1381.     ULONG InputTransferred, OutputTransferred;
  1382. BOOL dmaInterruptSource = 0;
  1384.     // Fast way to access embedded pointers in wave headers in other processes.
  1385. SetProcPermissions((DWORD)-1);
  1387.     while(TRUE)
  1388.     {
  1389. WaitForSingleObject(m_hAudioInterrupt, INFINITE);
  1390. AC97MSG(1,(TEXT("0x%xn"),s2440INT->rINTMSK));
  1391. AC97MSG(1,(TEXT("startn")));
  1392. dmaInterruptSource = 0;
  1393. //----- 1. Grab the lock -----
  1394. Lock();
  1396. __try
  1397. {
  1398. AC97MSG(1,(TEXT("tryn")));
  1400. //----- 3. Determine the interrupt source (input DMA operation or output DMA operation?) -----
  1401. //----- NOTE: Often, platforms use two separate DMA channels for input/output operations but
  1402. // have the OAL return SYSINTR_AUDIO as the interrupt source.  If this is the case,
  1403. // then the interrupt source (input or output DMA channel) must be determined in
  1404. // this step.
  1405. // charlie, determine the interrupt source
  1406. // s2440INT->rSRCPND
  1407. if( s2440INT->rINTMSK & BIT_DMA1 ){
  1408. dmaInterruptSource |= DMA_CH_OUT; // Output DMA is supported...
  1409. }
  1411. if( s2440INT->rINTMSK & BIT_DMA2 ){
  1412. dmaInterruptSource |= DMA_CH_MIC; // Input DMA is supported...
  1413. }
  1415. // For determine the interrupt source
  1416. //----- 2. Acknowledge the DMA interrupt -----
  1417. InterruptDone(m_IntrAudio);
  1419. if ( m_Dx != D0 ) continue;
  1421. //----- 4. Handle any interrupts on the input source -----
  1422. //    NOTE: The InterruptDone() call below automatically clears the interrupt.
  1423. // if((m_InputDMARunning) && (dmaInterruptSource == DMA_CH_MIC))
  1424. if((dmaInterruptSource == DMA_CH_MIC))
  1425. {
  1426. //----- Determine which buffer just completed the DMA transfer -----
  1427. if(m_InputDMAStatus & DMA_BIU)
  1428. {
  1429. m_InputDMAStatus &= ~DMA_STRTB; // Buffer B just completed...
  1430. m_InputDMAStatus |= DMA_DONEB;
  1432. m_InputDMAStatus &= ~DMA_BIU; // Buffer A is in use
  1433. #if DMA_FLAG
  1434. SELECT_AUDIO_DMA_INPUT_BUFFER_B();
  1435. #else
  1436. SELECT_AUDIO_DMA_INPUT_BUFFER_A();
  1437. #endif
  1438. AC97MSG(1,(TEXT("1n")));
  1439. }else
  1440. {
  1441. m_InputDMAStatus &= ~DMA_STRTA; // Buffer A just completed...
  1442. m_InputDMAStatus |= DMA_DONEA;
  1444. m_InputDMAStatus |= DMA_BIU; // Buffer B is in use
  1445. #if DMA_FLAG
  1446. SELECT_AUDIO_DMA_INPUT_BUFFER_A();
  1447. #else
  1448. SELECT_AUDIO_DMA_INPUT_BUFFER_B();
  1449. #endif
  1450. AC97MSG(1,(TEXT("2n")));
  1451. }
  1452. #if !DMA_FLAG
  1453. //----- 5. Schedule the next DMA transfer -----
  1454. AUDIO_IN_DMA_ENABLE();
  1455. #endif
  1457. //----- 6. Retrieve the next chunk of recorded data from the non-playing buffer -----
  1458. InputTransferred = TransferInputBuffers(m_InputDMAStatus);
  1459. }
  1461. //----- 7. Handle any interrupts on the output source -----
  1462. //    NOTE: The InterruptDone() call below automatically clears the interrupt.
  1463. // if((m_OutputDMARunning) && (dmaInterruptSource == DMA_CH_OUT))
  1464. // if((dmaInterruptSource == DMA_CH_OUT))
  1465. else
  1466. {
  1467. //----- Determine which buffer just completed the DMA transfer -----
  1468. if(m_OutputDMAStatus & DMA_BIU)
  1469. {
  1470. //RETAILMSG(DMA_CHK,(_T("BBrn")));
  1471. m_OutputDMAStatus &= ~DMA_STRTB; // Buffer A just completed...
  1472. m_OutputDMAStatus |= DMA_DONEB;
  1473. m_OutputDMAStatus &= ~DMA_BIU; // Buffer B is in use
  1475. delay_count = 0;
  1476.     while((v_pDMAregs->rDSTAT1&0xfffff)==0){
  1477.          RETAILMSG(1,(_T("3")));
  1478. #if WAIT_DMA_END
  1479. Sleep(1);
  1480. #else
  1481.          if( delay_count++ > DELAY_COUNT ) break;
  1482. #endif
  1483.          } 
  1485. #if DMA_FLAG
  1486. SELECT_AUDIO_DMA_OUTPUT_BUFFER_B(); // charlie. B => A
  1487. #else
  1488. SELECT_AUDIO_DMA_OUTPUT_BUFFER_A(); // charlie. B => A
  1489. #endif
  1490. }else
  1491. {
  1492. //RETAILMSG(DMA_CHK,(_T("AArn")));
  1493. m_OutputDMAStatus &= ~DMA_STRTA; // Buffer B just completed...
  1494. m_OutputDMAStatus |= DMA_DONEA;
  1495. m_OutputDMAStatus |= DMA_BIU; // Buffer A is in use
  1497. delay_count = 0;
  1498. while((v_pDMAregs->rDSTAT1&0xfffff)==0)
  1499. {
  1500.          RETAILMSG(1,(_T("4")));
  1501. #if WAIT_DMA_END
  1502. Sleep(1);
  1503. #else
  1504.          if( delay_count++ > DELAY_COUNT ) break;
  1505. #endif
  1506. }
  1509. #if DMA_FLAG
  1510. SELECT_AUDIO_DMA_OUTPUT_BUFFER_A(); // charlie. B => A
  1511. #else
  1512. SELECT_AUDIO_DMA_OUTPUT_BUFFER_B(); // charlie. B => A
  1513. #endif
  1514. }
  1515. #if !DMA_FLAG
  1516. //----- 8. Schedule the next DMA transfer -----
  1517. AUDIO_OUT_DMA_ENABLE();
  1518. #endif
  1519. //----- 9. Fill the non-playing buffer with the next chunk of audio data to play -----
  1520. OutputTransferred = TransferOutputBuffers(m_OutputDMAStatus);
  1521. }
  1523. }
  1524. __except(EXCEPTION_EXECUTE_HANDLER) 
  1525. {
  1526. DEBUGMSG(ZONE_ERROR, (TEXT("WAVDEV2.DLL:InterruptThread() - EXCEPTION: %d"), GetExceptionCode()));
  1527. }
  1529. //----- 10. Give up the lock ----- 
  1530. Unlock();
  1531. }  
  1532. }
  1535. /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1536. Function: AudioMute()
  1538. Description: Mutes/unmutes the specified audio channel.
  1540. Notes: If both audio channels are MUTED, then the chip 
  1541. is powered down to conserve battery life.  
  1542. Alternatively, if either audio channel is unMUTED, 
  1543. the chip is powered up.
  1545. Returns: Boolean indicating success
  1546. -------------------------------------------------------------------*/
  1547. BOOL HardwareContext::AudioMute(DWORD channel, BOOL bMute)
  1548. {
  1549. static DWORD dwActiveChannel = 0;
  1550. USHORT volume;
  1552. // 
  1553. // Turn off/on mute bit in volume control register.
  1554. // 
  1555. if( (channel & DMA_CH_OUT ) && !m_OutputDMARunning ) // 030711
  1556. {
  1557. if(bMute)
  1558. {
  1559. volume = ReadCodecRegister(AC97_HEADPHONE_VOL);
  1560.       WriteCodecRegister(AC97_HEADPHONE_VOL, volume | 0x8000);
  1561. }
  1562. else
  1563. {
  1564. volume = ReadCodecRegister(AC97_HEADPHONE_VOL);
  1565.       WriteCodecRegister(AC97_HEADPHONE_VOL, volume & ~0x8000);
  1566. }
  1567. }
  1569. if( (channel & DMA_CH_MIC ) && !m_InputDMARunning )
  1570. {
  1571. if(bMute)
  1572. {
  1573. volume = ReadCodecRegister(AC97_MIC_VOL);
  1574.       WriteCodecRegister(AC97_MIC_VOL, volume | 0x8000);
  1575. }
  1576. else
  1577. {
  1578. volume = ReadCodecRegister(AC97_MIC_VOL);
  1579.       WriteCodecRegister(AC97_MIC_VOL, volume & ~0x8000);
  1580. }
  1581. }
  1583. return TRUE;
  1584. }
  1587. void CallInterruptThread(HardwareContext *pHWContext)
  1588. {
  1589.     pHWContext->InterruptThread();
  1590. }
  1592. DWORD 
  1593. HardwareContext::Open(
  1594.     void
  1595.     )
  1596. {
  1597.     DWORD mmErr = MMSYSERR_NOERROR;
  1598.     
  1599.     // Don't allow play when not on, if there is a power constraint upon us.
  1600.     if ( D0 != m_Dx )
  1601.     {
  1602.         // Tell the Power Manager we need to power up.
  1603.         // If there is a power constraint then fail.
  1604.         DWORD dwErr = DevicePowerNotify(_T("WAV1:"), D0, POWER_NAME);
  1605.         if ( ERROR_SUCCESS !=  dwErr ) {
  1606.             RETAILMSG(1, (TEXT("AC97::Open:DevicePowerNotify ERROR: %urn"), dwErr ));
  1607.             mmErr = MMSYSERR_ERROR;
  1608.         }
  1609.     }
  1610.     
  1611.     return mmErr;
  1612. }
  1615. DWORD 
  1616. HardwareContext::Close(
  1617.     void
  1618.     )
  1619. {
  1620.     DWORD mmErr = MMSYSERR_NOERROR;
  1621. /*
  1622.     DWORD dwErr;
  1623.     
  1624.     // we are done so inform Power Manager to power us down, 030711
  1625. //    dwErr = DevicePowerNotify(_T("WAV1:"), (_CEDEVICE_POWER_STATE)D4, POWER_NAME);
  1626.     if ( ERROR_SUCCESS !=  dwErr ) {
  1627.         RETAILMSG(1, (TEXT("AC97::Close:DevicePowerNofify ERROR: %urn"), dwErr ));
  1628.             mmErr = MMSYSERR_ERROR;
  1629.     }
  1630. */
  1631.     
  1632.     return mmErr;
  1633. }
  1636. BOOL 
  1637. HardwareContext::IOControl( 
  1638.     DWORD  dwOpenData,
  1639.     DWORD  dwCode,
  1640.     PBYTE  pBufIn,
  1641.     DWORD  dwLenIn,
  1642.     PBYTE  pBufOut,
  1643.     DWORD  dwLenOut,
  1644.     PDWORD pdwActualOut)
  1645. {
  1646.     DWORD dwErr = ERROR_SUCCESS;    
  1647.     BOOL  bRc = TRUE;
  1649.     UNREFERENCED_PARAMETER(dwOpenData);
  1650.     
  1651.     switch (dwCode) {
  1652.         //
  1653.         // Power Management
  1654.         //
  1655.         case IOCTL_POWER_CAPABILITIES: 
  1656.         {
  1657.             PPOWER_CAPABILITIES ppc;
  1658.             RETAILMSG(1,(_T("IOCTL_POWER_CAPABILITIES++rn")));
  1659.             
  1660.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(POWER_CAPABILITIES)) ) {
  1661.                 bRc = FALSE;
  1662.                 dwErr = ERROR_INVALID_PARAMETER;
  1663.                 break;
  1664.             }
  1665.             
  1666.             ppc = (PPOWER_CAPABILITIES)pBufOut;
  1667.             
  1668.             memset(ppc, 0, sizeof(POWER_CAPABILITIES));
  1670.             // support D0, D4
  1671.             ppc->DeviceDx = 0x11;
  1673.             // no wake
  1674.             // no inrush
  1676.             // Report our nominal power consumption in uAmps rather than mWatts.
  1677.             ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;
  1679.             // REVIEW: Do we enable all these for normal playback?
  1680.             // D0: SPI + I2S + CODEC (Playback) + Headphone= 
  1681.             //     0.5 mA + 0.5 mA + (23 mW, into BUGBUG ohms ) + (30 mW, into 32 ohms)
  1682.             //     500 uA + 500 uA + 23000 uA + 32000 uA
  1683.             ppc->Power[D0] = 56000;
  1684.             
  1685.             *pdwActualOut = sizeof(POWER_CAPABILITIES);
  1686.             
  1687.             RETAILMSG(1,(_T("IOCTL_POWER_CAPABILITIES--rn")));
  1688.         } break;
  1690.         case IOCTL_POWER_SET: 
  1692.          bRc = TRUE;
  1693. break;
  1695. /*       
  1696.         {
  1697.             CEDEVICE_POWER_STATE NewDx;
  1699.             RETAILMSG(1,(_T("IOCTL_POWER_SET++rn")));
  1700.             
  1701.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) ) {
  1702.                 bRc = FALSE;
  1703.                 dwErr = ERROR_INVALID_PARAMETER;
  1704.                 break;
  1705.             }
  1706.             
  1707.             NewDx = *(PCEDEVICE_POWER_STATE)pBufOut;
  1709.             if ( VALID_DX(NewDx) ) {
  1710.                 // grab the CS since the normal Xxx_PowerXxx can not.
  1711.                 Lock();
  1712.                 switch ( NewDx ) {
  1713.                     case D0:
  1714.                         if (m_Dx != D0) {
  1715.                             PowerUp();
  1716.                             m_Dx = D0;
  1717.                         }
  1718.                         break;
  1720.                     default:
  1721.                         if (m_Dx != (_CEDEVICE_POWER_STATE)D4) {
  1722.                             PowerDown();
  1723.                             m_Dx = (_CEDEVICE_POWER_STATE)D4;
  1724.                         }
  1725.                         break;
  1726.                 }
  1727.                 
  1728.                 // return our state
  1729.                 *(PCEDEVICE_POWER_STATE)pBufOut = m_Dx;
  1730.                 
  1731.                 RETAILMSG(1, (TEXT("AC97AUDIO: IOCTL_POWER_SET: D%u => D%u rn"), NewDx, m_Dx));
  1733.                 Unlock();
  1734.                 
  1735.                 *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
  1736.             } else {
  1737.                 bRc = FALSE;
  1738.                 dwErr = ERROR_INVALID_PARAMETER;
  1739.             }
  1741.             RETAILMSG(1,(_T("IOCTL_POWER_SET--rn")));
  1742.             
  1743.         } break;
  1744. */
  1745.         case IOCTL_POWER_GET: 
  1747.             RETAILMSG(1,(_T("IOCTL_POWER_GET++rn")));
  1749.             if ( !pdwActualOut || !pBufOut || (dwLenOut < sizeof(CEDEVICE_POWER_STATE)) ) {
  1750.                 bRc = FALSE;
  1751.                 dwErr = ERROR_INVALID_PARAMETER;
  1752.                 break;
  1753.             }
  1755.             *(PCEDEVICE_POWER_STATE)pBufOut = m_Dx;
  1757.             RETAILMSG(1, (TEXT("AC97AUDIO: IOCTL_POWER_GET: D%u rn"), m_Dx));
  1759.             *pdwActualOut = sizeof(CEDEVICE_POWER_STATE);
  1761.             RETAILMSG(1,(_T("IOCTL_POWER_GET++rn")));
  1762.             break;
  1763.             
  1764.         default:
  1765.             bRc = FALSE;
  1766.             dwErr = ERROR_INVALID_FUNCTION;
  1767.             DEBUGMSG (ZONE_FUNCTION, (TEXT(" Unsupported ioctl 0x%Xrn"), dwCode));
  1768.             break;            
  1769.     }
  1770.     
  1771.     if ( !bRc ) {
  1772.         SetLastError(dwErr);
  1773.     }
  1774.     
  1775.     return(bRc);
  1776. }