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    Disable();
 447    if(request->ios2_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE &&
 448       (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 449    {
 450       Remove((APTR)request);
 451       request->ios2_Req.io_Error = IOERR_ABORTED;
 452       request->ios2_WireError = S2WERR_GENERIC_ERROR;
 453       ReplyMsg((APTR)request);
 454    }
 455    Enable();
 456
 457    return;
 458 }
 459
 460
 461
 462 /****i* atheros5000.device/DeleteDevice ************************************
 463 *
 464 *   NAME
 465 *       DeleteDevice
 466 *
 467 *   SYNOPSIS
 468 *       DeleteDevice()
 469 *
 470 *       VOID DeleteDevice(VOID);
 471 *
 472 ****************************************************************************
 473 *
 474 */
 475
 476 VOID DeleteDevice(struct DevBase *base)
 477 {
 478    UWORD neg_size, pos_size;
 479
 480    /* Close devices */
 481
 482    CloseDevice((APTR)&base->timer_request);
 483
 484    /* Close libraries */
 485
 486    if(base->dos_base != NULL)
 487       CloseLibrary((APTR)base->dos_base);
 488    if(base->openpci_base != NULL)
 489       CloseLibrary(base->openpci_base);
 490    if(base->prometheus_base != NULL)
 491       CloseLibrary(base->prometheus_base);
 492    if(base->utility_base != NULL)
 493       CloseLibrary((APTR)base->utility_base);
 494
 495    /* Free device's memory */
 496
 497    neg_size = base->device.dd_Library.lib_NegSize;
 498    pos_size = base->device.dd_Library.lib_PosSize;
 499    FreeMem((UBYTE *)base - neg_size, pos_size + neg_size);
 500
 501    return;
 502 }
 503
 504
 505
 506 /****i* atheros5000.device/CloseUnit ***************************************
 507 *
 508 *   NAME
 509 *       CloseUnit
 510 *
 511 *   SYNOPSIS
 512 *       CloseUnit(request)
 513 *
 514 *       VOID CloseUnit(struct IOSana2Req *);
 515 *
 516 ****************************************************************************
 517 *
 518 */
 519
 520 VOID CloseUnit(struct IOSana2Req *request, struct DevBase *base)
 521 {
 522    struct DevUnit *unit;
 523    struct Opener *opener;
 524
 525    /* Decrement device usage count and free buffer-management resources */
 526
 527    base->device.dd_Library.lib_OpenCnt--;
 528    opener = (APTR)request->ios2_BufferManagement;
 529    if(opener != NULL)
 530    {
 531       Disable();
 532       Remove((APTR)opener);
 533       Enable();
 534       FreeVec(opener);
 535    }
 536
 537    /* Delete the unit if it's no longer in use */
 538
 539    unit = (APTR)request->ios2_Req.io_Unit;
 540    if(unit != NULL)
 541    {
 542       if((--unit->open_count) == 0)
 543       {
 544          Remove((APTR)unit);
 545          switch(unit->bus)
 546          {
 547          case PCI_BUS:
 548             DeletePCIUnit(unit, base);
 549             break;
 550          }
 551       }
 552    }
 553
 554    return;
 555 }
 556
 557
 558
 559 /****i* atheros5000.device/GetUnit *****************************************
 560 *
 561 *   NAME
 562 *       GetUnit -- Get a unit by number.
 563 *
 564 *   SYNOPSIS
 565 *       unit = GetUnit(unit_num)
 566 *
 567 *       struct DevUnit *GetUnit(ULONG);
 568 *
 569 ****************************************************************************
 570 *
 571 */
 572
 573 struct DevUnit *GetUnit(ULONG unit_num, struct DevBase *base)
 574 {
 575    struct DevUnit *unit;
 576    ULONG pci_limit;
 577
 578    pci_limit = GetPCICount(base);
 579
 580    if(unit_num < pci_limit)
 581       unit = GetPCIUnit(unit_num, base);
 582    else
 583       unit = NULL;
 584
 585    return unit;
 586 }
 587
 588
 589
 590 /****i* atheros5000.device/WrapInt *****************************************
 591 *
 592 *   NAME
 593 *       WrapInt
 594 *
 595 ****************************************************************************
 596 *
 597 */
 598
 599 BOOL WrapInt(struct Interrupt *interrupt, struct DevBase *base)
 600 {
 601    BOOL success = TRUE;
 602    APTR *int_data;
 603
 604    if(base->wrapper_int_code != NULL)
 605    {
 606       int_data = AllocMem(2 * sizeof(APTR), MEMF_PUBLIC | MEMF_CLEAR);
 607       if(int_data != NULL)
 608       {
 609          int_data[0] = interrupt->is_Code;
 610          int_data[1] = interrupt->is_Data;
 611          interrupt->is_Code = base->wrapper_int_code;
 612          interrupt->is_Data = int_data;
 613       }
 614       else
 615          success = FALSE;
 616    }
 617
 618    return success;
 619 }
 620
 621
 622
 623 /****i* atheros5000.device/UnwrapInt ***************************************
 624 *
 625 *   NAME
 626 *       UnwrapInt
 627 *
 628 ****************************************************************************
 629 *
 630 */
 631
 632 VOID UnwrapInt(struct Interrupt *interrupt, struct DevBase *base)
 633 {
 634    if(interrupt->is_Code == base->wrapper_int_code)
 635       FreeMem(interrupt->is_Data, 2 * sizeof(APTR));
 636
 637    return;
 638 }
 639
 640
 641