1 /*- 2 * SPDX-License-Identifier: BSD-4-Clause 3 * 4 * Copyright (c) 2003 Hidetoshi Shimokawa 5 * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the acknowledgement as bellow: 18 * 19 * This product includes software developed by K. Kobayashi and H. Shimokawa 20 * 21 * 4. The name of the author may not be used to endorse or promote products 22 * derived from this software without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 26 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 27 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 28 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 32 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 33 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 * 36 */ 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/types.h> 41 #include <sys/mbuf.h> 42 #include <sys/bio.h> 43 44 #include <sys/kernel.h> 45 #include <sys/malloc.h> 46 #include <sys/conf.h> 47 #include <sys/poll.h> 48 49 #include <sys/bus.h> 50 #include <sys/ctype.h> 51 #include <machine/bus.h> 52 53 #include <sys/ioccom.h> 54 55 #include <dev/firewire/firewire.h> 56 #include <dev/firewire/firewirereg.h> 57 #include <dev/firewire/fwdma.h> 58 #include <dev/firewire/fwmem.h> 59 #include <dev/firewire/iec68113.h> 60 61 #define FWNODE_INVAL 0xffff 62 63 static d_open_t fw_open; 64 static d_close_t fw_close; 65 static d_ioctl_t fw_ioctl; 66 static d_poll_t fw_poll; 67 static d_read_t fw_read; /* for Isochronous packet */ 68 static d_write_t fw_write; 69 static d_mmap_t fw_mmap; 70 static d_strategy_t fw_strategy; 71 72 struct cdevsw firewire_cdevsw = { 73 .d_version = D_VERSION, 74 .d_open = fw_open, 75 .d_close = fw_close, 76 .d_read = fw_read, 77 .d_write = fw_write, 78 .d_ioctl = fw_ioctl, 79 .d_poll = fw_poll, 80 .d_mmap = fw_mmap, 81 .d_strategy = fw_strategy, 82 .d_name = "fw", 83 }; 84 85 struct fw_drv1 { 86 struct firewire_comm *fc; 87 struct fw_xferq *ir; 88 struct fw_xferq *it; 89 struct fw_isobufreq bufreq; 90 STAILQ_HEAD(, fw_bind) binds; 91 STAILQ_HEAD(, fw_xfer) rq; 92 }; 93 94 static int 95 fwdev_allocbuf(struct firewire_comm *fc, struct fw_xferq *q, 96 struct fw_bufspec *b) 97 { 98 int i; 99 100 if (q->flag & (FWXFERQ_RUNNING | FWXFERQ_EXTBUF)) 101 return (EBUSY); 102 103 q->bulkxfer = malloc(sizeof(struct fw_bulkxfer) * b->nchunk, 104 M_FW, M_WAITOK); 105 106 b->psize = roundup2(b->psize, sizeof(uint32_t)); 107 q->buf = fwdma_malloc_multiseg(fc, sizeof(uint32_t), 108 b->psize, b->nchunk * b->npacket, BUS_DMA_WAITOK); 109 110 if (q->buf == NULL) { 111 free(q->bulkxfer, M_FW); 112 q->bulkxfer = NULL; 113 return (ENOMEM); 114 } 115 q->bnchunk = b->nchunk; 116 q->bnpacket = b->npacket; 117 q->psize = (b->psize + 3) & ~3; 118 q->queued = 0; 119 120 STAILQ_INIT(&q->stvalid); 121 STAILQ_INIT(&q->stfree); 122 STAILQ_INIT(&q->stdma); 123 q->stproc = NULL; 124 125 for (i = 0; i < q->bnchunk; i++) { 126 q->bulkxfer[i].poffset = i * q->bnpacket; 127 q->bulkxfer[i].mbuf = NULL; 128 STAILQ_INSERT_TAIL(&q->stfree, &q->bulkxfer[i], link); 129 } 130 131 q->flag &= ~FWXFERQ_MODEMASK; 132 q->flag |= FWXFERQ_STREAM; 133 q->flag |= FWXFERQ_EXTBUF; 134 135 return (0); 136 } 137 138 static int 139 fwdev_freebuf(struct fw_xferq *q) 140 { 141 if (q->flag & FWXFERQ_EXTBUF) { 142 if (q->buf != NULL) 143 fwdma_free_multiseg(q->buf); 144 q->buf = NULL; 145 free(q->bulkxfer, M_FW); 146 q->bulkxfer = NULL; 147 q->flag &= ~FWXFERQ_EXTBUF; 148 q->psize = 0; 149 q->maxq = FWMAXQUEUE; 150 } 151 return (0); 152 } 153 154 155 static int 156 fw_open(struct cdev *dev, int flags, int fmt, fw_proc *td) 157 { 158 int err = 0; 159 int unit = DEV2UNIT(dev); 160 struct fw_drv1 *d; 161 struct firewire_softc *sc; 162 163 if (DEV_FWMEM(dev)) 164 return fwmem_open(dev, flags, fmt, td); 165 166 sc = devclass_get_softc(firewire_devclass, unit); 167 if (sc == NULL) 168 return (ENXIO); 169 170 FW_GLOCK(sc->fc); 171 if (dev->si_drv1 != NULL) { 172 FW_GUNLOCK(sc->fc); 173 return (EBUSY); 174 } 175 /* set dummy value for allocation */ 176 dev->si_drv1 = (void *)-1; 177 FW_GUNLOCK(sc->fc); 178 179 dev->si_drv1 = malloc(sizeof(struct fw_drv1), M_FW, M_WAITOK | M_ZERO); 180 181 if ((dev->si_flags & SI_NAMED) == 0) { 182 int unit = DEV2UNIT(dev); 183 int sub = DEV2SUB(dev); 184 185 make_dev(&firewire_cdevsw, dev2unit(dev), 186 UID_ROOT, GID_OPERATOR, 0660, "fw%d.%d", unit, sub); 187 } 188 189 d = dev->si_drv1; 190 d->fc = sc->fc; 191 STAILQ_INIT(&d->binds); 192 STAILQ_INIT(&d->rq); 193 194 return err; 195 } 196 197 static int 198 fw_close(struct cdev *dev, int flags, int fmt, fw_proc *td) 199 { 200 struct firewire_comm *fc; 201 struct fw_drv1 *d; 202 struct fw_xfer *xfer; 203 struct fw_bind *fwb; 204 int err = 0; 205 206 if (DEV_FWMEM(dev)) 207 return fwmem_close(dev, flags, fmt, td); 208 209 d = dev->si_drv1; 210 fc = d->fc; 211 212 /* remove binding */ 213 for (fwb = STAILQ_FIRST(&d->binds); fwb != NULL; 214 fwb = STAILQ_FIRST(&d->binds)) { 215 fw_bindremove(fc, fwb); 216 STAILQ_REMOVE_HEAD(&d->binds, chlist); 217 fw_xferlist_remove(&fwb->xferlist); 218 free(fwb, M_FW); 219 } 220 if (d->ir != NULL) { 221 struct fw_xferq *ir = d->ir; 222 223 if ((ir->flag & FWXFERQ_OPEN) == 0) 224 return (EINVAL); 225 if (ir->flag & FWXFERQ_RUNNING) { 226 ir->flag &= ~FWXFERQ_RUNNING; 227 fc->irx_disable(fc, ir->dmach); 228 } 229 /* free extbuf */ 230 fwdev_freebuf(ir); 231 /* drain receiving buffer */ 232 for (xfer = STAILQ_FIRST(&ir->q); 233 xfer != NULL; xfer = STAILQ_FIRST(&ir->q)) { 234 ir->queued--; 235 STAILQ_REMOVE_HEAD(&ir->q, link); 236 237 xfer->resp = 0; 238 fw_xfer_done(xfer); 239 } 240 ir->flag &= ~(FWXFERQ_OPEN | FWXFERQ_MODEMASK | 241 FWXFERQ_CHTAGMASK); 242 d->ir = NULL; 243 244 } 245 if (d->it != NULL) { 246 struct fw_xferq *it = d->it; 247 248 if ((it->flag & FWXFERQ_OPEN) == 0) 249 return (EINVAL); 250 if (it->flag & FWXFERQ_RUNNING) { 251 it->flag &= ~FWXFERQ_RUNNING; 252 fc->itx_disable(fc, it->dmach); 253 } 254 /* free extbuf */ 255 fwdev_freebuf(it); 256 it->flag &= ~(FWXFERQ_OPEN | 257 FWXFERQ_MODEMASK | FWXFERQ_CHTAGMASK); 258 d->it = NULL; 259 } 260 free(dev->si_drv1, M_FW); 261 dev->si_drv1 = NULL; 262 263 return err; 264 } 265 266 static int 267 fw_read_async(struct fw_drv1 *d, struct uio *uio, int ioflag) 268 { 269 int err = 0; 270 struct fw_xfer *xfer; 271 struct fw_bind *fwb; 272 struct fw_pkt *fp; 273 struct tcode_info *tinfo; 274 275 FW_GLOCK(d->fc); 276 while ((xfer = STAILQ_FIRST(&d->rq)) == NULL && err == 0) 277 err = msleep(&d->rq, FW_GMTX(d->fc), FWPRI, "fwra", 0); 278 279 if (err != 0) { 280 FW_GUNLOCK(d->fc); 281 return (err); 282 } 283 284 STAILQ_REMOVE_HEAD(&d->rq, link); 285 FW_GUNLOCK(xfer->fc); 286 fp = &xfer->recv.hdr; 287 #if 0 /* for GASP ?? */ 288 if (fc->irx_post != NULL) 289 fc->irx_post(fc, fp->mode.ld); 290 #endif 291 tinfo = &xfer->fc->tcode[fp->mode.hdr.tcode]; 292 err = uiomove(fp, tinfo->hdr_len, uio); 293 if (err) 294 goto out; 295 err = uiomove(xfer->recv.payload, xfer->recv.pay_len, uio); 296 297 out: 298 /* recycle this xfer */ 299 fwb = (struct fw_bind *)xfer->sc; 300 fw_xfer_unload(xfer); 301 xfer->recv.pay_len = PAGE_SIZE; 302 FW_GLOCK(xfer->fc); 303 STAILQ_INSERT_TAIL(&fwb->xferlist, xfer, link); 304 FW_GUNLOCK(xfer->fc); 305 return (err); 306 } 307 308 /* 309 * read request. 310 */ 311 static int 312 fw_read(struct cdev *dev, struct uio *uio, int ioflag) 313 { 314 struct fw_drv1 *d; 315 struct fw_xferq *ir; 316 struct firewire_comm *fc; 317 int err = 0, slept = 0; 318 struct fw_pkt *fp; 319 320 if (DEV_FWMEM(dev)) 321 return (physio(dev, uio, ioflag)); 322 323 d = dev->si_drv1; 324 fc = d->fc; 325 ir = d->ir; 326 327 if (ir == NULL) 328 return (fw_read_async(d, uio, ioflag)); 329 330 if (ir->buf == NULL) 331 return (EIO); 332 333 FW_GLOCK(fc); 334 readloop: 335 if (ir->stproc == NULL) { 336 /* iso bulkxfer */ 337 ir->stproc = STAILQ_FIRST(&ir->stvalid); 338 if (ir->stproc != NULL) { 339 STAILQ_REMOVE_HEAD(&ir->stvalid, link); 340 ir->queued = 0; 341 } 342 } 343 if (ir->stproc == NULL) { 344 /* no data available */ 345 if (slept == 0) { 346 slept = 1; 347 ir->flag |= FWXFERQ_WAKEUP; 348 err = msleep(ir, FW_GMTX(fc), FWPRI, "fw_read", hz); 349 ir->flag &= ~FWXFERQ_WAKEUP; 350 if (err == 0) 351 goto readloop; 352 } else if (slept == 1) 353 err = EIO; 354 FW_GUNLOCK(fc); 355 return err; 356 } else if (ir->stproc != NULL) { 357 /* iso bulkxfer */ 358 FW_GUNLOCK(fc); 359 fp = (struct fw_pkt *)fwdma_v_addr(ir->buf, 360 ir->stproc->poffset + ir->queued); 361 if (fc->irx_post != NULL) 362 fc->irx_post(fc, fp->mode.ld); 363 if (fp->mode.stream.len == 0) { 364 err = EIO; 365 return err; 366 } 367 err = uiomove((caddr_t)fp, 368 fp->mode.stream.len + sizeof(uint32_t), uio); 369 ir->queued++; 370 if (ir->queued >= ir->bnpacket) { 371 STAILQ_INSERT_TAIL(&ir->stfree, ir->stproc, link); 372 fc->irx_enable(fc, ir->dmach); 373 ir->stproc = NULL; 374 } 375 if (uio->uio_resid >= ir->psize) { 376 slept = -1; 377 FW_GLOCK(fc); 378 goto readloop; 379 } 380 } 381 return err; 382 } 383 384 static int 385 fw_write_async(struct fw_drv1 *d, struct uio *uio, int ioflag) 386 { 387 struct fw_xfer *xfer; 388 struct fw_pkt pkt; 389 struct tcode_info *tinfo; 390 int err; 391 392 bzero(&pkt, sizeof(struct fw_pkt)); 393 if ((err = uiomove((caddr_t)&pkt, sizeof(uint32_t), uio))) 394 return (err); 395 tinfo = &d->fc->tcode[pkt.mode.hdr.tcode]; 396 if ((err = uiomove((caddr_t)&pkt + sizeof(uint32_t), 397 tinfo->hdr_len - sizeof(uint32_t), uio))) 398 return (err); 399 400 if ((xfer = fw_xfer_alloc_buf(M_FWXFER, uio->uio_resid, 401 PAGE_SIZE/*XXX*/)) == NULL) 402 return (ENOMEM); 403 404 bcopy(&pkt, &xfer->send.hdr, sizeof(struct fw_pkt)); 405 xfer->send.pay_len = uio->uio_resid; 406 if (uio->uio_resid > 0) { 407 if ((err = uiomove((caddr_t)&xfer->send.payload[0], 408 uio->uio_resid, uio))) 409 goto out; 410 } 411 412 xfer->fc = d->fc; 413 xfer->sc = NULL; 414 xfer->hand = fw_xferwake; 415 xfer->send.spd = 2 /* XXX */; 416 417 if ((err = fw_asyreq(xfer->fc, -1, xfer))) 418 goto out; 419 420 if ((err = fw_xferwait(xfer))) 421 goto out; 422 423 if (xfer->resp != 0) { 424 err = xfer->resp; 425 goto out; 426 } 427 428 if (xfer->flag & FWXF_RCVD) { 429 FW_GLOCK(xfer->fc); 430 STAILQ_INSERT_TAIL(&d->rq, xfer, link); 431 FW_GUNLOCK(xfer->fc); 432 return (0); 433 } 434 435 out: 436 fw_xfer_free(xfer); 437 return (err); 438 } 439 440 static int 441 fw_write(struct cdev *dev, struct uio *uio, int ioflag) 442 { 443 int err = 0; 444 int slept = 0; 445 struct fw_drv1 *d; 446 struct fw_pkt *fp; 447 struct firewire_comm *fc; 448 struct fw_xferq *it; 449 450 if (DEV_FWMEM(dev)) 451 return (physio(dev, uio, ioflag)); 452 453 d = dev->si_drv1; 454 fc = d->fc; 455 it = d->it; 456 457 if (it == NULL) 458 return (fw_write_async(d, uio, ioflag)); 459 460 if (it->buf == NULL) 461 return (EIO); 462 463 FW_GLOCK(fc); 464 isoloop: 465 if (it->stproc == NULL) { 466 it->stproc = STAILQ_FIRST(&it->stfree); 467 if (it->stproc != NULL) { 468 STAILQ_REMOVE_HEAD(&it->stfree, link); 469 it->queued = 0; 470 } else if (slept == 0) { 471 slept = 1; 472 #if 0 /* XXX to avoid lock recursion */ 473 err = fc->itx_enable(fc, it->dmach); 474 if (err) 475 goto out; 476 #endif 477 err = msleep(it, FW_GMTX(fc), FWPRI, "fw_write", hz); 478 if (err) 479 goto out; 480 goto isoloop; 481 } else { 482 err = EIO; 483 goto out; 484 } 485 } 486 FW_GUNLOCK(fc); 487 fp = (struct fw_pkt *)fwdma_v_addr(it->buf, 488 it->stproc->poffset + it->queued); 489 err = uiomove((caddr_t)fp, sizeof(struct fw_isohdr), uio); 490 err = uiomove((caddr_t)fp->mode.stream.payload, 491 fp->mode.stream.len, uio); 492 it->queued++; 493 if (it->queued >= it->bnpacket) { 494 STAILQ_INSERT_TAIL(&it->stvalid, it->stproc, link); 495 it->stproc = NULL; 496 err = fc->itx_enable(fc, it->dmach); 497 } 498 if (uio->uio_resid >= sizeof(struct fw_isohdr)) { 499 slept = 0; 500 FW_GLOCK(fc); 501 goto isoloop; 502 } 503 return err; 504 505 out: 506 FW_GUNLOCK(fc); 507 return err; 508 } 509 510 static void 511 fw_hand(struct fw_xfer *xfer) 512 { 513 struct fw_bind *fwb; 514 struct fw_drv1 *d; 515 516 fwb = (struct fw_bind *)xfer->sc; 517 d = fwb->sc; 518 FW_GLOCK(xfer->fc); 519 STAILQ_INSERT_TAIL(&d->rq, xfer, link); 520 FW_GUNLOCK(xfer->fc); 521 wakeup(&d->rq); 522 } 523 524 /* 525 * ioctl support. 526 */ 527 int 528 fw_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, fw_proc *td) 529 { 530 struct firewire_comm *fc; 531 struct fw_drv1 *d; 532 int i, len, err = 0; 533 struct fw_device *fwdev; 534 struct fw_bind *fwb; 535 struct fw_xferq *ir, *it; 536 struct fw_xfer *xfer; 537 struct fw_pkt *fp; 538 struct fw_devinfo *devinfo; 539 void *ptr; 540 541 struct fw_devlstreq *fwdevlst = (struct fw_devlstreq *)data; 542 struct fw_asyreq *asyreq = (struct fw_asyreq *)data; 543 struct fw_isochreq *ichreq = (struct fw_isochreq *)data; 544 struct fw_isobufreq *ibufreq = (struct fw_isobufreq *)data; 545 struct fw_asybindreq *bindreq = (struct fw_asybindreq *)data; 546 struct fw_crom_buf *crom_buf = (struct fw_crom_buf *)data; 547 548 if (DEV_FWMEM(dev)) 549 return fwmem_ioctl(dev, cmd, data, flag, td); 550 551 if (!data) 552 return (EINVAL); 553 554 d = dev->si_drv1; 555 fc = d->fc; 556 ir = d->ir; 557 it = d->it; 558 559 switch (cmd) { 560 case FW_STSTREAM: 561 if (it == NULL) { 562 i = fw_open_isodma(fc, /* tx */1); 563 if (i < 0) { 564 err = EBUSY; 565 break; 566 } 567 it = fc->it[i]; 568 err = fwdev_allocbuf(fc, it, &d->bufreq.tx); 569 if (err) { 570 it->flag &= ~FWXFERQ_OPEN; 571 break; 572 } 573 } 574 it->flag &= ~0xff; 575 it->flag |= (0x3f & ichreq->ch); 576 it->flag |= ((0x3 & ichreq->tag) << 6); 577 d->it = it; 578 break; 579 case FW_GTSTREAM: 580 if (it != NULL) { 581 ichreq->ch = it->flag & 0x3f; 582 ichreq->tag = it->flag >> 2 & 0x3; 583 } else 584 err = EINVAL; 585 break; 586 case FW_SRSTREAM: 587 if (ir == NULL) { 588 i = fw_open_isodma(fc, /* tx */0); 589 if (i < 0) { 590 err = EBUSY; 591 break; 592 } 593 ir = fc->ir[i]; 594 err = fwdev_allocbuf(fc, ir, &d->bufreq.rx); 595 if (err) { 596 ir->flag &= ~FWXFERQ_OPEN; 597 break; 598 } 599 } 600 ir->flag &= ~0xff; 601 ir->flag |= (0x3f & ichreq->ch); 602 ir->flag |= ((0x3 & ichreq->tag) << 6); 603 d->ir = ir; 604 err = fc->irx_enable(fc, ir->dmach); 605 break; 606 case FW_GRSTREAM: 607 if (d->ir != NULL) { 608 ichreq->ch = ir->flag & 0x3f; 609 ichreq->tag = ir->flag >> 2 & 0x3; 610 } else 611 err = EINVAL; 612 break; 613 case FW_SSTBUF: 614 bcopy(ibufreq, &d->bufreq, sizeof(d->bufreq)); 615 break; 616 case FW_GSTBUF: 617 bzero(&ibufreq->rx, sizeof(ibufreq->rx)); 618 if (ir != NULL) { 619 ibufreq->rx.nchunk = ir->bnchunk; 620 ibufreq->rx.npacket = ir->bnpacket; 621 ibufreq->rx.psize = ir->psize; 622 } 623 bzero(&ibufreq->tx, sizeof(ibufreq->tx)); 624 if (it != NULL) { 625 ibufreq->tx.nchunk = it->bnchunk; 626 ibufreq->tx.npacket = it->bnpacket; 627 ibufreq->tx.psize = it->psize; 628 } 629 break; 630 case FW_ASYREQ: 631 { 632 struct tcode_info *tinfo; 633 int pay_len = 0; 634 635 fp = &asyreq->pkt; 636 tinfo = &fc->tcode[fp->mode.hdr.tcode]; 637 638 if ((tinfo->flag & FWTI_BLOCK_ASY) != 0) 639 pay_len = MAX(0, asyreq->req.len - tinfo->hdr_len); 640 641 xfer = fw_xfer_alloc_buf(M_FWXFER, pay_len, PAGE_SIZE/*XXX*/); 642 if (xfer == NULL) 643 return (ENOMEM); 644 645 switch (asyreq->req.type) { 646 case FWASREQNODE: 647 break; 648 case FWASREQEUI: 649 fwdev = fw_noderesolve_eui64(fc, 650 &asyreq->req.dst.eui); 651 if (fwdev == NULL) { 652 device_printf(fc->bdev, 653 "cannot find node\n"); 654 err = EINVAL; 655 goto out; 656 } 657 fp->mode.hdr.dst = FWLOCALBUS | fwdev->dst; 658 break; 659 case FWASRESTL: 660 /* XXX what's this? */ 661 break; 662 case FWASREQSTREAM: 663 /* nothing to do */ 664 break; 665 } 666 667 bcopy(fp, (void *)&xfer->send.hdr, tinfo->hdr_len); 668 if (pay_len > 0) 669 bcopy((char *)fp + tinfo->hdr_len, 670 xfer->send.payload, pay_len); 671 xfer->send.spd = asyreq->req.sped; 672 xfer->hand = fw_xferwake; 673 674 if ((err = fw_asyreq(fc, -1, xfer)) != 0) 675 goto out; 676 if ((err = fw_xferwait(xfer)) != 0) 677 goto out; 678 if (xfer->resp != 0) { 679 err = EIO; 680 goto out; 681 } 682 if ((tinfo->flag & FWTI_TLABEL) == 0) 683 goto out; 684 685 /* copy response */ 686 tinfo = &fc->tcode[xfer->recv.hdr.mode.hdr.tcode]; 687 if (xfer->recv.hdr.mode.hdr.tcode == FWTCODE_RRESB || 688 xfer->recv.hdr.mode.hdr.tcode == FWTCODE_LRES) { 689 pay_len = xfer->recv.pay_len; 690 if (asyreq->req.len >= xfer->recv.pay_len + tinfo->hdr_len) { 691 asyreq->req.len = xfer->recv.pay_len + 692 tinfo->hdr_len; 693 } else { 694 err = EINVAL; 695 pay_len = 0; 696 } 697 } else { 698 pay_len = 0; 699 } 700 bcopy(&xfer->recv.hdr, fp, tinfo->hdr_len); 701 bcopy(xfer->recv.payload, (char *)fp + tinfo->hdr_len, pay_len); 702 out: 703 fw_xfer_free_buf(xfer); 704 break; 705 } 706 case FW_IBUSRST: 707 fc->ibr(fc); 708 break; 709 case FW_CBINDADDR: 710 fwb = fw_bindlookup(fc, 711 bindreq->start.hi, bindreq->start.lo); 712 if (fwb == NULL) { 713 err = EINVAL; 714 break; 715 } 716 fw_bindremove(fc, fwb); 717 STAILQ_REMOVE(&d->binds, fwb, fw_bind, chlist); 718 fw_xferlist_remove(&fwb->xferlist); 719 free(fwb, M_FW); 720 break; 721 case FW_SBINDADDR: 722 if (bindreq->len <= 0) { 723 err = EINVAL; 724 break; 725 } 726 if (bindreq->start.hi > 0xffff) { 727 err = EINVAL; 728 break; 729 } 730 fwb = malloc(sizeof(struct fw_bind), M_FW, M_WAITOK); 731 fwb->start = ((u_int64_t)bindreq->start.hi << 32) | 732 bindreq->start.lo; 733 fwb->end = fwb->start + bindreq->len; 734 fwb->sc = d; 735 STAILQ_INIT(&fwb->xferlist); 736 err = fw_bindadd(fc, fwb); 737 if (err == 0) { 738 fw_xferlist_add(&fwb->xferlist, M_FWXFER, 739 /* XXX */ 740 PAGE_SIZE, PAGE_SIZE, 5, 741 fc, fwb, fw_hand); 742 STAILQ_INSERT_TAIL(&d->binds, fwb, chlist); 743 } 744 break; 745 case FW_GDEVLST: 746 i = len = 1; 747 /* myself */ 748 devinfo = &fwdevlst->dev[0]; 749 devinfo->dst = fc->nodeid; 750 devinfo->status = 0; /* XXX */ 751 devinfo->eui.hi = fc->eui.hi; 752 devinfo->eui.lo = fc->eui.lo; 753 STAILQ_FOREACH(fwdev, &fc->devices, link) { 754 if (len < FW_MAX_DEVLST) { 755 devinfo = &fwdevlst->dev[len++]; 756 devinfo->dst = fwdev->dst; 757 devinfo->status = 758 (fwdev->status == FWDEVINVAL) ? 0 : 1; 759 devinfo->eui.hi = fwdev->eui.hi; 760 devinfo->eui.lo = fwdev->eui.lo; 761 } 762 i++; 763 } 764 fwdevlst->n = i; 765 fwdevlst->info_len = len; 766 break; 767 case FW_GTPMAP: 768 bcopy(fc->topology_map, data, 769 (fc->topology_map->crc_len + 1) * 4); 770 break; 771 case FW_GCROM: 772 STAILQ_FOREACH(fwdev, &fc->devices, link) 773 if (FW_EUI64_EQUAL(fwdev->eui, crom_buf->eui)) 774 break; 775 if (fwdev == NULL) { 776 if (!FW_EUI64_EQUAL(fc->eui, crom_buf->eui)) { 777 err = FWNODE_INVAL; 778 break; 779 } 780 /* myself */ 781 ptr = malloc(CROMSIZE, M_FW, M_WAITOK); 782 len = CROMSIZE; 783 for (i = 0; i < CROMSIZE/4; i++) 784 ((uint32_t *)ptr)[i] 785 = ntohl(fc->config_rom[i]); 786 } else { 787 /* found */ 788 ptr = (void *)&fwdev->csrrom[0]; 789 if (fwdev->rommax < CSRROMOFF) 790 len = 0; 791 else 792 len = fwdev->rommax - CSRROMOFF + 4; 793 } 794 if (crom_buf->len < len) 795 len = crom_buf->len; 796 else 797 crom_buf->len = len; 798 err = copyout(ptr, crom_buf->ptr, len); 799 if (fwdev == NULL) 800 /* myself */ 801 free(ptr, M_FW); 802 break; 803 default: 804 fc->ioctl(dev, cmd, data, flag, td); 805 break; 806 } 807 return err; 808 } 809 int 810 fw_poll(struct cdev *dev, int events, fw_proc *td) 811 { 812 struct fw_xferq *ir; 813 int revents; 814 int tmp; 815 816 if (DEV_FWMEM(dev)) 817 return fwmem_poll(dev, events, td); 818 819 ir = ((struct fw_drv1 *)dev->si_drv1)->ir; 820 revents = 0; 821 tmp = POLLIN | POLLRDNORM; 822 if (events & tmp) { 823 if (STAILQ_FIRST(&ir->q) != NULL) 824 revents |= tmp; 825 else 826 selrecord(td, &ir->rsel); 827 } 828 tmp = POLLOUT | POLLWRNORM; 829 if (events & tmp) { 830 /* XXX should be fixed */ 831 revents |= tmp; 832 } 833 834 return revents; 835 } 836 837 static int 838 fw_mmap (struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr, 839 int nproto, vm_memattr_t *memattr) 840 { 841 842 if (DEV_FWMEM(dev)) 843 return fwmem_mmap(dev, offset, paddr, nproto, memattr); 844 845 return EINVAL; 846 } 847 848 static void 849 fw_strategy(struct bio *bp) 850 { 851 struct cdev *dev; 852 853 dev = bp->bio_dev; 854 if (DEV_FWMEM(dev)) { 855 fwmem_strategy(bp); 856 return; 857 } 858 859 bp->bio_error = EOPNOTSUPP; 860 bp->bio_flags |= BIO_ERROR; 861 bp->bio_resid = bp->bio_bcount; 862 biodone(bp); 863 } 864 865 int 866 fwdev_makedev(struct firewire_softc *sc) 867 { 868 int err = 0; 869 870 struct cdev *d; 871 int unit; 872 873 unit = device_get_unit(sc->fc->bdev); 874 sc->dev = make_dev(&firewire_cdevsw, MAKEMINOR(0, unit, 0), 875 UID_ROOT, GID_OPERATOR, 0660, "fw%d.%d", unit, 0); 876 d = make_dev(&firewire_cdevsw, MAKEMINOR(FWMEM_FLAG, unit, 0), 877 UID_ROOT, GID_OPERATOR, 0660, "fwmem%d.%d", unit, 0); 878 dev_depends(sc->dev, d); 879 make_dev_alias(sc->dev, "fw%d", unit); 880 make_dev_alias(d, "fwmem%d", unit); 881 882 return (err); 883 } 884 885 int 886 fwdev_destroydev(struct firewire_softc *sc) 887 { 888 int err = 0; 889 890 destroy_dev(sc->dev); 891 return (err); 892 } 893 894 #define NDEVTYPE 2 895 void 896 fwdev_clone(void *arg, struct ucred *cred, char *name, int namelen, 897 struct cdev **dev) 898 { 899 struct firewire_softc *sc; 900 char *devnames[NDEVTYPE] = {"fw", "fwmem"}; 901 char *subp = NULL; 902 int devflag[NDEVTYPE] = {0, FWMEM_FLAG}; 903 int i, unit = 0, sub = 0; 904 905 if (*dev != NULL) 906 return; 907 908 for (i = 0; i < NDEVTYPE; i++) 909 if (dev_stdclone(name, &subp, devnames[i], &unit) == 2) 910 goto found; 911 /* not match */ 912 return; 913 found: 914 915 if (subp == NULL || *subp++ != '.') 916 return; 917 918 /* /dev/fwU.S */ 919 while (isdigit(*subp)) { 920 sub *= 10; 921 sub += *subp++ - '0'; 922 } 923 if (*subp != '\0') 924 return; 925 926 sc = devclass_get_softc(firewire_devclass, unit); 927 if (sc == NULL) 928 return; 929 *dev = make_dev_credf(MAKEDEV_REF, &firewire_cdevsw, 930 MAKEMINOR(devflag[i], unit, sub), cred, UID_ROOT, GID_OPERATOR, 931 0660, "%s%d.%d", devnames[i], unit, sub); 932 dev_depends(sc->dev, *dev); 933 return; 934 } 935