1 #if 1
2 #if !defined(MSOS_TYPE_LINUX_KERNEL)
3 #include <stdio.h>
4 #include <string.h>
5 #else
6 #include <linux/string.h>
7 #include <linux/slab.h>
8 #endif
9
10 #include "MsTypes.h"
11 #include "utopia_dapi.h"
12 #include "utopia.h"
13 #include "drvHWI2C.h"
14 #include "drvHWI2C_v2.h"
15 #include "drvHWI2C_private.h"
16 #include "MsOS.h"
17 #endif
18
19
20
21 enum
22 {
23 HWI2C_POOL_ID0=0
24 } eHwi2cPoolID;
25
26 #ifdef CONFIG_MSTAR_UTPA2K_WDT_ENABLE
27 extern MS_BOOL _MDrv_HWI2C_Init(HWI2C_UnitCfg *psCfg);
28 extern MS_BOOL _MDrv_HWI2C_WriteBytes(MS_U16 u16SlaveCfg, MS_U32 uAddrCnt, MS_U8 *pRegAddr, MS_U32 uSize, MS_U8 *pData);
29 extern MS_BOOL _MDrv_HWI2C_ReadBytes(MS_U16 u16SlaveCfg, MS_U32 uAddrCnt, MS_U8 *pRegAddr, MS_U32 uSize, MS_U8 *pData);
30 extern MS_BOOL _MDrv_HWI2C_Start(void);
31 extern MS_BOOL _MDrv_HWI2C_Stop(void);
32 extern MS_BOOL _MDrv_HWI2C_SelectPort(HWI2C_PORT ePort);
33 extern MS_BOOL _MDrv_HWI2C_SetClk(HWI2C_CLKSEL eClk);
34 //extern MS_BOOL _MDrv_HWI2C_WriteBytesP1(MS_U16 u16SlaveCfg, MS_U32 uAddrCnt, MS_U8 *pRegAddr, MS_U32 uSize, MS_U8 *pData);
35 //extern MS_BOOL _MDrv_HWI2C_ReadBytesP1(MS_U16 u16SlaveCfg, MS_U32 uAddrCnt, MS_U8 *pRegAddr, MS_U32 uSize, MS_U8 *pData);
36 extern MS_BOOL _MDrv_HWI2C_GetPortIndex(HWI2C_PORT ePort, MS_U8* pu8Port);
37 void* psI2cResource = NULL;
HWIICStr(MS_U32 u32PowerState,void * pModule)38 MS_U32 HWIICStr(MS_U32 u32PowerState, void* pModule)
39 {
40 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
41 //UtopiaModuleGetSTRPrivate(pModule, (void**));
42
43 if (u32PowerState == E_POWER_SUSPEND)
44 {
45 /* Please Implement Module Suspend Flow Here. */
46 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
47 }
48 else if (u32PowerState == E_POWER_RESUME)
49 {
50 /* Please Implement Module Resume Flow Here. */
51 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
52 }
53 else
54 {
55 u32Return = UTOPIA_STATUS_FAIL;
56 }
57 return u32Return;// for success
58 }
59
60 // this func will be call to init by utopia20 framework
HWI2CRegisterToUtopia(void)61 void HWI2CRegisterToUtopia(void)
62 {
63 // 1. deal with module
64 void* pUtopiaModule = NULL;
65 HWI2C_RESOURCE_PRIVATE * pResPri = NULL;
66 UtopiaModuleCreate(MODULE_HWI2C, 8, &pUtopiaModule);
67 UtopiaModuleRegister(pUtopiaModule);
68 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
69 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)HWI2COpen, (FUtopiaClose)HWI2CClose, (FUtopiaIOctl)HWI2CIoctl);
70
71 #if defined(MSOS_TYPE_LINUX_KERNEL)
72 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule,(FUtopiaSTR)HWIICStr);
73 //UtopiaModuleSetSTRPrivate(pUtopiaModule, STRPrivateDataSize);
74 #endif
75
76 // 2. deal with resource
77 // start func to add res, call once will create 2 access in resource. Also can declare BDMA_POOL_ID_BDMA1 for another channel depend on driver owner.
78 UtopiaModuleAddResourceStart(pUtopiaModule, HWI2C_POOL_ID0);
79 // resource can alloc private for internal use, ex, BDMA_RESOURCE_PRIVATE
80 UtopiaResourceCreate("hwi2c_0", sizeof(HWI2C_RESOURCE_PRIVATE), &psI2cResource);
81 // func to reg res
82 UtopiaResourceRegister(pUtopiaModule, psI2cResource, HWI2C_POOL_ID0);
83 // end function to add res
84 UtopiaModuleAddResourceEnd(pUtopiaModule, HWI2C_POOL_ID0);
85 if(UtopiaResourceObtain(pUtopiaModule, HWI2C_POOL_ID0, &psI2cResource) != 0)
86 {
87 printf("UtopiaResourceObtainToInstant fail\n");
88 }
89 UtopiaResourceGetPrivate(psI2cResource, (void**)&pResPri);
90 UtopiaResourceRelease(psI2cResource);
91 }
92
93
94 //MS_U32 HWI2COpen(void** ppInstance, void* pAttribute)
HWI2COpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)95 MS_U32 HWI2COpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
96 {
97 HWI2C_INSTANT_PRIVATE *pHWI2CPri = NULL;
98 printf("\n[HWI2C INFO] hwi2c open");
99 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__));
100 // instance is allocated here, also can allocate private for internal use, ex, BDMA_INSTANT_PRIVATE
101 UtopiaInstanceCreate(sizeof(HWI2C_INSTANT_PRIVATE), ppInstance);
102 // setup func in private and assign the calling func in func ptr in instance private
103 UtopiaInstanceGetPrivate(*ppInstance, (void**)&pHWI2CPri);
104
105 #if 0
106 //pHWI2CPri->fpHWI2CInit = MDrv_HWI2C_Init;
107 pHWI2CPri->fpHWI2CStart = MDrv_HWI2C_Start;
108 pHWI2CPri->fpHWI2CStop = MDrv_HWI2C_Stop;
109 //pHWI2CPri->fpHWI2CGetPortIndex = MDrv_HWI2C_GetPortIndex;
110 pHWI2CPri->fpHWI2CSelectPort = MDrv_HWI2C_SelectPort;
111 pHWI2CPri->fpHWI2CSetClk = MDrv_HWI2C_SetClk;
112 //pHWI2CPri->fpHWI2CSetReadMode = MDrv_HWI2C_SetReadMode;
113 //pHWI2CPri->fpHWI2CWriteByte = MDrv_HWI2C_WriteByte;
114 pHWI2CPri->fpHWI2CWriteBytes = MDrv_HWI2C_WriteBytes;
115 //pHWI2CPri->fpHWI2CReadByte = MDrv_HWI2C_ReadByte;
116 pHWI2CPri->fpHWI2CReadBytes = MDrv_HWI2C_ReadBytes;
117 //pHWI2CPri->fpHWI2CSelectPort1 = MDrv_HWI2C_SelectPort1;
118 //pHWI2CPri->fpHWI2CSetClkP1 = MDrv_HWI2C_SetClkP1;
119 //pHWI2CPri->fpHWI2CSetReadModeP1 = MDrv_HWI2C_SetReadModeP1;
120 //pHWI2CPri->fpHWI2CWriteByteP1 = MDrv_HWI2C_WriteByteP1;
121 //pHWI2CPri->fpHWI2CWriteBytesP1 = MDrv_HWI2C_WriteBytesP1;
122 //pHWI2CPri->fpHWI2CReadByteP1 = MDrv_HWI2C_ReadByteP1;
123 //pHWI2CPri->fpHWI2CReadBytesP1 = MDrv_HWI2C_ReadBytesP1;
124 //pHWI2CPri->fpHWI2CSetDbgLevel = MDrv_HWI2C_SetDbgLevel;
125 //pHWI2CPri->fpHWI2CGetLibVer = MDrv_HWI2C_GetLibVer;
126 //pHWI2CPri->fpHWI2CGetStatus = MDrv_HWI2C_GetStatus;
127 //pHWI2CPri->fpHWI2CGetInfo = MDrv_HWI2C_GetInfo;
128 //pHWI2CPri->fpHWI2CSetPowerState = MDrv_HWI2C_SetPowerState;
129 //_MDrv_HWI2C_Init_((HWI2C_UnitCfg *) pAttribute);
130 #else
131 pHWI2CPri->fpHWI2CInit = MDrv_HWI2C_Init_U2K;
132 pHWI2CPri->fpHWI2CStart = MDrv_HWI2C_Start_U2K;
133 pHWI2CPri->fpHWI2CStop = MDrv_HWI2C_Stop_U2K;
134 pHWI2CPri->fpHWI2CSelectPort = MDrv_HWI2C_SelectPort_U2K;
135 pHWI2CPri->fpHWI2CSetClk = MDrv_HWI2C_SetClk_U2K;
136 pHWI2CPri->fpHWI2CWriteBytes = MDrv_HWI2C_WriteBytes_U2K;
137 pHWI2CPri->fpHWI2CReadBytes = MDrv_HWI2C_ReadBytes_U2K;
138 // pHWI2CPri->fpHWI2CWriteBytesP1 = MDrv_HWI2C_WriteBytesP1_U2K;
139 // pHWI2CPri->fpHWI2CReadBytesP1 = MDrv_HWI2C_ReadBytesP1_U2K;
140 #endif
141
142 return UTOPIA_STATUS_SUCCESS;
143 }
144
145 // FIXME: why static?
HWI2CIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)146 MS_U32 HWI2CIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
147 {
148 void* pModule = NULL;
149 HWI2C_RESOURCE_PRIVATE * pResPri = NULL;
150 UtopiaInstanceGetModule(pInstance, &pModule);
151 void* pResource = NULL;
152 MS_U32 u32Ret = 0;
153 //MS_U32 u32SearchAddr;
154 //MS_U32 u32CRC32;
155
156 HWI2C_PRIVATE_PARAM *param = NULL;
157 if (pArgs != NULL)
158 param= (HWI2C_PRIVATE_PARAM *) pArgs;
159
160 if (param == NULL)
161 return UTOPIA_STATUS_ERR_RESOURCE;
162
163 HWI2C_INSTANT_PRIVATE* psHWI2CInstPri = NULL;
164 UtopiaInstanceGetPrivate(pInstance, (void**)&psHWI2CInstPri);
165 UtopiaResourceGetPrivate(psI2cResource, (void**)&pResPri);
166 switch(u32Cmd)
167 {
168 case MDrv_CMD_HWI2C_Init:
169 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
170 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
171 {
172 printf("UtopiaResourceObtainToInstant fail\n");
173 return UTOPIA_STATUS_ERR_RESOURCE;
174 }
175 pResPri->privateInit.psCfg = param->privateInit.psCfg;
176 u32Ret = psHWI2CInstPri->fpHWI2CInit(param->privateInit.psCfg);
177 UtopiaResourceRelease(pResource);
178 break;
179
180 case MDrv_CMD_HWI2C_Start:
181 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
182 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
183 {
184 printf("UtopiaResourceObtainToInstant fail\n");
185 return UTOPIA_STATUS_ERR_RESOURCE;
186 }
187
188 u32Ret = psHWI2CInstPri->fpHWI2CStart();
189 UtopiaResourceRelease(pResource);
190 break;
191
192 case MDrv_CMD_HWI2C_Stop:
193 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
194 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
195 {
196 printf("UtopiaResourceObtainToInstant fail\n");
197 return UTOPIA_STATUS_ERR_RESOURCE;
198 }
199
200 u32Ret = psHWI2CInstPri->fpHWI2CStop();
201 UtopiaResourceRelease(pResource);
202 break;
203
204 case MDrv_CMD_HWI2C_WriteBytes:
205 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
206 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
207 {
208 printf("UtopiaResourceObtainToInstant fail\n");
209 return UTOPIA_STATUS_ERR_RESOURCE;
210 }
211 u32Ret = psHWI2CInstPri->fpHWI2CWriteBytes(param->privateWriteBytes.u16SlaveCfg,
212 param->privateWriteBytes.uAddrCnt,
213 param->privateWriteBytes.pRegAddr,
214 param->privateWriteBytes.uSize,
215 param->privateWriteBytes.pData);
216
217 param->privateWriteBytes.bReturn = (MS_BOOL) u32Ret;
218 UtopiaResourceRelease(pResource);
219 break;
220
221 case MDrv_CMD_HWI2C_ReadBytes:
222 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
223 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
224 {
225 printf("UtopiaResourceObtainToInstant fail\n");
226 return UTOPIA_STATUS_ERR_RESOURCE;
227 }
228
229 u32Ret = psHWI2CInstPri->fpHWI2CReadBytes(param->privateReadBytes.u16SlaveCfg,
230 param->privateReadBytes.uAddrCnt,
231 param->privateReadBytes.pRegAddr,
232 param->privateReadBytes.uSize,
233 param->privateReadBytes.pData);
234
235 param->privateReadBytes.bReturn = (MS_BOOL) u32Ret;
236 UtopiaResourceRelease(pResource);
237 break;
238
239 case MDrv_CMD_HWI2C_SelectPort:
240 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
241 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
242 {
243 printf("UtopiaResourceObtainToInstant fail\n");
244 return UTOPIA_STATUS_ERR_RESOURCE;
245 }
246
247 u32Ret = psHWI2CInstPri->fpHWI2CSelectPort(param->privateSelectPort.ePort);
248 UtopiaResourceRelease(pResource);
249 break;
250
251 case MDrv_CMD_HWI2C_SetClk:
252 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
253 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
254 {
255 printf("UtopiaResourceObtainToInstant fail\n");
256 return UTOPIA_STATUS_ERR_RESOURCE;
257 }
258
259 u32Ret = psHWI2CInstPri->fpHWI2CSetClk(param->privateSetClk.eClk);
260
261 UtopiaResourceRelease(pResource);
262 break;
263 case MDrv_CMD_HWI2C_GetConfig:
264 param->privateInit.psCfg = pResPri->privateInit.psCfg;
265 u32Ret = UTOPIA_STATUS_SUCCESS;
266 break;
267 #if 0
268 case MDrv_CMD_HWI2C_WriteBytesP1:
269 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
270 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
271 {
272 printf("UtopiaResourceObtainToInstant fail\n");
273 return UTOPIA_STATUS_ERR_RESOURCE;
274 }
275
276 u32Ret = psHWI2CInstPri->fpHWI2CWriteBytesP1(param->privateWriteBytesP1.u16SlaveCfg,
277 param->privateWriteBytesP1.uAddrCnt,
278 param->privateWriteBytesP1.pRegAddr,
279 param->privateWriteBytesP1.uSize,
280 param->privateWriteBytesP1.pData);
281
282 UtopiaResourceRelease(pResource);
283 break;
284
285 case MDrv_CMD_HWI2C_ReadBytesP1:
286 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
287 if(UtopiaResourceObtain(pModule, HWI2C_POOL_ID0, &pResource) != 0)
288 {
289 printf("UtopiaResourceObtainToInstant fail\n");
290 return UTOPIA_STATUS_ERR_RESOURCE;
291 }
292
293 u32Ret = psHWI2CInstPri->fpHWI2CReadBytesP1(param->privateReadBytesP1.u16SlaveCfg,
294 param->privateReadBytesP1.uAddrCnt,
295 param->privateReadBytesP1.pRegAddr,
296 param->privateReadBytesP1.uSize,
297 param->privateReadBytesP1.pData);
298
299 UtopiaResourceRelease(pResource);
300 break;
301 #endif
302 default:
303 break;
304 };
305
306 return (u32Ret==TRUE?UTOPIA_STATUS_SUCCESS:UTOPIA_STATUS_FAIL); // FIXME: error code
307 }
308
HWI2CClose(void * pInstance)309 MS_U32 HWI2CClose(void* pInstance)
310 {
311 UtopiaInstanceDelete(pInstance);
312 return UTOPIA_STATUS_SUCCESS;
313 }
314 #endif
315