workbench/devs/networks/rhine/device.c

   1 /*
   2
   3 Copyright (C) 2000-2011 Neil Cafferkey
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 MA 02111-1307, USA.
  19
  20 */
  21
  22
  23 #include <exec/types.h>
  24 #include <exec/resident.h>
  25 #include <exec/errors.h>
  26 #include <utility/utility.h>
  27 #include "initializers.h"
  28
  29 #include <proto/exec.h>
  30 #include <clib/alib_protos.h>
  31 #include <proto/utility.h>
  32
  33 #include "device.h"
  34
  35 #include "device_protos.h"
  36 #include "pci_protos.h"
  37 #include "request_protos.h"
  38
  39
  40 /* Private prototypes */
  41
  42 static VOID DeleteDevice(struct DevBase *base);
  43
  44
  45 /* Return an error immediately if someone tries to run the device */
  46
  47 LONG Main()
  48 {
  49    return -1;
  50 }
  51
  52
  53 const TEXT device_name[] = DEVICE_NAME;
  54 const TEXT version_string[] =
  55    DEVICE_NAME " " STR(VERSION) "." STR(REVISION) " (" DATE ")\n";
  56 const TEXT utility_name[] = UTILITYNAME;
  57 static const TEXT prometheus_name[] = "prometheus.library";
  58 const TEXT timer_name[] = TIMERNAME;
  59
  60
  61 static const APTR vectors[] =
  62 {
  63    (APTR)DevOpen,
  64    (APTR)DevClose,
  65    (APTR)DevExpunge,
  66    (APTR)DevReserved,
  67    (APTR)DevBeginIO,
  68    (APTR)DevAbortIO,
  69    (APTR)-1
  70 };
  71
  72
  73 const struct
  74 {
  75    SMALLINITBYTEDEF(type);
  76    SMALLINITPINTDEF(name);
  77    SMALLINITBYTEDEF(flags);
  78    SMALLINITWORDDEF(version);
  79    SMALLINITWORDDEF(revision);
  80    SMALLINITPINTDEF(id_string);
  81    INITENDDEF;
  82 }
  83 init_data =
  84 {
  85    SMALLINITBYTE(OFFSET(Node, ln_Type), NT_DEVICE),
  86    SMALLINITPINT(OFFSET(Node, ln_Name), device_name),
  87    SMALLINITBYTE(OFFSET(Library, lib_Flags), LIBF_SUMUSED | LIBF_CHANGED),
  88    SMALLINITWORD(OFFSET(Library, lib_Version), VERSION),
  89    SMALLINITWORD(OFFSET(Library, lib_Revision), REVISION),
  90    SMALLINITPINT(OFFSET(Library, lib_IdString), version_string),
  91    INITEND
  92 };
  93
  94
  95 static const APTR init_table[] =
  96 {
  97    (APTR)sizeof(struct DevBase),
  98    (APTR)vectors,
  99    (APTR)&init_data,
 100    (APTR)DevInit
 101 };
 102
 103
 104 const struct Resident rom_tag =
 105 {
 106    RTC_MATCHWORD,
 107    (struct Resident *)&rom_tag,
 108    (APTR)(&rom_tag + 1),
 109    RTF_AUTOINIT,
 110    VERSION,
 111    NT_DEVICE,
 112    0,
 113    (STRPTR)device_name,
 114    (STRPTR)version_string,
 115    (APTR)init_table
 116 };
 117
 118
 119 static const ULONG rx_tags[] =
 120 {
 121    S2_CopyToBuff,
 122    S2_CopyToBuff16,
 123 };
 124
 125
 126 static const ULONG tx_tags[] =
 127 {
 128    S2_CopyFromBuff,
 129    S2_CopyFromBuff16,
 130    S2_CopyFromBuff32
 131 };
 132
 133
 134
 135 /****i* rhine.device/DevInit ***********************************************
 136 *
 137 *   NAME
 138 *       DevInit
 139 *
 140 *   SYNOPSIS
 141 *       dev_base = DevInit(dev_base, seg_list)
 142 *
 143 *       struct DevBase *DevInit(struct DevBase *, APTR);
 144 *
 145 ****************************************************************************
 146 *
 147 */
 148
 149 struct DevBase *DevInit(REG(d0, struct DevBase *dev_base),
 150    REG(a0, APTR seg_list), REG(BASE_REG, struct DevBase *base))
 151 {
 152    BOOL success = TRUE;
 153
 154    /* Initialise base structure */
 155
 156    dev_base->sys_base = (APTR)base;
 157    base = dev_base;
 158    base->seg_list = seg_list;
 159    NewList((APTR)(&base->pci_units));
 160
 161    /* Open libraries, resources and devices */
 162
 163    base->utility_base = (APTR)OpenLibrary(utility_name, UTILITY_VERSION);
 164    base->prometheus_base = OpenLibrary(prometheus_name, PROMETHEUS_VERSION);
 165
 166    if(base->utility_base == NULL)
 167       success = FALSE;
 168
 169    if(OpenDevice(timer_name, UNIT_ECLOCK, (APTR)&base->timer_request, 0)
 170       != 0)
 171       success = FALSE;
 172
 173    if(!success)
 174    {
 175       DeleteDevice(base);
 176       base = NULL;
 177    }
 178
 179    return base;
 180 }
 181
 182
 183
 184 /****i* rhine.device/DevOpen ***********************************************
 185 *
 186 *   NAME
 187 *       DevOpen
 188 *
 189 *   SYNOPSIS
 190 *       error = DevOpen(request, unit_num, flags)
 191 *
 192 *       BYTE DevOpen(struct IOSana2Req *, ULONG, ULONG);
 193 *
 194 ****************************************************************************
 195 *
 196 */
 197
 198 BYTE DevOpen(REG(a1, struct IOSana2Req *request),
 199    REG(d0, ULONG unit_num), REG(d1, ULONG flags),
 200    REG(BASE_REG, struct DevBase *base))
 201 {
 202    struct DevUnit *unit;
 203    BYTE error = 0;
 204    struct Opener *opener;
 205    struct TagItem *tag_list;
 206    UWORD i;
 207
 208    base->device.dd_Library.lib_OpenCnt++;
 209    base->device.dd_Library.lib_Flags &= ~LIBF_DELEXP;
 210
 211    request->ios2_Req.io_Unit = NULL;
 212    tag_list = request->ios2_BufferManagement;
 213    request->ios2_BufferManagement = NULL;
 214
 215    /* Check request size */
 216
 217    if(request->ios2_Req.io_Message.mn_Length < sizeof(struct IOSana2Req))
 218       error = IOERR_OPENFAIL;
 219
 220    /* Get the requested unit */
 221
 222    if(error == 0)
 223    {
 224       request->ios2_Req.io_Unit = (APTR)(unit = GetUnit(unit_num, base));
 225       if(unit == NULL)
 226          error = IOERR_OPENFAIL;
 227    }
 228
 229    /* Handle device sharing */
 230
 231    if(error == 0)
 232    {
 233       if(unit->open_count != 0 && ((unit->flags & UNITF_SHARED) == 0
 234          || (flags & SANA2OPF_MINE) != 0))
 235          error = IOERR_UNITBUSY;
 236       unit->open_count++;
 237    }
 238
 239    if(error == 0)
 240    {
 241       if((flags & SANA2OPF_MINE) == 0)
 242          unit->flags |= UNITF_SHARED;
 243       else if((flags & SANA2OPF_PROM) != 0)
 244          unit->flags |= UNITF_PROM;
 245
 246       /* Set up buffer-management structure and get hooks */
 247
 248       request->ios2_BufferManagement = opener =
 249          AllocVec(sizeof(struct Opener), MEMF_PUBLIC | MEMF_CLEAR);
 250       if(opener == NULL)
 251          error = IOERR_OPENFAIL;
 252    }
 253
 254    if(error == 0)
 255    {
 256       NewList(&opener->read_port.mp_MsgList);
 257       opener->read_port.mp_Flags = PA_IGNORE;
 258       NewList(&opener->mgmt_port.mp_MsgList);
 259       opener->mgmt_port.mp_Flags = PA_IGNORE;
 260       NewList((APTR)&opener->initial_stats);
 261
 262       for(i = 0; i < 2; i++)
 263          opener->rx_function = (APTR)GetTagData(rx_tags[i],
 264             (UPINT)opener->rx_function, tag_list);
 265       for(i = 0; i < 3; i++)
 266          opener->tx_function = (APTR)GetTagData(tx_tags[i],
 267             (UPINT)opener->tx_function, tag_list);
 268
 269       opener->filter_hook = (APTR)GetTagData(S2_PacketFilter, (UPINT)NULL,
 270          tag_list);
 271       opener->dma_tx_function =
 272          (APTR)GetTagData(S2_DMACopyFromBuff32, (UPINT)NULL, tag_list);
 273
 274       Disable();
 275       AddTail((APTR)&unit->openers, (APTR)opener);
 276       Enable();
 277    }
 278
 279    /* Back out if anything went wrong */
 280
 281    if(error != 0)
 282       CloseUnit(request, base);
 283
 284    /* Return */
 285
 286    request->ios2_Req.io_Error = error;
 287    return error;
 288 }
 289
 290
 291
 292 /****i* rhine.device/DevClose **********************************************
 293 *
 294 *   NAME
 295 *       DevClose
 296 *
 297 *   SYNOPSIS
 298 *       seg_list = DevClose(request)
 299 *
 300 *       APTR DevClose(struct IOSana2Req *);
 301 *
 302 ****************************************************************************
 303 *
 304 */
 305
 306 APTR DevClose(REG(a1, struct IOSana2Req *request),
 307    REG(BASE_REG, struct DevBase *base))
 308 {
 309    APTR seg_list = NULL;
 310
 311    /* Close the unit */
 312
 313    CloseUnit(request, base);
 314
 315    /* Expunge the device if a delayed expunge is pending */
 316
 317    if(base->device.dd_Library.lib_OpenCnt == 0)
 318    {
 319       if((base->device.dd_Library.lib_Flags & LIBF_DELEXP) != 0)
 320          seg_list = DevExpunge(base);
 321    }
 322
 323    return seg_list;
 324 }
 325
 326
 327
 328 /****i* rhine.device/DevExpunge ********************************************
 329 *
 330 *   NAME
 331 *       DevExpunge
 332 *
 333 *   SYNOPSIS
 334 *       seg_list = DevExpunge()
 335 *
 336 *       APTR DevExpunge(VOID);
 337 *
 338 ****************************************************************************
 339 *
 340 */
 341
 342 APTR DevExpunge(REG(BASE_REG, struct DevBase *base))
 343 {
 344    APTR seg_list;
 345
 346    if(base->device.dd_Library.lib_OpenCnt == 0)
 347    {
 348       seg_list = base->seg_list;
 349       Remove((APTR)base);
 350       DeleteDevice(base);
 351    }
 352    else
 353    {
 354       base->device.dd_Library.lib_Flags |= LIBF_DELEXP;
 355       seg_list = NULL;
 356    }
 357
 358    return seg_list;
 359 }
 360
 361
 362
 363 /****i* rhine.device/DevReserved *******************************************
 364 *
 365 *   NAME
 366 *       DevReserved
 367 *
 368 *   SYNOPSIS
 369 *       result = DevReserved()
 370 *
 371 *       APTR DevReserved(VOID);
 372 *
 373 ****************************************************************************
 374 *
 375 */
 376
 377 APTR DevReserved()
 378 {
 379    return NULL;
 380 }
 381
 382
 383
 384 /****i* rhine.device/DevBeginIO ********************************************
 385 *
 386 *   NAME
 387 *       DevBeginIO
 388 *
 389 *   SYNOPSIS
 390 *       DevBeginIO(request)
 391 *
 392 *       VOID DevBeginIO(struct IORequest *);
 393 *
 394 ****************************************************************************
 395 *
 396 */
 397
 398 VOID DevBeginIO(REG(a1, struct IOSana2Req *request),
 399    REG(BASE_REG, struct DevBase *base))
 400 {
 401    struct DevUnit *unit;
 402
 403    request->ios2_Req.io_Error = 0;
 404    unit = (APTR)request->ios2_Req.io_Unit;
 405
 406    if(AttemptSemaphore(&unit->access_lock))
 407       ServiceRequest(request, base);
 408    else
 409       PutRequest(unit->request_ports[GENERAL_QUEUE], (APTR)request, base);
 410
 411    return;
 412 }
 413
 414
 415
 416 /****i* rhine.device/DevAbortIO ********************************************
 417 *
 418 *   NAME
 419 *       DevAbortIO -- Try to stop a request.
 420 *
 421 *   SYNOPSIS
 422 *       DevAbortIO(request)
 423 *
 424 *       VOID DevAbortIO(struct IOSana2Req *);
 425 *
 426 *   FUNCTION
 427 *       Do our best to halt the progress of a request.
 428 *
 429 ****************************************************************************
 430 *
 431 */
 432
 433 VOID DevAbortIO(REG(a1, struct IOSana2Req *request),
 434    REG(BASE_REG, struct DevBase *base))
 435 {
 436    Disable();
 437    if(request->ios2_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE &&
 438       (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 439    {
 440       Remove((APTR)request);
 441       request->ios2_Req.io_Error = IOERR_ABORTED;
 442       request->ios2_WireError = S2WERR_GENERIC_ERROR;
 443       ReplyMsg((APTR)request);
 444    }
 445    Enable();
 446
 447    return;
 448 }
 449
 450
 451
 452 /****i* rhine.device/DeleteDevice ******************************************
 453 *
 454 *   NAME
 455 *       DeleteDevice
 456 *
 457 *   SYNOPSIS
 458 *       DeleteDevice()
 459 *
 460 *       VOID DeleteDevice(VOID);
 461 *
 462 ****************************************************************************
 463 *
 464 */
 465
 466 VOID DeleteDevice(struct DevBase *base)
 467 {
 468    UWORD neg_size, pos_size;
 469
 470    /* Close devices */
 471
 472    CloseDevice((APTR)&base->timer_request);
 473
 474    /* Close libraries */
 475
 476    if(base->prometheus_base != NULL)
 477       CloseLibrary(base->prometheus_base);
 478    if(base->utility_base != NULL)
 479       CloseLibrary((APTR)base->utility_base);
 480
 481    /* Free device's memory */
 482
 483    neg_size = base->device.dd_Library.lib_NegSize;
 484    pos_size = base->device.dd_Library.lib_PosSize;
 485    FreeMem((UBYTE *)base - neg_size, pos_size + neg_size);
 486
 487    return;
 488 }
 489
 490
 491
 492 /****i* rhine.device/CloseUnit *********************************************
 493 *
 494 *   NAME
 495 *       CloseUnit
 496 *
 497 *   SYNOPSIS
 498 *       CloseUnit(request)
 499 *
 500 *       VOID CloseUnit(struct IOSana2Req *);
 501 *
 502 ****************************************************************************
 503 *
 504 */
 505
 506 VOID CloseUnit(struct IOSana2Req *request, struct DevBase *base)
 507 {
 508    struct DevUnit *unit;
 509    struct Opener *opener;
 510
 511    /* Decrement device usage count and free buffer-management resources */
 512
 513    base->device.dd_Library.lib_OpenCnt--;
 514    opener = (APTR)request->ios2_BufferManagement;
 515    if(opener != NULL)
 516    {
 517       Disable();
 518       Remove((APTR)opener);
 519       Enable();
 520       FreeVec(opener);
 521    }
 522
 523    /* Delete the unit if it's no longer in use */
 524
 525    unit = (APTR)request->ios2_Req.io_Unit;
 526    if(unit != NULL)
 527    {
 528       if((--unit->open_count) == 0)
 529       {
 530          Remove((APTR)unit);
 531          switch(unit->bus)
 532          {
 533          case PCI_BUS:
 534             DeletePCIUnit(unit, base);
 535             break;
 536          }
 537       }
 538    }
 539
 540    return;
 541 }
 542
 543
 544
 545 /****i* rhine.device/GetUnit ***********************************************
 546 *
 547 *   NAME
 548 *       GetUnit -- Get a unit by number.
 549 *
 550 *   SYNOPSIS
 551 *       unit = GetUnit(unit_num)
 552 *
 553 *       struct DevUnit *GetUnit(ULONG);
 554 *
 555 ****************************************************************************
 556 *
 557 */
 558
 559 struct DevUnit *GetUnit(ULONG unit_num, struct DevBase *base)
 560 {
 561    struct DevUnit *unit;
 562    ULONG pci_limit;
 563
 564    pci_limit = GetPCICount(base);
 565
 566    if(unit_num < pci_limit)
 567       unit = GetPCIUnit(unit_num, base);
 568    else
 569       unit = NULL;
 570
 571    return unit;
 572 }
 573
 574
 575
 576 /****i* rhine.device/WrapInt ***********************************************
 577 *
 578 *   NAME
 579 *       WrapInt
 580 *
 581 ****************************************************************************
 582 *
 583 */
 584
 585 BOOL WrapInt(struct Interrupt *interrupt, struct DevBase *base)
 586 {
 587    BOOL success = TRUE;
 588    APTR *int_data;
 589
 590    if(base->wrapper_int_code != NULL)
 591    {
 592       int_data = AllocMem(2 * sizeof(APTR), MEMF_PUBLIC | MEMF_CLEAR);
 593       if(int_data != NULL)
 594       {
 595          int_data[0] = interrupt->is_Code;
 596          int_data[1] = interrupt->is_Data;
 597          interrupt->is_Code = base->wrapper_int_code;
 598          interrupt->is_Data = int_data;
 599       }
 600       else
 601          success = FALSE;
 602    }
 603
 604    return success;
 605 }
 606
 607
 608
 609 /****i* rhine.device/UnwrapInt *********************************************
 610 *
 611 *   NAME
 612 *       UnwrapInt
 613 *
 614 ****************************************************************************
 615 *
 616 */
 617
 618 VOID UnwrapInt(struct Interrupt *interrupt, struct DevBase *base)
 619 {
 620    if(interrupt->is_Code == base->wrapper_int_code)
 621       FreeMem(interrupt->is_Data, 2 * sizeof(APTR));
 622
 623    return;
 624 }
 625
 626
 627