aplfw/driver/ether/ne2000/ne2000drv.c

   1 /**
   2  *  Hyper Operating System  Application Framework
   3  *
   4  * @file  ne2000drv.c
   5  * @brief %jp{NE2000互換Ether用デバイスドライバ}
   6  *
   7  * Copyright (C) 2006 by Project HOS
   8  * http://sourceforge.jp/projects/hos/
   9  */
  10
  11
  12 #include "ne2000drv_local.h"
  13
  14
  15
  16 /* 仮想関数テーブル */
  17 const T_DRVOBJ_METHODS Ne2000Drv_Methods =
  18         {
  19                 Ne2000Drv_Delete,
  20                 Ne2000Drv_Open,
  21                 Ne2000Drv_Close,
  22                 Ne2000Drv_IoControl,
  23                 Ne2000Drv_Seek,
  24                 Ne2000Drv_Read,
  25                 Ne2000Drv_Write,
  26                 Ne2000Drv_Flush,
  27         };
  28
  29
  30 /** コンストラクタ */
  31 void Ne2000Drv_Create(C_NE2000DRV *self, void *pRegAddr, int iIntNum)
  32 {
  33         /* 親クラスコンストラクタ呼び出し */
  34         SyncDrv_Create(&self->SyncDrv, &Ne2000Drv_Methods);
  35
  36         /* メンバ変数初期化 */
  37         self->iOpenCount = 0;
  38
  39         /* Ne2000Hal 初期化 */
  40         Ne2000Hal_Create(&self->Ne2000Hal, pRegAddr);
  41
  42         /* イベント生成 */
  43         self->hEvtRecv = SysEvt_Create(SYSEVT_ATTR_AUTOCLEAR);
  44         self->hEvtSend = SysEvt_Create(SYSEVT_ATTR_AUTOCLEAR);
  45
  46         /* ミューテックス生成 */
  47         self->hMtx = SysMtx_Create(SYSMTX_ATTR_NORMAL);
  48
  49         /* 割込み処理登録 */
  50         SysIsr_Create(iIntNum, Ne2000Drv_Isr, (VPARAM)self);
  51 }
  52
  53
  54 /** デストラクタ */
  55 void Ne2000Drv_Delete(C_DRVOBJ *pDrvObj)
  56 {
  57         C_NE2000DRV *self;
  58
  59         /* upper cast */
  60         self = (C_NE2000DRV *)pDrvObj;
  61
  62         /* オブジェクト削除 */
  63         SysEvt_Delete(self->hEvtRecv);
  64         SysEvt_Delete(self->hEvtSend);
  65         SysMtx_Delete(self->hMtx);
  66
  67         /* 親クラスデストラクタ */
  68         SyncDrv_Delete(&self->SyncDrv);
  69 }
  70
  71
  72 /** オープン */
  73 HANDLE Ne2000Drv_Open(C_DRVOBJ *pDrvObj, const char *pszPath, int iMode)
  74 {
  75         C_NE2000DRV *self;
  76         C_SYNCFILE      *pFile;
  77
  78         /* upper cast */
  79         self = (C_NE2000DRV *)pDrvObj;
  80
  81         /* create file descriptor */
  82         if ( (pFile = SysMem_Alloc(sizeof(C_SYNCFILE))) == NULL )
  83         {
  84                 return HANDLE_NULL;
  85         }
  86         SyncFile_Create(pFile, &self->SyncDrv, NULL);
  87
  88
  89         /* オープン処理 */
  90         SysMtx_Lock(self->hMtx);
  91         if ( self->iOpenCount++ == 0 )
  92         {
  93                 Ne2000Hal_Setup(&self->Ne2000Hal);
  94         }
  95         SysMtx_Unlock(self->hMtx);
  96
  97
  98         return (HANDLE)pFile;
  99 }
 100
 101
 102 /** クローズ */
 103 void Ne2000Drv_Close(C_DRVOBJ *pDrvObj, C_FILEOBJ *pFileObj)
 104 {
 105         C_NE2000DRV *self;
 106         C_SYNCFILE      *pFile;
 107
 108         /* upper cast */
 109         self  = (C_NE2000DRV *)pDrvObj;
 110         pFile = (C_SYNCFILE *)pFileObj;
 111
 112         SysMtx_Lock(self->hMtx);
 113         if ( --self->iOpenCount == 0 )
 114         {
 115                 Ne2000Hal_Stop(&self->Ne2000Hal);
 116         }
 117         SysMtx_Unlock(self->hMtx);
 118
 119
 120         /* ディスクリプタ削除 */
 121         SyncFile_Delete((C_SYNCFILE *)pFile);
 122         SysMem_Free(pFile);
 123 }
 124
 125
 126 /** %jp{受信} */
 127 FILE_SIZE Ne2000Drv_Read(C_DRVOBJ *pDrvObj, C_FILEOBJ *pFileObj, void *pBuf, FILE_SIZE Size)
 128 {
 129         C_NE2000DRV     *self;
 130         C_SYNCFILE              *pFile;
 131         unsigned char   *pubBuf;
 132         int                             iRecvSize = 0;
 133
 134         /* upper cast */
 135         self  = (C_NE2000DRV *)pDrvObj;
 136         pFile = (C_SYNCFILE *)pFileObj;
 137
 138         /* バッファ */
 139         pubBuf = (unsigned char *)pBuf;
 140
 141         for ( ; ; )
 142         {
 143                 SysMtx_Lock(self->hMtx);
 144                 iRecvSize = Ne2000Hal_Recv(&self->Ne2000Hal, pubBuf, Size);
 145                 SysMtx_Unlock(self->hMtx);
 146
 147                 if ( iRecvSize > 0 )
 148                 {
 149                         break;
 150                 }
 151
 152                 /* ブロッキングでなければ抜ける */
 153                 if ( pFile->cReadMode != FILE_RMODE_BLOCKING )
 154                 {
 155                         break;
 156                 }
 157
 158                 /* 受信イベントを待つ */
 159                 SysEvt_Wait(self->hEvtRecv);
 160                 SysEvt_Clear(self->hEvtRecv);
 161         }
 162
 163         return iRecvSize;
 164 }
 165
 166
 167 /** %jp{送信} */
 168 FILE_SIZE Ne2000Drv_Write(C_DRVOBJ *pDrvObj, C_FILEOBJ *pFileObj, const void *pData, FILE_SIZE Size)
 169 {
 170         C_NE2000DRV     *self;
 171         C_SYNCFILE              *pFile;
 172
 173         /* upper cast */
 174         self  = (C_NE2000DRV *)pDrvObj;
 175         pFile = (C_SYNCFILE *)pFileObj;
 176
 177         SysMtx_Lock(self->hMtx);
 178         Size = Ne2000Hal_Send(&self->Ne2000Hal, pData, Size);
 179         SysMtx_Unlock(self->hMtx);
 180
 181         return Size;
 182 }
 183
 184
 185 /* 割込み処理 */
 186 void Ne2000Drv_Isr(VPARAM Param)
 187 {
 188         C_NE2000DRV *self;
 189
 190         self = (C_NE2000DRV *)Param;
 191 }
 192
 193
 194 /* end of file */