workbench/devs/USB/stack/usbclass.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 <aros/debug.h>
  24 #include <aros/libcall.h>
  25
  26 #include <exec/types.h>
  27 #include <oop/oop.h>
  28 #include <dos/dos.h>
  29 #include <dos/dosextens.h>
  30
  31 #include <hidd/hidd.h>
  32 #include <usb/usb.h>
  33
  34 #include <proto/oop.h>
  35 #include <proto/dos.h>
  36
  37 #include <stdint.h>
  38
  39 #include "usb.h"
  40 #include "misc.h"
  41
  42 OOP_Object *METHOD(USB, Root, New)
  43 {
  44     D(bug("[USB] USB::New()\n"));
  45
  46     BASE(cl->UserData)->LibNode.lib_OpenCnt++;
  47
  48     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
  49     D(bug("[USB] USB::New() = %p\n", o));
  50
  51     if (!o)
  52         BASE(cl->UserData)->LibNode.lib_OpenCnt--;
  53
  54     return o;
  55 }
  56
  57 void METHOD(USB, Root, Dispose)
  58 {
  59     struct Library *base = &BASE(cl->UserData)->LibNode;
  60
  61     D(bug("[USB] USB::Dispose\n"));
  62
  63     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
  64
  65     base->lib_OpenCnt--;
  66 }
  67
  68 void METHOD(USB, Root, Get)
  69 {
  70     uint32_t idx;
  71     D(bug("[USB] USB::Get\n"));
  72
  73     if (IS_USB_ATTR(msg->attrID, idx))
  74     {
  75         switch (idx)
  76         {
  77             case aoHidd_USB_Bus:
  78             {
  79                 D(bug("[USB] USB Get Bus. *msg->storage = %p\n", *msg->storage));
  80                 usb_driver_t *driver;
  81
  82                 ObtainSemaphore(&SD(cl)->driverListLock);
  83
  84                 if (*msg->storage)
  85                 {
  86                     ForeachNode(&SD(cl)->driverList, driver)
  87                     {
  88                         if ((IPTR)driver->d_Driver == *msg->storage)
  89                             break;
  90                     }
  91
  92                     if (driver)
  93                         driver = (usb_driver_t *)GetSucc(&driver->d_Node);
  94                 }
  95                 else
  96                     driver = (usb_driver_t *)GetHead(&SD(cl)->driverList);
  97
  98                 D(bug("[USB] driver=%p\n", driver));
  99
 100                 if (driver)
 101                     *msg->storage = (IPTR)driver->d_Driver;
 102                 else
 103                     *msg->storage = (IPTR)NULL;
 104
 105                 ReleaseSemaphore(&SD(cl)->driverListLock);
 106                 break;
 107             }
 108             default:
 109                 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 110         }
 111     }
 112     else
 113         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 114 }
 115
 116 BOOL METHOD(USB, Hidd_USB, AttachDriver)
 117 {
 118     BOOL retval = FALSE;
 119     D(bug("[USB] USB::AttachDriver(%p)\n", msg->driverObject));
 120
 121     if (msg->driverObject)
 122     {
 123         usb_driver_t *drv = AllocPooled(SD(cl)->MemPool, sizeof(struct usb_driver));
 124
 125         if (drv)
 126         {
 127             int i;
 128             drv->d_Driver = msg->driverObject;
 129             InitSemaphore(&drv->d_Lock);
 130
 131             for (i=0; i < (BITMAP_SIZE/32); i++) {
 132                 drv->bitmap[i] = 0;
 133             }
 134             setBitmap(drv->bitmap, 0);
 135             setBitmap(drv->bitmap, 1);
 136
 137             ObtainSemaphore(&SD(cl)->driverListLock);
 138             AddTail(&SD(cl)->driverList, &drv->d_Node);
 139             ReleaseSemaphore(&SD(cl)->driverListLock);
 140
 141             //HIDD_USBHub_OnOff(drv->d_Driver, FALSE);
 142             HIDD_USBHub_OnOff(drv->d_Driver, TRUE);
 143
 144             retval = TRUE;
 145         }
 146     }
 147
 148
 149     return retval;
 150 }
 151
 152 BOOL METHOD(USB, Hidd_USB, DetachDriver)
 153 {
 154     D(bug("[USB] USB::DetachDriver()\n"));
 155
 156     return FALSE;
 157 }
 158
 159 void METHOD(USB, Hidd_USB, AddClass)
 160 {
 161     struct usb_ExtClass *ec = NULL;
 162     int found = 0;
 163
 164     D(bug("[USB] USB::AddClass(\"%s\")\n", msg->className));
 165
 166     ForeachNode(&SD(cl)->extClassList, ec)
 167     {
 168         if (!strcmp(msg->className, ec->ec_ShortName))
 169         {
 170             found = 1;
 171             break;
 172         }
 173     }
 174
 175     if (!found)
 176     {
 177         D(bug("[USB] Class not on the list. Adding it.\n"));
 178
 179         ec = AllocVecPooled(SD(cl)->MemPool, sizeof(struct usb_ExtClass));
 180
 181         ec->ec_Node.ln_Name = AllocVecPooled(SD(cl)->MemPool, strlen(msg->className)+1);
 182         CopyMem(msg->className, ec->ec_Node.ln_Name, strlen(msg->className)+1);
 183         ec->ec_ShortName = AllocVecPooled(SD(cl)->MemPool, strlen(msg->className)+1);
 184         CopyMem(msg->className, (char *)ec->ec_ShortName, strlen(msg->className)+1);
 185         AddTail(&SD(cl)->extClassList, &ec->ec_Node);
 186     }
 187 }
 188
 189 uint8_t METHOD(USB, Hidd_USB, AllocAddress)
 190 {
 191     struct usb_driver *drv = NULL;
 192     uint8_t addr = 0;
 193
 194     ObtainSemaphore(&SD(cl)->driverListLock);
 195     ForeachNode(&SD(cl)->driverList, drv)
 196     {
 197         if (drv->d_Driver == msg->driverObject)
 198             break;
 199     }
 200     ReleaseSemaphore(&SD(cl)->driverListLock);
 201
 202     if (drv)
 203     {
 204         ObtainSemaphore(&drv->d_Lock);
 205         addr = allocBitmap(drv->bitmap);
 206         ReleaseSemaphore(&drv->d_Lock);
 207     }
 208
 209     return addr;
 210 }
 211
 212 void METHOD(USB, Hidd_USB, FreeAddress)
 213 {
 214     struct usb_driver *drv = NULL;
 215
 216     ObtainSemaphore(&SD(cl)->driverListLock);
 217     ForeachNode(&SD(cl)->driverList, drv)
 218     {
 219         if (drv->d_Driver == msg->driverObject)
 220             break;
 221     }
 222     ReleaseSemaphore(&SD(cl)->driverListLock);
 223
 224     if (drv)
 225     {
 226         ObtainSemaphore(&drv->d_Lock);
 227         freeBitmap(drv->bitmap, msg->address);
 228         ReleaseSemaphore(&drv->d_Lock);
 229     }
 230 }
 231
 232 OOP_Object *METHOD(USB, Hidd_USB, NewDevice)
 233 {
 234     OOP_Object *new_device = NULL;
 235     APTR pipe;
 236     OOP_Object *bus;
 237     usb_device_descriptor_t descriptor;
 238     usb_config_descriptor_t config;
 239     void *cdesc;
 240     uint8_t address;
 241
 242     USBDevice_Request request = {
 243             bmRequestType:      UT_READ_DEVICE,
 244             bRequest:           UR_GET_DESCRIPTOR,
 245             wValue:             AROS_WORD2LE(UDESC_DEVICE << 8),
 246             wIndex:             AROS_WORD2LE(0),
 247             wLength:            AROS_WORD2LE(8)
 248     };
 249
 250     memset(&descriptor, 0, sizeof(descriptor));
 251
 252     OOP_GetAttr(msg->hub, aHidd_USBDevice_Bus, (IPTR*)&bus);
 253
 254     if (bus)
 255     {
 256         struct usb_ExtClass *ec;
 257         struct usb_driver *drv = NULL;
 258
 259         ObtainSemaphore(&SD(cl)->driverListLock);
 260         ForeachNode(&SD(cl)->driverList, drv)
 261         {
 262             if (drv->d_Driver == bus)
 263                 break;
 264         }
 265         ReleaseSemaphore(&SD(cl)->driverListLock);
 266
 267         ObtainSemaphore(&drv->d_Lock);
 268
 269         pipe = HIDD_USBDrv_CreatePipe(bus, PIPE_Control, msg->fast, 0, 0, 0, 8, 100);
 270
 271         HIDD_USBDrv_ControlTransfer(bus, pipe, &request, &descriptor, 8);
 272         D(bug("[USB] USB::NewDevice()\n"));
 273         D(
 274           DumpDescriptor(&descriptor);
 275         );
 276
 277         if ((address = HIDD_USB_AllocAddress(o, bus)))
 278         {
 279             USBDevice_Request req = {
 280                     bmRequestType:  UT_WRITE_DEVICE,
 281                     bRequest:       UR_SET_ADDRESS,
 282                     wValue:         AROS_WORD2LE(address),
 283                     wIndex:         AROS_WORD2LE(0),
 284                     wLength:        AROS_WORD2LE(0)
 285             };
 286
 287             HIDD_USBDrv_ControlTransfer(bus, pipe, &req, NULL, 0);
 288
 289             HIDD_USBDrv_DeletePipe(bus, pipe);
 290
 291             pipe = HIDD_USBDrv_CreatePipe(bus, PIPE_Control, msg->fast, address, 0, 0, descriptor.bMaxPacketSize, 100);
 292
 293             if (!pipe)
 294             {
 295                 bug("[USB] Could not set device address\n");
 296                 return NULL;
 297             }
 298         }
 299
 300         request.wValue = AROS_WORD2LE(UDESC_CONFIG << 8);
 301         request.wLength = AROS_WORD2LE(USB_CONFIG_DESCRIPTOR_SIZE);
 302
 303         HIDD_USBDrv_ControlTransfer(bus, pipe, &request, &config, USB_CONFIG_DESCRIPTOR_SIZE);
 304
 305         cdesc = AllocVecPooled(SD(cl)->MemPool, AROS_LE2WORD(config.wTotalLength));
 306         if (cdesc)
 307         {
 308             request.wLength = config.wTotalLength;
 309             HIDD_USBDrv_ControlTransfer(bus, pipe, &request, cdesc, AROS_LE2WORD(config.wTotalLength));
 310         }
 311
 312         HIDD_USBDrv_DeletePipe(bus, pipe);
 313
 314         struct TagItem tags[] = {
 315                 { aHidd_USBDevice_Interface,        0 },
 316                 { aHidd_USBDevice_Address,          address },
 317                 { aHidd_USBDevice_Next,             0 },
 318                 { aHidd_USBDevice_Hub,              (uintptr_t)msg->hub },
 319                 { aHidd_USBDevice_Fast,             msg->fast },
 320                 { aHidd_USBDevice_MaxPacketSize,    descriptor.bMaxPacketSize },
 321                 { TAG_DONE, 0UL },
 322         };
 323
 324         switch(descriptor.bDeviceClass)
 325         {
 326             case UDCLASS_HUB:
 327                 new_device = OOP_NewObject(NULL, (STRPTR)CLID_Hidd_USBHub, tags);
 328                 HIDD_USBHub_OnOff(new_device, TRUE);
 329                 break;
 330
 331             default:
 332             {
 333                 int i;
 334
 335                 /* Try a match for every interface */
 336                 for (i = config.bNumInterface; i > 0; i--)
 337                 {
 338                     D(bug("[USB] Looking for a driver for interface no. %d\n", i));
 339                     tags[0].ti_Data = i - 1;
 340
 341                     ForeachNode(&SD(cl)->extClassList, ec)
 342                     {
 343                         D(bug("[USB] Trying external class \"%s\"\n", ec->ec_Node.ln_Name));
 344
 345                         if (!ec->ec_LibBase)
 346                             ec->ec_LibBase = OpenLibrary(ec->ec_Node.ln_Name, 0);
 347
 348                         if (ec->ec_LibBase)
 349                         {
 350                             void *clid = AROS_LVO_CALL3(void *,
 351                                                           AROS_LCA(usb_device_descriptor_t *, &descriptor, A0),
 352                                                           AROS_LCA(usb_config_descriptor_t *, cdesc, A1),
 353                                                           AROS_LCA(int, i - 1, D0),
 354                                                           struct Library *, ec->ec_LibBase, 5,);
 355                             if (clid)
 356                             {
 357                                 new_device = OOP_NewObject(NULL, (STRPTR)clid, tags);
 358
 359                                 if (new_device)
 360                                 {
 361                                     tags[2].ti_Data = (intptr_t)new_device;
 362                                     break;      /* One loop up */
 363                                 }
 364                             }
 365                         }
 366                     }
 367                 }
 368
 369                 break;
 370             }
 371         }
 372
 373         if (cdesc)
 374             FreeVecPooled(SD(cl)->MemPool, cdesc);
 375
 376         ReleaseSemaphore(&drv->d_Lock);
 377     }
 378
 379     return new_device;
 380 }