Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright 2006-2007 Advanced Micro Devices, Inc.  
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice shall be included in
  12.  * all copies or substantial portions of the Software.
  13.  *
  14.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17.  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20.  * OTHER DEALINGS IN THE SOFTWARE.
  21.  */
  22.  
  23. /**
  24.  
  25. Module Name:
  26.  
  27.     hwserv_drv.c
  28.    
  29. Abstract:
  30.  
  31.                 Functions defined in the Command Decoder Specification document
  32.  
  33. Revision History:
  34.  
  35.         NEG:27.09.2002  Initiated.
  36. --*/
  37. #include "CD_binding.h"
  38. #include "CD_hw_services.h"
  39.  
  40. //trace settings
  41. #if DEBUG_OUTPUT_DEVICE & 1
  42.         #define TRACE_USING_STDERR          //define it to use stderr as trace output,
  43. #endif
  44. #if DEBUG_OUTPUT_DEVICE & 2
  45.         #define TRACE_USING_RS232
  46. #endif
  47. #if DEBUG_OUTPUT_DEVICE & 4
  48.         #define TRACE_USING_LPT
  49. #endif
  50.  
  51.  
  52. #if DEBUG_PARSER == 4
  53.         #define IO_TRACE                                        //IO access trace switch, undefine it to turn off
  54.         #define PCI_TRACE                                       //PCI access trace switch, undefine it to turn off
  55.         #define MEM_TRACE                                       //MEM access trace switch, undefine it to turn off
  56. #endif
  57.  
  58. UINT32 CailReadATIRegister(VOID*,UINT32);
  59. VOID   CailWriteATIRegister(VOID*,UINT32,UINT32);
  60. VOID*  CailAllocateMemory(VOID*,UINT16);
  61. VOID   CailReleaseMemory(VOID *,VOID *);
  62. VOID   CailDelayMicroSeconds(VOID *,UINT32 );
  63. VOID   CailReadPCIConfigData(VOID*,VOID*,UINT32,UINT16);
  64. VOID   CailWritePCIConfigData(VOID*,VOID*,UINT32,UINT16);
  65. UINT32 CailReadFBData(VOID*,UINT32);
  66. VOID   CailWriteFBData(VOID*,UINT32,UINT32);
  67. ULONG  CailReadPLL(VOID *Context ,ULONG Address);
  68. VOID   CailWritePLL(VOID *Context,ULONG Address,ULONG Data);
  69. ULONG  CailReadMC(VOID *Context ,ULONG Address);
  70. VOID   CailWriteMC(VOID *Context ,ULONG Address,ULONG Data);
  71.  
  72.  
  73. #if DEBUG_PARSER>0
  74. VOID   CailVideoDebugPrint(VOID*,ULONG_PTR, UINT16);
  75. #endif
  76. // Delay function
  77. #if ( defined ENABLE_PARSER_DELAY || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  78.  
  79. VOID    DelayMilliseconds(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  80. {
  81.             CailDelayMicroSeconds(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->SourceData32*1000);
  82. }
  83.  
  84. VOID    DelayMicroseconds(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  85. {
  86.             CailDelayMicroSeconds(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->SourceData32);
  87. }
  88. #endif
  89.  
  90. VOID    PostCharOutput(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  91. {
  92. }
  93.  
  94. VOID    CallerDebugFunc(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  95. {
  96. }
  97.  
  98.  
  99. // PCI READ Access
  100.  
  101. #if ( defined ENABLE_PARSER_PCIREAD8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  102. UINT8   ReadPCIReg8(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  103. {
  104.     UINT8 rvl;
  105.     CailReadPCIConfigData(pWorkingTableData->pDeviceData->CAIL,&rvl,pWorkingTableData->Index,sizeof(UINT8));
  106.         return rvl;
  107. }
  108. #endif
  109.  
  110.  
  111. #if ( defined ENABLE_PARSER_PCIREAD16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  112. UINT16  ReadPCIReg16(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  113. {
  114.  
  115.     UINT16 rvl;
  116.     CailReadPCIConfigData(pWorkingTableData->pDeviceData->CAIL,&rvl,pWorkingTableData->Index,sizeof(UINT16));
  117.     return rvl;
  118.  
  119. }
  120. #endif
  121.  
  122.  
  123.  
  124. #if ( defined ENABLE_PARSER_PCIREAD32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  125. UINT32  ReadPCIReg32   (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  126. {
  127.  
  128.     UINT32 rvl;
  129.     CailReadPCIConfigData(pWorkingTableData->pDeviceData->CAIL,&rvl,pWorkingTableData->Index,sizeof(UINT32));
  130.     return rvl;
  131. }
  132. #endif
  133.  
  134.  
  135. // PCI WRITE Access
  136.  
  137. #if ( defined ENABLE_PARSER_PCIWRITE8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  138. VOID    WritePCIReg8    (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  139. {
  140.  
  141.     CailWritePCIConfigData(pWorkingTableData->pDeviceData->CAIL,&(pWorkingTableData->DestData32),pWorkingTableData->Index,sizeof(UINT8));
  142.  
  143. }
  144.  
  145. #endif
  146.  
  147.  
  148. #if ( defined ENABLE_PARSER_PCIWRITE16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  149. VOID    WritePCIReg16  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  150. {
  151.  
  152.         CailWritePCIConfigData(pWorkingTableData->pDeviceData->CAIL,&(pWorkingTableData->DestData32),pWorkingTableData->Index,sizeof(UINT16));
  153. }
  154.  
  155. #endif
  156.  
  157.  
  158. #if ( defined ENABLE_PARSER_PCIWRITE32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  159. VOID    WritePCIReg32  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  160. {
  161.     CailWritePCIConfigData(pWorkingTableData->pDeviceData->CAIL,&(pWorkingTableData->DestData32),pWorkingTableData->Index,sizeof(UINT32));
  162. }
  163. #endif
  164.  
  165.  
  166.  
  167.  
  168. // System IO Access
  169. #if ( defined ENABLE_PARSER_SYS_IOREAD8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  170. UINT8   ReadSysIOReg8    (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  171. {
  172.     UINT8 rvl;
  173.     rvl=0;
  174.     //rvl= (UINT8) ReadGenericPciCfg(dev,reg,sizeof(UINT8));
  175.         return rvl;
  176. }
  177. #endif
  178.  
  179.  
  180. #if ( defined ENABLE_PARSER_SYS_IOREAD16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  181. UINT16  ReadSysIOReg16(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  182. {
  183.  
  184.     UINT16 rvl;
  185.     rvl=0;
  186.     //rvl= (UINT16) ReadGenericPciCfg(dev,reg,sizeof(UINT16));
  187.     return rvl;
  188.  
  189. }
  190. #endif
  191.  
  192.  
  193.  
  194. #if ( defined ENABLE_PARSER_SYS_IOREAD32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  195. UINT32  ReadSysIOReg32   (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  196. {
  197.  
  198.     UINT32 rvl;
  199.     rvl=0;
  200.     //rvl= (UINT32) ReadGenericPciCfg(dev,reg,sizeof(UINT32));
  201.     return rvl;
  202. }
  203. #endif
  204.  
  205.  
  206. // PCI WRITE Access
  207.  
  208. #if ( defined ENABLE_PARSER_SYS_IOWRITE8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  209. VOID    WriteSysIOReg8  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  210. {
  211.  
  212.     //WriteGenericPciCfg(dev,reg,sizeof(UINT8),(UINT32)value);
  213. }
  214.  
  215. #endif
  216.  
  217.  
  218. #if ( defined ENABLE_PARSER_SYS_IOWRITE16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  219. VOID    WriteSysIOReg16  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  220. {
  221.  
  222.     //WriteGenericPciCfg(dev,reg,sizeof(UINT16),(UINT32)value);
  223. }
  224.  
  225. #endif
  226.  
  227.  
  228. #if ( defined ENABLE_PARSER_SYS_IOWRITE32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  229. VOID    WriteSysIOReg32  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  230. {
  231.     //WriteGenericPciCfg(dev,reg,sizeof(UINT32),(UINT32)value);
  232. }
  233. #endif
  234.  
  235. // ATI Registers Memory Mapped Access
  236.  
  237. #if ( defined ENABLE_PARSER_REGISTERS_MEMORY_ACCESS || defined ENABLE_ALL_SERVICE_FUNCTIONS)
  238.  
  239. UINT32  ReadReg32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  240. {
  241.     return CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
  242. }
  243.  
  244. VOID    WriteReg32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  245. {
  246.     CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,(UINT16)pWorkingTableData->Index,pWorkingTableData->DestData32 );
  247. }
  248.  
  249.  
  250. VOID    ReadIndReg32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  251. {
  252.     pWorkingTableData->IndirectData = CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,*(UINT16*)(pWorkingTableData->IndirectIOTablePointer+1));
  253. }
  254.  
  255. VOID    WriteIndReg32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  256. {
  257.     CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,*(UINT16*)(pWorkingTableData->IndirectIOTablePointer+1),pWorkingTableData->IndirectData );
  258. }
  259.  
  260. #endif
  261.  
  262. // ATI Registers IO Mapped Access
  263.  
  264. #if ( defined ENABLE_PARSER_REGISTERS_IO_ACCESS || defined ENABLE_ALL_SERVICE_FUNCTIONS )
  265. UINT32  ReadRegIO (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  266. {
  267.     //return CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
  268.     return 0;
  269. }
  270. VOID    WriteRegIO(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  271. {
  272.       //  return CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32 );
  273. }
  274. #endif
  275.  
  276. // access to Frame buffer, dummy function, need more information to implement it  
  277. UINT32  ReadFrameBuffer32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  278. {
  279.    
  280.     return CailReadFBData(pWorkingTableData->pDeviceData->CAIL, (pWorkingTableData->Index <<2 ));
  281.  
  282. }
  283.  
  284. VOID    WriteFrameBuffer32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  285. {
  286.     CailWriteFBData(pWorkingTableData->pDeviceData->CAIL,(pWorkingTableData->Index <<2), pWorkingTableData->DestData32);
  287.  
  288. }
  289.  
  290.  
  291. VOID *AllocateMemory(DEVICE_DATA *pDeviceData , UINT16 MemSize)
  292. {
  293.     if(MemSize)
  294.         return(CailAllocateMemory(pDeviceData->CAIL,MemSize));
  295.     else
  296.         return NULL;
  297. }
  298.  
  299.  
  300. VOID ReleaseMemory(DEVICE_DATA *pDeviceData , WORKING_TABLE_DATA* pWorkingTableData)
  301. {
  302.     if( pWorkingTableData)
  303.         CailReleaseMemory(pDeviceData->CAIL, pWorkingTableData);
  304. }
  305.  
  306.  
  307. UINT32  ReadMC32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  308. {
  309.     UINT32 ReadData;
  310.     ReadData=(UINT32)CailReadMC(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
  311.     return ReadData;
  312. }
  313.  
  314. VOID    WriteMC32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  315. {
  316.     CailWriteMC(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32);    
  317. }
  318.  
  319. UINT32  ReadPLL32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  320. {
  321.     UINT32 ReadData;
  322.     ReadData=(UINT32)CailReadPLL(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
  323.     return ReadData;
  324.  
  325. }
  326.  
  327. VOID    WritePLL32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
  328. {
  329.     CailWritePLL(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32);    
  330.  
  331. }
  332.  
  333.  
  334.  
  335. #if DEBUG_PARSER>0
  336. VOID CD_print_string    (DEVICE_DATA *pDeviceData, UINT8 *str)
  337. {
  338.     CailVideoDebugPrint( pDeviceData->CAIL, (ULONG_PTR) str, PARSER_STRINGS);
  339. }
  340.  
  341. VOID CD_print_value     (DEVICE_DATA *pDeviceData, ULONG_PTR value, UINT16 value_type )
  342. {
  343.     CailVideoDebugPrint( pDeviceData->CAIL, (ULONG_PTR)value, value_type);
  344. }
  345.  
  346. #endif
  347.  
  348. // EOF
  349.