workbench/devs/networks/intelpro100/os4_device.c

   1 /*
   2
   3 Copyright (C) 2000-2009 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 <exec/emulation.h>
  27 #include <utility/utility.h>
  28 #include <expansion/expansion.h>
  29
  30 #include <proto/exec.h>
  31 #include <clib/alib_protos.h>
  32 #include <proto/utility.h>
  33
  34 #include "device.h"
  35
  36 #include "unit_protos.h"
  37 #include "pci_protos.h"
  38 #include "request_protos.h"
  39
  40
  41 /* Private prototypes */
  42
  43 static struct DevBase *DevInit(struct DevBase *dev_base, APTR seg_list,
  44    struct ExecIFace *i_exec);
  45 static ULONG IfaceObtain(struct Interface *self);
  46 static ULONG IfaceRelease(struct Interface *self);
  47 static LONG DevOpen(struct Interface *self, struct IOSana2Req *request,
  48    ULONG unit_num, ULONG flags);
  49 static APTR DevClose(struct Interface *self, struct IOSana2Req *request);
  50 static APTR DevExpunge(struct Interface *self);
  51 static VOID DevBeginIO(struct Interface *self, struct IOSana2Req *request);
  52 static VOID DevAbortIO(struct Interface *self, struct IOSana2Req *request);
  53 static VOID DeleteDevice(struct DevBase *base);
  54 static struct DevUnit *GetUnit(ULONG unit_num, struct DevBase *base);
  55 static BOOL RXFunction(struct IOSana2Req *request, APTR buffer, ULONG size);
  56 static BOOL TXFunction(APTR buffer, struct IOSana2Req *request, ULONG size);
  57 static UBYTE *DMATXFunction(struct IOSana2Req *request);
  58 static ULONG OS4Int(struct ExceptionContext ex_context,
  59    struct ExecBase *sys_base, APTR *int_data);
  60
  61
  62 /* Return an error immediately if someone tries to run the device */
  63
  64 LONG Main()
  65 {
  66    return -1;
  67 }
  68
  69 const TEXT device_name[] = DEVICE_NAME;
  70 static const TEXT version_string[] =
  71    DEVICE_NAME " " STR(VERSION) "." STR(REVISION) " (" DATE ")\n";
  72 static const TEXT manager_name[] = "__device";
  73 static const TEXT utility_name[] = UTILITYNAME;
  74 static const TEXT expansion_name[] = EXPANSIONNAME;
  75 static const TEXT timer_name[] = TIMERNAME;
  76
  77
  78 static const APTR manager_vectors[] =
  79 {
  80    (APTR)IfaceObtain,
  81    (APTR)IfaceRelease,
  82    (APTR)NULL,
  83    (APTR)NULL,
  84    (APTR)DevOpen,
  85    (APTR)DevClose,
  86    (APTR)DevExpunge,
  87    (APTR)NULL,
  88    (APTR)DevBeginIO,
  89    (APTR)DevAbortIO,
  90    (APTR)-1
  91 };
  92
  93
  94 static const struct TagItem manager_tags[] =
  95 {
  96    {MIT_Name, (UPINT)manager_name},
  97    {MIT_VectorTable, (UPINT)manager_vectors},
  98    {MIT_Version, 1},
  99    {TAG_END, 0}
 100 };
 101
 102
 103 static const struct TagItem *interfaces[] =
 104 {
 105    manager_tags,
 106    NULL
 107 };
 108
 109
 110 static const struct TagItem init_tags[] =
 111 {
 112    {CLT_DataSize, sizeof(struct DevBase)},
 113    {CLT_InitFunc, (UPINT)DevInit},
 114    {CLT_Interfaces, (UPINT)interfaces},
 115    {TAG_END, 0}
 116 };
 117
 118
 119 const struct Resident rom_tag =
 120 {
 121    RTC_MATCHWORD,
 122    (struct Resident *)&rom_tag,
 123    (APTR)(&rom_tag + 1),
 124    RTF_AUTOINIT | RTF_NATIVE,
 125    VERSION,
 126    NT_DEVICE,
 127    0,
 128    (STRPTR)device_name,
 129    (STRPTR)version_string,
 130    (APTR)init_tags
 131 };
 132
 133
 134 static const ULONG rx_tags[] =
 135 {
 136    S2_CopyToBuff,
 137    S2_CopyToBuff16,
 138 };
 139
 140
 141 static const ULONG tx_tags[] =
 142 {
 143    S2_CopyFromBuff,
 144    S2_CopyFromBuff16,
 145    S2_CopyFromBuff32
 146 };
 147
 148
 149
 150 /****i* intelpro100.device/DevInit *****************************************
 151 *
 152 *   NAME
 153 *       DevInit
 154 *
 155 *   SYNOPSIS
 156 *       dev_base = DevInit(dev_base, seg_list, i_exec)
 157 *
 158 *       struct DevBase *DevInit(struct DevBase *, APTR, ExecIFace *);
 159 *
 160 ****************************************************************************
 161 *
 162 */
 163
 164 static struct DevBase *DevInit(struct DevBase *dev_base, APTR seg_list,
 165    struct ExecIFace *i_exec)
 166 {
 167    struct DevBase *base;
 168    BOOL success = TRUE;
 169
 170    dev_base->i_exec = i_exec;
 171    base = dev_base;
 172    base->seg_list = seg_list;
 173    base->sys_base = (APTR)i_exec->Data.LibBase;
 174
 175    base->device.dd_Library.lib_Node.ln_Type = NT_DEVICE;
 176    base->device.dd_Library.lib_Node.ln_Name = (TEXT *)device_name;
 177    base->device.dd_Library.lib_Flags = LIBF_SUMUSED | LIBF_CHANGED;
 178    base->device.dd_Library.lib_Version = VERSION;
 179    base->device.dd_Library.lib_Revision = REVISION;
 180    base->device.dd_Library.lib_IdString = (TEXT *)version_string;
 181
 182
 183    base->utility_base = (APTR)OpenLibrary(utility_name, UTILITY_VERSION);
 184    base->expansion_base = OpenLibrary(expansion_name, EXPANSION_VERSION);
 185    if(base->utility_base == NULL || base->expansion_base == NULL)
 186       success = FALSE;
 187
 188    if(OpenDevice(timer_name, UNIT_VBLANK, (APTR)&base->timer_request, 0) !=
 189       0)
 190       success = FALSE;
 191
 192    NewList((APTR)(&dev_base->pci_units));
 193    base->wrapper_int_code = (APTR)OS4Int;
 194
 195    if(success)
 196    {
 197       base->i_utility =
 198         (APTR)GetInterface((APTR)UtilityBase, "main", 1, NULL);
 199       base->i_pci =
 200         (APTR)GetInterface(ExpansionBase, "pci", 1, NULL);
 201       base->i_timer =
 202         (APTR)GetInterface((APTR)TimerBase, "main", 1, NULL);
 203       if(base->i_utility == NULL || base->i_pci == NULL
 204          || base->i_timer == NULL)
 205          success = FALSE;
 206    }
 207
 208    if(!success)
 209    {
 210       DeleteDevice(base);
 211       base = NULL;
 212    }
 213
 214    return base;
 215 }
 216
 217
 218
 219 /****i* intelpro100.device/IfaceObtain *************************************
 220 *
 221 *   NAME
 222 *       IfaceObtain
 223 *
 224 *   SYNOPSIS
 225 *       ref_count = IfaceObtain(self)
 226 *
 227 *       ULONG IfaceObtain(struct Interface *);
 228 *
 229 ****************************************************************************
 230 *
 231 */
 232
 233 static ULONG IfaceObtain(struct Interface *self)
 234 {
 235    return self->Data.RefCount++;
 236 }
 237
 238
 239
 240 /****i* intelpro100.device/IfaceRelease ************************************
 241 *
 242 *   NAME
 243 *       IfaceRelease
 244 *
 245 *   SYNOPSIS
 246 *       ref_count = IfaceRelease(self)
 247 *
 248 *       ULONG IfaceRelease(struct Interface *);
 249 *
 250 ****************************************************************************
 251 *
 252 */
 253
 254 static ULONG IfaceRelease(struct Interface *self)
 255 {
 256    return --self->Data.RefCount;
 257 }
 258
 259
 260
 261 /****i* intelpro100.device/DevOpen *****************************************
 262 *
 263 *   NAME
 264 *       DevOpen
 265 *
 266 *   SYNOPSIS
 267 *       error = DevOpen(self, request, unit_num, flags)
 268 *
 269 *       LONG DevOpen(struct Interface *, struct IOSana2Req *, ULONG, ULONG);
 270 *
 271 ****************************************************************************
 272 *
 273 */
 274
 275 static LONG DevOpen(struct Interface *self, struct IOSana2Req *request,
 276    ULONG unit_num, ULONG flags)
 277 {
 278    struct DevBase *base;
 279    struct DevUnit *unit;
 280    BYTE error = 0;
 281    struct Opener *opener;
 282    struct TagItem *tag_list;
 283    UWORD i;
 284
 285    base = (APTR)self->Data.LibBase;
 286    base->device.dd_Library.lib_OpenCnt++;
 287    base->device.dd_Library.lib_Flags &= ~LIBF_DELEXP;
 288
 289    request->ios2_Req.io_Unit = NULL;
 290    tag_list = request->ios2_BufferManagement;
 291    request->ios2_BufferManagement = NULL;
 292
 293    /* Check request size */
 294
 295    if(request->ios2_Req.io_Message.mn_Length < sizeof(struct IOSana2Req))
 296       error = IOERR_OPENFAIL;
 297
 298    /* Get the requested unit */
 299
 300    if(error == 0)
 301    {
 302       request->ios2_Req.io_Unit = (APTR)(unit = GetUnit(unit_num, base));
 303       if(unit == NULL)
 304          error = IOERR_OPENFAIL;
 305    }
 306
 307    /* Handle device sharing */
 308
 309    if(error == 0)
 310    {
 311       if((unit->open_count != 0) && (((unit->flags & UNITF_SHARED) == 0)
 312          || ((flags & SANA2OPF_MINE) != 0)))
 313          error = IOERR_UNITBUSY;
 314       unit->open_count++;
 315    }
 316
 317    if(error == 0)
 318    {
 319       if((flags & SANA2OPF_MINE) == 0)
 320          unit->flags |= UNITF_SHARED;
 321       else if((flags & SANA2OPF_PROM) != 0)
 322          unit->flags |= UNITF_PROM;
 323
 324       /* Set up buffer-management structure and get hooks */
 325
 326       request->ios2_BufferManagement = opener =
 327          AllocVec(sizeof(struct Opener), MEMF_PUBLIC | MEMF_CLEAR);
 328       if(opener == NULL)
 329          error = IOERR_OPENFAIL;
 330    }
 331
 332    if(error == 0)
 333    {
 334       NewList(&opener->read_port.mp_MsgList);
 335       opener->read_port.mp_Flags = PA_IGNORE;
 336       NewList((APTR)&opener->initial_stats);
 337
 338       for(i = 0; i < 2; i++)
 339          opener->real_rx_function = (APTR)GetTagData(rx_tags[i],
 340             (UPINT)opener->real_rx_function, tag_list);
 341       for(i = 0; i < 3; i++)
 342          opener->real_tx_function = (APTR)GetTagData(tx_tags[i],
 343             (UPINT)opener->real_tx_function, tag_list);
 344
 345       opener->filter_hook = (APTR)GetTagData(S2_PacketFilter, (UPINT)NULL,
 346          tag_list);
 347       opener->real_dma_tx_function =
 348          (APTR)GetTagData(S2_DMACopyFromBuff32, (UPINT)NULL, tag_list);
 349
 350       opener->rx_function = (APTR)RXFunction;
 351       opener->tx_function = (APTR)TXFunction;
 352       if(opener->real_dma_tx_function != NULL)
 353          opener->dma_tx_function = (APTR)DMATXFunction;
 354
 355       Disable();
 356       AddTail((APTR)&unit->openers, (APTR)opener);
 357       Enable();
 358    }
 359
 360    /* Back out if anything went wrong */
 361
 362    if(error != 0)
 363       DevClose(self, request);
 364
 365    /* Return */
 366
 367    request->ios2_Req.io_Error = error;
 368    return error;
 369 }
 370
 371
 372
 373 /****i* intelpro100.device/DevClose ****************************************
 374 *
 375 *   NAME
 376 *       DevClose
 377 *
 378 *   SYNOPSIS
 379 *       seg_list = DevClose(request)
 380 *
 381 *       APTR DevClose(struct IOSana2Req *);
 382 *
 383 ****************************************************************************
 384 *
 385 */
 386
 387 static APTR DevClose(struct Interface *self, struct IOSana2Req *request)
 388 {
 389    struct DevBase *base;
 390    struct DevUnit *unit;
 391    APTR seg_list;
 392    struct Opener *opener;
 393
 394    /* Free buffer-management resources */
 395
 396    base = (APTR)self->Data.LibBase;
 397    opener = (APTR)request->ios2_BufferManagement;
 398    if(opener != NULL)
 399    {
 400       Disable();
 401       Remove((APTR)opener);
 402       Enable();
 403       FreeVec(opener);
 404    }
 405
 406    /* Delete the unit if it's no longer in use */
 407
 408    unit = (APTR)request->ios2_Req.io_Unit;
 409    if(unit != NULL)
 410    {
 411       if((--unit->open_count) == 0)
 412       {
 413          Remove((APTR)unit);
 414          switch(unit->bus)
 415          {
 416          case PCI_BUS:
 417             DeletePCIUnit(unit, base);
 418          }
 419       }
 420    }
 421
 422    /* Expunge the device if a delayed expunge is pending */
 423
 424    seg_list = NULL;
 425
 426    if((--base->device.dd_Library.lib_OpenCnt) == 0)
 427    {
 428       if((base->device.dd_Library.lib_Flags & LIBF_DELEXP) != 0)
 429          seg_list = DevExpunge(self);
 430    }
 431
 432    return seg_list;
 433 }
 434
 435
 436
 437 /****i* intelpro100.device/DevExpunge **************************************
 438 *
 439 *   NAME
 440 *       DevExpunge
 441 *
 442 *   SYNOPSIS
 443 *       seg_list = DevExpunge()
 444 *
 445 *       APTR DevExpunge(VOID);
 446 *
 447 ****************************************************************************
 448 *
 449 */
 450
 451 static APTR DevExpunge(struct Interface *self)
 452 {
 453    struct DevBase *base;
 454    APTR seg_list;
 455
 456    base = (APTR)self->Data.LibBase;
 457    if(base->device.dd_Library.lib_OpenCnt == 0)
 458    {
 459       seg_list = base->seg_list;
 460       Remove((APTR)base);
 461       DeleteDevice(base);
 462    }
 463    else
 464    {
 465       base->device.dd_Library.lib_Flags |= LIBF_DELEXP;
 466       seg_list = NULL;
 467    }
 468
 469    return seg_list;
 470 }
 471
 472
 473
 474 /****i* intelpro100.device/DevBeginIO **************************************
 475 *
 476 *   NAME
 477 *       DevBeginIO
 478 *
 479 *   SYNOPSIS
 480 *       DevBeginIO(request)
 481 *
 482 *       VOID DevBeginIO(struct IORequest *);
 483 *
 484 ****************************************************************************
 485 *
 486 */
 487
 488 static VOID DevBeginIO(struct Interface *self, struct IOSana2Req *request)
 489 {
 490    struct DevBase *base;
 491    struct DevUnit *unit;
 492
 493    /* Replace caller's cookie with our own */
 494
 495    base = (APTR)self->Data.LibBase;
 496    request->ios2_Req.io_Error = 0;
 497    unit = (APTR)request->ios2_Req.io_Unit;
 498    switch(request->ios2_Req.io_Command)
 499    {
 500    case CMD_READ:
 501    case CMD_WRITE:
 502    case S2_MULTICAST:
 503    case S2_BROADCAST:
 504    case S2_READORPHAN:
 505       request->ios2_StatData = request->ios2_Data;
 506       request->ios2_Data = request;
 507    }
 508
 509    /* Send request for processing */
 510
 511    if(AttemptSemaphore(&unit->access_lock))
 512       ServiceRequest(request, base);
 513    else
 514    {
 515       PutRequest(unit->request_ports[GENERAL_QUEUE], (APTR)request, base);
 516    }
 517
 518    return;
 519 }
 520
 521
 522
 523 /****i* intelpro100.device/DevAbortIO **************************************
 524 *
 525 *   NAME
 526 *       DevAbortIO -- Try to stop a request.
 527 *
 528 *   SYNOPSIS
 529 *       DevAbortIO(request)
 530 *
 531 *       VOID DevAbortIO(struct IOSana2Req *);
 532 *
 533 ****************************************************************************
 534 *
 535 * Disable() used instead of a semaphore because device uses interrupts.
 536 *
 537 */
 538
 539 static VOID DevAbortIO(struct Interface *self, struct IOSana2Req *request)
 540 {
 541    struct DevBase *base;
 542    struct DevUnit *unit;
 543
 544    base = (APTR)self->Data.LibBase;
 545    unit = (APTR)request->ios2_Req.io_Unit;
 546
 547    Disable();
 548    if((request->ios2_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE)
 549       && ((request->ios2_Req.io_Flags & IOF_QUICK) == 0))
 550    {
 551       Remove((APTR)request);
 552       request->ios2_Req.io_Error = IOERR_ABORTED;
 553       request->ios2_WireError = S2WERR_GENERIC_ERROR;
 554       ReplyMsg((APTR)request);
 555    }
 556    Enable();
 557
 558    return;
 559 }
 560
 561
 562
 563 /****i* intelpro100.device/DeleteDevice ************************************
 564 *
 565 *   NAME
 566 *       DeleteDevice
 567 *
 568 *   SYNOPSIS
 569 *       DeleteDevice()
 570 *
 571 *       VOID DeleteDevice(VOID);
 572 *
 573 ****************************************************************************
 574 *
 575 */
 576
 577 static VOID DeleteDevice(struct DevBase *base)
 578 {
 579    /* Close interfaces */
 580
 581    DropInterface((APTR)base->i_timer);
 582    DropInterface((APTR)base->i_pci);
 583    DropInterface((APTR)base->i_utility);
 584
 585    /* Close devices */
 586
 587    CloseDevice((APTR)&base->timer_request);
 588
 589    /* Close libraries */
 590
 591    if(base->expansion_base != NULL)
 592       CloseLibrary(base->expansion_base);
 593    if(base->utility_base != NULL)
 594       CloseLibrary((APTR)base->utility_base);
 595
 596    /* Free device's memory */
 597
 598    DeleteLibrary((APTR)base);
 599
 600    return;
 601 }
 602
 603
 604
 605 /****i* intelpro100.device/GetUnit *****************************************
 606 *
 607 *   NAME
 608 *       GetUnit -- Get a unit by number.
 609 *
 610 *   SYNOPSIS
 611 *       unit = GetUnit(unit_num)
 612 *
 613 *       struct DevUnit *GetUnit(ULONG);
 614 *
 615 ****************************************************************************
 616 *
 617 */
 618
 619 static struct DevUnit *GetUnit(ULONG unit_num, struct DevBase *base)
 620 {
 621    struct DevUnit *unit;
 622    ULONG pci_limit;
 623
 624    pci_limit = GetPCICount(base);
 625
 626    if(unit_num < pci_limit)
 627       unit = GetPCIUnit(unit_num, base);
 628    else
 629       unit = NULL;
 630
 631    return unit;
 632 }
 633
 634
 635
 636 /****i* intelpro100.device/RXFunction **************************************
 637 *
 638 *   NAME
 639 *       RXFunction
 640 *
 641 ****************************************************************************
 642 *
 643 */
 644
 645 static BOOL RXFunction(struct IOSana2Req *request, APTR buffer, ULONG size)
 646 {
 647    struct DevBase *base;
 648    struct Opener *opener;
 649    APTR cookie;
 650
 651    opener = request->ios2_BufferManagement;
 652    cookie = request->ios2_StatData;
 653    base = (struct DevBase *)request->ios2_Req.io_Device;
 654    request->ios2_Data = cookie;
 655
 656    return EmulateTags(opener->real_rx_function,
 657       ET_RegisterA0, cookie, ET_RegisterA1, buffer,
 658       ET_RegisterD0, size, TAG_END);
 659 }
 660
 661
 662
 663 /****i* intelpro100.device/TXFunction **************************************
 664 *
 665 *   NAME
 666 *       TXFunction
 667 *
 668 ****************************************************************************
 669 *
 670 */
 671
 672 static BOOL TXFunction(APTR buffer, struct IOSana2Req *request, ULONG size)
 673 {
 674    struct DevBase *base;
 675    struct Opener *opener;
 676    APTR cookie;
 677
 678    opener = request->ios2_BufferManagement;
 679    cookie = request->ios2_StatData;
 680    base = (struct DevBase *)request->ios2_Req.io_Device;
 681    request->ios2_Data = cookie;
 682    return EmulateTags(opener->real_tx_function,
 683       ET_RegisterA0, buffer, ET_RegisterA1, cookie,
 684       ET_RegisterD0, size, TAG_END);
 685 }
 686
 687
 688
 689 /****i* intelpro100.device/DMATXFunction ***********************************
 690 *
 691 *   NAME
 692 *       DMATXFunction
 693 *
 694 ****************************************************************************
 695 *
 696 */
 697
 698 static UBYTE *DMATXFunction(struct IOSana2Req *request)
 699 {
 700    struct DevBase *base;
 701    struct Opener *opener;
 702    APTR cookie;
 703
 704    opener = request->ios2_BufferManagement;
 705    cookie = request->ios2_StatData;
 706    base = (struct DevBase *)request->ios2_Req.io_Device;
 707    request->ios2_Data = cookie;
 708    return (UBYTE *)EmulateTags(opener->real_dma_tx_function,
 709       ET_RegisterA0, cookie, TAG_END);
 710 }
 711
 712
 713
 714 /****i* intelpro100.device/OS4Int ******************************************
 715 *
 716 *   NAME
 717 *       OS4Int
 718 *
 719 ****************************************************************************
 720 *
 721 */
 722
 723 static ULONG OS4Int(struct ExceptionContext ex_context,
 724    struct ExecBase *sys_base, APTR *int_data)
 725 {
 726    BOOL (*int_code)(APTR, APTR);
 727
 728    int_code = int_data[0];
 729    return int_code(int_data[1], int_code);
 730 }
 731
 732
 733