Annotation of sys/dev/usb/uow.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: uow.c,v 1.23 2007/06/14 10:11:16 mbalmer Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2006 Alexander Yurchenko <grange@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: /*
! 20: * Maxim/Dallas DS2490 USB 1-Wire adapter driver.
! 21: */
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/systm.h>
! 25: #include <sys/device.h>
! 26: #include <sys/kernel.h>
! 27: #include <sys/proc.h>
! 28:
! 29: #include <dev/onewire/onewirereg.h>
! 30: #include <dev/onewire/onewirevar.h>
! 31:
! 32: #include <dev/usb/usb.h>
! 33: #include <dev/usb/usbdevs.h>
! 34: #include <dev/usb/usbdi.h>
! 35: #include <dev/usb/usbdi_util.h>
! 36:
! 37: #include <dev/usb/uowreg.h>
! 38:
! 39: #ifdef UOW_DEBUG
! 40: #define DPRINTF(x) printf x
! 41: #else
! 42: #define DPRINTF(x)
! 43: #endif
! 44:
! 45: #define UOW_TIMEOUT 1000 /* ms */
! 46:
! 47: struct uow_softc {
! 48: struct device sc_dev;
! 49:
! 50: struct onewire_bus sc_ow_bus;
! 51: struct device *sc_ow_dev;
! 52:
! 53: usbd_device_handle sc_udev;
! 54: usbd_interface_handle sc_iface;
! 55: usbd_pipe_handle sc_ph_ibulk;
! 56: usbd_pipe_handle sc_ph_obulk;
! 57: usbd_pipe_handle sc_ph_intr;
! 58: u_int8_t sc_regs[DS2490_NREGS];
! 59: usbd_xfer_handle sc_xfer;
! 60: u_int8_t sc_fifo[DS2490_DATAFIFOSIZE];
! 61: };
! 62:
! 63: int uow_match(struct device *, void *, void *);
! 64: void uow_attach(struct device *, struct device *, void *);
! 65: int uow_detach(struct device *, int);
! 66: int uow_activate(struct device *, enum devact);
! 67:
! 68: struct cfdriver uow_cd = {
! 69: NULL, "uow", DV_DULL
! 70: };
! 71:
! 72: const struct cfattach uow_ca = {
! 73: sizeof(struct uow_softc),
! 74: uow_match,
! 75: uow_attach,
! 76: uow_detach,
! 77: uow_activate,
! 78: };
! 79:
! 80: /* List of supported devices */
! 81: static const struct usb_devno uow_devs[] = {
! 82: { USB_VENDOR_DALLAS, USB_PRODUCT_DALLAS_USB_FOB_IBUTTON }
! 83: };
! 84:
! 85: int uow_ow_reset(void *);
! 86: int uow_ow_bit(void *, int);
! 87: int uow_ow_read_byte(void *);
! 88: void uow_ow_write_byte(void *, int);
! 89: void uow_ow_read_block(void *, void *, int);
! 90: void uow_ow_write_block(void *, const void *, int);
! 91: void uow_ow_matchrom(void *, u_int64_t);
! 92: int uow_ow_search(void *, u_int64_t *, int, u_int64_t);
! 93:
! 94: int uow_cmd(struct uow_softc *, int, int, int);
! 95: #define uow_ctlcmd(s, c, p) uow_cmd((s), DS2490_CONTROL_CMD, (c), (p))
! 96: #define uow_commcmd(s, c, p) uow_cmd((s), DS2490_COMM_CMD, (c), (p))
! 97: #define uow_modecmd(s, c, p) uow_cmd((s), DS2490_MODE_CMD, (c), (p))
! 98:
! 99: void uow_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
! 100: int uow_read(struct uow_softc *, void *, int);
! 101: int uow_write(struct uow_softc *, const void *, int);
! 102: int uow_reset(struct uow_softc *);
! 103:
! 104: int
! 105: uow_match(struct device *parent, void *match, void *aux)
! 106: {
! 107: struct usb_attach_arg *uaa = aux;
! 108:
! 109: if (uaa->iface != NULL)
! 110: return (UMATCH_NONE);
! 111:
! 112: return ((usb_lookup(uow_devs, uaa->vendor, uaa->product) != NULL) ?
! 113: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
! 114: }
! 115:
! 116: void
! 117: uow_attach(struct device *parent, struct device *self, void *aux)
! 118: {
! 119: struct uow_softc *sc = (struct uow_softc *)self;
! 120: struct usb_attach_arg *uaa = aux;
! 121: usb_interface_descriptor_t *id;
! 122: usb_endpoint_descriptor_t *ed;
! 123: char *devinfop;
! 124: int ep_ibulk = -1, ep_obulk = -1, ep_intr = -1;
! 125: struct onewirebus_attach_args oba;
! 126: usbd_status error;
! 127: int i;
! 128:
! 129: sc->sc_udev = uaa->device;
! 130:
! 131: /* Display device info string */
! 132: printf("\n");
! 133: devinfop = usbd_devinfo_alloc(uaa->device, 0);
! 134: printf("%s: %s\n", sc->sc_dev.dv_xname, devinfop);
! 135: usbd_devinfo_free(devinfop);
! 136:
! 137: /* Set USB configuration */
! 138: if ((error = usbd_set_config_no(sc->sc_udev,
! 139: DS2490_USB_CONFIG, 0)) != 0) {
! 140: printf("%s: failed to set config %d: %s\n",
! 141: sc->sc_dev.dv_xname, DS2490_USB_CONFIG,
! 142: usbd_errstr(error));
! 143: return;
! 144: }
! 145:
! 146: /* Get interface handle */
! 147: if ((error = usbd_device2interface_handle(sc->sc_udev,
! 148: DS2490_USB_IFACE, &sc->sc_iface)) != 0) {
! 149: printf("%s: failed to get iface %d: %s\n",
! 150: sc->sc_dev.dv_xname, DS2490_USB_IFACE,
! 151: usbd_errstr(error));
! 152: return;
! 153: }
! 154:
! 155: /* Find endpoints */
! 156: id = usbd_get_interface_descriptor(sc->sc_iface);
! 157: for (i = 0; i < id->bNumEndpoints; i++) {
! 158: ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
! 159: if (ed == NULL) {
! 160: printf("%s: failed to get endpoint %d descriptor\n",
! 161: sc->sc_dev.dv_xname, i);
! 162: return;
! 163: }
! 164:
! 165: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 166: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
! 167: ep_ibulk = ed->bEndpointAddress;
! 168: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
! 169: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
! 170: ep_obulk = ed->bEndpointAddress;
! 171: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 172: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT)
! 173: ep_intr = ed->bEndpointAddress;
! 174: }
! 175: if (ep_ibulk == -1 || ep_obulk == -1 || ep_intr == -1) {
! 176: printf("%s: missing endpoint: ibulk %d, obulk %d, intr %d\n",
! 177: sc->sc_dev.dv_xname, ep_ibulk, ep_obulk, ep_intr);
! 178: return;
! 179: }
! 180:
! 181: /* Open pipes */
! 182: if ((error = usbd_open_pipe(sc->sc_iface, ep_ibulk, USBD_EXCLUSIVE_USE,
! 183: &sc->sc_ph_ibulk)) != 0) {
! 184: printf("%s: failed to open bulk-in pipe: %s\n",
! 185: sc->sc_dev.dv_xname, usbd_errstr(error));
! 186: return;
! 187: }
! 188: if ((error = usbd_open_pipe(sc->sc_iface, ep_obulk, USBD_EXCLUSIVE_USE,
! 189: &sc->sc_ph_obulk)) != 0) {
! 190: printf("%s: failed to open bulk-out pipe: %s\n",
! 191: sc->sc_dev.dv_xname, usbd_errstr(error));
! 192: goto fail;
! 193: }
! 194: if ((error = usbd_open_pipe_intr(sc->sc_iface, ep_intr,
! 195: USBD_SHORT_XFER_OK, &sc->sc_ph_intr, sc,
! 196: sc->sc_regs, sizeof(sc->sc_regs), uow_intr,
! 197: USBD_DEFAULT_INTERVAL)) != 0) {
! 198: printf("%s: failed to open intr pipe: %s\n",
! 199: sc->sc_dev.dv_xname, usbd_errstr(error));
! 200: goto fail;
! 201: }
! 202:
! 203: #if 0
! 204: /* Allocate xfer for bulk transfers */
! 205: if ((sc->sc_xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 206: printf("%s: failed to alloc bulk xfer\n",
! 207: sc->sc_dev.dv_xname);
! 208: goto fail;
! 209: }
! 210: #endif
! 211:
! 212: memset(sc->sc_fifo, 0xff, sizeof(sc->sc_fifo));
! 213:
! 214: /* Reset device */
! 215: uow_reset(sc);
! 216:
! 217: /* Attach 1-Wire bus */
! 218: sc->sc_ow_bus.bus_cookie = sc;
! 219: sc->sc_ow_bus.bus_reset = uow_ow_reset;
! 220: sc->sc_ow_bus.bus_bit = uow_ow_bit;
! 221: sc->sc_ow_bus.bus_read_byte = uow_ow_read_byte;
! 222: sc->sc_ow_bus.bus_write_byte = uow_ow_write_byte;
! 223: sc->sc_ow_bus.bus_read_block = uow_ow_read_block;
! 224: sc->sc_ow_bus.bus_write_block = uow_ow_write_block;
! 225: sc->sc_ow_bus.bus_matchrom = uow_ow_matchrom;
! 226: sc->sc_ow_bus.bus_search = uow_ow_search;
! 227:
! 228: bzero(&oba, sizeof(oba));
! 229: oba.oba_bus = &sc->sc_ow_bus;
! 230: sc->sc_ow_dev = config_found(self, &oba, onewirebus_print);
! 231:
! 232: return;
! 233:
! 234: fail:
! 235: if (sc->sc_ph_ibulk != NULL)
! 236: usbd_close_pipe(sc->sc_ph_ibulk);
! 237: if (sc->sc_ph_obulk != NULL)
! 238: usbd_close_pipe(sc->sc_ph_obulk);
! 239: if (sc->sc_ph_intr != NULL)
! 240: usbd_close_pipe(sc->sc_ph_intr);
! 241: if (sc->sc_xfer != NULL)
! 242: usbd_free_xfer(sc->sc_xfer);
! 243: }
! 244:
! 245: int
! 246: uow_detach(struct device *self, int flags)
! 247: {
! 248: struct uow_softc *sc = (struct uow_softc *)self;
! 249: int rv = 0, s;
! 250:
! 251: s = splusb();
! 252:
! 253: if (sc->sc_ph_ibulk != NULL) {
! 254: usbd_abort_pipe(sc->sc_ph_ibulk);
! 255: usbd_close_pipe(sc->sc_ph_ibulk);
! 256: }
! 257: if (sc->sc_ph_obulk != NULL) {
! 258: usbd_abort_pipe(sc->sc_ph_obulk);
! 259: usbd_close_pipe(sc->sc_ph_obulk);
! 260: }
! 261: if (sc->sc_ph_intr != NULL) {
! 262: usbd_abort_pipe(sc->sc_ph_intr);
! 263: usbd_close_pipe(sc->sc_ph_intr);
! 264: }
! 265:
! 266: if (sc->sc_xfer != NULL)
! 267: usbd_free_xfer(sc->sc_xfer);
! 268:
! 269: if (sc->sc_ow_dev != NULL)
! 270: rv = config_detach(sc->sc_ow_dev, flags);
! 271:
! 272: splx(s);
! 273:
! 274: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 275: &sc->sc_dev);
! 276:
! 277: return (rv);
! 278: }
! 279:
! 280: int
! 281: uow_activate(struct device *self, enum devact act)
! 282: {
! 283: struct uow_softc *sc = (struct uow_softc *)self;
! 284: int rv = 0;
! 285:
! 286: switch (act) {
! 287: case DVACT_ACTIVATE:
! 288: break;
! 289: case DVACT_DEACTIVATE:
! 290: if (sc->sc_ow_dev != NULL)
! 291: rv = config_deactivate(sc->sc_ow_dev);
! 292: break;
! 293: }
! 294:
! 295: return (rv);
! 296: }
! 297:
! 298: int
! 299: uow_ow_reset(void *arg)
! 300: {
! 301: struct uow_softc *sc = arg;
! 302:
! 303: if (uow_commcmd(sc, DS2490_COMM_1WIRE_RESET | DS2490_BIT_IM, 0) != 0)
! 304: return (1);
! 305:
! 306: /* XXX: check presence pulse */
! 307: return (0);
! 308: }
! 309:
! 310: int
! 311: uow_ow_bit(void *arg, int value)
! 312: {
! 313: struct uow_softc *sc = arg;
! 314: u_int8_t data;
! 315:
! 316: if (uow_commcmd(sc, DS2490_COMM_BIT_IO | DS2490_BIT_IM |
! 317: (value ? DS2490_BIT_D : 0), 0) != 0)
! 318: return (1);
! 319: if (uow_read(sc, &data, 1) != 1)
! 320: return (1);
! 321:
! 322: return (data);
! 323: }
! 324:
! 325: int
! 326: uow_ow_read_byte(void *arg)
! 327: {
! 328: struct uow_softc *sc = arg;
! 329: u_int8_t data;
! 330:
! 331: if (uow_commcmd(sc, DS2490_COMM_BYTE_IO | DS2490_BIT_IM, 0xff) != 0)
! 332: return (-1);
! 333: if (uow_read(sc, &data, 1) != 1)
! 334: return (-1);
! 335:
! 336: return (data);
! 337: }
! 338:
! 339: void
! 340: uow_ow_write_byte(void *arg, int value)
! 341: {
! 342: struct uow_softc *sc = arg;
! 343: u_int8_t data;
! 344:
! 345: if (uow_commcmd(sc, DS2490_COMM_BYTE_IO | DS2490_BIT_IM, value) != 0)
! 346: return;
! 347: uow_read(sc, &data, sizeof(data));
! 348: }
! 349:
! 350: void
! 351: uow_ow_read_block(void *arg, void *buf, int len)
! 352: {
! 353: struct uow_softc *sc = arg;
! 354:
! 355: if (uow_write(sc, sc->sc_fifo, len) != 0)
! 356: return;
! 357: if (uow_commcmd(sc, DS2490_COMM_BLOCK_IO | DS2490_BIT_IM, len) != 0)
! 358: return;
! 359: uow_read(sc, buf, len);
! 360: }
! 361:
! 362: void
! 363: uow_ow_write_block(void *arg, const void *buf, int len)
! 364: {
! 365: struct uow_softc *sc = arg;
! 366:
! 367: if (uow_write(sc, buf, len) != 0)
! 368: return;
! 369: if (uow_commcmd(sc, DS2490_COMM_BLOCK_IO | DS2490_BIT_IM, len) != 0)
! 370: return;
! 371: }
! 372:
! 373: void
! 374: uow_ow_matchrom(void *arg, u_int64_t rom)
! 375: {
! 376: struct uow_softc *sc = arg;
! 377: u_int8_t data[8];
! 378: int i;
! 379:
! 380: for (i = 0; i < 8; i++)
! 381: data[i] = (rom >> (i * 8)) & 0xff;
! 382:
! 383: if (uow_write(sc, data, 8) != 0)
! 384: return;
! 385: if (uow_commcmd(sc, DS2490_COMM_MATCH_ACCESS | DS2490_BIT_IM,
! 386: ONEWIRE_CMD_MATCH_ROM) != 0)
! 387: return;
! 388: }
! 389:
! 390: int
! 391: uow_ow_search(void *arg, u_int64_t *buf, int size, u_int64_t startrom)
! 392: {
! 393: struct uow_softc *sc = arg;
! 394: u_int8_t data[8];
! 395: int i, rv;
! 396:
! 397: for (i = 0; i < 8; i++)
! 398: data[i] = (startrom >> (i * 8)) & 0xff;
! 399:
! 400: if (uow_write(sc, data, 8) != 0)
! 401: return (-1);
! 402: if (uow_commcmd(sc, DS2490_COMM_SEARCH_ACCESS | DS2490_BIT_IM |
! 403: DS2490_BIT_SM | DS2490_BIT_RST | DS2490_BIT_F, size << 8 |
! 404: ONEWIRE_CMD_SEARCH_ROM) != 0)
! 405: return (-1);
! 406:
! 407: if ((rv = uow_read(sc, buf, size * 8)) == -1)
! 408: return (-1);
! 409:
! 410: return (rv / 8);
! 411: }
! 412:
! 413: int
! 414: uow_cmd(struct uow_softc *sc, int type, int cmd, int param)
! 415: {
! 416: usb_device_request_t req;
! 417: usbd_status error;
! 418:
! 419: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
! 420: req.bRequest = type;
! 421: USETW(req.wValue, cmd);
! 422: USETW(req.wIndex, param);
! 423: USETW(req.wLength, 0);
! 424: if ((error = usbd_do_request(sc->sc_udev, &req, NULL)) != 0) {
! 425: printf("%s: cmd failed, type 0x%02x, cmd 0x%04x, "
! 426: "param 0x%04x: %s\n", sc->sc_dev.dv_xname, type, cmd,
! 427: param, usbd_errstr(error));
! 428: if (cmd != DS2490_CTL_RESET_DEVICE)
! 429: uow_reset(sc);
! 430: return (1);
! 431: }
! 432:
! 433: again:
! 434: if (tsleep(sc->sc_regs, PRIBIO, "uowcmd",
! 435: (UOW_TIMEOUT * hz) / 1000) != 0) {
! 436: printf("%s: cmd timeout, type 0x%02x, cmd 0x%04x, "
! 437: "param 0x%04x\n", sc->sc_dev.dv_xname, type, cmd,
! 438: param);
! 439: return (1);
! 440: }
! 441: if ((sc->sc_regs[DS2490_ST_STFL] & DS2490_ST_STFL_IDLE) == 0)
! 442: goto again;
! 443:
! 444: return (0);
! 445: }
! 446:
! 447: void
! 448: uow_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 449: {
! 450: struct uow_softc *sc = priv;
! 451:
! 452: if (status != USBD_NORMAL_COMPLETION) {
! 453: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 454: return;
! 455: if (status == USBD_STALLED)
! 456: usbd_clear_endpoint_stall_async(sc->sc_ph_intr);
! 457: return;
! 458: }
! 459:
! 460: wakeup(sc->sc_regs);
! 461: }
! 462:
! 463: int
! 464: uow_read(struct uow_softc *sc, void *buf, int len)
! 465: {
! 466: usbd_status error;
! 467: int count;
! 468:
! 469: /* XXX: implement FIFO status monitoring */
! 470: if (len > DS2490_DATAFIFOSIZE) {
! 471: printf("%s: read %d bytes, xfer too big\n",
! 472: sc->sc_dev.dv_xname, len);
! 473: return (-1);
! 474: }
! 475:
! 476: if ((sc->sc_xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 477: printf("%s: failed to alloc xfer\n", sc->sc_dev.dv_xname);
! 478: return (-1);
! 479: }
! 480: usbd_setup_xfer(sc->sc_xfer, sc->sc_ph_ibulk, sc, buf, len,
! 481: USBD_SHORT_XFER_OK, UOW_TIMEOUT, NULL);
! 482: error = usbd_sync_transfer(sc->sc_xfer);
! 483: usbd_free_xfer(sc->sc_xfer);
! 484: if (error != 0) {
! 485: printf("%s: read failed, len %d: %s\n",
! 486: sc->sc_dev.dv_xname, len, usbd_errstr(error));
! 487: uow_reset(sc);
! 488: return (-1);
! 489: }
! 490:
! 491: usbd_get_xfer_status(sc->sc_xfer, NULL, NULL, &count, &error);
! 492: return (count);
! 493: }
! 494:
! 495: int
! 496: uow_write(struct uow_softc *sc, const void *buf, int len)
! 497: {
! 498: usbd_status error;
! 499:
! 500: /* XXX: implement FIFO status monitoring */
! 501: if (len > DS2490_DATAFIFOSIZE) {
! 502: printf("%s: write %d bytes, xfer too big\n",
! 503: sc->sc_dev.dv_xname, len);
! 504: return (1);
! 505: }
! 506:
! 507: if ((sc->sc_xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 508: printf("%s: failed to alloc xfer\n", sc->sc_dev.dv_xname);
! 509: return (-1);
! 510: }
! 511: usbd_setup_xfer(sc->sc_xfer, sc->sc_ph_obulk, sc, (void *)buf, len, 0,
! 512: UOW_TIMEOUT, NULL);
! 513: error = usbd_sync_transfer(sc->sc_xfer);
! 514: usbd_free_xfer(sc->sc_xfer);
! 515: if (error != 0) {
! 516: printf("%s: write failed, len %d: %s\n",
! 517: sc->sc_dev.dv_xname, len, usbd_errstr(error));
! 518: uow_reset(sc);
! 519: return (1);
! 520: }
! 521:
! 522: return (0);
! 523: }
! 524:
! 525: int
! 526: uow_reset(struct uow_softc *sc)
! 527: {
! 528: return (uow_ctlcmd(sc, DS2490_CTL_RESET_DEVICE, 0));
! 529: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to uow.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb