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