workbench/devs/USB/drivers/OHCI/ohcihub.c

   1 /*
   2     Copyright (C) 2006 by Michal Schulz
   3     $Id$
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU Library General Public License as
   7     published by the Free Software Foundation; either version 2 of the
   8     License, or (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this program; if not, write to the
  17     Free Software Foundation, Inc.,
  18     59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  */
  20
  21 #define DEBUG 0
  22
  23 #include <inttypes.h>
  24
  25 #include <exec/types.h>
  26 #include <exec/errors.h>
  27 #include <oop/oop.h>
  28 #include <usb/usb.h>
  29 #include <utility/tagitem.h>
  30 #include <aros/debug.h>
  31 #include <aros/symbolsets.h>
  32
  33 #include <devices/timer.h>
  34
  35 #include <hidd/hidd.h>
  36 #include <hidd/pci.h>
  37
  38 #include <proto/oop.h>
  39 #include <proto/utility.h>
  40
  41 #include <stdio.h>
  42
  43 #include "ohci.h"
  44
  45 BOOL METHOD(OHCI, Hidd_USBHub, GetHubDescriptor)
  46 {
  47     ohci_data_t *ohci = OOP_INST_DATA(cl, o);
  48
  49     if (ohci->hubDescr.bDescriptorType) {
  50         CopyMem(&ohci->hubDescr, msg->descriptor, sizeof(ohci->hubDescr));
  51         return TRUE;
  52     }
  53     else
  54         return FALSE;
  55 }
  56
  57 BOOL METHOD(OHCI, Hidd_USBHub, OnOff)
  58 {
  59     ohci_data_t *ohci = OOP_INST_DATA(cl, o);
  60     BOOL retval = FALSE;
  61
  62     D(bug("[OHCI] USBHub::OnOff(%d)\n", msg->on));
  63
  64     if (msg->on)
  65         retval = OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  66
  67     uint32_t ctl = AROS_OHCI2LONG(mmio(ohci->regs->HcControl));
  68     ctl &= ~HC_CTRL_HCFS_MASK;
  69     ctl |= msg->on ? HC_CTRL_HCFS_OPERATIONAL : HC_CTRL_HCFS_SUSPENDED;
  70     mmio(ohci->regs->HcControl) = AROS_LONG2OHCI(ctl);
  71
  72     ohci->running = msg->on;
  73
  74     /*
  75      * Some OHCI Root Hub interrupts pending and the HUB has been just enabled?
  76      * Go, fire up the interrupts!
  77      */
  78     if (msg->on && ohci->pendingRHSC)
  79     {
  80         ohci->pendingRHSC = 0;
  81         struct Interrupt *intr;
  82
  83         Disable();
  84         ForeachNode(&ohci->intList, intr)
  85         {
  86             Cause(intr);
  87         }
  88         Enable();
  89     }
  90
  91     if (!msg->on)
  92         retval = OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  93
  94     return retval;
  95 }
  96
  97 BOOL METHOD(OHCI, Hidd_USBHub, PortReset)
  98 {
  99     ohci_data_t *ohci = OOP_INST_DATA(cl, o);
 100     int i;
 101
 102     D(bug("[OHCI] Port %d reset\n", msg->portNummer));
 103
 104     mmio(ohci->regs->HcRhPortStatus[msg->portNummer-1]) = AROS_LONG2OHCI(UPS_RESET);
 105
 106     for (i=0; i < 5; i++)
 107     {
 108         D(bug("[OHCI] Reset: Waiting for completion\n"));
 109
 110         ohci_Delay(ohci->tr, USB_PORT_ROOT_RESET_DELAY);
 111         if ((mmio(ohci->regs->HcRhPortStatus[msg->portNummer-1]) & AROS_LONG2OHCI(UPS_RESET)) == 0)
 112             break;
 113     }
 114
 115     if (i == 5)
 116         return FALSE;
 117
 118     mmio(ohci->regs->HcRhPortStatus[msg->portNummer-1]) = AROS_LONG2OHCI(UPS_C_PORT_RESET << 16);
 119
 120     return TRUE;
 121 }
 122
 123 BOOL METHOD(OHCI, Hidd_USBHub, GetHubStatus)
 124 {
 125     return TRUE;
 126 }
 127
 128 BOOL METHOD(OHCI, Hidd_USBHub, ClearHubFeature)
 129 {
 130
 131     return TRUE;
 132 }
 133
 134 BOOL METHOD(OHCI, Hidd_USBHub, SetHubFeature)
 135 {
 136     return TRUE;
 137 }
 138
 139 BOOL METHOD(OHCI, Hidd_USBHub, GetPortStatus)
 140 {
 141     ohci_data_t *ohci = OOP_INST_DATA(cl, o);
 142     BOOL retval = FALSE;
 143
 144     if (msg->port >= 1 && msg->port <= ohci->hubDescr.bNbrPorts)
 145     {
 146         uint32_t val = AROS_OHCI2LONG(mmio(ohci->regs->HcRhPortStatus[msg->port-1]));
 147         msg->status->wPortStatus = AROS_WORD2LE(val);
 148         msg->status->wPortChange = AROS_WORD2LE(val >> 16);
 149         retval = TRUE;
 150     }
 151
 152     D(bug("[OHCI] GetPortStatus: sts=%04x chg=%04x\n", AROS_LE2WORD(msg->status->wPortStatus), AROS_LE2WORD(msg->status->wPortChange)));
 153
 154     return retval;
 155 }
 156
 157 BOOL METHOD(OHCI, Hidd_USBHub, ClearPortFeature)
 158 {
 159     ohci_data_t *ohci = OOP_INST_DATA(cl, o);
 160
 161     D(bug("[OHCI] ClearPortFeature(). Port=%d, Feature=%08x\n", msg->port, msg->feature));
 162
 163     if (msg->port > ohci->hubDescr.bNbrPorts)
 164         return FALSE;
 165
 166     switch (msg->feature)
 167     {
 168         case UHF_PORT_ENABLE:
 169             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_CURRENT_CONNECT_STATUS);
 170             break;
 171
 172         case UHF_PORT_SUSPEND:
 173             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_OVERCURRENT_INDICATOR);
 174             break;
 175
 176         case UHF_PORT_POWER:
 177             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_LOW_SPEED);
 178             break;
 179
 180         case UHF_C_PORT_CONNECTION:
 181             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_C_CONNECT_STATUS << 16);
 182             break;
 183
 184         case UHF_C_PORT_ENABLE:
 185             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_C_PORT_ENABLED << 16);
 186             break;
 187
 188         case UHF_C_PORT_SUSPEND:
 189             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_C_SUSPEND << 16);
 190             break;
 191
 192         case UHF_C_PORT_OVER_CURRENT:
 193             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_C_OVERCURRENT_INDICATOR << 16);
 194             break;
 195
 196         case UHF_C_PORT_RESET:
 197             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_C_PORT_RESET << 16);
 198             break;
 199     }
 200
 201     switch (msg->feature)
 202     {
 203         case UHF_C_PORT_CONNECTION:
 204         case UHF_C_PORT_ENABLE:
 205         case UHF_C_PORT_SUSPEND:
 206         case UHF_C_PORT_OVER_CURRENT:
 207         case UHF_C_PORT_RESET:
 208             if (!CheckIO((struct IORequest *)ohci->timerReq))
 209                 AbortIO((struct IORequest *)ohci->timerReq);
 210             GetMsg(&ohci->timerPort);
 211             SetSignal(0, 1 << ohci->timerPort.mp_SigBit);
 212
 213             D(bug("[OHCI] Reenabling the RHSC interrupt\n"));
 214             mmio(ohci->regs->HcInterruptEnable) = mmio(ohci->regs->HcInterruptEnable) | AROS_LONG2OHCI(HC_INTR_RHSC);
 215             break;
 216
 217         default:
 218             break;
 219     }
 220
 221     return TRUE;
 222 }
 223
 224 BOOL METHOD(OHCI, Hidd_USBHub, SetPortFeature)
 225 {
 226     ohci_data_t *ohci = OOP_INST_DATA(cl, o);
 227     int i;
 228
 229     D(bug("[OHCI] SetPortFeature(). Port=%d, Feature=%08x\n", msg->port, msg->feature));
 230
 231     if (msg->port > ohci->hubDescr.bNbrPorts)
 232         return FALSE;
 233
 234     switch (msg->feature)
 235     {
 236         case UHF_PORT_ENABLE:
 237             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_PORT_ENABLED);
 238             break;
 239
 240         case UHF_PORT_SUSPEND:
 241             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_SUSPEND);
 242             break;
 243
 244         case UHF_PORT_POWER:
 245             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_PORT_POWER);
 246             break;
 247
 248         case UHF_PORT_RESET:
 249             mmio(ohci->regs->HcRhPortStatus[msg->port-1]) = AROS_LONG2OHCI(UPS_RESET);
 250             for (i=0; i < 5; i++)
 251             {
 252                 ohci_Delay(ohci->tr, USB_PORT_ROOT_RESET_DELAY);
 253                 if ((mmio(ohci->regs->HcRhPortStatus[msg->port-1]) & AROS_LONG2OHCI(UPS_RESET)) == 0)
 254                     break;
 255             }
 256             if (i == 5)
 257                 return FALSE;
 258
 259             break;
 260     }
 261
 262     return TRUE;
 263 }
 264
 265 AROS_INTH1(OHCI_HubInterrupt, ohci_data_t *,ohci)
 266 {
 267     AROS_INTFUNC_INIT
 268
 269     /* Remove self from the msg queue */
 270     GetMsg(&ohci->timerPort);
 271
 272     if (ohci->timerReq->tr_node.io_Error == IOERR_ABORTED)
 273     {
 274         D(bug("[OHCI] INTR: Abrted\n"));
 275         return FALSE;
 276     }
 277
 278     D(bug("[OHCI] INTR: Reenabling the RHSC interrupt\n"));
 279
 280     /* Reenable the RHSC interrupt */
 281     mmio(ohci->regs->HcInterruptStatus) = AROS_LONG2OHCI(HC_INTR_RHSC);
 282     mmio(ohci->regs->HcInterruptEnable) = AROS_LONG2OHCI(HC_INTR_RHSC);
 283
 284     return FALSE;
 285
 286     AROS_INTFUNC_EXIT
 287 }