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