sys/bus/usb/usbdi_util.c

   1 /*      $NetBSD: usbdi_util.c,v 1.42 2004/12/03 08:53:40 augustss Exp $ */
   2 /*      $FreeBSD: src/sys/dev/usb/usbdi_util.c,v 1.34 2005/03/01 08:01:22 sobomax Exp $ */
   3 /*      $DragonFly: src/sys/bus/usb/usbdi_util.c,v 1.11 2006/12/23 00:12:17 swildner Exp $      */
   4
   5 /*
   6  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to The NetBSD Foundation
  10  * by Lennart Augustsson (lennart@augustsson.net) at
  11  * Carlstedt Research & Technology.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. All advertising materials mentioning features or use of this software
  22  *    must display the following acknowledgement:
  23  *        This product includes software developed by the NetBSD
  24  *        Foundation, Inc. and its contributors.
  25  * 4. Neither the name of The NetBSD Foundation nor the names of its
  26  *    contributors may be used to endorse or promote products derived
  27  *    from this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  30  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  31  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  32  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  33  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  34  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  35  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  36  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  37  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  38  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39  * POSSIBILITY OF SUCH DAMAGE.
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/module.h>
  46 #include <sys/malloc.h>
  47 #if defined(__NetBSD__) || defined(__OpenBSD__)
  48 #include <sys/proc.h>
  49 #include <sys/device.h>
  50 #elif defined(__FreeBSD__) || defined(__DragonFly__)
  51 #include <sys/bus.h>
  52 #endif
  53 #ifdef __DragonFly__
  54 #include <sys/thread2.h>
  55 #endif
  56
  57 #include <bus/usb/usb.h>
  58 #include <bus/usb/usbhid.h>
  59
  60 #include <bus/usb/usbdi.h>
  61 #include <bus/usb/usbdi_util.h>
  62
  63 #ifdef USB_DEBUG
  64 #define DPRINTF(x)      if (usbdebug) logprintf x
  65 #define DPRINTFN(n,x)   if (usbdebug>(n)) logprintf x
  66 extern int usbdebug;
  67 #else
  68 #define DPRINTF(x)
  69 #define DPRINTFN(n,x)
  70 #endif
  71
  72 usbd_status
  73 usbd_get_desc(usbd_device_handle dev, int type, int index, int len, void *desc)
  74 {
  75         usb_device_request_t req;
  76
  77         DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n",
  78                     type, index, len));
  79
  80         req.bmRequestType = UT_READ_DEVICE;
  81         req.bRequest = UR_GET_DESCRIPTOR;
  82         USETW2(req.wValue, type, index);
  83         USETW(req.wIndex, 0);
  84         USETW(req.wLength, len);
  85         return (usbd_do_request(dev, &req, desc));
  86 }
  87
  88 usbd_status
  89 usbd_get_config_desc(usbd_device_handle dev, int confidx,
  90                      usb_config_descriptor_t *d)
  91 {
  92         usbd_status err;
  93
  94         DPRINTFN(3,("usbd_get_config_desc: confidx=%d\n", confidx));
  95         err = usbd_get_desc(dev, UDESC_CONFIG, confidx,
  96                             USB_CONFIG_DESCRIPTOR_SIZE, d);
  97         if (err)
  98                 return (err);
  99         if (d->bDescriptorType != UDESC_CONFIG) {
 100                 DPRINTFN(-1,("usbd_get_config_desc: confidx=%d, bad desc "
 101                              "len=%d type=%d\n",
 102                              confidx, d->bLength, d->bDescriptorType));
 103                 return (USBD_INVAL);
 104         }
 105         return (USBD_NORMAL_COMPLETION);
 106 }
 107
 108 usbd_status
 109 usbd_get_config_desc_full(usbd_device_handle dev, int conf, void *d, int size)
 110 {
 111         DPRINTFN(3,("usbd_get_config_desc_full: conf=%d\n", conf));
 112         return (usbd_get_desc(dev, UDESC_CONFIG, conf, size, d));
 113 }
 114
 115 usbd_status
 116 usbd_get_device_desc(usbd_device_handle dev, usb_device_descriptor_t *d)
 117 {
 118         DPRINTFN(3,("usbd_get_device_desc:\n"));
 119         return (usbd_get_desc(dev, UDESC_DEVICE,
 120                              0, USB_DEVICE_DESCRIPTOR_SIZE, d));
 121 }
 122
 123 usbd_status
 124 usbd_get_device_status(usbd_device_handle dev, usb_status_t *st)
 125 {
 126         usb_device_request_t req;
 127
 128         req.bmRequestType = UT_READ_DEVICE;
 129         req.bRequest = UR_GET_STATUS;
 130         USETW(req.wValue, 0);
 131         USETW(req.wIndex, 0);
 132         USETW(req.wLength, sizeof(usb_status_t));
 133         return (usbd_do_request(dev, &req, st));
 134 }
 135
 136 usbd_status
 137 usbd_get_hub_status(usbd_device_handle dev, usb_hub_status_t *st)
 138 {
 139         usb_device_request_t req;
 140
 141         req.bmRequestType = UT_READ_CLASS_DEVICE;
 142         req.bRequest = UR_GET_STATUS;
 143         USETW(req.wValue, 0);
 144         USETW(req.wIndex, 0);
 145         USETW(req.wLength, sizeof(usb_hub_status_t));
 146         return (usbd_do_request(dev, &req, st));
 147 }
 148
 149 usbd_status
 150 usbd_set_address(usbd_device_handle dev, int addr)
 151 {
 152         usb_device_request_t req;
 153
 154         req.bmRequestType = UT_WRITE_DEVICE;
 155         req.bRequest = UR_SET_ADDRESS;
 156         USETW(req.wValue, addr);
 157         USETW(req.wIndex, 0);
 158         USETW(req.wLength, 0);
 159         return usbd_do_request(dev, &req, 0);
 160 }
 161
 162 usbd_status
 163 usbd_get_port_status(usbd_device_handle dev, int port, usb_port_status_t *ps)
 164 {
 165         usb_device_request_t req;
 166
 167         req.bmRequestType = UT_READ_CLASS_OTHER;
 168         req.bRequest = UR_GET_STATUS;
 169         USETW(req.wValue, 0);
 170         USETW(req.wIndex, port);
 171         USETW(req.wLength, sizeof *ps);
 172         return (usbd_do_request(dev, &req, ps));
 173 }
 174
 175 usbd_status
 176 usbd_clear_hub_feature(usbd_device_handle dev, int sel)
 177 {
 178         usb_device_request_t req;
 179
 180         req.bmRequestType = UT_WRITE_CLASS_DEVICE;
 181         req.bRequest = UR_CLEAR_FEATURE;
 182         USETW(req.wValue, sel);
 183         USETW(req.wIndex, 0);
 184         USETW(req.wLength, 0);
 185         return (usbd_do_request(dev, &req, 0));
 186 }
 187
 188 usbd_status
 189 usbd_set_hub_feature(usbd_device_handle dev, int sel)
 190 {
 191         usb_device_request_t req;
 192
 193         req.bmRequestType = UT_WRITE_CLASS_DEVICE;
 194         req.bRequest = UR_SET_FEATURE;
 195         USETW(req.wValue, sel);
 196         USETW(req.wIndex, 0);
 197         USETW(req.wLength, 0);
 198         return (usbd_do_request(dev, &req, 0));
 199 }
 200
 201 usbd_status
 202 usbd_clear_port_feature(usbd_device_handle dev, int port, int sel)
 203 {
 204         usb_device_request_t req;
 205
 206         req.bmRequestType = UT_WRITE_CLASS_OTHER;
 207         req.bRequest = UR_CLEAR_FEATURE;
 208         USETW(req.wValue, sel);
 209         USETW(req.wIndex, port);
 210         USETW(req.wLength, 0);
 211         return (usbd_do_request(dev, &req, 0));
 212 }
 213
 214 usbd_status
 215 usbd_set_port_feature(usbd_device_handle dev, int port, int sel)
 216 {
 217         usb_device_request_t req;
 218
 219         req.bmRequestType = UT_WRITE_CLASS_OTHER;
 220         req.bRequest = UR_SET_FEATURE;
 221         USETW(req.wValue, sel);
 222         USETW(req.wIndex, port);
 223         USETW(req.wLength, 0);
 224         return (usbd_do_request(dev, &req, 0));
 225 }
 226
 227 usbd_status
 228 usbd_get_protocol(usbd_interface_handle iface, u_int8_t *report)
 229 {
 230         usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
 231         usbd_device_handle dev;
 232         usb_device_request_t req;
 233
 234         DPRINTFN(4, ("usbd_get_protocol: iface=%p, endpt=%d\n",
 235                      iface, id->bInterfaceNumber));
 236         if (id == NULL)
 237                 return (USBD_IOERROR);
 238         usbd_interface2device_handle(iface, &dev);
 239         req.bmRequestType = UT_READ_CLASS_INTERFACE;
 240         req.bRequest = UR_GET_PROTOCOL;
 241         USETW(req.wValue, 0);
 242         USETW(req.wIndex, id->bInterfaceNumber);
 243         USETW(req.wLength, 1);
 244         return (usbd_do_request(dev, &req, report));
 245 }
 246
 247 usbd_status
 248 usbd_set_protocol(usbd_interface_handle iface, int report)
 249 {
 250         usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
 251         usbd_device_handle dev;
 252         usb_device_request_t req;
 253
 254         DPRINTFN(4, ("usbd_set_protocol: iface=%p, report=%d, endpt=%d\n",
 255                      iface, report, id->bInterfaceNumber));
 256         if (id == NULL)
 257                 return (USBD_IOERROR);
 258         usbd_interface2device_handle(iface, &dev);
 259         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 260         req.bRequest = UR_SET_PROTOCOL;
 261         USETW(req.wValue, report);
 262         USETW(req.wIndex, id->bInterfaceNumber);
 263         USETW(req.wLength, 0);
 264         return (usbd_do_request(dev, &req, 0));
 265 }
 266
 267 usbd_status
 268 usbd_set_report(usbd_interface_handle iface, int type, int id, void *data,
 269                 int len)
 270 {
 271         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
 272         usbd_device_handle dev;
 273         usb_device_request_t req;
 274
 275         DPRINTFN(4, ("usbd_set_report: len=%d\n", len));
 276         if (ifd == NULL)
 277                 return (USBD_IOERROR);
 278         usbd_interface2device_handle(iface, &dev);
 279         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 280         req.bRequest = UR_SET_REPORT;
 281         USETW2(req.wValue, type, id);
 282         USETW(req.wIndex, ifd->bInterfaceNumber);
 283         USETW(req.wLength, len);
 284         return (usbd_do_request(dev, &req, data));
 285 }
 286
 287 usbd_status
 288 usbd_set_report_async(usbd_interface_handle iface, int type, int id, void *data,
 289                       int len)
 290 {
 291         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
 292         usbd_device_handle dev;
 293         usb_device_request_t req;
 294
 295         DPRINTFN(4, ("usbd_set_report_async: len=%d\n", len));
 296         if (ifd == NULL)
 297                 return (USBD_IOERROR);
 298         usbd_interface2device_handle(iface, &dev);
 299         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 300         req.bRequest = UR_SET_REPORT;
 301         USETW2(req.wValue, type, id);
 302         USETW(req.wIndex, ifd->bInterfaceNumber);
 303         USETW(req.wLength, len);
 304         return (usbd_do_request_async(dev, &req, data));
 305 }
 306
 307 usbd_status
 308 usbd_get_report(usbd_interface_handle iface, int type, int id, void *data,
 309                 int len)
 310 {
 311         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
 312         usbd_device_handle dev;
 313         usb_device_request_t req;
 314
 315         DPRINTFN(4, ("usbd_get_report: len=%d\n", len));
 316         if (ifd == NULL)
 317                 return (USBD_IOERROR);
 318         usbd_interface2device_handle(iface, &dev);
 319         req.bmRequestType = UT_READ_CLASS_INTERFACE;
 320         req.bRequest = UR_GET_REPORT;
 321         USETW2(req.wValue, type, id);
 322         USETW(req.wIndex, ifd->bInterfaceNumber);
 323         USETW(req.wLength, len);
 324         return (usbd_do_request(dev, &req, data));
 325 }
 326
 327 usbd_status
 328 usbd_set_idle(usbd_interface_handle iface, int duration, int id)
 329 {
 330         usb_interface_descriptor_t *ifd = usbd_get_interface_descriptor(iface);
 331         usbd_device_handle dev;
 332         usb_device_request_t req;
 333
 334         DPRINTFN(4, ("usbd_set_idle: %d %d\n", duration, id));
 335         if (ifd == NULL)
 336                 return (USBD_IOERROR);
 337         usbd_interface2device_handle(iface, &dev);
 338         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 339         req.bRequest = UR_SET_IDLE;
 340         USETW2(req.wValue, duration, id);
 341         USETW(req.wIndex, ifd->bInterfaceNumber);
 342         USETW(req.wLength, 0);
 343         return (usbd_do_request(dev, &req, 0));
 344 }
 345
 346 usbd_status
 347 usbd_get_report_descriptor(usbd_device_handle dev, int ifcno,
 348                            int size, void *d)
 349 {
 350         usb_device_request_t req;
 351
 352         req.bmRequestType = UT_READ_INTERFACE;
 353         req.bRequest = UR_GET_DESCRIPTOR;
 354         USETW2(req.wValue, UDESC_REPORT, 0); /* report id should be 0 */
 355         USETW(req.wIndex, ifcno);
 356         USETW(req.wLength, size);
 357         return (usbd_do_request(dev, &req, d));
 358 }
 359
 360 usb_hid_descriptor_t *
 361 usbd_get_hid_descriptor(usbd_interface_handle ifc)
 362 {
 363         usb_interface_descriptor_t *idesc = usbd_get_interface_descriptor(ifc);
 364         usbd_device_handle dev;
 365         usb_config_descriptor_t *cdesc;
 366         usb_hid_descriptor_t *hd;
 367         char *p, *end;
 368
 369         if (idesc == NULL)
 370                 return (NULL);
 371         usbd_interface2device_handle(ifc, &dev);
 372         cdesc = usbd_get_config_descriptor(dev);
 373
 374         p = (char *)idesc + idesc->bLength;
 375         end = (char *)cdesc + UGETW(cdesc->wTotalLength);
 376
 377         for (; p < end; p += hd->bLength) {
 378                 hd = (usb_hid_descriptor_t *)p;
 379                 if (p + hd->bLength <= end && hd->bDescriptorType == UDESC_HID)
 380                         return (hd);
 381                 if (hd->bDescriptorType == UDESC_INTERFACE)
 382                         break;
 383         }
 384         return (NULL);
 385 }
 386
 387 usbd_status
 388 usbd_read_report_desc(usbd_interface_handle ifc, void **descp, int *sizep,
 389                       usb_malloc_type mem)
 390 {
 391         usb_interface_descriptor_t *id;
 392         usb_hid_descriptor_t *hid;
 393         usbd_device_handle dev;
 394         usbd_status err;
 395
 396         usbd_interface2device_handle(ifc, &dev);
 397         id = usbd_get_interface_descriptor(ifc);
 398         if (id == NULL)
 399                 return (USBD_INVAL);
 400         hid = usbd_get_hid_descriptor(ifc);
 401         if (hid == NULL)
 402                 return (USBD_IOERROR);
 403         *sizep = UGETW(hid->descrs[0].wDescriptorLength);
 404         *descp = kmalloc(*sizep, mem, M_INTWAIT);
 405         err = usbd_get_report_descriptor(dev, id->bInterfaceNumber,
 406                                          *sizep, *descp);
 407         if (err) {
 408                 kfree(*descp, mem);
 409                 *descp = NULL;
 410                 return (err);
 411         }
 412         return (USBD_NORMAL_COMPLETION);
 413 }
 414
 415 usbd_status
 416 usbd_get_config(usbd_device_handle dev, u_int8_t *conf)
 417 {
 418         usb_device_request_t req;
 419
 420         req.bmRequestType = UT_READ_DEVICE;
 421         req.bRequest = UR_GET_CONFIG;
 422         USETW(req.wValue, 0);
 423         USETW(req.wIndex, 0);
 424         USETW(req.wLength, 1);
 425         return (usbd_do_request(dev, &req, conf));
 426 }
 427
 428 Static void usbd_bulk_transfer_cb(usbd_xfer_handle xfer,
 429                                   usbd_private_handle priv, usbd_status status);
 430 Static void
 431 usbd_bulk_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
 432                       usbd_status status)
 433 {
 434         wakeup(xfer);
 435 }
 436
 437 usbd_status
 438 usbd_bulk_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
 439                    u_int16_t flags, u_int32_t timeout, void *buf,
 440                    u_int32_t *size, char *lbl)
 441 {
 442         usbd_status err;
 443         int error;
 444
 445         usbd_setup_xfer(xfer, pipe, 0, buf, *size,
 446                         flags, timeout, usbd_bulk_transfer_cb);
 447         DPRINTFN(1, ("usbd_bulk_transfer: start transfer %d bytes\n", *size));
 448         crit_enter();
 449         err = usbd_transfer(xfer);
 450         if (err != USBD_IN_PROGRESS) {
 451                 crit_exit();
 452                 return (err);
 453         }
 454         error = tsleep((caddr_t)xfer, PCATCH, lbl, 0);
 455         crit_exit();
 456         if (error) {
 457                 DPRINTF(("usbd_bulk_transfer: tsleep=%d\n", error));
 458                 usbd_abort_pipe(pipe);
 459                 return (USBD_INTERRUPTED);
 460         }
 461         usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
 462         DPRINTFN(1,("usbd_bulk_transfer: transferred %d\n", *size));
 463         if (err) {
 464                 DPRINTF(("usbd_bulk_transfer: error=%d\n", err));
 465                 usbd_clear_endpoint_stall(pipe);
 466         }
 467         return (err);
 468 }
 469
 470 Static void usbd_intr_transfer_cb(usbd_xfer_handle xfer,
 471                                   usbd_private_handle priv, usbd_status status);
 472 Static void
 473 usbd_intr_transfer_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
 474                       usbd_status status)
 475 {
 476         wakeup(xfer);
 477 }
 478
 479 usbd_status
 480 usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
 481                    u_int16_t flags, u_int32_t timeout, void *buf,
 482                    u_int32_t *size, char *lbl)
 483 {
 484         usbd_status err;
 485         int error;
 486
 487         usbd_setup_xfer(xfer, pipe, 0, buf, *size,
 488                         flags, timeout, usbd_intr_transfer_cb);
 489         DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size));
 490         crit_enter();           /* don't want callback until tsleep() */
 491         err = usbd_transfer(xfer);
 492         if (err != USBD_IN_PROGRESS) {
 493                 crit_exit();
 494                 return (err);
 495         }
 496         error = tsleep(xfer, PCATCH, lbl, 0);
 497         crit_exit();
 498         if (error) {
 499                 DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error));
 500                 usbd_abort_pipe(pipe);
 501                 return (USBD_INTERRUPTED);
 502         }
 503         usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
 504         DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size));
 505         if (err) {
 506                 DPRINTF(("usbd_intr_transfer: error=%d\n", err));
 507                 usbd_clear_endpoint_stall(pipe);
 508         }
 509         return (err);
 510 }
 511
 512 void
 513 usb_detach_wait(device_ptr_t dv)
 514 {
 515         DPRINTF(("usb_detach_wait: waiting for %s\n", USBDEVPTRNAME(dv)));
 516         if (tsleep(dv, 0, "usbdet", hz * 60))
 517                 kprintf("usb_detach_wait: %s didn't detach\n",
 518                         USBDEVPTRNAME(dv));
 519         DPRINTF(("usb_detach_wait: %s done\n", USBDEVPTRNAME(dv)));
 520 }
 521
 522 void
 523 usb_detach_wakeup(device_ptr_t dv)
 524 {
 525         DPRINTF(("usb_detach_wakeup: for %s\n", USBDEVPTRNAME(dv)));
 526         wakeup(dv);
 527 }
 528
 529 const usb_descriptor_t *
 530 usb_find_desc(usbd_device_handle dev, int type, int subtype)
 531 {
 532         usbd_desc_iter_t iter;
 533         const usb_descriptor_t *desc;
 534
 535         usb_desc_iter_init(dev, &iter);
 536         for (;;) {
 537                 desc = usb_desc_iter_next(&iter);
 538                 if (!desc || (desc->bDescriptorType == type &&
 539                               (subtype == USBD_SUBTYPE_ANY ||
 540                                subtype == desc->bDescriptorSubtype)))
 541                         break;
 542         }
 543         return desc;
 544 }