1 /* 2 * Copyright (c) 2003 Hidetoshi Shimokawa 3 * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the acknowledgement as bellow: 16 * 17 * This product includes software developed by K. Kobayashi and H. Shimokawa 18 * 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 25 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 26 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 27 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 28 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 30 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 31 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 * 34 * $FreeBSD: src/sys/dev/firewire/fwdev.c,v 1.2.4.11 2003/04/28 03:29:18 simokawa Exp $ 35 * 36 */ 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/types.h> 41 #include <sys/mbuf.h> 42 43 #include <sys/kernel.h> 44 #include <sys/malloc.h> 45 #include <sys/conf.h> 46 #include <sys/poll.h> 47 48 #include <sys/bus.h> 49 #include <machine/bus.h> 50 51 #include <sys/ioccom.h> 52 53 #include <dev/firewire/firewire.h> 54 #include <dev/firewire/firewirereg.h> 55 #include <dev/firewire/fwdma.h> 56 #include <dev/firewire/fwmem.h> 57 #include <dev/firewire/iec68113.h> 58 59 #define CDEV_MAJOR 127 60 #define FWNODE_INVAL 0xffff 61 62 static d_open_t fw_open; 63 static d_close_t fw_close; 64 static d_ioctl_t fw_ioctl; 65 static d_poll_t fw_poll; 66 static d_read_t fw_read; /* for Isochronous packet */ 67 static d_write_t fw_write; 68 static d_mmap_t fw_mmap; 69 70 struct cdevsw firewire_cdevsw = 71 { 72 #if __FreeBSD_version >= 500104 73 .d_open = fw_open, 74 .d_close = fw_close, 75 .d_read = fw_read, 76 .d_write = fw_write, 77 .d_ioctl = fw_ioctl, 78 .d_poll = fw_poll, 79 .d_mmap = fw_mmap, 80 .d_name = "fw", 81 .d_maj = CDEV_MAJOR, 82 .d_flags = D_MEM 83 #else 84 fw_open, fw_close, fw_read, fw_write, fw_ioctl, 85 fw_poll, fw_mmap, nostrategy, "fw", CDEV_MAJOR, nodump, nopsize, D_MEM 86 #endif 87 }; 88 89 static int 90 fw_open (dev_t dev, int flags, int fmt, fw_proc *td) 91 { 92 struct firewire_softc *sc; 93 int unit = DEV2UNIT(dev); 94 int sub = DEV2DMACH(dev); 95 96 int err = 0; 97 98 if (DEV_FWMEM(dev)) 99 return fwmem_open(dev, flags, fmt, td); 100 101 sc = devclass_get_softc(firewire_devclass, unit); 102 if(sc->fc->ir[sub]->flag & FWXFERQ_OPEN){ 103 err = EBUSY; 104 return err; 105 } 106 if(sc->fc->it[sub]->flag & FWXFERQ_OPEN){ 107 err = EBUSY; 108 return err; 109 } 110 if(sc->fc->ir[sub]->flag & FWXFERQ_MODEMASK){ 111 err = EBUSY; 112 return err; 113 } 114 /* Default is per packet mode */ 115 sc->fc->ir[sub]->flag |= FWXFERQ_OPEN; 116 sc->fc->it[sub]->flag |= FWXFERQ_OPEN; 117 return err; 118 } 119 120 static int 121 fw_close (dev_t dev, int flags, int fmt, fw_proc *td) 122 { 123 struct firewire_softc *sc; 124 int unit = DEV2UNIT(dev); 125 int sub = DEV2DMACH(dev); 126 struct fw_xfer *xfer; 127 struct fw_bind *fwb; 128 int err = 0; 129 130 if (DEV_FWMEM(dev)) 131 return fwmem_close(dev, flags, fmt, td); 132 133 sc = devclass_get_softc(firewire_devclass, unit); 134 if(!(sc->fc->ir[sub]->flag & FWXFERQ_OPEN)){ 135 err = EINVAL; 136 return err; 137 } 138 sc->fc->ir[sub]->flag &= ~FWXFERQ_OPEN; 139 if(!(sc->fc->it[sub]->flag & FWXFERQ_OPEN)){ 140 err = EINVAL; 141 return err; 142 } 143 sc->fc->it[sub]->flag &= ~FWXFERQ_OPEN; 144 145 if(sc->fc->ir[sub]->flag & FWXFERQ_RUNNING){ 146 sc->fc->irx_disable(sc->fc, sub); 147 } 148 if(sc->fc->it[sub]->flag & FWXFERQ_RUNNING){ 149 sc->fc->it[sub]->flag &= ~FWXFERQ_RUNNING; 150 sc->fc->itx_disable(sc->fc, sub); 151 } 152 if(sc->fc->ir[sub]->flag & FWXFERQ_EXTBUF){ 153 if (sc->fc->ir[sub]->buf != NULL) 154 fwdma_free_multiseg(sc->fc->ir[sub]->buf); 155 sc->fc->ir[sub]->buf = NULL; 156 free(sc->fc->ir[sub]->bulkxfer, M_FW); 157 sc->fc->ir[sub]->bulkxfer = NULL; 158 sc->fc->ir[sub]->flag &= ~FWXFERQ_EXTBUF; 159 sc->fc->ir[sub]->psize = PAGE_SIZE; 160 sc->fc->ir[sub]->maxq = FWMAXQUEUE; 161 } 162 if(sc->fc->it[sub]->flag & FWXFERQ_EXTBUF){ 163 if (sc->fc->it[sub]->buf != NULL) 164 fwdma_free_multiseg(sc->fc->it[sub]->buf); 165 sc->fc->it[sub]->buf = NULL; 166 free(sc->fc->it[sub]->bulkxfer, M_FW); 167 sc->fc->it[sub]->bulkxfer = NULL; 168 sc->fc->it[sub]->flag &= ~FWXFERQ_EXTBUF; 169 sc->fc->it[sub]->psize = 0; 170 sc->fc->it[sub]->maxq = FWMAXQUEUE; 171 } 172 for(xfer = STAILQ_FIRST(&sc->fc->ir[sub]->q); 173 xfer != NULL; xfer = STAILQ_FIRST(&sc->fc->ir[sub]->q)){ 174 sc->fc->ir[sub]->queued--; 175 STAILQ_REMOVE_HEAD(&sc->fc->ir[sub]->q, link); 176 177 xfer->resp = 0; 178 fw_xfer_done(xfer); 179 } 180 for(fwb = STAILQ_FIRST(&sc->fc->ir[sub]->binds); fwb != NULL; 181 fwb = STAILQ_FIRST(&sc->fc->ir[sub]->binds)){ 182 STAILQ_REMOVE(&sc->fc->binds, fwb, fw_bind, fclist); 183 STAILQ_REMOVE_HEAD(&sc->fc->ir[sub]->binds, chlist); 184 free(fwb, M_FW); 185 } 186 sc->fc->ir[sub]->flag &= ~(FWXFERQ_MODEMASK | FWXFERQ_CHTAGMASK); 187 sc->fc->it[sub]->flag &= ~(FWXFERQ_MODEMASK | FWXFERQ_CHTAGMASK); 188 return err; 189 } 190 191 /* 192 * read request. 193 */ 194 static int 195 fw_read (dev_t dev, struct uio *uio, int ioflag) 196 { 197 struct firewire_softc *sc; 198 struct fw_xferq *ir; 199 struct fw_xfer *xfer; 200 int err = 0, s, slept = 0; 201 int unit = DEV2UNIT(dev); 202 int sub = DEV2DMACH(dev); 203 struct fw_pkt *fp; 204 205 if (DEV_FWMEM(dev)) 206 return fwmem_read(dev, uio, ioflag); 207 208 sc = devclass_get_softc(firewire_devclass, unit); 209 210 ir = sc->fc->ir[sub]; 211 212 readloop: 213 xfer = STAILQ_FIRST(&ir->q); 214 if (ir->stproc == NULL) { 215 /* iso bulkxfer */ 216 ir->stproc = STAILQ_FIRST(&ir->stvalid); 217 if (ir->stproc != NULL) { 218 s = splfw(); 219 STAILQ_REMOVE_HEAD(&ir->stvalid, link); 220 splx(s); 221 ir->queued = 0; 222 } 223 } 224 if (xfer == NULL && ir->stproc == NULL) { 225 /* no data avaliable */ 226 if (slept == 0) { 227 slept = 1; 228 ir->flag |= FWXFERQ_WAKEUP; 229 err = tsleep(ir, FWPRI, "fw_read", hz); 230 ir->flag &= ~FWXFERQ_WAKEUP; 231 if (err == 0) 232 goto readloop; 233 } else if (slept == 1) 234 err = EIO; 235 return err; 236 } else if(xfer != NULL) { 237 /* per packet mode or FWACT_CH bind?*/ 238 s = splfw(); 239 ir->queued --; 240 STAILQ_REMOVE_HEAD(&ir->q, link); 241 splx(s); 242 fp = (struct fw_pkt *)xfer->recv.buf; 243 if(sc->fc->irx_post != NULL) 244 sc->fc->irx_post(sc->fc, fp->mode.ld); 245 err = uiomove(xfer->recv.buf, xfer->recv.len, uio); 246 /* XXX we should recycle this xfer */ 247 fw_xfer_free( xfer); 248 } else if(ir->stproc != NULL) { 249 /* iso bulkxfer */ 250 fp = (struct fw_pkt *)fwdma_v_addr(ir->buf, 251 ir->stproc->poffset + ir->queued); 252 if(sc->fc->irx_post != NULL) 253 sc->fc->irx_post(sc->fc, fp->mode.ld); 254 if(fp->mode.stream.len == 0){ 255 err = EIO; 256 return err; 257 } 258 err = uiomove((caddr_t)fp, 259 fp->mode.stream.len + sizeof(u_int32_t), uio); 260 ir->queued ++; 261 if(ir->queued >= ir->bnpacket){ 262 s = splfw(); 263 STAILQ_INSERT_TAIL(&ir->stfree, ir->stproc, link); 264 splx(s); 265 sc->fc->irx_enable(sc->fc, sub); 266 ir->stproc = NULL; 267 } 268 if (uio->uio_resid >= ir->psize) { 269 slept = -1; 270 goto readloop; 271 } 272 } 273 return err; 274 } 275 276 static int 277 fw_write (dev_t dev, struct uio *uio, int ioflag) 278 { 279 int err = 0; 280 struct firewire_softc *sc; 281 int unit = DEV2UNIT(dev); 282 int sub = DEV2DMACH(dev); 283 int s, slept = 0; 284 struct fw_pkt *fp; 285 struct firewire_comm *fc; 286 struct fw_xferq *it; 287 288 if (DEV_FWMEM(dev)) 289 return fwmem_write(dev, uio, ioflag); 290 291 sc = devclass_get_softc(firewire_devclass, unit); 292 fc = sc->fc; 293 it = sc->fc->it[sub]; 294 isoloop: 295 if (it->stproc == NULL) { 296 it->stproc = STAILQ_FIRST(&it->stfree); 297 if (it->stproc != NULL) { 298 s = splfw(); 299 STAILQ_REMOVE_HEAD(&it->stfree, link); 300 splx(s); 301 it->queued = 0; 302 } else if (slept == 0) { 303 slept = 1; 304 err = sc->fc->itx_enable(sc->fc, sub); 305 if (err) 306 return err; 307 err = tsleep(it, FWPRI, "fw_write", hz); 308 if (err) 309 return err; 310 goto isoloop; 311 } else { 312 err = EIO; 313 return err; 314 } 315 } 316 fp = (struct fw_pkt *)fwdma_v_addr(it->buf, 317 it->stproc->poffset + it->queued); 318 err = uiomove((caddr_t)fp, sizeof(struct fw_isohdr), uio); 319 err = uiomove((caddr_t)fp->mode.stream.payload, 320 fp->mode.stream.len, uio); 321 it->queued ++; 322 if (it->queued >= it->bnpacket) { 323 s = splfw(); 324 STAILQ_INSERT_TAIL(&it->stvalid, it->stproc, link); 325 splx(s); 326 it->stproc = NULL; 327 err = sc->fc->itx_enable(sc->fc, sub); 328 } 329 if (uio->uio_resid >= sizeof(struct fw_isohdr)) { 330 slept = 0; 331 goto isoloop; 332 } 333 return err; 334 } 335 336 /* 337 * ioctl support. 338 */ 339 int 340 fw_ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, fw_proc *td) 341 { 342 struct firewire_softc *sc; 343 int unit = DEV2UNIT(dev); 344 int sub = DEV2DMACH(dev); 345 int s, i, len, err = 0; 346 struct fw_device *fwdev; 347 struct fw_bind *fwb; 348 struct fw_xferq *ir, *it; 349 struct fw_xfer *xfer; 350 struct fw_pkt *fp; 351 struct fw_devinfo *devinfo; 352 353 struct fw_devlstreq *fwdevlst = (struct fw_devlstreq *)data; 354 struct fw_asyreq *asyreq = (struct fw_asyreq *)data; 355 struct fw_isochreq *ichreq = (struct fw_isochreq *)data; 356 struct fw_isobufreq *ibufreq = (struct fw_isobufreq *)data; 357 struct fw_asybindreq *bindreq = (struct fw_asybindreq *)data; 358 struct fw_crom_buf *crom_buf = (struct fw_crom_buf *)data; 359 360 if (DEV_FWMEM(dev)) 361 return fwmem_ioctl(dev, cmd, data, flag, td); 362 363 sc = devclass_get_softc(firewire_devclass, unit); 364 if (!data) 365 return(EINVAL); 366 367 switch (cmd) { 368 case FW_STSTREAM: 369 sc->fc->it[sub]->flag &= ~0xff; 370 sc->fc->it[sub]->flag |= (0x3f & ichreq->ch); 371 sc->fc->it[sub]->flag |= ((0x3 & ichreq->tag) << 6); 372 err = 0; 373 break; 374 case FW_GTSTREAM: 375 ichreq->ch = sc->fc->it[sub]->flag & 0x3f; 376 ichreq->tag =(sc->fc->it[sub]->flag) >> 2 & 0x3; 377 err = 0; 378 break; 379 case FW_SRSTREAM: 380 sc->fc->ir[sub]->flag &= ~0xff; 381 sc->fc->ir[sub]->flag |= (0x3f & ichreq->ch); 382 sc->fc->ir[sub]->flag |= ((0x3 & ichreq->tag) << 6); 383 err = sc->fc->irx_enable(sc->fc, sub); 384 break; 385 case FW_GRSTREAM: 386 ichreq->ch = sc->fc->ir[sub]->flag & 0x3f; 387 ichreq->tag =(sc->fc->ir[sub]->flag) >> 2 & 0x3; 388 err = 0; 389 break; 390 case FW_SSTBUF: 391 ir = sc->fc->ir[sub]; 392 it = sc->fc->it[sub]; 393 394 if(ir->flag & FWXFERQ_RUNNING || it->flag & FWXFERQ_RUNNING){ 395 return(EBUSY); 396 } 397 if((ir->flag & FWXFERQ_EXTBUF) || (it->flag & FWXFERQ_EXTBUF)){ 398 return(EBUSY); 399 } 400 if((ibufreq->rx.nchunk * 401 ibufreq->rx.psize * ibufreq->rx.npacket) + 402 (ibufreq->tx.nchunk * 403 ibufreq->tx.psize * ibufreq->tx.npacket) <= 0){ 404 return(EINVAL); 405 } 406 ir->bulkxfer 407 = (struct fw_bulkxfer *)malloc(sizeof(struct fw_bulkxfer) * ibufreq->rx.nchunk, M_FW, M_WAITOK); 408 if(ir->bulkxfer == NULL){ 409 return(ENOMEM); 410 } 411 it->bulkxfer 412 = (struct fw_bulkxfer *)malloc(sizeof(struct fw_bulkxfer) * ibufreq->tx.nchunk, M_FW, M_WAITOK); 413 if(it->bulkxfer == NULL){ 414 return(ENOMEM); 415 } 416 if (ibufreq->rx.psize > 0) { 417 ibufreq->rx.psize = roundup2(ibufreq->rx.psize, 418 sizeof(u_int32_t)); 419 ir->buf = fwdma_malloc_multiseg( 420 sc->fc, sizeof(u_int32_t), 421 ibufreq->rx.psize, 422 ibufreq->rx.nchunk * ibufreq->rx.npacket, 423 BUS_DMA_WAITOK); 424 425 if(ir->buf == NULL){ 426 free(ir->bulkxfer, M_FW); 427 free(it->bulkxfer, M_FW); 428 ir->bulkxfer = NULL; 429 it->bulkxfer = NULL; 430 it->buf = NULL; 431 return(ENOMEM); 432 } 433 } 434 if (ibufreq->tx.psize > 0) { 435 ibufreq->tx.psize = roundup2(ibufreq->tx.psize, 436 sizeof(u_int32_t)); 437 it->buf = fwdma_malloc_multiseg( 438 sc->fc, sizeof(u_int32_t), 439 ibufreq->tx.psize, 440 ibufreq->tx.nchunk * ibufreq->tx.npacket, 441 BUS_DMA_WAITOK); 442 443 if(it->buf == NULL){ 444 free(ir->bulkxfer, M_FW); 445 free(it->bulkxfer, M_FW); 446 fwdma_free_multiseg(ir->buf); 447 ir->bulkxfer = NULL; 448 it->bulkxfer = NULL; 449 it->buf = NULL; 450 return(ENOMEM); 451 } 452 } 453 454 ir->bnchunk = ibufreq->rx.nchunk; 455 ir->bnpacket = ibufreq->rx.npacket; 456 ir->psize = (ibufreq->rx.psize + 3) & ~3; 457 ir->queued = 0; 458 459 it->bnchunk = ibufreq->tx.nchunk; 460 it->bnpacket = ibufreq->tx.npacket; 461 it->psize = (ibufreq->tx.psize + 3) & ~3; 462 it->queued = 0; 463 464 STAILQ_INIT(&ir->stvalid); 465 STAILQ_INIT(&ir->stfree); 466 STAILQ_INIT(&ir->stdma); 467 ir->stproc = NULL; 468 469 STAILQ_INIT(&it->stvalid); 470 STAILQ_INIT(&it->stfree); 471 STAILQ_INIT(&it->stdma); 472 it->stproc = NULL; 473 474 for(i = 0 ; i < sc->fc->ir[sub]->bnchunk; i++){ 475 ir->bulkxfer[i].poffset = i * ir->bnpacket; 476 ir->bulkxfer[i].mbuf = NULL; 477 STAILQ_INSERT_TAIL(&ir->stfree, 478 &ir->bulkxfer[i], link); 479 } 480 for(i = 0 ; i < sc->fc->it[sub]->bnchunk; i++){ 481 it->bulkxfer[i].poffset = i * it->bnpacket; 482 it->bulkxfer[i].mbuf = NULL; 483 STAILQ_INSERT_TAIL(&it->stfree, 484 &it->bulkxfer[i], link); 485 } 486 ir->flag &= ~FWXFERQ_MODEMASK; 487 ir->flag |= FWXFERQ_STREAM; 488 ir->flag |= FWXFERQ_EXTBUF; 489 490 it->flag &= ~FWXFERQ_MODEMASK; 491 it->flag |= FWXFERQ_STREAM; 492 it->flag |= FWXFERQ_EXTBUF; 493 err = 0; 494 break; 495 case FW_GSTBUF: 496 ibufreq->rx.nchunk = sc->fc->ir[sub]->bnchunk; 497 ibufreq->rx.npacket = sc->fc->ir[sub]->bnpacket; 498 ibufreq->rx.psize = sc->fc->ir[sub]->psize; 499 500 ibufreq->tx.nchunk = sc->fc->it[sub]->bnchunk; 501 ibufreq->tx.npacket = sc->fc->it[sub]->bnpacket; 502 ibufreq->tx.psize = sc->fc->it[sub]->psize; 503 break; 504 case FW_ASYREQ: 505 xfer = fw_xfer_alloc_buf(M_FWXFER, asyreq->req.len, 506 PAGE_SIZE /* XXX */); 507 if(xfer == NULL){ 508 err = ENOMEM; 509 return err; 510 } 511 fp = &asyreq->pkt; 512 switch (asyreq->req.type) { 513 case FWASREQNODE: 514 xfer->dst = fp->mode.hdr.dst; 515 break; 516 case FWASREQEUI: 517 fwdev = fw_noderesolve_eui64(sc->fc, 518 &asyreq->req.dst.eui); 519 if (fwdev == NULL) { 520 device_printf(sc->fc->bdev, 521 "cannot find node\n"); 522 err = EINVAL; 523 goto error; 524 } 525 xfer->dst = FWLOCALBUS | fwdev->dst; 526 fp->mode.hdr.dst = xfer->dst; 527 break; 528 case FWASRESTL: 529 /* XXX what's this? */ 530 break; 531 case FWASREQSTREAM: 532 /* nothing to do */ 533 break; 534 } 535 xfer->spd = asyreq->req.sped; 536 bcopy(fp, xfer->send.buf, xfer->send.len); 537 xfer->act.hand = fw_asy_callback; 538 err = fw_asyreq(sc->fc, sub, xfer); 539 if(err){ 540 fw_xfer_free( xfer); 541 return err; 542 } 543 err = tsleep(xfer, FWPRI, "asyreq", hz); 544 if(err == 0){ 545 if(asyreq->req.len >= xfer->recv.len){ 546 asyreq->req.len = xfer->recv.len; 547 }else{ 548 err = EINVAL; 549 } 550 bcopy(xfer->recv.buf, fp, asyreq->req.len); 551 } 552 error: 553 fw_xfer_free( xfer); 554 break; 555 case FW_IBUSRST: 556 sc->fc->ibr(sc->fc); 557 break; 558 case FW_CBINDADDR: 559 fwb = fw_bindlookup(sc->fc, 560 bindreq->start.hi, bindreq->start.lo); 561 if(fwb == NULL){ 562 err = EINVAL; 563 break; 564 } 565 STAILQ_REMOVE(&sc->fc->binds, fwb, fw_bind, fclist); 566 STAILQ_REMOVE(&sc->fc->ir[sub]->binds, fwb, fw_bind, chlist); 567 free(fwb, M_FW); 568 break; 569 case FW_SBINDADDR: 570 if(bindreq->len <= 0 ){ 571 err = EINVAL; 572 break; 573 } 574 if(bindreq->start.hi > 0xffff ){ 575 err = EINVAL; 576 break; 577 } 578 fwb = (struct fw_bind *)malloc(sizeof (struct fw_bind), M_FW, M_NOWAIT); 579 if(fwb == NULL){ 580 err = ENOMEM; 581 break; 582 } 583 fwb->start_hi = bindreq->start.hi; 584 fwb->start_lo = bindreq->start.lo; 585 fwb->addrlen = bindreq->len; 586 fwb->sub = sub; 587 fwb->act_type = FWACT_CH; 588 589 xfer = fw_xfer_alloc(M_FWXFER); 590 if(xfer == NULL){ 591 err = ENOMEM; 592 return err; 593 } 594 xfer->fc = sc->fc; 595 596 s = splfw(); 597 /* XXX broken. need multiple xfer */ 598 STAILQ_INIT(&fwb->xferlist); 599 STAILQ_INSERT_TAIL(&fwb->xferlist, xfer, link); 600 splx(s); 601 err = fw_bindadd(sc->fc, fwb); 602 break; 603 case FW_GDEVLST: 604 i = len = 1; 605 /* myself */ 606 devinfo = &fwdevlst->dev[0]; 607 devinfo->dst = sc->fc->nodeid; 608 devinfo->status = 0; /* XXX */ 609 devinfo->eui.hi = sc->fc->eui.hi; 610 devinfo->eui.lo = sc->fc->eui.lo; 611 STAILQ_FOREACH(fwdev, &sc->fc->devices, link) { 612 if(len < FW_MAX_DEVLST){ 613 devinfo = &fwdevlst->dev[len++]; 614 devinfo->dst = fwdev->dst; 615 devinfo->status = 616 (fwdev->status == FWDEVINVAL)?0:1; 617 devinfo->eui.hi = fwdev->eui.hi; 618 devinfo->eui.lo = fwdev->eui.lo; 619 } 620 i++; 621 } 622 fwdevlst->n = i; 623 fwdevlst->info_len = len; 624 break; 625 case FW_GTPMAP: 626 bcopy(sc->fc->topology_map, data, 627 (sc->fc->topology_map->crc_len + 1) * 4); 628 break; 629 case FW_GCROM: 630 STAILQ_FOREACH(fwdev, &sc->fc->devices, link) 631 if (FW_EUI64_EQUAL(fwdev->eui, crom_buf->eui)) 632 break; 633 if (fwdev == NULL) { 634 err = FWNODE_INVAL; 635 break; 636 } 637 if (fwdev->rommax < CSRROMOFF) 638 len = 0; 639 else 640 len = fwdev->rommax - CSRROMOFF + 4; 641 if (crom_buf->len < len) 642 len = crom_buf->len; 643 else 644 crom_buf->len = len; 645 err = copyout(&fwdev->csrrom[0], crom_buf->ptr, len); 646 break; 647 default: 648 sc->fc->ioctl (dev, cmd, data, flag, td); 649 break; 650 } 651 return err; 652 } 653 int 654 fw_poll(dev_t dev, int events, fw_proc *td) 655 { 656 int revents; 657 int tmp; 658 int unit = DEV2UNIT(dev); 659 int sub = DEV2DMACH(dev); 660 struct firewire_softc *sc; 661 662 if (DEV_FWMEM(dev)) 663 return fwmem_poll(dev, events, td); 664 665 sc = devclass_get_softc(firewire_devclass, unit); 666 revents = 0; 667 tmp = POLLIN | POLLRDNORM; 668 if (events & tmp) { 669 if (STAILQ_FIRST(&sc->fc->ir[sub]->q) != NULL) 670 revents |= tmp; 671 else 672 selrecord(td, &sc->fc->ir[sub]->rsel); 673 } 674 tmp = POLLOUT | POLLWRNORM; 675 if (events & tmp) { 676 /* XXX should be fixed */ 677 revents |= tmp; 678 } 679 680 return revents; 681 } 682 683 static int 684 #if __FreeBSD_version < 500102 685 fw_mmap (dev_t dev, vm_offset_t offset, int nproto) 686 #else 687 fw_mmap (dev_t dev, vm_offset_t offset, vm_paddr_t *paddr, int nproto) 688 #endif 689 { 690 struct firewire_softc *fc; 691 int unit = DEV2UNIT(dev); 692 693 if (DEV_FWMEM(dev)) 694 #if __FreeBSD_version < 500102 695 return fwmem_mmap(dev, offset, nproto); 696 #else 697 return fwmem_mmap(dev, offset, paddr, nproto); 698 #endif 699 700 fc = devclass_get_softc(firewire_devclass, unit); 701 702 return EINVAL; 703 } 704