开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
flsocket.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：20k
源码类别：

VxWorks

开发平台：

C/C++

flsocket.c：源码内容
  1. /*
  2.  * $Log:   P:/user/amir/lite/vcs/flsocket.c_v  $
  3.  * 
  4.  *    Rev 1.21   09 Jan 1998 17:10:00   Hdei
  5.  * changed MALLOC FREE to MALLOC_TFFS FREE_TFFS.
  6.  *
  7.  *    Rev 1.21   29 Sep 1997 14:22:36   danig
  8.  * flExitSocket
  9.  * 
  10.  *    Rev 1.21   28 Sep 1997 18:24:02   danig
  11.  * flExitSocket
  12.  * 
  13.  *    Rev 1.20   10 Sep 1997 16:27:54   danig
  14.  * Got rid of generic names
  15.  * 
  16.  *    Rev 1.19   04 Sep 1997 16:23:36   danig
  17.  * Debug messages
  18.  * 
  19.  *    Rev 1.18   28 Aug 1997 17:49:24   danig
  20.  * Buffer & remapped per socket
  21.  * 
  22.  *    Rev 1.17   17 Aug 1997 15:10:48   danig
  23.  * Turn off the card change indicator in flResetCardChanged
  24.  * 
  25.  *    Rev 1.16   27 Jul 1997 11:59:38   amirban
  26.  * Socket.volNo initialization
  27.  * 
  28.  *    Rev 1.15   27 Jul 1997 10:12:12   amirban
  29.  * physicalToPointer and FAR -> FAR0
  30.  * 
  31.  *    Rev 1.14   20 Jul 1997 17:15:38   amirban
  32.  * No watchDogTimer
  33.  * 
  34.  *    Rev 1.13   07 Jul 1997 15:21:46   amirban
  35.  * Ver 2.0
  36.  * 
  37.  *    Rev 1.12   08 Jun 1997 17:03:22   amirban
  38.  * power on callback
  39.  * 
  40.  *    Rev 1.11   15 Apr 1997 19:13:48   danig
  41.  * Added SOCKET_12_VOLTS before a call to vppOff.
  42.  * 
  43.  *    Rev 1.10   25 Nov 1996 17:23:38   danig
  44.  * Changed doNotDisturb from Boolean to counter
  45.  * 
  46.  *    Rev 1.9   20 Nov 1996 16:24:34   danig
  47.  * added remapped to socketSetBusy.
  48.  * 
  49.  *    Rev 1.8   08 Oct 1996 12:17:52   amirban
  50.  * Defined remapped
  51.  * 
  52.  *    Rev 1.7   18 Aug 1996 13:48:38   amirban
  53.  * Comments
  54.  * 
  55.  *    Rev 1.6   15 Aug 1996 11:51:16   amirban
  56.  * Wait state mistake
  57.  *
  58.  *    Rev 1.5   31 Jul 1996 14:31:14   amirban
  59.  * Background stuff, and 5V Vpp
  60.  * 
  61.  *    Rev 1.4   09 Jul 1996 14:36:52   amirban
  62.  * CPU_i386 define
  63.  * 
  64.  *    Rev 1.3   01 Jul 1996 15:41:44   amirban
  65.  * init for all sockets
  66.  * 
  67.  *    Rev 1.2   09 Jun 1996 18:16:30   amirban
  68.  * Correction of socketSetBusy
  69.  * 
  70.  *    Rev 1.1   03 Jun 1996 16:20:26   amirban
  71.  * Typo fix
  72.  * 
  73.  *    Rev 1.0   20 Mar 1996 13:33:06   amirban
  74.  * Initial revision.
  75.  */
  77. /************************************************************************/
  78. /*                                                                      */
  79. /* FAT-FTL Lite Software Development Kit */
  80. /* Copyright (C) M-Systems Ltd. 1995-1996 */
  81. /* */
  82. /************************************************************************/
  85. #include "flsocket.h"
  87. unsigned noOfDrives = 0; /* No. of drives actually registered */
  89. static FLSocket vols[DRIVES];
  91. #ifndef SINGLE_BUFFER
  92. #ifdef MALLOC_TFFS
  93. static FLBuffer *volBuffers[DRIVES];
  94. #else
  95. static FLBuffer volBuffers[DRIVES];
  96. #endif
  97. #endif
  99. /*----------------------------------------------------------------------*/
  100. /*                 f l S o c k e t N o O f  */
  101. /* */
  102. /* Gets the volume no. connected to a socket */
  103. /* */
  104. /* Parameters:                                                          */
  105. /* vol : Pointer identifying drive */
  106. /*                                                                      */
  107. /* Returns:                                                             */
  108. /*  volume no. of socket */
  109. /*----------------------------------------------------------------------*/
  111. unsigned flSocketNoOf(const FLSocket vol)
  112. {
  113.   return vol.volNo;
  114. }
  117. /*----------------------------------------------------------------------*/
  118. /*                 f l S o c k e t O f     */
  119. /* */
  120. /* Gets the socket connected to a volume no. */
  121. /* */
  122. /* Parameters:                                                          */
  123. /* volNo : Volume no. for which to get socket */
  124. /*                                                                      */
  125. /* Returns:                                                             */
  126. /*  socket of volume no. */
  127. /*----------------------------------------------------------------------*/
  129. FLSocket *flSocketOf(unsigned volNo)
  130. {
  131.   return &vols[volNo];
  132. }
  134. #ifndef SINGLE_BUFFER
  135. /*----------------------------------------------------------------------*/
  136. /*                 f l B u f f e r O f     */
  137. /* */
  138. /* Gets the buffer connected to a volume no. */
  139. /* */
  140. /* Parameters:                                                          */
  141. /* volNo : Volume no. for which to get socket */
  142. /*                                                                      */
  143. /* Returns:                                                             */
  144. /*  buffer of volume no. */
  145. /*----------------------------------------------------------------------*/
  147. FLBuffer *flBufferOf(unsigned volNo)
  148. {
  149. #ifdef MALLOC_TFFS
  150.   return volBuffers[volNo];
  151. #else
  152.   return &volBuffers[volNo];
  153. #endif
  154. }
  155. #endif /* SINGLE_BUFFER */
  157. /*----------------------------------------------------------------------*/
  158. /*               f l W r i t e P r o t e c t e d */
  159. /* */
  160. /* Returns the write-protect state of the media */
  161. /* */
  162. /* Parameters:                                                          */
  163. /* vol : Pointer identifying drive */
  164. /*                                                                      */
  165. /* Returns:                                                             */
  166. /* 0 = not write-protected, other = write-protected */
  167. /*----------------------------------------------------------------------*/
  169. FLBoolean flWriteProtected(FLSocket vol)
  170. {
  171.   return vol.writeProtected(&vol);
  172. }
  175. #ifndef FIXED_MEDIA
  177. /*----------------------------------------------------------------------*/
  178. /*             f l R e s e t C a r d C h a n g e d */
  179. /* */
  180. /* Acknowledges a media-change condition and turns off the condition. */
  181. /* */
  182. /* Parameters:                                                          */
  183. /* vol : Pointer identifying drive */
  184. /*                                                                      */
  185. /*----------------------------------------------------------------------*/
  187. void flResetCardChanged(FLSocket vol)
  188. {
  189.   if (vol.getAndClearCardChangeIndicator)
  190.       vol.getAndClearCardChangeIndicator(&vol);  /* turn off the indicator */
  192.   vol.cardChanged = FALSE;
  193. }
  196. /*----------------------------------------------------------------------*/
  197. /*                 f l M e d i a C h e c k */
  198. /* */
  199. /* Checks the presence and change status of the media */
  200. /* */
  201. /* Parameters:                                                          */
  202. /* vol : Pointer identifying drive */
  203. /*                                                                      */
  204. /* Returns:                                                             */
  205. /*  flOK -> Media present and not changed */
  206. /* driveNotReady   -> Media not present */
  207. /* diskChange -> Media present but changed */
  208. /*----------------------------------------------------------------------*/
  210. FLStatus flMediaCheck(FLSocket vol)
  211. {
  212.   if (!vol.cardDetected(&vol)) {
  213.     vol.cardChanged = TRUE;
  214.     return flDriveNotReady;
  215.   }
  217.   if (vol.getAndClearCardChangeIndicator &&
  218.       vol.getAndClearCardChangeIndicator(&vol))
  219.     vol.cardChanged = TRUE;
  221.   return vol.cardChanged ? flDiskChange : flOK;
  222. }
  224. #endif
  226. /*----------------------------------------------------------------------*/
  227. /*                f l I n i t S o c k e t s         */
  228. /* */
  229. /* First call to this module: Initializes the controller and all sockets*/
  230. /* */
  231. /* Parameters:                                                          */
  232. /* vol : Pointer identifying drive */
  233. /*                                                                      */
  234. /* Returns:                                                             */
  235. /* FLStatus : 0 on success, failed otherwise */
  236. /*----------------------------------------------------------------------*/
  238. FLStatus flInitSockets(void)
  239. {
  240.   unsigned volNo;
  241.   FLSocket vol = vols;
  243.   for (volNo = 0; volNo < noOfDrives; volNo++, pVol++) {
  244.     flSetWindowSpeed(&vol, 250);
  245.     flSetWindowBusWidth(&vol, 16);
  246.     flSetWindowSize(&vol, 2); /* make it 8 KBytes */
  248.     vol.cardChanged = FALSE;
  250.   #ifndef SINGLE_BUFFER
  251.   #ifdef MALLOC_TFFS
  252.     /* allocate buffer for this socket */
  253.     volBuffers[volNo] = (FLBuffer *)MALLOC_TFFS(sizeof(FLBuffer));
  254.     if (volBuffers[volNo] == NULL) {
  255.     #ifdef DEBUG_PRINT
  256.       DEBUG_PRINT("Debug: failed allocating sector buffer.n");
  257.     #endif
  258.       return flNotEnoughMemory;
  259.     }
  260.   #endif
  261.   #endif
  263.     checkStatus(vol.initSocket(&vol));
  265.   #ifdef SOCKET_12_VOLTS
  266.     vol.VppOff(&vol);
  267.     vol.VppState = PowerOff;
  268.     vol.VppUsers = 0;
  269.   #endif
  270.     vol.VccOff(&vol);
  271.     vol.VccState = PowerOff;
  272.     vol.VccUsers = 0;
  273.   }
  275.   return flOK;
  276. }
  279. /*----------------------------------------------------------------------*/
  280. /*            f l G e t M a p p i n g C o n t e x t */
  281. /* */
  282. /* Returns the currently mapped window page (in 4KB units) */
  283. /* */
  284. /* Parameters:                                                          */
  285. /* vol : Pointer identifying drive */
  286. /*                                                                      */
  287. /* Returns:                                                             */
  288. /* unsigned int : Current mapped page no. */
  289. /*----------------------------------------------------------------------*/
  291. unsigned flGetMappingContext(FLSocket vol)
  292. {
  293.   return vol.window.currentPage;
  294. }
  297. /*----------------------------------------------------------------------*/
  298. /*                       f l M a p         */
  299. /* */
  300. /* Maps the window to a specified card address and returns a pointer to */
  301. /* that location (some offset within the window). */
  302. /* */
  303. /* NOTE: Addresses over 128M are attribute memory. On PCMCIA adapters, */
  304. /* subtract 128M from the address and map to attribute memory. */
  305. /*                                                                      */
  306. /* Parameters:                                                          */
  307. /* vol : Pointer identifying drive */
  308. /*      address : Byte-address on card. NOT necessarily on a  */
  309. /*   full-window boundary. */
  310. /*   If above 128MB, address is in attribute space.*/
  311. /*                                                                      */
  312. /* Returns:                                                             */
  313. /* Pointer to a location within the window mapping the address. */
  314. /*----------------------------------------------------------------------*/
  316. void FAR0 *flMap(FLSocket vol, CardAddress address)
  317. {
  318.   unsigned pageToMap;
  320.   if (vol.window.currentPage == UNDEFINED_MAPPING)
  321.     vol.setWindow(&vol);
  322.   pageToMap = (unsigned) ((address & -vol.window.size) >> 12);
  324.   if (vol.window.currentPage != pageToMap) {
  325.     vol.setMappingContext(&vol, pageToMap);
  326.     vol.window.currentPage = pageToMap;
  327.     vol.remapped = TRUE; /* indicate remapping done */
  328.   }
  330.   return addToFarPointer(vol.window.base,address & (vol.window.size - 1));
  331. }
  334. /*----------------------------------------------------------------------*/
  335. /*             f l S e t W i n d o w B u s W i d t h */
  336. /* */
  337. /* Requests to set the window bus width to 8 or 16 bits. */
  338. /* Whether the request is filled depends on hardware capabilities. */
  339. /* */
  340. /* Parameters:                                                          */
  341. /* vol : Pointer identifying drive */
  342. /*      width : Requested bus width */
  343. /*                                                                      */
  344. /*----------------------------------------------------------------------*/
  346. void flSetWindowBusWidth(FLSocket vol, unsigned width)
  347. {
  348.   vol.window.busWidth = width;
  349.   vol.window.currentPage = UNDEFINED_MAPPING; /* force remapping */
  350. }
  353. /*----------------------------------------------------------------------*/
  354. /*            f l S e t W i n d o w S p e e d */
  355. /* */
  356. /* Requests to set the window speed to a specified value. */
  357. /* The window speed is set to a speed equal or slower than requested, */
  358. /* if possible in hardware. */
  359. /* */
  360. /* Parameters:                                                          */
  361. /* vol : Pointer identifying drive */
  362. /*      nsec : Requested window speed in nanosec. */
  363. /*                                                                      */
  364. /*----------------------------------------------------------------------*/
  366. void flSetWindowSpeed(FLSocket vol, unsigned nsec)
  367. {
  368.   vol.window.speed = nsec;
  369.   vol.window.currentPage = UNDEFINED_MAPPING; /* force remapping */
  370. }
  373. /*----------------------------------------------------------------------*/
  374. /*             f l S e t W i n d o w S i z e */
  375. /* */
  376. /* Requests to set the window size to a specified value (power of 2). */
  377. /* The window size is set to a size equal or greater than requested, */
  378. /* if possible in hardware. */
  379. /* */
  380. /* Parameters:                                                          */
  381. /* vol : Pointer identifying drive */
  382. /*      sizeIn4KBUnits : Requested window size in 4 KByte units. */
  383. /*  MUST be a power of 2. */
  384. /*                                                                      */
  385. /*----------------------------------------------------------------------*/
  387. void flSetWindowSize(FLSocket vol, unsigned sizeIn4KBunits)
  388. {
  389.   vol.window.size = (long) (sizeIn4KBunits) * 0x1000L;
  390. /* Size may not be possible. Actual size will be set by 'setWindow' */
  391.   vol.window.base = physicalToPointer((long) vol.window.baseAddress << 12,
  392.       vol.window.size,vol.volNo);
  393.   vol.window.currentPage = UNDEFINED_MAPPING; /* force remapping */
  394. }
  397. /*----------------------------------------------------------------------*/
  398. /*            f l S o c k e t S e t B u s y */
  399. /* */
  400. /* Notifies the start and end of a file-system operation. */
  401. /* */
  402. /* Parameters:                                                          */
  403. /* vol : Pointer identifying drive */
  404. /*      state : TFFS_ON (1) = operation entry */
  405. /*   TFFS_OFF(0) = operation exit */
  406. /*                                                                      */
  407. /*----------------------------------------------------------------------*/
  409. void flSocketSetBusy(FLSocket vol, FLBoolean state)
  410. {
  411.   if (state == TFFS_OFF) {
  412. #if POLLING_INTERVAL == 0
  413.     /* If we are not polling, activate the interval routine before exit */
  414.     flIntervalRoutine(&vol);
  415. #endif
  416.   }
  417.   else {
  418.     vol.window.currentPage = UNDEFINED_MAPPING; /* don't assume mapping still valid */
  419.     vol.remapped = TRUE;
  420.   }
  421. }
  424. /*----------------------------------------------------------------------*/
  425. /*                   f l N e e d V c c */
  426. /* */
  427. /* Turns on Vcc, if not on already */
  428. /* */
  429. /* Parameters:                                                          */
  430. /* vol : Pointer identifying drive */
  431. /*                                                                      */
  432. /* Returns:                                                             */
  433. /* FLStatus : 0 on success, failed otherwise */
  434. /*----------------------------------------------------------------------*/
  436. void flNeedVcc(FLSocket vol)
  437. {
  438.   vol.VccUsers++;
  439.   if (vol.VccState == PowerOff) {
  440.     vol.VccOn(&vol);
  441.     if (vol.powerOnCallback)
  442.       vol.powerOnCallback(vol.flash);
  443.   }
  444.   vol.VccState = PowerOn;
  445. }
  448. /*----------------------------------------------------------------------*/
  449. /*                f l D o n t N e e d V c c */
  450. /* */
  451. /* Notifies that Vcc is no longer needed, allowing it to be turned off. */
  452. /* */
  453. /* Parameters:                                                          */
  454. /* vol : Pointer identifying drive */
  455. /*                                                                      */
  456. /*----------------------------------------------------------------------*/
  458. void flDontNeedVcc(FLSocket vol)
  459. {
  460.   if (vol.VccUsers > 0)
  461.     vol.VccUsers--;
  462. }
  464. #ifdef SOCKET_12_VOLTS
  466. /*----------------------------------------------------------------------*/
  467. /*                   f l N e e d V p p */
  468. /* */
  469. /* Turns on Vpp, if not on already */
  470. /* */
  471. /* Parameters:                                                          */
  472. /* vol : Pointer identifying drive */
  473. /*                                                                      */
  474. /* Returns:                                                             */
  475. /* FLStatus : 0 on success, failed otherwise */
  476. /*----------------------------------------------------------------------*/
  478. FLStatus flNeedVpp(FLSocket vol)
  479. {
  480.   vol.VppUsers++;
  481.   if (vol.VppState == PowerOff)
  482.     checkStatus(vol.VppOn(&vol));
  483.   vol.VppState = PowerOn;
  485.   return flOK;
  486. }
  489. /*----------------------------------------------------------------------*/
  490. /*                f l D o n t N e e d V p p */
  491. /* */
  492. /* Notifies that Vpp is no longer needed, allowing it to be turned off. */
  493. /* */
  494. /* Parameters:                                                          */
  495. /* vol : Pointer identifying drive */
  496. /*                                                                      */
  497. /*----------------------------------------------------------------------*/
  499. void flDontNeedVpp(FLSocket vol)
  500. {
  501.   if (vol.VppUsers > 0)
  502.     vol.VppUsers--;
  503.   
  504.   if (vol.VppUsers == 0) /* ADDED. to support ss5 */
  505.       {
  506.       vol.VppState = PowerOff;
  507.       vol.VppOff (&vol);
  508.       }
  509. }
  511. #endif /* SOCKET_12_VOLTS */
  514. /*----------------------------------------------------------------------*/
  515. /*           f l S e t P o w e r O n C a l l b a c k */
  516. /* */
  517. /* Sets a routine address to call when powering on the socket. */
  518. /* */
  519. /* Parameters:                                                          */
  520. /* vol : Pointer identifying drive */
  521. /*      routine : Routine to call when turning on power */
  522. /* flash : Flash object of routine */
  523. /*                                                                      */
  524. /*----------------------------------------------------------------------*/
  526. void flSetPowerOnCallback(FLSocket vol, void (*routine)(void *flash), void *flash)
  527. {
  528.   vol.powerOnCallback = routine;
  529.   vol.flash = flash;
  530. }
  534. /*----------------------------------------------------------------------*/
  535. /*             f l I n t e r v a l R o u t i n e */
  536. /* */
  537. /* Performs periodic socket actions: Checks card presence, and handles  */
  538. /* the Vcc & Vpp turn off mechanisms. */
  539. /*                                                                      */
  540. /* The routine may be called from the interval timer or sunchronously. */
  541. /* */
  542. /* Parameters:                                                          */
  543. /* vol : Pointer identifying drive */
  544. /*                                                                      */
  545. /*----------------------------------------------------------------------*/
  547. void flIntervalRoutine(FLSocket vol)
  548. {
  549. #ifndef FIXED_MEDIA
  550.   if (vol.getAndClearCardChangeIndicator == NULL &&
  551.       !vol.cardChanged)
  552.     if (!vol.cardDetected(&vol)) /* Check that the card is still there */
  553.       vol.cardChanged = TRUE;
  554. #endif
  556.   if (vol.VppUsers == 0) {
  557.     if (vol.VppState == PowerOn)
  558.       vol.VppState = PowerGoingOff;
  559.     else if (vol.VppState == PowerGoingOff) {
  560.       vol.VppState = PowerOff;
  561. #ifdef SOCKET_12_VOLTS
  562.       vol.VppOff(&vol);
  563. #endif
  564.     }
  565.     if (vol.VccUsers == 0) {
  566.       if (vol.VccState == PowerOn)
  567. vol.VccState = PowerGoingOff;
  568.       else if (vol.VccState == PowerGoingOff) {
  569. vol.VccState = PowerOff;
  570. vol.VccOff(&vol);
  571.       }
  572.     }
  573.   }
  574. }
  576. #ifdef EXIT
  577. /*----------------------------------------------------------------------*/
  578. /*             f l E x i t S o c k e t */
  579. /* */
  580. /* Reset the socket and free resources that were allocated for this */
  581. /* socket. */
  582. /* This function is called when FLite exits. */
  583. /* */
  584. /* Parameters:                                                          */
  585. /* vol : Pointer identifying drive */
  586. /*                                                                      */
  587. /*----------------------------------------------------------------------*/
  589. void flExitSocket(FLSocket vol)
  590. {
  591.   flMap(&vol, 0);                           /* reset the mapping register */
  592.   flDontNeedVcc(&vol);
  593.   flSocketSetBusy(&vol,TFFS_OFF);
  594.   vol.freeSocket(&vol);                     /* free allocated resources */
  595. #ifndef SINGLE_BUFFER
  596. #ifdef MALLOC_TFFS
  597.   FREE_TFFS(volBuffers[vol.volNo]);
  598. #endif
  599. #endif
  600. }
  601. #endif /* EXIT */