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