rom/usb/pciusbhc/xhci/pcixhci_device.c

   1 /*
   2     Copyright © 2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PCI XHCI USB host controller
   6     Lang: English
   7 */
   8
   9 #ifdef DEBUG
  10 #undef DEBUG
  11 #endif
  12 #define DEBUG 1
  13
  14 #include <aros/debug.h>
  15 #include <aros/macros.h>
  16 #include <aros/asmcall.h>
  17 #include <aros/symbolsets.h>
  18
  19 #include <proto/oop.h>
  20 #include <proto/exec.h>
  21 #include <proto/stdc.h>
  22 #include <proto/arossupport.h>
  23
  24 #include <devices/usb.h>
  25 #include <devices/usb_hub.h>
  26 #include <devices/newstyle.h>
  27 #include <devices/usbhardware.h>
  28
  29 #include <asm/io.h>
  30 #include <inttypes.h>
  31
  32 #include <hidd/pci.h>
  33 #include <hidd/hidd.h>
  34
  35 #include "pcixhci_intern.h"
  36
  37 #include LC_LIBDEFS_FILE
  38
  39 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR LIBBASE) {
  40     mybug(0,("[PCIXHCI] Init: Entering function\n"));
  41
  42     struct OOP_ABDescr attrbases[] = {
  43             { (STRPTR)IID_Hidd,           &LIBBASE->HiddAB },
  44             { (STRPTR)IID_Hidd_PCIDevice, &LIBBASE->HiddPCIDeviceAB },
  45             { NULL, NULL }
  46     };
  47
  48     if ((LIBBASE->pci = OOP_NewObject(NULL, (STRPTR)CLID_Hidd_PCI, NULL))) {
  49         if(OOP_ObtainAttrBases(attrbases)) {
  50             return(PCIXHCI_Discover(LIBBASE));
  51         }
  52     }
  53
  54     /* Someone here failed... */
  55     OOP_ReleaseAttrBases(attrbases);
  56     OOP_DisposeObject(LIBBASE->pci);
  57
  58     mybug(0,("[PCIXHCI] Init: Failing...\n"));
  59     return FALSE;
  60 }
  61
  62 static int GM_UNIQUENAME(Open)(LIBBASETYPEPTR LIBBASE, struct IOUsbHWReq *ioreq, ULONG unitnum, ULONG flags) {
  63     mybug(0, ("[PCIXHCI] Open: Entering function\n"));
  64     mybug(0, ("[PCIXHCI] Open: Unit %d\n", unitnum));
  65
  66     struct PCIXHCIUnit *unit;
  67
  68     ioreq->iouh_Req.io_Unit  = NULL;
  69     ioreq->iouh_Req.io_Error = IOERR_OPENFAIL;
  70
  71     ForeachNode(&LIBBASE->unit_list, unit) {
  72         if(unit->number == unitnum) {
  73             mybug(0, ("          Found unit from node list %s %p\n\n", unit->name, unit));
  74
  75             if(ioreq->iouh_Req.io_Message.mn_Length < sizeof(struct IOUsbHWReq)) {
  76                 mybug(-1, ("[PCIXHCI] Open: Invalid MN_LENGTH!\n"));
  77                 ioreq->iouh_Req.io_Error = IOERR_BADLENGTH;
  78                 return FALSE;
  79             }
  80
  81             ioreq->iouh_Req.io_Unit                    = (struct Unit *) unit;
  82             ioreq->iouh_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  83             ioreq->iouh_Req.io_Error                               = 0;
  84
  85             return TRUE;
  86         }
  87     }
  88
  89     return FALSE;
  90 }
  91
  92 static int GM_UNIQUENAME(Close)(LIBBASETYPEPTR LIBBASE, struct IOUsbHWReq *ioreq) {
  93     mybug(0, ("[PCIXHCI] Close: Entering function\n"));
  94
  95     ioreq->iouh_Req.io_Unit   = (APTR) -1;
  96     ioreq->iouh_Req.io_Device = (APTR) -1;
  97
  98     return TRUE;
  99 }
 100
 101 static int GM_UNIQUENAME(Expunge)(LIBBASETYPEPTR LIBBASE) {
 102
 103     struct PCIXHCIUnit *unit;
 104
 105     ForeachNode(&LIBBASE->unit_list, unit) {
 106         HIDD_PCIDevice_Release(unit->hc.pcidevice);
 107         REMOVE(unit);
 108         FreeVec(unit);
 109     }
 110
 111     struct OOP_ABDescr attrbases[] = {
 112             { (STRPTR)IID_Hidd,           &LIBBASE->HiddAB },
 113             { (STRPTR)IID_Hidd_PCIDevice, &LIBBASE->HiddPCIDeviceAB },
 114             { NULL, NULL }
 115     };
 116
 117     OOP_ReleaseAttrBases(attrbases);
 118     OOP_DisposeObject(LIBBASE->pci);
 119
 120     return TRUE;
 121 }
 122
 123 ADD2INITLIB(GM_UNIQUENAME(Init), 0)
 124 ADD2OPENDEV(GM_UNIQUENAME(Open), 0)
 125 ADD2CLOSEDEV(GM_UNIQUENAME(Close), 0)
 126 ADD2EXPUNGELIB(GM_UNIQUENAME(Expunge), 0)
 127
 128 AROS_LH1(void, BeginIO, AROS_LHA(struct IOUsbHWReq *, ioreq, A1), LIBBASETYPEPTR, LIBBASE, 5, PCIXHCI) {
 129     AROS_LIBFUNC_INIT
 130     mybug(0, ("[PCIXHCI] BeginIO: Entering function\n"));
 131
 132     WORD ret = RC_OK;
 133
 134     ioreq->iouh_Req.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 135     ioreq->iouh_Req.io_Error                               = UHIOERR_NO_ERROR;
 136
 137     struct PCIXHCIUnit *unit = (struct PCIXHCIUnit *) ioreq->iouh_Req.io_Unit;
 138
 139     if(unit != NULL) {
 140
 141         switch (ioreq->iouh_Req.io_Command) {
 142             case CMD_RESET:
 143                 mybug_unit(0, ("CMD_RESET\n"));
 144                 break;
 145             case CMD_FLUSH:
 146                 mybug_unit(0, ("CMD_FLUSH\n"));
 147                 break;
 148             case UHCMD_QUERYDEVICE:
 149                 mybug_unit(0, ("UHCMD_QUERYDEVICE\n"));
 150                 ret = cmdQueryDevice(ioreq);
 151                 break;
 152             case UHCMD_USBRESET:
 153                 mybug_unit(0, ("UHCMD_USBRESET\n"));
 154                 ret = cmdUsbReset(ioreq);
 155                 break;
 156             case UHCMD_USBRESUME:
 157                 mybug_unit(0, ("UHCMD_USBRESUME\n"));
 158                 break;
 159             case UHCMD_USBSUSPEND:
 160                 mybug_unit(0, ("UHCMD_USBSUSPEND\n"));
 161                 break;
 162             case UHCMD_USBOPER:
 163                 mybug_unit(0, ("UHCMD_USBOPER\n"));
 164                 //ret = cmdUsbOper(ioreq);
 165                 break;
 166             case UHCMD_CONTROLXFER:
 167                 mybug_unit(0, ("UHCMD_CONTROLXFER unit %p %s\n", unit, unit->name));
 168                 ret = cmdControlXFer(ioreq);
 169                 break;
 170             case UHCMD_BULKXFER:
 171                 mybug_unit(0, ("UHCMD_BULKXFER\n"));
 172                 break;
 173             case UHCMD_INTXFER:
 174                 mybug_unit(0, ("UHCMD_INTXFER unit %p %s\n", unit, unit->name));
 175                 ret = cmdIntXFer(ioreq);
 176                 break;
 177             case UHCMD_ISOXFER:
 178                 mybug_unit(0, ("UHCMD_ISOXFER\n"));
 179                 break;
 180
 181             /* Poseidon doesn't actually check this, ever... */
 182             case NSCMD_DEVICEQUERY:
 183                 mybug_unit(0, ("NSCMD_DEVICEQUERY\n"));
 184
 185                 static const UWORD NSDSupported[] = {
 186                     CMD_FLUSH, CMD_RESET,
 187                     UHCMD_QUERYDEVICE,
 188                     UHCMD_USBRESET,
 189                     UHCMD_USBRESUME,
 190                     UHCMD_USBSUSPEND,
 191                     UHCMD_USBOPER,
 192                     UHCMD_CONTROLXFER ,
 193                     UHCMD_ISOXFER,
 194                     UHCMD_INTXFER,
 195                     UHCMD_BULKXFER,
 196                     NSCMD_DEVICEQUERY,
 197                     0
 198                 };
 199
 200                 struct NSDeviceQueryResult *nsdq = (struct NSDeviceQueryResult *)((struct IOStdReq *)(ioreq))->io_Data;
 201                 nsdq->DevQueryFormat    = 0;
 202                 nsdq->SizeAvailable     = sizeof(struct NSDeviceQueryResult);
 203                 nsdq->DeviceType        = NSDEVTYPE_USBHARDWARE;
 204                 nsdq->DeviceSubType     = 0;
 205                 nsdq->SupportedCommands = (UWORD *)NSDSupported;
 206                 ret = RC_OK;
 207                 break;
 208             default:
 209                 mybug_unit(-1, ("IOERR_NOCMD\n"));
 210                 ret = IOERR_NOCMD;
 211                 break;
 212         }
 213     } else {
 214         /* We have aborted the request as unit is invalid */
 215         ret = IOERR_ABORTED;
 216     }
 217
 218     if(ret != RC_DONTREPLY) {
 219         /* Set error codes */
 220         if (ret != RC_OK) {
 221             ioreq->iouh_Req.io_Error = ret & 0xff;
 222         }
 223         /* Terminate the iorequest */
 224         ioreq->iouh_Req.io_Message.mn_Node.ln_Type = NT_FREEMSG;
 225         /* If not quick I/O, reply the message */
 226         if(!(ioreq->iouh_Req.io_Flags & IOF_QUICK)) {
 227             ReplyMsg(&ioreq->iouh_Req.io_Message);
 228         }
 229     }
 230
 231     AROS_LIBFUNC_EXIT
 232 }
 233
 234 AROS_LH1(LONG, AbortIO, AROS_LHA(struct IOUsbHWReq *, ioreq, A1), LIBBASETYPEPTR, LIBBASE, 6, PCIXHCI) {
 235     AROS_LIBFUNC_INIT
 236     mybug(-1, ("[PCIXHCI] AbortIO: Entering function\n"));
 237
 238     if(ioreq->iouh_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE) {
 239         if(cmdAbortIO(ioreq)) {
 240             return(0);
 241         }
 242     }
 243
 244     return(-1);
 245     AROS_LIBFUNC_EXIT
 246 }
 247
 248