retarget.c
上传用户:wealth48
上传日期:2022-06-24
资源大小:1701k
文件大小:6k
源码类别:

uCOS

开发平台:

C/C++

  1. /*
  2. ** Copyright (C) ARM Limited, 2001. All rights reserved.
  3. */
  4. /*
  5. ** This implements a 'retarget' layer for low-level IO.  Typically, this
  6. ** would contain your own target-dependent implementations of fputc(),
  7. ** ferror(), etc.
  8. ** 
  9. ** This example provides implementations of fputc(), ferror(),
  10. ** _sys_exit(), _ttywrch() and __user_initial_stackheap().
  11. **
  12. ** Here, semihosting SWIs are used to display text onto the console 
  13. ** of the host debugger.  This mechanism is portable across ARMulator,
  14. ** Angel, Multi-ICE and EmbeddedICE.
  15. **
  16. ** Alternatively, to output characters from the serial port of an 
  17. ** ARM Integrator Board (see serial.c), use:
  18. **
  19. **     #define USE_SERIAL_PORT
  20. **
  21. ** or compile with 
  22. **
  23. **     -DUSE_SERIAL_PORT
  24. */
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <rt_misc.h>
  28. #include <time.h>
  29. #include "../inc/sys/lib.h"
  30. #undef DEBUG
  31. //#define DEBUG
  32. #ifdef DEBUG
  33. #define DPRINTF printf
  34. #else
  35. #define DPRINTF(...)
  36. #endif
  37. #if (USE_YAFFS==1)
  38. struct __FILE { int handle;   /* Add whatever you need here */};
  39. #define yaffs_Map2File(nfile) ((FILE*)(nfile+1))
  40. #define File_Map2yaffs(cfile) ((int)(cfile)-1)
  41. #else
  42. #endif
  43. FILE __stdin, __stdout, __stderr;
  44. extern unsigned int bottom_of_heap;     /* defined in heap.s */
  45. int fputc(int ch, FILE *f)
  46. {
  47. /* Place your implementation of fputc here     */
  48. /* e.g. write a character to a UART, or to the */
  49. /* debugger console with SWI WriteC            */
  50. if(f == &__stdout) //for console out put e.g. printf
  51. CONSOLE_PUTC(ch);
  52. return ch;
  53. }
  54. int ferror(FILE *f)
  55. {   /* Your implementation of ferror */
  56.     return EOF;
  57. }
  58. void _sys_exit(int return_code)
  59. {
  60. for(;;);
  61. }
  62. int __raise(int signal, int argument)//void _ttywrch(int ch)
  63. {
  64. return 0;
  65. }
  66. __value_in_regs struct __initial_stackheap __user_initial_stackheap(
  67.         unsigned R0, unsigned SP, unsigned R2, unsigned SL)
  68. {
  69.     struct __initial_stackheap config;
  70.     
  71.     config.heap_base = (unsigned int)&bottom_of_heap; // defined in heap.s
  72.                                                       // placed by scatterfile   
  73.     config.stack_base = SP;   // inherit SP from the execution environment
  74.     return config;
  75. }
  76. /*
  77. Below is an equivalent example assembler version of __user_initial_stackheap.
  78. It will be entered with the value of the stackpointer in r1 (as set in init.s), 
  79. this does not need to be changed and so can be passed unmodified out of the 
  80. function. 
  81.     IMPORT bottom_of_heap
  82.     EXPORT __user_initial_stackheap
  83. __user_initial_stackheap    
  84.     LDR   r0,=bottom_of_heap
  85.     MOV   pc,lr
  86. */
  87. int fclose(FILE * stream)
  88. {
  89. #if (USE_YAFFS==1)
  90. yaffs_close(File_Map2yaffs(stream));
  91. return 0;
  92. #else
  93. CloseOSFile(stream);
  94. return 0;
  95. #endif
  96. }
  97. FILE *fopen(const char * filename, const char * mode)
  98. {
  99. #if (USE_YAFFS==1)
  100. #define FILE_FLAG_W 1
  101. #define FILE_FLAG_R 2
  102. #define FILE_FLAG_A 4
  103. #define FILE_FLAG_PLUS 8
  104. const static unsigned int fileoflagTAB[]={ 0xff, // 0 xx
  105. O_WRONLY|O_CREAT|O_TRUNC, // 1->"w"
  106. O_RDONLY, // 2->"r"
  107. 0xff, // 3->"wr" xx
  108. O_WRONLY|O_CREAT|O_APPEND, // 4->"a"
  109. 0xff, // 5->"aw" xx
  110. 0xff, // 6->"ar" xx
  111. 0xff, // 7->"awr" xx
  112. 0xff, // 8->"+" xx
  113. O_RDWR|O_CREAT|O_TRUNC, // 9->"w+"
  114. O_RDWR, // 10->"r+"
  115. 0xff, // 11->"wr+" xx
  116. O_RDWR|O_CREAT|O_APPEND, // 12->"a+"
  117. 0xff, // 13->"aw+" xx
  118. 0xff, // 14->"ar+" xx
  119. 0xff, // 15->"awr+" xx
  120. };
  121. unsigned int filestatus=0, fileoflag;
  122. const char *p=mode;
  123. int ret;
  124. while(*p){
  125. if(*p=='w')
  126. filestatus|=FILE_FLAG_W;
  127. if(*p=='r')
  128. filestatus|=FILE_FLAG_R;
  129. if(*p=='a')
  130. filestatus|=FILE_FLAG_A;
  131. if(*p=='+')
  132. filestatus|=FILE_FLAG_PLUS;
  133. p++;
  134. }
  135. fileoflag=fileoflagTAB[filestatus];
  136. DPRINTF("fopen: %s, Flag: 0x%xn", filename, fileoflag);
  137. if(fileoflag==0xff)
  138. return NULL;
  139. if((ret=yaffs_open(filename, fileoflag, S_IWRITE|S_IREAD))<0){
  140. DPRINTF("Open file: %s failed!n", filename);
  141. return NULL;
  142. }
  143. else{
  144. DPRINTF("Open file: %s success!n", filename);
  145. }
  146. return yaffs_Map2File(ret);
  147. #else //#if (USE_YAFFS==1)
  148. #ifdef DEBUG
  149. FILE *ret;
  150. #endif
  151. //we only support read only mode.
  152. if(strcmp(mode, "rb")!=0 || mode[0]!='r')
  153. return NULL;
  154. DPRINTF("fopen: %sn", filename);
  155. #ifdef DEBUG
  156. ret=OpenOSFile(filename , FILEMODE_READ);
  157. if(ret==NULL)
  158. DPRINTF("fopen: %s failedn", filename);
  159. return ret;
  160. #else
  161. return OpenOSFile((char*)filename , FILEMODE_READ);
  162. #endif
  163. #endif //#if (USE_YAFFS==1)
  164. }
  165. FILE *freopen(const char * filename, const char * mode,
  166. FILE * stream)
  167. {
  168. DPRINTF("freopen: %sn", filename);
  169. fclose(stream);
  170. return fopen(filename, mode);
  171. }
  172. int fflush(FILE * stream)
  173. {
  174. DPRINTF("fflush:n");
  175. return 0;
  176. }
  177. int fseek(FILE * stream, long int offset, int whence)
  178. {
  179. #if (USE_YAFFS==1)
  180. return yaffs_lseek(File_Map2yaffs(stream), offset, whence);
  181. #else
  182. if(whence==SEEK_CUR)
  183. offset+=stream->fileCurpos;
  184. else if(whence==SEEK_END)
  185. offset+=stream->filesize;
  186. DPRINTF("seek: 0x%xn", offset);
  187. if(SeekOSFile(stream, offset)!=offset){
  188. DPRINTF("seek: failed");
  189. return -1;
  190. }
  191. return 0;
  192. #endif //#if (USE_YAFFS==1)
  193. }
  194. FILE *tmpfile(void)
  195. {
  196. DPRINTF("tmpfile:n");
  197. return NULL;
  198. }
  199. void rewind(FILE * stream)
  200. {
  201. #if (USE_YAFFS==1)
  202. yaffs_lseek(File_Map2yaffs(stream), 0, SEEK_SET);
  203. #endif
  204. }
  205. int fgetc(FILE * stream)
  206. {
  207. unsigned char c;
  208. if(stream == &__stdin) //for console out put e.g. printf
  209. return CONSOLE_GETC();
  210. DPRINTF("fgetc:n");
  211. if(fread(&c, 1, 1, stream)!=1)
  212. return 0;
  213. return c;
  214. }
  215. size_t fread(void * ptr,size_t size, size_t nmemb, FILE * stream)
  216. {
  217. int nbyte=size*nmemb;
  218. DPRINTF("fread: %d byte", nbyte);
  219. #if (USE_YAFFS==1)
  220. return yaffs_read(File_Map2yaffs(stream), ptr, nbyte);
  221. #else
  222. return ReadOSFile(stream, ptr, nbyte);
  223. #endif
  224. }
  225. size_t fwrite(const void * ptr,size_t size, size_t nmemb, FILE * stream)
  226. {
  227. #if (USE_YAFFS==1)
  228. int nbyte=size*nmemb;
  229. DPRINTF("fread: %d byte", nbyte);
  230. return yaffs_write(File_Map2yaffs(stream), ptr, nbyte);
  231. #else
  232. return 0;
  233. #endif
  234. }
  235. long int ftell(FILE * stream)
  236. {
  237. return 0;
  238. }
  239. int ungetc(int c, FILE * stream)
  240. {
  241. return 0;
  242. }
  243. time_t time(time_t * timer)
  244. {
  245. return NULL;
  246. }