1:
14:
15:
19:
20:
21:
#include "AG903_errno.h"
22:
#include "osw/oswrapper.h"
23:
#include "uc3wrapper.h"
24:
25:
typedef struct _AG903_OSWMemMap {
26: uintptr_t ttbr0;
27: uint32_t ttbr0sz;
28: uintptr_t ttbr1;
29: uint32_t ttbr1sz;
30: uintptr_t l2tbl;
31: uint32_t l2tblsz;
32: uintptr_t ramtop;
33: uintptr_t ramend;
34: } AG903_OSWMemMap;
35:
36:
typedef struct _AG903_OSWBlkInf {
37: VP topaddr;
38: }AG903_OSWBlkInf;
39:
42:
#define BOUNDARY 8
43:
#define OSWBLKINF_SIZE (((
sizeof(AG903_OSWBlkInf) + BOUNDARY-1)/BOUNDARY)*BOUNDARY)
44:
45:
static volatile ER OswLastErr=0;
46:
static AG903_OSWMemMap OswMemMap = {0};
47:
static uint16_t OswIntDisableCnt[
AG903_OSW_IRQ_NUM_MAX]={0};
48:
static uint8_t OswIntPriorityTbl[
AG903_OSW_IRQ_NUM_MAX]={0};
49:
50:
51:
static int32_t OSW_CreMpl(int32_t mplid,
AG903_OSWCMpl* pk_cmpl, int32_t* getid);
52:
static int32_t OSW_CreMpf(int32_t mpfid,
AG903_OSWCMpf* pk_cmpf, int32_t* getid);
53:
static void OSW_SetMemoryType(uintptr_t addr, uint32_t size, uint8_t type);
54:
static void OSW_CleanDataCache(uintptr_t addr, uint32_t size);
55:
static void OSW_InvalidDataCache(uintptr_t addr, uint32_t size);
56:
static void OSW_SetLastErcd(ER ercd);
57:
static int32_t OSW_ChgErcd(ER ercd);
58:
59:
extern void OSW_GetTtbInfo(uint32_t* ttbcr, uint32_t* ttbr0, uint32_t* ttbr1);
60:
61:
62:
75: int32_t
AG903_OSWprInitMemory(uintptr_t ramtop, uint32_t ramsize)
76: {
77:
78: uint32_t* wp;
79: uint32_t ttbcr, ttbr0, ttbr1;
80: uint32_t loop, cnt;
81: uint32_t l1offset;
82: uint32_t setval;
83: uint8_t ttbcrn;
84:
85:
if( (0>=ramtop) || (0>=ramsize) ||
86: (0xFFFFF&ramtop) || (0xFFFFF&ramsize) ) {
87:
return -
AG903_EINVAL;
88: }
89: OSW_GetTtbInfo(&ttbcr, &ttbr0, &ttbr1);
90: ttbcrn = (uint8_t)(ttbcr&0x03);
91: OswMemMap.ttbr0 = ttbr0&(0xFFFFFF80<<(7-ttbcrn));
92: OswMemMap.ttbr0sz = (0x4000>>ttbcrn);
93: OswMemMap.ttbr1 = ttbr1&0xFFFFFC00;
94: OswMemMap.ttbr1sz = 0x4000;
95: OswMemMap.l2tblsz = 0x1000*((ramsize>>22)+1);
96: OswMemMap.l2tbl = (uintptr_t)(ramtop+ramsize-OswMemMap.l2tblsz);
97: OswMemMap.ramtop = ramtop;
98: OswMemMap.ramend = OswMemMap.l2tbl-1;
99:
100:
101: setval = (ramtop |
AG903_OSW_MEMTYPE_NORMAL_CACHE_ON);
102: cnt = (ramsize>>12);
103: wp = (uint32_t*)OswMemMap.l2tbl;
104:
for(loop=0; loop<cnt; loop++) {
105: (*wp) = setval;
106: setval += 0x1000;
107: wp++;
108: }
109:
110:
111: OSW_CleanDataCache(OswMemMap.ttbr0, OswMemMap.ttbr0sz);
112: OSW_InvalidDataCache(OswMemMap.ttbr0, OswMemMap.ttbr0sz);
113: OSW_CleanDataCache(OswMemMap.ttbr1, OswMemMap.ttbr1sz);
114: OSW_InvalidDataCache(OswMemMap.ttbr1, OswMemMap.ttbr1sz);
115: OSW_CleanDataCache(OswMemMap.l2tbl, OswMemMap.l2tblsz);
116: OSW_InvalidDataCache(OswMemMap.l2tbl, OswMemMap.l2tblsz);
117:
118:
119: setval = (OswMemMap.l2tbl | 0x01);
120: cnt = (ramsize>>20);
121: l1offset = (ramtop>>18);
122:
if(OswMemMap.ttbr0sz > l1offset) {
123: wp = (uint32_t*)(OswMemMap.ttbr0+l1offset);
124: }
125:
else {
126: wp = (uint32_t*)(OswMemMap.ttbr1+(l1offset-OswMemMap.ttbr0sz));
127: }
128:
for(loop=0; loop<cnt; loop++) {
129: (*wp) = setval;
130: setval += 0x400;
131:
if(++wp == (uint32_t*)(OswMemMap.ttbr0+OswMemMap.ttbr0sz)) {
132: wp = (uint32_t*)OswMemMap.ttbr1;
133: }
134: }
135:
136: _kernel_invalid_tlb();
137:
138:
return AG903_ENONE;
139: }
140:
141:
161: int32_t
AG903_OSWprCreMpl(int32_t mplid,
AG903_OSWCMpl* pk_cmpl)
162: {
163: int32_t retval;
164: int32_t getid;
165:
166: retval = OSW_CreMpl(mplid, pk_cmpl, &getid);
167:
168:
return retval;
169: }
170:
171:
188: int32_t
AG903_OSWprCreMplAuto(
AG903_OSWCMpl* pk_cmpl)
189: {
190: int32_t retval;
191: int32_t getid = 0;
192:
193: retval = OSW_CreMpl(0, pk_cmpl, &getid);
194:
if( (
AG903_ENONE==retval)&&(0<getid) ) {
195: retval = getid;
196: }
197:
198:
return retval;
199: }
200:
201:
212: int32_t
AG903_OSWprDelMpl(int32_t mplid)
213: {
214: ER ercd;
215: int32_t retval;
216:
217: ercd = del_mpl((ID)mplid);
218: OSW_SetLastErcd(ercd);
219: retval = OSW_ChgErcd(ercd);
220:
221:
return retval;
222: }
223:
224:
242: int32_t
AG903_OSWprGetMpl(int32_t mplid, uint32_t blksz,
void** p_blk)
243: {
244:
return AG903_OSWprGetMplAlign(mplid, BOUNDARY, blksz, p_blk);
245: }
246:
247:
273: int32_t
AG903_OSWprGetMplAlign(int32_t mplid, uint32_t align, uint32_t blksz,
void** p_blk)
274: {
275: ER ercd;
276: VP getaddr;
277: AG903_OSWBlkInf* blkinf;
278: int32_t retval;
279: uint32_t extsize;
280:
void *blk;
281:
int bit_count;
282:
int ii;
283:
284:
if( (NULL == p_blk) ||
285: (0 == blksz) ) {
286:
return -
AG903_EINVAL;
287: }
288:
289:
if (align < 4) {
290:
return -
AG903_EINVAL;
291: }
292:
293: bit_count = 0;
294:
for (ii = 0; ii < (
int)
sizeof(align)*8; ii++) {
295:
if (align>>ii & 0x1) {
296: bit_count += 1;
297: }
298: }
299:
if (bit_count != 1) {
300:
return -
AG903_EINVAL;
301: }
302:
303: extsize = OSWBLKINF_SIZE + align-1;
304:
305: ercd = pget_mpl((ID)mplid, (UINT)(blksz+extsize), (VP*)&getaddr);
306: OSW_SetLastErcd(ercd);
307: retval = OSW_ChgErcd(ercd);
308:
309:
if(
AG903_ENONE == retval) {
310: blk = (
void *)(((uintptr_t)getaddr + extsize) & ~(align-1));
311: *p_blk = blk;
312:
313: blkinf = (AG903_OSWBlkInf*)((uintptr_t)blk - OSWBLKINF_SIZE);
314: blkinf->topaddr = getaddr;
315: }
else {
316: *p_blk = NULL;
317: }
318:
319:
return retval;
320: }
321:
322:
334: int32_t
AG903_OSWprRelMpl(int32_t mplid,
void* blk)
335: {
336: ER ercd;
337: AG903_OSWBlkInf* blkinf;
338: int32_t retval;
339:
340:
if(NULL == blk) {
341:
return -
AG903_EINVAL;
342: }
343:
344: blkinf = (AG903_OSWBlkInf*)((int8_t*)blk - OSWBLKINF_SIZE);
345: blk = blkinf->topaddr;
346:
347: ercd = rel_mpl((ID)mplid, (VP)blk);
348: OSW_SetLastErcd(ercd);
349: retval = OSW_ChgErcd(ercd);
350:
351:
return retval;
352: }
353:
354:
368: int32_t
AG903_OSWprRefMpl(int32_t mplid,
AG903_OSWRMpl* pk_rmpl)
369: {
370: ER ercd;
371: int32_t retval;
372: T_RMPL rmpl;
373:
374:
if(NULL == pk_rmpl) {
375:
return -
AG903_EINVAL;
376: }
377:
378: ercd = ref_mpl((ID)mplid, &rmpl);
379: OSW_SetLastErcd(ercd);
380: retval = OSW_ChgErcd(ercd);
381:
382:
if(
AG903_ENONE == retval) {
383: pk_rmpl->wtskid = rmpl.wtskid;
384: pk_rmpl->fmplsz = rmpl.fmplsz;
385: pk_rmpl->fblksz = (rmpl.fblksz > OSWBLKINF_SIZE) ? (rmpl.fblksz - OSWBLKINF_SIZE) : 0;
386: }
387:
388:
return retval;
389: }
390:
391:
410: int32_t
AG903_OSWprCreMpf(int32_t mpfid,
AG903_OSWCMpf* pk_cmpf)
411: {
412: int32_t retval;
413: int32_t getid;
414:
415: retval = OSW_CreMpf(mpfid, pk_cmpf, &getid);
416:
417:
return retval;
418: }
419:
420:
433: int32_t
AG903_OSWprCreMpfAuto(
AG903_OSWCMpf* pk_cmpf)
434: {
435: int32_t retval;
436: int32_t getid = 0;
437:
438: retval = OSW_CreMpf(0, pk_cmpf, &getid);
439:
if( (
AG903_ENONE==retval)&&(0<getid) ) {
440: retval = getid;
441: }
442:
443:
return retval;
444: }
445:
446:
456: int32_t
AG903_OSWprDelMpf(int32_t mpfid)
457: {
458: ER ercd;
459: int32_t retval;
460:
461: ercd = del_mpf((ID)mpfid);
462: OSW_SetLastErcd(ercd);
463: retval = OSW_ChgErcd(ercd);
464:
465:
return retval;
466: }
467:
468:
482: int32_t
AG903_OSWprGetMpf(int32_t mpfid,
void** p_blk)
483: {
484: ER ercd;
485: int32_t retval;
486:
487:
if(NULL == p_blk) {
488:
return -
AG903_EINVAL;
489: }
490:
491: ercd = pget_mpf((ID)mpfid, (VP*)p_blk);
492: OSW_SetLastErcd(ercd);
493: retval = OSW_ChgErcd(ercd);
494:
495:
return retval;
496: }
497:
498:
509: int32_t
AG903_OSWprRelMpf(int32_t mpfid,
void* blk)
510: {
511: ER ercd;
512: int32_t retval;
513:
514:
if(NULL == blk) {
515:
return -
AG903_EINVAL;
516: }
517:
518: ercd = rel_mpf((ID)mpfid, (VP)blk);
519: OSW_SetLastErcd(ercd);
520: retval = OSW_ChgErcd(ercd);
521:
522:
return retval;
523: }
524:
525:
536: int32_t
AG903_OSWprRefMpf(int32_t mpfid,
AG903_OSWRMpf* pk_rmpf)
537: {
538: ER ercd;
539: int32_t retval;
540: T_RMPF rmpf;
541:
542:
if(NULL == pk_rmpf) {
543:
return -
AG903_EINVAL;
544: }
545:
546: ercd = ref_mpf((ID)mpfid, &rmpf);
547: OSW_SetLastErcd(ercd);
548: retval = OSW_ChgErcd(ercd);
549:
550:
if(
AG903_ENONE == retval) {
551: pk_rmpf->wtskid = rmpf.wtskid;
552: pk_rmpf->fblkcnt = rmpf.fblkcnt;
553: }
554:
555:
return retval;
556: }
557:
558:
569: int32_t
AG903_OSWprIniInt(
void)
570: {
571: uint32_t loop;
572:
573:
for(loop=0; loop<
AG903_OSW_IRQ_NUM_MAX; loop++) {
574: OswIntPriorityTbl[loop] =
AG903_OSW_DEFAULT_INTRPRI;
575: }
576:
577:
return AG903_ENONE;
578: }
579:
580:
595: int32_t
AG903_OSWprCreIsrAuto(
AG903_OSWCIsr* pk_cisr)
596: {
597: ID isrid;
598: int32_t retval;
599: T_CISR cisr;
600:
601:
if(NULL == pk_cisr) {
602:
return -
AG903_EINVAL;
603: }
604:
if( (
AG903_OSW_IRQ_NUM_MAX <= pk_cisr->intno) ||
605: (
AG903_OSW_HLNG != pk_cisr->atr) ||
606: (NULL == pk_cisr->func) ) {
607:
return -
AG903_EINVAL;
608: }
609:
610: cisr.isratr = (ATR)(TA_HLNG|TA_FPU);
611: cisr.exinf = (VP_INT)pk_cisr->exinf;
612: cisr.intno = (INTNO)(
AG903_OSW_IRQ_TOPID + pk_cisr->intno);
613: cisr.isr = (FP)pk_cisr->func;
614: cisr.imask = (IMASK)(OswIntPriorityTbl[pk_cisr->intno]<<3);
615: isrid = acre_isr(&cisr);
616: OSW_SetLastErcd(isrid);
617:
if(0 > isrid) {
618: retval = OSW_ChgErcd(isrid);
619: }
620:
else if(0 == isrid) {
621: retval = -
AG903_ESYS;
622: }
623:
else {
624: retval = isrid;
625: }
626:
627:
return retval;
628: }
629:
630:
640: int32_t
AG903_OSWprDelIsr(int32_t isrid)
641: {
642: ER ercd;
643: int32_t retval;
644:
645: ercd = del_isr((ID)isrid);
646: OSW_SetLastErcd(ercd);
647: retval = OSW_ChgErcd(ercd);
648:
649:
return retval;
650: }
651:
652:
663: int32_t
AG903_OSWprRefIsr(int32_t isrid,
AG903_OSWRIsr* pk_risr)
664: {
665: ER ercd;
666: int32_t retval;
667: T_RISR risr;
668:
669:
if(NULL == pk_risr) {
670:
return -
AG903_EINVAL;
671: }
672:
673: ercd = ref_isr((ID)isrid, &risr);
674: OSW_SetLastErcd(ercd);
675: retval = OSW_ChgErcd(ercd);
676:
677:
if(
AG903_ENONE == retval) {
678: pk_risr->intno = (risr.intno -
AG903_OSW_IRQ_TOPID);
679: pk_risr->isr = (VP)risr.isr;
680: }
681:
682:
return retval;
683: }
684:
685:
695: int32_t
AG903_OSWprDisInt(uint32_t intno)
696: {
697: ER ercd;
698: int32_t retval;
699:
700:
if(
AG903_OSW_IRQ_NUM_MAX <= intno) {
701:
return -
AG903_EINVAL;
702: }
703:
704: ercd = dis_int((INTNO)(
AG903_OSW_IRQ_TOPID+intno));
705: OSW_SetLastErcd(ercd);
706: retval = OSW_ChgErcd(ercd);
707:
708: OswIntDisableCnt[intno]++;
709:
710:
return retval;
711: }
712:
713:
724: int32_t
AG903_OSWprEnaInt(uint32_t intno)
725: {
726: ER ercd;
727: int32_t retval =
AG903_ENONE;
728:
729:
if(
AG903_OSW_IRQ_NUM_MAX <= intno) {
730:
return -
AG903_EINVAL;
731: }
732:
733:
if(0 < OswIntDisableCnt[intno]) {
734: OswIntDisableCnt[intno]--;
735: }
736:
if(0 >= OswIntDisableCnt[intno]) {
737: ercd = ena_int((INTNO)(
AG903_OSW_IRQ_TOPID+intno));
738: OSW_SetLastErcd(ercd);
739: retval = OSW_ChgErcd(ercd);
740: }
741:
742:
return retval;
743: }
744:
745:
754: int32_t
AG903_OSWprChgIms(uint32_t imask)
755: {
756: ER ercd;
757: int32_t retval;
758:
759: ercd = chg_ims((IMASK)imask);
760: OSW_SetLastErcd(ercd);
761: retval = OSW_ChgErcd(ercd);
762:
763:
return retval;
764: }
765:
766:
775: int32_t
AG903_OSWprGetIms(uint32_t* imask)
776: {
777: ER ercd;
778: int32_t retval;
779:
780:
if(NULL == imask) {
781:
return -
AG903_EINVAL;
782: }
783:
784: *imask = 0;
785: ercd = get_ims((IMASK*)imask);
786: OSW_SetLastErcd(ercd);
787: retval = OSW_ChgErcd(ercd);
788:
789:
return retval;
790: }
791:
792:
804: int32_t
AG903_OSWprSetIpri (uint32_t intno, uint8_t intpri)
805: {
806:
if( (
AG903_OSW_IRQ_NUM_MAX <= intno) ||
807: (
AG903_OSW_IRQ_PRI_MAX <= intpri) ) {
808:
return -
AG903_EINVAL;
809: }
810: OswIntPriorityTbl[intno] = intpri;
811:
812:
return AG903_ENONE;
813: }
814:
815:
826:
static int32_t OSW_CreMpl(int32_t mplid,
AG903_OSWCMpl* pk_cmpl, int32_t* getid)
827: {
828: ER ercd;
829: int32_t retval =
AG903_ENONE;
830: int32_t result;
831: uint32_t size;
832: T_CMPL cmpl;
833:
834:
if(NULL == pk_cmpl) {
835:
return -
AG903_EINVAL;
836: }
837:
if(AG903_OSW_ATRNUM <= pk_cmpl->mplatr) {
838:
return -
AG903_EINVAL;
839: }
840:
switch (pk_cmpl->memtype) {
841:
case AG903_OSW_NORMAL_CACHE_OFF:
842:
case AG903_OSW_NORMAL_CACHE_ON:
843:
case AG903_OSW_STRONGLY_ORDERED:
844:
break;
845:
default:
846:
return -
AG903_EINVAL;
847: }
848:
if(NULL != pk_cmpl->mpl) {
849:
if((uint32_t)pk_cmpl->mpl %
AG903_OSW_CACHE_PAGESIZE) {
850:
return -
AG903_EINVAL;
851: }
852: size = ((pk_cmpl->mplsz+
AG903_OSW_CACHE_PAGESIZE-1) /
AG903_OSW_CACHE_PAGESIZE);
853: size *=
AG903_OSW_CACHE_PAGESIZE;
854:
if( (OswMemMap.ramtop > (uint32_t)pk_cmpl->mpl) ||
855: (OswMemMap.ramend < ((uint32_t)pk_cmpl->mpl+size)) ) {
856:
return -
AG903_EINVAL;
857: }
858: }
859:
else {
860:
861:
862:
863: size = pk_cmpl->mplsz;
864: }
865:
866:
if(AG903_OSW_ATRPRI == pk_cmpl->mplatr) {
867: cmpl.mplatr = (ATR)TA_TPRI;
868: }
869:
else {
870: cmpl.mplatr = (ATR)TA_TFIFO;
871: }
872: cmpl.mplsz = (SIZE)size;
873: cmpl.mpl = (VP)pk_cmpl->mpl;
874: cmpl.name = NULL;
875:
if(0==mplid) {
876: result = acre_mpl(&cmpl);
877: OSW_SetLastErcd(result);
878:
if(0 > result) {
879: retval = OSW_ChgErcd(result);
880: }
881:
else if(0 == result) {
882: retval = -
AG903_ESYS;
883: }
884:
else {
885: (*getid) = result;
886: }
887: }
888:
else {
889: ercd = cre_mpl((ID)mplid, &cmpl);
890: OSW_SetLastErcd(ercd);
891:
if(E_OK == ercd) {
892: (*getid) = mplid;
893: }
894:
else {
895: retval = OSW_ChgErcd(ercd);
896: }
897: }
898:
899:
if(
AG903_ENONE == retval) {
900:
if(NULL == pk_cmpl->mpl) {
901:
902: }
903:
else {
904: OSW_SetMemoryType((uintptr_t)pk_cmpl->mpl, size, pk_cmpl->memtype);
905: }
906: }
907:
908:
return retval;
909: }
910:
911:
918:
static int32_t OSW_CreMpf(int32_t mpfid,
AG903_OSWCMpf* pk_cmpf, int32_t* getid)
919: {
920: ER ercd;
921: int32_t retval =
AG903_ENONE;
922: int32_t result;
923: uint32_t size = 0;
924: T_CMPF cmpf;
925:
926:
if(NULL == pk_cmpf) {
927:
return -
AG903_EINVAL;
928: }
929:
if(AG903_OSW_ATRNUM <= pk_cmpf->mpfatr) {
930:
return -
AG903_EINVAL;
931: }
932:
switch (pk_cmpf->memtype) {
933:
case AG903_OSW_NORMAL_CACHE_OFF:
934:
case AG903_OSW_NORMAL_CACHE_ON:
935:
case AG903_OSW_STRONGLY_ORDERED:
936:
break;
937:
default:
938:
return -
AG903_EINVAL;
939: }
940:
if(NULL != pk_cmpf->mpf) {
941:
if((uint32_t)pk_cmpf->mpf %
AG903_OSW_CACHE_PAGESIZE) {
942:
return -
AG903_EINVAL;
943: }
944: size = (pk_cmpf->blksz * pk_cmpf->blkcnt);
945:
if(size %
AG903_OSW_CACHE_PAGESIZE) {
946:
return -
AG903_EINVAL;
947: }
948:
if( (OswMemMap.ramtop > (uint32_t)pk_cmpf->mpf) ||
949: (OswMemMap.ramend < ((uint32_t)pk_cmpf->mpf+size)) ) {
950:
return -
AG903_EINVAL;
951: }
952: }
953:
else {
954:
955:
956:
957: }
958:
959:
if(AG903_OSW_ATRPRI == pk_cmpf->mpfatr) {
960: cmpf.mpfatr = (ATR)TA_TPRI;
961: }
962:
else {
963: cmpf.mpfatr = (ATR)TA_TFIFO;
964: }
965: cmpf.blkcnt = (UINT)pk_cmpf->blkcnt;
966: cmpf.blksz = (UINT)pk_cmpf->blksz;
967: cmpf.mpf = (VP)pk_cmpf->mpf;
968: cmpf.name = NULL;
969:
if(0==mpfid) {
970: result = acre_mpf(&cmpf);
971: OSW_SetLastErcd(result);
972:
if(0 > result) {
973: retval = OSW_ChgErcd(result);
974: }
975:
else if(0 == result) {
976: retval = -
AG903_ESYS;
977: }
978:
else {
979: (*getid) = result;
980: }
981: }
982:
else {
983: ercd = cre_mpf((ID)mpfid, &cmpf);
984: OSW_SetLastErcd(ercd);
985:
if(E_OK == ercd) {
986: (*getid) = mpfid;
987: }
988:
else {
989: retval = OSW_ChgErcd(ercd);
990: }
991: }
992:
993:
if(
AG903_ENONE == retval) {
994:
if(NULL == pk_cmpf->mpf) {
995:
996: }
997:
else {
998: OSW_SetMemoryType((uintptr_t)pk_cmpf->mpf, size, pk_cmpf->memtype);
999: }
1000: }
1001:
1002:
return retval;
1003: }
1004:
1005:
1013:
static void OSW_SetMemoryType(uintptr_t addr, uint32_t size, uint8_t type)
1014: {
1015: uint32_t* wp;
1016: uint32_t loop, cnt;
1017: uint32_t setval;
1018: uint32_t offset;
1019:
1020: OSW_CleanDataCache(addr, size);
1021: OSW_InvalidDataCache(addr, size);
1022:
1023:
switch(type) {
1024:
case AG903_OSW_NORMAL_CACHE_ON:
1025: setval = (addr |
AG903_OSW_MEMTYPE_NORMAL_CACHE_ON);
1026:
break;
1027:
case AG903_OSW_NORMAL_CACHE_OFF:
1028: setval = (addr |
AG903_OSW_MEMTYPE_NORMAL_CACHE_OFF);
1029:
break;
1030:
case AG903_OSW_STRONGLY_ORDERED:
1031: setval = (addr |
AG903_OSW_MEMTYPE_STRONGLY_ORDERED);
1032:
break;
1033:
default:
1034:
1035: setval = (addr |
AG903_OSW_MEMTYPE_NORMAL_CACHE_OFF);
1036:
break;
1037: }
1038: offset = (addr-OswMemMap.ramtop)>>10;
1039: wp = (uint32_t*)(OswMemMap.l2tbl+offset);
1040: cnt = (size>>12);
1041:
for(loop=0; loop<cnt; loop++) {
1042: (*wp) = setval;
1043: setval += 0x1000;
1044: wp++;
1045: }
1046: OSW_CleanDataCache(OswMemMap.l2tbl+offset, (cnt<<2));
1047: OSW_InvalidDataCache(OswMemMap.l2tbl+offset, (cnt<<2));
1048: _kernel_invalid_tlb();
1049:
1050:
return;
1051: }
1052:
1053:
1058:
static void OSW_CleanDataCache(uintptr_t addr, uint32_t size)
1059: {
1060: _kernel_clean_data_cache((
void*)addr, size);
1061: _kernel_clean_l2_cache((
void*)addr, size);
1062:
1063:
return;
1064: }
1065:
1066:
1071:
static void OSW_InvalidDataCache(uintptr_t addr, uint32_t size)
1072: {
1073: _kernel_invalid_data_cache((
void*)addr, size);
1074: _kernel_invalid_l2_cache((
void*)addr, size);
1075:
1076:
return;
1077: }
1078:
1079:
1083:
static void OSW_SetLastErcd(ER ercd)
1084: {
1085: OswLastErr = ercd;
1086:
return;
1087: }
1088:
1089:
1094:
static int32_t OSW_ChgErcd(ER ercd)
1095: {
1096: int32_t retval;
1097:
1098:
switch(ercd) {
1099:
case E_OK:
1100: retval =
AG903_ENONE;
1101:
break;
1102:
case E_SYS:
1103: retval = -
AG903_ESYS;
1104:
break;
1105:
case E_NOSPT:
1106: retval = -
AG903_ENOTSUP;
1107:
break;
1108:
case E_RSFN:
1109:
case E_RSATR:
1110:
case E_PAR:
1111:
case E_ID:
1112:
case E_NOEXS:
1113: retval = -
AG903_EINVAL;
1114:
break;
1115:
case E_CTX:
1116:
case E_MACV:
1117:
case E_OACV:
1118:
case E_ILUSE:
1119: retval = -
AG903_EPERM;
1120:
break;
1121:
case E_NOMEM:
1122:
case E_TMOUT:
1123: retval = -
AG903_EFAULT;
1124:
break;
1125:
case E_NOID:
1126: retval = -
AG903_ENOID;
1127:
break;
1128:
case E_OBJ:
1129: retval = -
AG903_EEXIST;
1130:
break;
1131:
case E_QOVR:
1132: retval = -
AG903_ENOBUFS;
1133:
break;
1134:
case E_RLWAI:
1135:
case E_DLT:
1136:
case E_CLS:
1137: retval = -
AG903_ECANCELED;
1138:
break;
1139:
case E_BOVR:
1140: retval = -
AG903_ENOBUFS;
1141:
break;
1142:
default:
1143: retval = -
AG903_ESYS;
1144:
break;
1145: }
1146:
1147:
return retval;
1148: }