sys/dev/firewire/fwdev.c

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