workbench/devs/networks/fec/fec_init.c

   1 /*
   2  * fec_init.c
   3  *
   4  *  Created on: May 14, 2009
   5  *      Author: misc
   6  */
   7
   8 #define DEBUG 1
   9 #include <aros/debug.h>
  10 #include <aros/libcall.h>
  11 #include <aros/symbolsets.h>
  12
  13 #include <exec/memory.h>
  14 #include <exec/io.h>
  15 #include <exec/errors.h>
  16 #include <exec/devices.h>
  17 #include <exec/ports.h>
  18
  19 #include <utility/tagitem.h>
  20
  21 #include <devices/sana2.h>
  22 #include <devices/sana2specialstats.h>
  23
  24 #include <proto/openfirmware.h>
  25 #include <proto/exec.h>
  26 #include <proto/utility.h>
  27
  28 #include <inttypes.h>
  29
  30 #include "fec.h"
  31
  32 #include LC_LIBDEFS_FILE
  33
  34 typedef struct {
  35         uint8_t b[6];
  36 } mac_addr_t;
  37
  38 typedef struct {
  39         intptr_t        addr;
  40         intptr_t        size;
  41 } reg_t;
  42
  43 static int FEC_Init(struct FECBase *FECBase)
  44 {
  45         int retval = FALSE;
  46         void *OpenFirmwareBase = NULL;
  47         fec_t *fec = NULL;
  48
  49         D(bug("[FEC] Fast Ethernet Controller Init.\n"));
  50
  51         OpenFirmwareBase = OpenResource("openfirmware.resource");
  52
  53         if (OpenFirmwareBase)
  54         {
  55                 void *key, *prop;
  56
  57                 key = OF_OpenKey("/builtin/ethernet");
  58
  59                 if (key)
  60                 {
  61                         prop = OF_FindProperty(key, "reg");
  62
  63                         if (prop)
  64                         {
  65                                 reg_t *reg = OF_GetPropValue(prop);
  66                                 fec = (fec_t *)reg->addr;
  67
  68                                 D(bug("[FEC] FEC registers at %08x\n", fec));
  69
  70                                 prop = OF_FindProperty(key, "mac-address");
  71
  72                                 if (prop)
  73                                 {
  74                                         FECBase->feb_Pool = CreatePool(MEMF_CLEAR | MEMF_PUBLIC | MEMF_SEM_PROTECTED, 8192, 4096);
  75
  76                                         if (FECBase->feb_Pool)
  77                                         {
  78                                                 if (FEC_CreateUnit(FECBase, fec))
  79                                                 {
  80                                                         mac_addr_t *mac = OF_GetPropValue(prop);
  81                                                         D(bug("[FEC] MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
  82                                                                         mac->b[0], mac->b[1], mac->b[2], mac->b[3], mac->b[4], mac->b[5]));
  83
  84                                                         FECBase->feb_Unit->feu_OrgAddr[0] = mac->b[0];
  85                                                         FECBase->feb_Unit->feu_OrgAddr[1] = mac->b[1];
  86                                                         FECBase->feb_Unit->feu_OrgAddr[2] = mac->b[2];
  87                                                         FECBase->feb_Unit->feu_OrgAddr[3] = mac->b[3];
  88                                                         FECBase->feb_Unit->feu_OrgAddr[4] = mac->b[4];
  89                                                         FECBase->feb_Unit->feu_OrgAddr[5] = mac->b[5];
  90
  91                                                         retval = TRUE;
  92                                                 }
  93                                                 else
  94                                                 {
  95                                                         D(bug("[FEC] Failed to create the unit\n"));
  96
  97                                                         DeletePool(FECBase->feb_Pool);
  98                                                 }
  99                                         }
 100                                 }
 101                         }
 102                 }
 103         }
 104         else
 105         {
 106                 bug("[FEC] OpenFirmware not found. Aborting.\n");
 107         }
 108
 109         return retval;
 110 }
 111
 112
 113 static const uintptr_t rx_tags[] = {
 114     S2_CopyToBuff,
 115     S2_CopyToBuff16
 116 };
 117
 118 static const uintptr_t tx_tags[] = {
 119     S2_CopyFromBuff,
 120     S2_CopyFromBuff16,
 121     S2_CopyFromBuff32
 122 };
 123
 124 /*
 125  * Open device handles currently only one pcnet32 unit.
 126  */
 127 static int FEC_Open(struct FECBase *FECBase, struct IOSana2Req* req, ULONG unitnum, ULONG flags)
 128 {
 129     struct TagItem *tags;
 130     struct FECUnit *unit = NULL;
 131     struct Opener *opener;
 132     BYTE error=0;
 133     int i;
 134
 135     D(bug("[FEC] OpenDevice(%d)\n", unitnum));
 136
 137     req->ios2_Req.io_Unit = NULL;
 138     tags = req->ios2_BufferManagement;
 139
 140     req->ios2_BufferManagement = NULL;
 141
 142     /* Check request size */
 143
 144     if(req->ios2_Req.io_Message.mn_Length < sizeof(struct IOSana2Req))
 145         error = IOERR_OPENFAIL;
 146
 147     if ((error != 0) || (unitnum > 1))
 148     {
 149         error = IOERR_OPENFAIL;
 150     }
 151     else
 152     {
 153         unit = FECBase->feb_Unit;
 154         req->ios2_Req.io_Unit = &unit->feu_Unit;
 155     }
 156
 157     /* Handle device sharing */
 158     if(error == 0)
 159     {
 160         if(unit->feu_OpenCount != 0 && ((unit->feu_Flags & IFF_SHARED) == 0 ||
 161           (flags & SANA2OPF_MINE) != 0))
 162             error = IOERR_UNITBUSY;
 163         else
 164             unit->feu_OpenCount++;
 165     }
 166
 167     if(error == 0)
 168     {
 169         if((flags & SANA2OPF_MINE) == 0)
 170             unit->feu_Flags |= IFF_SHARED;
 171         else if((flags & SANA2OPF_PROM) != 0)
 172             unit->feu_Flags |= IFF_PROMISC;
 173
 174         /* Set up buffer-management structure and get hooks */
 175         opener = AllocVecPooled(FECBase->feb_Pool, sizeof(struct Opener));
 176         req->ios2_BufferManagement = (APTR)opener;
 177
 178         if(opener == NULL)
 179             error = IOERR_OPENFAIL;
 180     }
 181
 182     if(error == 0)
 183     {
 184         NEWLIST(&opener->read_port.mp_MsgList);
 185         opener->read_port.mp_Flags = PA_IGNORE;
 186         NEWLIST((APTR)&opener->initial_stats);
 187
 188         for(i = 0; i < 2; i++)
 189             opener->rx_function = (APTR)GetTagData(rx_tags[i], (IPTR)opener->rx_function, tags);
 190         for(i = 0; i < 3; i++)
 191             opener->tx_function = (APTR)GetTagData(tx_tags[i], (IPTR)opener->tx_function, tags);
 192
 193         opener->filter_hook = (APTR)GetTagData(S2_PacketFilter, 0, tags);
 194
 195         Disable();
 196         AddTail((APTR)&unit->feu_Openers, (APTR)opener);
 197         Enable();
 198     }
 199
 200     if (error != 0)
 201         CloseDevice((struct IORequest *)req);
 202     else
 203         unit->start(unit);
 204
 205     req->ios2_Req.io_Error = error;
 206     return (error !=0) ? FALSE : TRUE;
 207 }
 208
 209 static int FEC_Close(struct FECBase *FECBase, struct IOSana2Req* req)
 210 {
 211     struct FECUnit *unit = (struct FECUnit *)req->ios2_Req.io_Unit;
 212     struct Opener *opener;
 213
 214     if (unit)
 215     {
 216         D(bug("[FEC] CloseDevice\n"));
 217
 218         unit->stop(unit);
 219
 220         opener = (APTR)req->ios2_BufferManagement;
 221         if (opener != NULL)
 222         {
 223             Disable();
 224             Remove((struct Node *)opener);
 225             Enable();
 226             FreeVecPooled(FECBase->feb_Pool, opener);
 227         }
 228     }
 229
 230     return TRUE;
 231 }
 232
 233 ADD2INITLIB(FEC_Init,0)
 234 ADD2OPENDEV(FEC_Open,0)
 235 ADD2CLOSEDEV(FEC_Close,0)
 236
 237 AROS_LH1(void, beginio,
 238     AROS_LHA(struct IOSana2Req *, req, A1),
 239     LIBBASETYPEPTR, LIBBASE, 5, FEC)
 240 {
 241     AROS_LIBFUNC_INIT
 242
 243     struct FECUnit *unit;
 244
 245     req->ios2_Req.io_Error = 0;
 246     unit = (APTR)req->ios2_Req.io_Unit;
 247
 248     if (unit)
 249     {
 250         D(bug("[FEC] BeginIO\n"));
 251
 252         if (AttemptSemaphore(&unit->feu_Lock))
 253         {
 254             handle_request(LIBBASE, req);
 255         }
 256         else
 257         {
 258             req->ios2_Req.io_Flags &= ~IOF_QUICK;
 259             PutMsg(unit->feu_InputPort, (struct Message *)req);
 260         }
 261     }
 262
 263     AROS_LIBFUNC_EXIT
 264 }
 265
 266 AROS_LH1(LONG, abortio,
 267     AROS_LHA(struct IOSana2Req *, req, A1),
 268     LIBBASETYPEPTR, LIBBASE, 6, FEC)
 269 {
 270     AROS_LIBFUNC_INIT
 271
 272     struct FECUnit *unit;
 273     unit = (APTR)req->ios2_Req.io_Unit;
 274
 275     if (unit)
 276     {
 277         D(bug("[FEC] AbortIO\n"));
 278
 279         Disable();
 280         if ((req->ios2_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE) &&
 281                 (req->ios2_Req.io_Flags & IOF_QUICK) == 0)
 282         {
 283             Remove((struct Node *)req);
 284             req->ios2_Req.io_Error = IOERR_ABORTED;
 285             req->ios2_WireError = S2WERR_GENERIC_ERROR;
 286             ReplyMsg((struct Message *)req);
 287         }
 288         Enable();
 289     }
 290
 291     return 0;
 292
 293     AROS_LIBFUNC_EXIT
 294 }