1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
4 // All rights reserved.
5 //
6 // Unless otherwise stipulated in writing, any and all information contained
7 // herein regardless in any format shall remain the sole proprietary of
8 // MStar Semiconductor Inc. and be kept in strict confidence
9 // ("MStar Confidential Information") by the recipient.
10 // Any unauthorized act including without limitation unauthorized disclosure,
11 // copying, use, reproduction, sale, distribution, modification, disassembling,
12 // reverse engineering and compiling of the contents of MStar Confidential
13 // Information is unlawful and strictly prohibited. MStar hereby reserves the
14 // rights to any and all damages, losses, costs and expenses resulting therefrom.
15 //
16 ////////////////////////////////////////////////////////////////////////////////
17
18 ///////////////////////////////////////////////////////////////////////////////////////////////////
19 ///
20 /// file halMSPI.c
21 /// @brief Master SPI Driver Interface
22 /// @author MStar Semiconductor Inc.
23 ///////////////////////////////////////////////////////////////////////////////////////////////////
24
25
26 //-------------------------------------------------------------------------------------------------
27 // Include Files
28 //-------------------------------------------------------------------------------------------------
29 #include "MsCommon.h"
30 #include "MsTypes.h"
31 #include "halMSPI.h"
32 #include "regMSPI.h"
33
34 //-------------------------------------------------------------------------------------------------
35 // Local Defines
36 //-------------------------------------------------------------------------------------------------
37 #define MSP_READ(addr) READ_WORD(_hal_msp.VirtMspBaseAddr + ((addr)<<2))
38 #define MSP_WRITE(addr, val) WRITE_WORD(_hal_msp.VirtMspBaseAddr + ((addr)<<2), (val))
39 #define CLK_READ(addr) READ_WORD(_hal_msp.VirtClkBaseAddr + ((addr)<<2))
40 #define CLK_WRITE(addr, val) WRITE_WORD(_hal_msp.VirtClkBaseAddr + ((addr)<<2), (val))
41 #define _HAL_MSPI_Trigger() MSP_WRITE(MSPI_TRIGGER_OFFSET,MSPI_TRIGGER)
42 #define _HAL_MSPI_ClearDone() MSP_WRITE(MSPI_DONE_CLEAR_OFFSET,MSPI_CLEAR_DONE)
43 #define MAX_CHECK_CNT 2000
44 #define DEBUG_HAL_MSPI(debug_level, x) do { if (_u8HalMSPIDbgLevel >= (debug_level)) (x); } while(0)
45
46 //-------------------------------------------------------------------------------------------------
47 // Local Structures
48 //-------------------------------------------------------------------------------------------------
49 typedef struct
50 {
51 MS_VIRT VirtMspBaseAddr;
52 MS_VIRT VirtClkBaseAddr;
53 } hal_msp_t;
54
55 //-------------------------------------------------------------------------------------------------
56 // Local Variables
57 //-------------------------------------------------------------------------------------------------
58 static hal_msp_t _hal_msp =
59 {
60 .VirtMspBaseAddr = BASEADDR_RIU + BK_MSP,
61 .VirtClkBaseAddr = BASEADDR_RIU + BK_CLK0
62 };
63
64 static MS_U8 guChipSelect = 0;
65 MS_U8 _u8HalMSPIDbgLevel;
66 static MS_BOOL _gbMspiIntEnable;
67
68 //-------------------------------------------------------------------------------------------------
69 // Local Functions
70 //-------------------------------------------------------------------------------------------------
71
72 //------------------------------------------------------------------------------
73 /// Description : Set MSPI read /write buf size in current operation
74 /// @param Direct \b OUT: read /write operation direction
75 /// @param Size \b OUT: size of read /write buffer
76 //------------------------------------------------------------------------------
77
_HAL_MSPI_RWBUFSize(MS_BOOL Direct,MS_U8 Size)78 static void _HAL_MSPI_RWBUFSize(MS_BOOL Direct, MS_U8 Size)
79 {
80 MS_U16 u16Data = 0;
81 u16Data = MSP_READ(MSPI_RBF_SIZE_OFFSET);
82
83 if(Direct == MSPI_READ_INDEX)
84 {
85 u16Data &= MSPI_RWSIZE_MASK;
86 u16Data |= Size << MSPI_RSIZE_BIT_OFFSET;
87 }
88 else
89 {
90 u16Data &= ~MSPI_RWSIZE_MASK;
91 u16Data |= Size;
92 }
93 MSP_WRITE(MSPI_RBF_SIZE_OFFSET, u16Data);
94 }
95
96 //------------------------------------------------------------------------------
97 /// Description : SPI chip select enable and disable
98 /// @param Enable \b OUT: enable or disable chip select
99 //------------------------------------------------------------------------------
_HAL_MSPI_ChipSelect(MS_BOOL Enable)100 static void _HAL_MSPI_ChipSelect(MS_BOOL Enable)
101 {
102 MS_U16 regdata = 0;
103 MS_U8 bitmask = 0;
104 regdata = MSP_READ(MSPI_CHIP_SELECT_OFFSET);
105 if(Enable)
106 {
107 bitmask = ~(1 << guChipSelect);
108 regdata &= bitmask;
109 }
110 else
111 {
112 bitmask = (1 << guChipSelect);
113 regdata |= bitmask;
114 }
115 MSP_WRITE(MSPI_CHIP_SELECT_OFFSET, regdata);
116 }
117
118 //------------------------------------------------------------------------------
119 /// Description : check MSPI operation complete
120 /// @return TRUE : operation complete
121 /// @return FAIL : failed timeout
122 //------------------------------------------------------------------------------
_HAL_MSPI_CheckDone(void)123 static MS_BOOL _HAL_MSPI_CheckDone(void)
124 {
125 MS_U16 uCheckDoneCnt = 0;
126 MS_U16 uDoneFlag = 0;
127 while(uCheckDoneCnt < MAX_CHECK_CNT)
128 {
129 uDoneFlag = MSP_READ(MSPI_DONE_OFFSET);
130 if(uDoneFlag & MSPI_DONE_FLAG)
131 return TRUE;
132 uCheckDoneCnt++;
133 }
134 DEBUG_MSPI(E_MSPI_DBGLV_ERR,printf("ERROR:MSPI Operation Timeout!!!!!\n"));
135 return FALSE;
136 }
137
_HAL_MSPI_GetCLK(MS_U16 u16CLK)138 static MS_U32 _HAL_MSPI_GetCLK(MS_U16 u16CLK)
139 {
140 MS_U32 u32MspiClk = 0;
141 switch (u16CLK)
142 {
143 case 0:
144 u32MspiClk = 108000000;
145 return u32MspiClk;
146 case 1:
147 u32MspiClk = 54000000;
148 return u32MspiClk;
149 case 2:
150 u32MspiClk = 24000000;
151 return u32MspiClk;
152 case 3:
153 u32MspiClk = 11000000;
154 return u32MspiClk;
155 default:
156 printf("ERROR CLOCK SETTING NOT SUPPORT \r\n");
157 return u32MspiClk;
158 }
159 }
160
161 //-------------------------------------------------------------------------------------------------
162 // Global Functions
163 //-------------------------------------------------------------------------------------------------
164
165 //------------------------------------------------------------------------------
166 /// Description : MSPI initial
167 /// @return void :
168 //------------------------------------------------------------------------------
HAL_MSPI_Init(void)169 void HAL_MSPI_Init(void)
170 {
171 MS_U16 TempData;
172 //init MSP
173 DEBUG_MSPI(E_MSPI_DBGLV_INFO,printf("HAL_MSPI_Init\n"));
174
175 // CLK SETTING
176 TempData = CLK_READ(MSPI_CLK_CFG);
177 TempData &= ~(MSPI_CLK_MASK); //use "~" instead of "!" for coverity issue
178 CLK_WRITE(MSPI_CLK_CFG, TempData);
179
180
181 if(_gbMspiIntEnable)
182 {
183 MSP_WRITE(MSPI_CTRL_OFFSET,(MSPI_INT_ENABLE|MSPI_RESET|MSPI_ENABLE));
184 }
185 else
186 {
187 MSP_WRITE(MSPI_CTRL_OFFSET,(MSPI_RESET|MSPI_ENABLE));
188 }
189 }
190
191 //------------------------------------------------------------------------------
192 /// Description : MSPI interrupt enable
193 /// @param bEnable \b OUT: enable or disable mspi interrupt
194 /// @return void:
195 //------------------------------------------------------------------------------
HAL_MSPI_IntEnable(MS_BOOL bEnable)196 void HAL_MSPI_IntEnable(MS_BOOL bEnable)
197 {
198 if(bEnable)
199 _gbMspiIntEnable = TRUE;
200 else
201 _gbMspiIntEnable = FALSE;
202 }
203
204 //------------------------------------------------------------------------------
205 /// Description : Get Max of chip select
206 /// @param void:
207 /// @return Max of Chip select
208 //------------------------------------------------------------------------------
HAL_MSPI_ChipSelectMax(void)209 MS_U8 HAL_MSPI_ChipSelectMax(void)
210 {
211 return MSPI_CHIP_SELECT_MAX;
212 }
213
214 //------------------------------------------------------------------------------
215 /// Description : Set MSPI chip select
216 /// @param u8CS \u8 OUT: MSPI chip select
217 /// @return void:
218 //------------------------------------------------------------------------------
HAL_MSPI_SetChipSelect(MS_U8 u8CS)219 void HAL_MSPI_SetChipSelect(MS_U8 u8CS)
220 {
221 guChipSelect = u8CS;
222 }
223
224 //------------------------------------------------------------------------------
225 /// Description : Config MSP MMIO base address
226 /// @param u32PMBankBaseAddr \b IN :base address of MMIO (PM domain)
227 /// @param u32NONPMRegBaseAddr \b IN :base address of MMIO
228 /// @param u8DeviceIndex \b IN: index of HW IP
229 //------------------------------------------------------------------------------
HAL_MSPI_MMIOConfig(MS_U32 u32PMBankBaseAddr,MS_U32 u32NONPMRegBaseAddr,MS_U8 u8DeviceIndex)230 void HAL_MSPI_MMIOConfig(MS_U32 u32PMBankBaseAddr, MS_U32 u32NONPMRegBaseAddr, MS_U8 u8DeviceIndex)
231 {
232 DEBUG_MSPI(E_MSPI_DBGLV_INFO,printf("%s(0x%08X)\n", __FUNCTION__, (int)u32NONPMRegBaseAddr));
233 if(u8DeviceIndex)
234 _hal_msp.VirtMspBaseAddr = u32NONPMRegBaseAddr + BK_MSP1;
235 else
236 _hal_msp.VirtMspBaseAddr = u32NONPMRegBaseAddr + BK_MSP;
237 _hal_msp.VirtClkBaseAddr = u32NONPMRegBaseAddr + BK_CLK0;
238 }
239
240 //-------------------------------------------------------------------------------------------------
241 /// Description : read data from MSPI
242 /// @param pData \b IN :pointer to receive data from MSPI read buffer
243 /// @param u16Size \ b OTU : read data size
244 /// @return TRUE : read data success
245 /// @return FALSE : read data fail
246 //-------------------------------------------------------------------------------------------------
HAL_MSPI_Read(MS_U8 * pData,MS_U16 u16Size)247 MS_BOOL HAL_MSPI_Read(MS_U8 *pData, MS_U16 u16Size)
248 {
249 MS_U8 u8Index = 0;
250 MS_U16 u16TempBuf = 0;
251 MS_U16 i =0, j = 0;
252
253 for(i = 0; i < u16Size; i+= MAX_READ_BUF_SIZE)
254 {
255 u16TempBuf = u16Size - i;
256 if(u16TempBuf > MAX_READ_BUF_SIZE)
257 {
258 j = MAX_READ_BUF_SIZE;
259 }
260 else
261 {
262 j = u16TempBuf;
263 }
264 _HAL_MSPI_RWBUFSize(MSPI_READ_INDEX, j);
265
266 HAL_MSPI_Trigger();
267 DEBUG_MSPI(E_MSPI_DBGLV_DEBUG,printf("Read Size %x\n",j));
268 for(u8Index = 0; u8Index < j; u8Index++)
269 {
270
271 if(u8Index & 1)
272 {
273 u16TempBuf = MSP_READ((MSPI_READ_BUF_OFFSET + (u8Index >> 1)));
274 DEBUG_MSPI(E_MSPI_DBGLV_DEBUG,printf("read Buf data %x index %d\n",u16TempBuf, u8Index));
275 pData[u8Index] = u16TempBuf >> 8;
276 pData[u8Index-1] = u16TempBuf & 0xFF;
277 }
278 else if(u8Index == (j -1))
279 {
280 u16TempBuf = MSP_READ((MSPI_READ_BUF_OFFSET + (u8Index >> 1)));
281 DEBUG_MSPI(E_MSPI_DBGLV_DEBUG,printf("read Buf data %x index %d\n",u16TempBuf, u8Index));
282 pData[u8Index] = u16TempBuf & 0xFF;
283 }
284 }
285 pData+= j;
286 }
287 return TRUE;
288 }
289
290 //------------------------------------------------------------------------------
291 /// Description : read data from MSPI
292 /// @param pData \b OUT :pointer to write data to MSPI write buffer
293 /// @param u16Size \ b OTU : write data size
294 /// @return TRUE : write data success
295 /// @return FALSE : wirte data fail
296 //------------------------------------------------------------------------------
HAL_MSPI_Wirte(MS_U8 * pData,MS_U16 u16Size)297 MS_BOOL HAL_MSPI_Wirte(MS_U8 *pData, MS_U16 u16Size)
298 {
299 MS_U8 u8Index = 0;
300 MS_U16 u16TempBuf = 0;
301 MS_U16 i =0, j = 0;
302 for(i = 0; i < u16Size; i+= MAX_WRITE_BUF_SIZE)
303 {
304 u16TempBuf = u16Size - i;
305 if(u16TempBuf > MAX_WRITE_BUF_SIZE)
306 {
307 j = MAX_WRITE_BUF_SIZE;
308 }
309 else
310 {
311 j = u16TempBuf;
312 }
313 DEBUG_MSPI(E_MSPI_DBGLV_DEBUG,printf("Write Size %x\n",j));
314 for(u8Index = 0; u8Index < j; u8Index++)
315 {
316 if(u8Index & 1)
317 {
318 u16TempBuf = (pData[u8Index] << 8) | pData[u8Index-1];
319 DEBUG_MSPI(E_MSPI_DBGLV_DEBUG,printf("write Buf data %x index %d\n",u16TempBuf, u8Index));
320 MSP_WRITE((MSPI_WRITE_BUF_OFFSET + (u8Index >> 1)),u16TempBuf);
321 }
322 else if(u8Index == (j -1))
323 {
324 DEBUG_MSPI(E_MSPI_DBGLV_DEBUG,printf("write Buf data %x index %d\n",pData[u8Index], u8Index));
325 MSP_WRITE((MSPI_WRITE_BUF_OFFSET + (u8Index >> 1)),pData[u8Index]);
326 }
327 }
328 pData += j;
329 _HAL_MSPI_RWBUFSize(MSPI_WRITE_INDEX, j);
330 HAL_MSPI_Trigger();
331 }
332 // set write data size
333
334 return TRUE;
335 }
336
337 //------------------------------------------------------------------------------
338 /// Description : Reset DC register setting of MSPI
339 /// @param NONE
340 /// @return TRUE : reset complete
341 //------------------------------------------------------------------------------
HAL_MSPI_Reset_DCConfig(void)342 MS_BOOL HAL_MSPI_Reset_DCConfig(void)
343 {
344 //DC reset
345 MSP_WRITE(MSPI_DC_TR_START_OFFSET, 0x00);
346 MSP_WRITE(MSPI_DC_TB_OFFSET, 0x00);
347 return TRUE;
348 }
349
350 //------------------------------------------------------------------------------
351 /// Description : Reset Frame register setting of MSPI
352 /// @param NONE
353 /// @return TRUE : reset complete
354 //------------------------------------------------------------------------------
HAL_MSPI_Reset_FrameConfig(void)355 MS_BOOL HAL_MSPI_Reset_FrameConfig(void)
356 {
357 // Frame reset
358 MSP_WRITE(MSPI_FRAME_WBIT_OFFSET, 0xFFF);
359 MSP_WRITE(MSPI_FRAME_WBIT_OFFSET+2, 0xFFF);
360 MSP_WRITE(MSPI_FRAME_RBIT_OFFSET, 0xFFF);
361 MSP_WRITE(MSPI_FRAME_RBIT_OFFSET+2, 0xFFF);
362 return TRUE;
363 }
364
365 //------------------------------------------------------------------------------
366 /// Description : Reset CLK register setting of MSPI
367 /// @param NONE
368 /// @return TRUE : reset complete
369 //------------------------------------------------------------------------------
HAL_MSPI_Reset_CLKConfig(void)370 MS_BOOL HAL_MSPI_Reset_CLKConfig(void)
371 {
372 MS_U16 Tempbuf;
373 //reset clock
374 Tempbuf = MSP_READ(MSPI_CTRL_OFFSET);
375 Tempbuf &= 0x3F;
376 MSP_WRITE(MSPI_CTRL_OFFSET, Tempbuf);
377 return TRUE;
378 }
379
380 //------------------------------------------------------------------------------
381 /// Description : get read/write buffer size
382 /// @param bDirection \b OUT specify to get read/write buffer size
383 /// @return buffer sizel
384 //------------------------------------------------------------------------------
HAL_MSPI_GetBufSize(MS_BOOL bDirection)385 MS_U8 HAL_MSPI_GetBufSize(MS_BOOL bDirection)
386 {
387 if(bDirection == MSPI_READ_INDEX)
388 return MAX_READ_BUF_SIZE;
389 else
390 return MAX_WRITE_BUF_SIZE;
391 }
392
393 //------------------------------------------------------------------------------
394 /// Description : Trigger MSPI operation
395 /// @return TRUE : operation success
396 /// @return FALSE : operation timeout
397 //------------------------------------------------------------------------------
HAL_MSPI_Trigger(void)398 MS_BOOL HAL_MSPI_Trigger(void)
399 {
400 // chip select enable
401 // _HAL_MSPI_ChipSelect(TRUE);
402
403 // trigger operation
404 _HAL_MSPI_Trigger();
405 // check operation complete
406 if(!_HAL_MSPI_CheckDone())
407 return FALSE;
408 // clear done flag
409 _HAL_MSPI_ClearDone();
410 // chip select disable
411 // _HAL_MSPI_ChipSelect(FALSE);
412 // reset read/write buffer size
413 MSP_WRITE(MSPI_RBF_SIZE_OFFSET,0x0);
414 return TRUE;
415 }
416
HAL_MSPI_SlaveEnable(MS_BOOL Enable)417 void HAL_MSPI_SlaveEnable(MS_BOOL Enable)
418 {
419 _HAL_MSPI_ChipSelect(Enable);
420 }
421
422 //------------------------------------------------------------------------------
423 /// Description : get valid range of DC timing
424 /// @param eDCField \b OUT enum of DC timing type
425 /// @return NONE
426 //------------------------------------------------------------------------------
HAL_MSPI_DCConfigMax(eDC_config eDCField)427 MS_U8 HAL_MSPI_DCConfigMax(eDC_config eDCField)
428 {
429 switch(eDCField)
430 {
431 case E_MSPI_TRSTART:
432 return MSPI_DC_TRSTART_MAX;
433 case E_MSPI_TREND:
434 return MSPI_DC_TREND_MAX;
435 case E_MSPI_TB:
436 return MSPI_DC_TB_MAX;
437 case E_MSPI_TRW:
438 return MSPI_DC_TRW_MAX;
439 default:
440 return 0;
441 }
442
443 }
444
445 //------------------------------------------------------------------------------
446 /// Description : config spi transfer timing
447 /// @param ptDCConfig \b OUT struct pointer of bits of buffer tranferred to slave config
448 /// @return NONE
449 //------------------------------------------------------------------------------
HAL_MSPI_SetDcTiming(eDC_config eDCField,MS_U8 u8DCtiming)450 void HAL_MSPI_SetDcTiming (eDC_config eDCField, MS_U8 u8DCtiming)
451 {
452 MS_U16 u16TempBuf = 0;
453 switch(eDCField)
454 {
455 case E_MSPI_TRSTART:
456 u16TempBuf = MSP_READ(MSPI_DC_TR_START_OFFSET);
457 u16TempBuf &= (~MSPI_DC_MASK);
458 u16TempBuf |= u8DCtiming;
459 MSP_WRITE(MSPI_DC_TR_START_OFFSET, u16TempBuf);
460 break;
461 case E_MSPI_TREND:
462 u16TempBuf = MSP_READ(MSPI_DC_TR_END_OFFSET);
463 u16TempBuf &= MSPI_DC_MASK;
464 u16TempBuf |= u8DCtiming << MSPI_DC_BIT_OFFSET;
465 MSP_WRITE(MSPI_DC_TR_END_OFFSET, u16TempBuf);
466 break;
467 case E_MSPI_TB:
468 u16TempBuf = MSP_READ(MSPI_DC_TB_OFFSET);
469 u16TempBuf &= (~MSPI_DC_MASK);
470 u16TempBuf |= u8DCtiming;
471 MSP_WRITE(MSPI_DC_TB_OFFSET, u16TempBuf);
472 break;
473 case E_MSPI_TRW:
474 u16TempBuf = MSP_READ(MSPI_DC_TRW_OFFSET);
475 u16TempBuf &= MSPI_DC_MASK;
476 u16TempBuf |= u8DCtiming << MSPI_DC_BIT_OFFSET;
477 MSP_WRITE(MSPI_DC_TRW_OFFSET, u16TempBuf);
478 break;
479 }
480 }
481
HAL_MSPI_CLKConfigMax(eCLK_config eCLKField)482 MS_U8 HAL_MSPI_CLKConfigMax(eCLK_config eCLKField)
483 {
484 switch(eCLKField)
485 {
486 case E_MSPI_POL:
487 return MSPI_CLK_POLARITY_MAX;
488 case E_MSPI_PHA:
489 return MSPI_CLK_PHASE_MAX;
490 case E_MSPI_CLK:
491 return MSPI_CLK_CLOCK_MAX;
492 default:
493 return 0;
494 }
495 }
496
HAL_MSPI_SetCLKTiming(eCLK_config eCLKField,MS_U8 u8CLKVal)497 void HAL_MSPI_SetCLKTiming(eCLK_config eCLKField, MS_U8 u8CLKVal)
498 {
499 MS_U16 u16TempBuf = 0;
500 switch(eCLKField)
501 {
502 case E_MSPI_POL:
503 u16TempBuf = MSP_READ(MSPI_CLK_CLOCK_OFFSET);
504 u16TempBuf &= ~(MSPI_CLK_POLARITY_MASK);
505 u16TempBuf |= u8CLKVal << MSPI_CLK_POLARITY_BIT_OFFSET;
506 break;
507 case E_MSPI_PHA:
508 u16TempBuf = MSP_READ(MSPI_CLK_CLOCK_OFFSET);
509 u16TempBuf &= ~(MSPI_CLK_PHASE_MASK);
510 u16TempBuf |= u8CLKVal << MSPI_CLK_PHASE_BIT_OFFSET;
511 break;
512 case E_MSPI_CLK:
513 u16TempBuf = MSP_READ(MSPI_CLK_CLOCK_OFFSET);
514 u16TempBuf &= MSPI_CLK_CLOCK_MASK;
515 u16TempBuf |= u8CLKVal << MSPI_CLK_CLOCK_BIT_OFFSET;
516 break;
517 }
518 MSP_WRITE(MSPI_CLK_CLOCK_OFFSET, u16TempBuf);
519 }
520
HAL_MSPI_FrameConfigMax(void)521 MS_U8 HAL_MSPI_FrameConfigMax(void)
522 {
523 return MSPI_FRAME_BIT_MAX;
524 }
525
HAL_MSPI_SetPerFrameSize(MS_BOOL bDirect,MS_U8 u8BufOffset,MS_U8 u8PerFrameSize)526 void HAL_MSPI_SetPerFrameSize(MS_BOOL bDirect, MS_U8 u8BufOffset, MS_U8 u8PerFrameSize)
527 {
528 MS_U8 u8Index = 0;
529 MS_U16 u16TempBuf = 0;
530 MS_U8 u8BitOffset = 0;
531 MS_U16 u16regIndex = 0;
532 if(bDirect == MSPI_READ_INDEX)
533 {
534 u16regIndex = MSPI_FRAME_RBIT_OFFSET;
535 }
536 else
537 {
538 u16regIndex = MSPI_FRAME_WBIT_OFFSET;
539 }
540 if(u8BufOffset >=4)
541 {
542 u8Index++;
543 u8BufOffset -= 4;
544 }
545 u8BitOffset = u8BufOffset * MSPI_FRAME_BIT_FIELD;
546 u16TempBuf = MSP_READ(u16regIndex+ u8Index);
547 u16TempBuf &= ~(MSPI_FRAME_BIT_MASK << u8BitOffset);
548 u16TempBuf |= u8PerFrameSize << u8BitOffset;
549 MSP_WRITE((u16regIndex + u8Index), u16TempBuf);
550 }
551
HAL_MSPI_CLOCK_Config(MS_U32 u32MaxClock)552 MS_BOOL HAL_MSPI_CLOCK_Config(MS_U32 u32MaxClock)
553 {
554 MS_U16 u16ClkDiv = 0;
555 MS_U16 u16ClkLevel = 0;
556 MS_U16 u16TempDiv = 0;
557 MS_U32 u32Clock = 0;
558 MS_U32 u32TempClock = 0;
559 MS_U32 u32ClockMatch = 0;
560 MS_U8 u8ClkIdx = 0;
561 MS_U8 u8DivIdx = 0;
562 u32MaxClock = u32MaxClock
563 * 1000000;
564 // get current clock
565
566 for(u8ClkIdx = 0; u8ClkIdx < MSPI_MAXCLKLEVEL; u8ClkIdx++)
567 {
568 u32Clock = _HAL_MSPI_GetCLK(u8ClkIdx);
569 if(u32Clock < u32MaxClock && u32Clock > u32ClockMatch)
570 {
571 u32ClockMatch = u32Clock;
572 u16ClkLevel = u8ClkIdx;
573 }
574 else if(u32Clock >= u32MaxClock )
575 {
576 if(u32Clock == u32MaxClock)
577 break;
578 else
579 {
580 for(u8DivIdx = 1; u8DivIdx < MSPI_CLK_CLOCK_MAX; u8DivIdx++)
581 {
582 u32TempClock = u32Clock / (1 << (u8DivIdx + 1));
583 if(u32TempClock <= u32MaxClock)
584 {
585 if(u32TempClock > u32ClockMatch)
586 {
587 u32ClockMatch = u32TempClock;
588 u16ClkDiv = u8DivIdx;
589 u16ClkLevel = u8ClkIdx;
590 }
591 break;
592 }
593 }
594 }
595 }
596 }
597 //set clock div of mspi
598 u16TempDiv = MSP_READ(MSPI_CLK_CLOCK_OFFSET);
599 u16TempDiv &= MSPI_CLK_CLOCK_MASK;
600 u16TempDiv |= u16ClkDiv << MSPI_CLK_CLOCK_BIT_OFFSET;
601 MSP_WRITE(MSPI_CLK_CLOCK_OFFSET, u16TempDiv);
602 u16ClkLevel = u16ClkLevel << MSPI_CLK_CFG_OFFSET;
603 CLK_WRITE(MSPI_CLK_CFG, u16ClkLevel);
604 return TRUE;
605 }
606
607
HAL_MSPI_CLK_Config(MS_U8 u8Chanel,MS_U32 u32MspiClk)608 MS_BOOL HAL_MSPI_CLK_Config(MS_U8 u8Chanel,MS_U32 u32MspiClk)
609 {
610
611 return TRUE;
612 }
613
HAL_MSPI_RWBytes(MS_BOOL Direct,MS_U8 u8Bytes)614 MS_BOOL HAL_MSPI_RWBytes(MS_BOOL Direct, MS_U8 u8Bytes)
615 {
616 //set read write trigger buffer size
617 _HAL_MSPI_RWBUFSize(Direct, u8Bytes);
618 return TRUE;
619 }
620