sys/bus/firewire/firewire.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: src/sys/dev/firewire/firewire.c,v 1.3.2.22 2003/05/12 04:16:30 simokawa Exp $
  35  * $DragonFly: src/sys/bus/firewire/firewire.c,v 1.3 2003/08/07 21:16:45 dillon Exp $
  36  *
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/types.h>
  42 #include <sys/mbuf.h>
  43 #include <sys/socket.h>
  44 #include <sys/socketvar.h>
  45
  46 #include <sys/kernel.h>
  47 #include <sys/malloc.h>
  48 #include <sys/conf.h>
  49 #include <sys/sysctl.h>
  50
  51 #include <machine/cpufunc.h>    /* for rdtsc proto for clock.h below */
  52 #include <machine/clock.h>
  53
  54 #include <sys/bus.h>            /* used by smbus and newbus */
  55 #include <machine/bus.h>
  56
  57 #include "firewire.h"
  58 #include "firewirereg.h"
  59 #include "fwmem.h"
  60 #include "iec13213.h"
  61 #include "iec68113.h"
  62
  63 int firewire_debug=0, try_bmr=1;
  64 SYSCTL_INT(_debug, OID_AUTO, firewire_debug, CTLFLAG_RW, &firewire_debug, 0,
  65         "FireWire driver debug flag");
  66 SYSCTL_NODE(_hw, OID_AUTO, firewire, CTLFLAG_RD, 0, "FireWire Subsystem");
  67 SYSCTL_INT(_hw_firewire, OID_AUTO, try_bmr, CTLFLAG_RW, &try_bmr, 0,
  68         "Try to be a bus manager");
  69
  70 MALLOC_DEFINE(M_FW, "firewire", "FireWire");
  71 MALLOC_DEFINE(M_FWXFER, "fw_xfer", "XFER/FireWire");
  72
  73 #define FW_MAXASYRTY 4
  74 #define FW_MAXDEVRCNT 4
  75
  76 devclass_t firewire_devclass;
  77
  78 static int firewire_match      __P((device_t));
  79 static int firewire_attach      __P((device_t));
  80 static int firewire_detach      __P((device_t));
  81 #if 0
  82 static int firewire_shutdown    __P((device_t));
  83 #endif
  84 static device_t firewire_add_child   __P((device_t, int, const char *, int));
  85 static void fw_try_bmr __P((void *));
  86 static void fw_try_bmr_callback __P((struct fw_xfer *));
  87 static void fw_asystart __P((struct fw_xfer *));
  88 static int fw_get_tlabel __P((struct firewire_comm *, struct fw_xfer *));
  89 static void fw_bus_probe __P((struct firewire_comm *));
  90 static void fw_bus_explore __P((struct firewire_comm *));
  91 static void fw_bus_explore_callback __P((struct fw_xfer *));
  92 static void fw_attach_dev __P((struct firewire_comm *));
  93 #ifdef FW_VMACCESS
  94 static void fw_vmaccess __P((struct fw_xfer *));
  95 #endif
  96 struct fw_xfer *asyreqq __P((struct firewire_comm *, u_int8_t, u_int8_t, u_int8_t,
  97         u_int32_t, u_int32_t, void (*)__P((struct fw_xfer *))));
  98 static int fw_bmr __P((struct firewire_comm *));
  99
 100 static device_method_t firewire_methods[] = {
 101         /* Device interface */
 102         DEVMETHOD(device_probe,         firewire_match),
 103         DEVMETHOD(device_attach,        firewire_attach),
 104         DEVMETHOD(device_detach,        firewire_detach),
 105         DEVMETHOD(device_suspend,       bus_generic_suspend),
 106         DEVMETHOD(device_resume,        bus_generic_resume),
 107         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 108
 109         /* Bus interface */
 110         DEVMETHOD(bus_add_child,        firewire_add_child),
 111         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 112
 113         { 0, 0 }
 114 };
 115 char linkspeed[7][0x10]={"S100","S200","S400","S800","S1600","S3200","Unknown"};
 116
 117 /* IEEE-1394a Table C-2 Gap count as a function of hops*/
 118 #define MAX_GAPHOP 15
 119 u_int gap_cnt[] = { 5,  5,  7,  8, 10, 13, 16, 18,
 120                    21, 24, 26, 29, 32, 35, 37, 40};
 121
 122 extern struct cdevsw firewire_cdevsw;
 123
 124 static driver_t firewire_driver = {
 125         "firewire",
 126         firewire_methods,
 127         sizeof(struct firewire_softc),
 128 };
 129
 130 /*
 131  * Lookup fwdev by node id.
 132  */
 133 struct fw_device *
 134 fw_noderesolve_nodeid(struct firewire_comm *fc, int dst)
 135 {
 136         struct fw_device *fwdev;
 137         int s;
 138
 139         s = splfw();
 140         STAILQ_FOREACH(fwdev, &fc->devices, link)
 141                 if (fwdev->dst == dst)
 142                         break;
 143         splx(s);
 144
 145         if(fwdev == NULL) return NULL;
 146         if(fwdev->status == FWDEVINVAL) return NULL;
 147         return fwdev;
 148 }
 149
 150 /*
 151  * Lookup fwdev by EUI64.
 152  */
 153 struct fw_device *
 154 fw_noderesolve_eui64(struct firewire_comm *fc, struct fw_eui64 *eui)
 155 {
 156         struct fw_device *fwdev;
 157         int s;
 158
 159         s = splfw();
 160         STAILQ_FOREACH(fwdev, &fc->devices, link)
 161                 if (FW_EUI64_EQUAL(fwdev->eui, *eui))
 162                         break;
 163         splx(s);
 164
 165         if(fwdev == NULL) return NULL;
 166         if(fwdev->status == FWDEVINVAL) return NULL;
 167         return fwdev;
 168 }
 169
 170 /*
 171  * Async. request procedure for userland application.
 172  */
 173 int
 174 fw_asyreq(struct firewire_comm *fc, int sub, struct fw_xfer *xfer)
 175 {
 176         int err = 0;
 177         struct fw_xferq *xferq;
 178         int tl = 0, len;
 179         struct fw_pkt *fp;
 180         int tcode;
 181         struct tcode_info *info;
 182
 183         if(xfer == NULL) return EINVAL;
 184         if(xfer->send.len > MAXREC(fc->maxrec)){
 185                 printf("send.len > maxrec\n");
 186                 return EINVAL;
 187         }
 188         if(xfer->act.hand == NULL){
 189                 printf("act.hand == NULL\n");
 190                 return EINVAL;
 191         }
 192         fp = (struct fw_pkt *)xfer->send.buf;
 193
 194         tcode = fp->mode.common.tcode & 0xf;
 195         info = &fc->tcode[tcode];
 196         if (info->flag == 0) {
 197                 printf("invalid tcode=%d\n", tcode);
 198                 return EINVAL;
 199         }
 200         if (info->flag & FWTI_REQ)
 201                 xferq = fc->atq;
 202         else
 203                 xferq = fc->ats;
 204         len = info->hdr_len;
 205         if (info->flag & FWTI_BLOCK_STR)
 206                 len += fp->mode.stream.len;
 207         else if (info->flag & FWTI_BLOCK_ASY)
 208                 len += fp->mode.rresb.len;
 209         if( len >  xfer->send.len ){
 210                 printf("len(%d) > send.len(%d) (tcode=%d)\n",
 211                                 len, xfer->send.len, tcode);
 212                 return EINVAL;
 213         }
 214         xfer->send.len = len;
 215
 216         if(xferq->start == NULL){
 217                 printf("xferq->start == NULL\n");
 218                 return EINVAL;
 219         }
 220         if(!(xferq->queued < xferq->maxq)){
 221                 device_printf(fc->bdev, "Discard a packet (queued=%d)\n",
 222                         xferq->queued);
 223                 return EINVAL;
 224         }
 225
 226
 227         if (info->flag & FWTI_TLABEL) {
 228                 if((tl = fw_get_tlabel(fc, xfer)) == -1 )
 229                         return EIO;
 230                 fp->mode.hdr.tlrt = tl << 2;
 231         }
 232
 233         xfer->tl = tl;
 234         xfer->resp = 0;
 235         xfer->fc = fc;
 236         xfer->q = xferq;
 237         xfer->retry_req = fw_asybusy;
 238
 239         fw_asystart(xfer);
 240         return err;
 241 }
 242 /*
 243  * Wakeup blocked process.
 244  */
 245 void
 246 fw_asy_callback(struct fw_xfer *xfer){
 247         wakeup(xfer);
 248         return;
 249 }
 250 /*
 251  * Postpone to later retry.
 252  */
 253 void fw_asybusy(struct fw_xfer *xfer){
 254         printf("fw_asybusy\n");
 255 /*
 256         xfer->ch =  timeout((timeout_t *)fw_asystart, (void *)xfer, 20000);
 257 */
 258         DELAY(20000);
 259         fw_asystart(xfer);
 260         return;
 261 }
 262
 263 /*
 264  * Async. request with given xfer structure.
 265  */
 266 static void
 267 fw_asystart(struct fw_xfer *xfer)
 268 {
 269         struct firewire_comm *fc = xfer->fc;
 270         int s;
 271         if(xfer->retry++ >= fc->max_asyretry){
 272                 device_printf(fc->bdev, "max_asyretry exceeded\n");
 273                 xfer->resp = EBUSY;
 274                 xfer->state = FWXF_BUSY;
 275                 xfer->act.hand(xfer);
 276                 return;
 277         }
 278 #if 0 /* XXX allow bus explore packets only after bus rest */
 279         if (fc->status < FWBUSEXPLORE) {
 280                 xfer->resp = EAGAIN;
 281                 xfer->state = FWXF_BUSY;
 282                 if (xfer->act.hand != NULL)
 283                         xfer->act.hand(xfer);
 284                 return;
 285         }
 286 #endif
 287         s = splfw();
 288         xfer->state = FWXF_INQ;
 289         STAILQ_INSERT_TAIL(&xfer->q->q, xfer, link);
 290         xfer->q->queued ++;
 291         splx(s);
 292         /* XXX just queue for mbuf */
 293         if (xfer->mbuf == NULL)
 294                 xfer->q->start(fc);
 295         return;
 296 }
 297
 298 static int
 299 firewire_match( device_t dev )
 300 {
 301         device_set_desc(dev, "IEEE1394(FireWire) bus");
 302         return -140;
 303 }
 304
 305 static void
 306 firewire_xfer_timeout(struct firewire_comm *fc)
 307 {
 308         struct fw_xfer *xfer;
 309         struct tlabel *tl;
 310         struct timeval tv;
 311         struct timeval split_timeout;
 312         int i, s;
 313
 314         split_timeout.tv_sec = 6;
 315         split_timeout.tv_usec = 0;
 316
 317         microtime(&tv);
 318         timevalsub(&tv, &split_timeout);
 319
 320         s = splfw();
 321         for (i = 0; i < 0x40; i ++) {
 322                 while ((tl = STAILQ_FIRST(&fc->tlabels[i])) != NULL) {
 323                         xfer = tl->xfer;
 324                         if (timevalcmp(&xfer->tv, &tv, >))
 325                                 /* the rests are newer than this */
 326                                 break;
 327                         device_printf(fc->bdev,
 328                                 "split transaction timeout dst=0x%x tl=0x%x\n",
 329                                 xfer->dst, i);
 330                         xfer->resp = ETIMEDOUT;
 331                         STAILQ_REMOVE_HEAD(&fc->tlabels[i], link);
 332                         fw_xfer_done(xfer);
 333                 }
 334         }
 335         splx(s);
 336 }
 337
 338 static void
 339 firewire_watchdog(void *arg)
 340 {
 341         struct firewire_comm *fc;
 342
 343         fc = (struct firewire_comm *)arg;
 344         firewire_xfer_timeout(fc);
 345         fc->timeout(fc);
 346         callout_reset(&fc->timeout_callout, hz,
 347                         (void *)firewire_watchdog, (void *)fc);
 348 }
 349
 350 /*
 351  * The attach routine.
 352  */
 353 static int
 354 firewire_attach( device_t dev )
 355 {
 356         int i, unitmask, mn;
 357         struct firewire_softc *sc = device_get_softc(dev);
 358         device_t pa = device_get_parent(dev);
 359         struct firewire_comm *fc;
 360         dev_t d;
 361
 362         fc = (struct firewire_comm *)device_get_softc(pa);
 363         sc->fc = fc;
 364         fc->status = -1;
 365
 366         unitmask = UNIT2MIN(device_get_unit(dev));
 367
 368         if( fc->nisodma > FWMAXNDMA) fc->nisodma = FWMAXNDMA;
 369         for ( i = 0 ; i < fc->nisodma ; i++ ){
 370                 mn = unitmask | i;
 371                 /* XXX device name should be improved */
 372                 d = make_dev(&firewire_cdevsw, unit2minor(mn),
 373                         UID_ROOT, GID_OPERATOR, 0660,
 374                         "fw%x", mn);
 375 #if __FreeBSD_version >= 500000
 376                 if (i == 0)
 377                         sc->dev = d;
 378                 else
 379                         dev_depends(sc->dev, d);
 380 #else
 381                 sc->dev[i] = d;
 382 #endif
 383         }
 384         d = make_dev(&firewire_cdevsw, unit2minor(unitmask | FWMEM_FLAG),
 385                         UID_ROOT, GID_OPERATOR, 0660,
 386                         "fwmem%d", device_get_unit(dev));
 387 #if __FreeBSD_version >= 500000
 388         dev_depends(sc->dev, d);
 389 #else
 390         sc->dev[i] = d;
 391 #endif
 392         CALLOUT_INIT(&sc->fc->timeout_callout);
 393         CALLOUT_INIT(&sc->fc->bmr_callout);
 394         CALLOUT_INIT(&sc->fc->retry_probe_callout);
 395         CALLOUT_INIT(&sc->fc->busprobe_callout);
 396
 397         callout_reset(&sc->fc->timeout_callout, hz,
 398                         (void *)firewire_watchdog, (void *)sc->fc);
 399
 400         /* Locate our children */
 401         bus_generic_probe(dev);
 402
 403         /* launch attachement of the added children */
 404         bus_generic_attach(dev);
 405
 406         /* bus_reset */
 407         fc->ibr(fc);
 408
 409         return 0;
 410 }
 411
 412 /*
 413  * Attach it as child.
 414  */
 415 static device_t
 416 firewire_add_child(device_t dev, int order, const char *name, int unit)
 417 {
 418         device_t child;
 419         struct firewire_softc *sc;
 420
 421         sc = (struct firewire_softc *)device_get_softc(dev);
 422         child = device_add_child(dev, name, unit);
 423         if (child) {
 424                 device_set_ivars(child, sc->fc);
 425                 device_probe_and_attach(child);
 426         }
 427
 428         return child;
 429 }
 430
 431 /*
 432  * Dettach it.
 433  */
 434 static int
 435 firewire_detach( device_t dev )
 436 {
 437         struct firewire_softc *sc;
 438         struct csrdir *csrd, *next;
 439         struct fw_device *fwdev, *fwdev_next;
 440
 441         sc = (struct firewire_softc *)device_get_softc(dev);
 442
 443         bus_generic_detach(dev);
 444
 445         callout_stop(&sc->fc->timeout_callout);
 446         callout_stop(&sc->fc->bmr_callout);
 447         callout_stop(&sc->fc->retry_probe_callout);
 448         callout_stop(&sc->fc->busprobe_callout);
 449
 450 #if __FreeBSD_version >= 500000
 451         destroy_dev(sc->dev);
 452 #else
 453         {
 454                 int j;
 455                 for (j = 0 ; j < sc->fc->nisodma + 1; j++)
 456                         destroy_dev(sc->dev[j]);
 457         }
 458 #endif
 459         /* XXX xfree_free and untimeout on all xfers */
 460         for (fwdev = STAILQ_FIRST(&sc->fc->devices); fwdev != NULL;
 461                                                         fwdev = fwdev_next) {
 462                 fwdev_next = STAILQ_NEXT(fwdev, link);
 463                 free(fwdev, M_FW);
 464         }
 465         for (csrd = SLIST_FIRST(&sc->fc->csrfree); csrd != NULL; csrd = next) {
 466                 next = SLIST_NEXT(csrd, link);
 467                 free(csrd, M_FW);
 468         }
 469         free(sc->fc->topology_map, M_FW);
 470         free(sc->fc->speed_map, M_FW);
 471         return(0);
 472 }
 473 #if 0
 474 static int
 475 firewire_shutdown( device_t dev )
 476 {
 477         return 0;
 478 }
 479 #endif
 480
 481
 482 static void
 483 fw_xferq_drain(struct fw_xferq *xferq)
 484 {
 485         struct fw_xfer *xfer;
 486
 487         while ((xfer = STAILQ_FIRST(&xferq->q)) != NULL) {
 488                 STAILQ_REMOVE_HEAD(&xferq->q, link);
 489                 xferq->queued --;
 490                 xfer->resp = EAGAIN;
 491                 fw_xfer_done(xfer);
 492         }
 493 }
 494
 495 void
 496 fw_drain_txq(struct firewire_comm *fc)
 497 {
 498         int i;
 499
 500         fw_xferq_drain(fc->atq);
 501         fw_xferq_drain(fc->ats);
 502         for(i = 0; i < fc->nisodma; i++)
 503                 fw_xferq_drain(fc->it[i]);
 504 }
 505
 506 /*
 507  * Called after bus reset.
 508  */
 509 void
 510 fw_busreset(struct firewire_comm *fc)
 511 {
 512         struct firewire_dev_comm *fdc;
 513         device_t *devlistp;
 514         int devcnt;
 515         int i;
 516
 517         switch(fc->status){
 518         case FWBUSMGRELECT:
 519                 callout_stop(&fc->bmr_callout);
 520                 break;
 521         default:
 522                 break;
 523         }
 524         fc->status = FWBUSRESET;
 525         CSRARC(fc, STATE_CLEAR)
 526                         = 1 << 23 | 0 << 17 | 1 << 16 | 1 << 15 | 1 << 14 ;
 527         CSRARC(fc, STATE_SET) = CSRARC(fc, STATE_CLEAR);
 528         CSRARC(fc, NODE_IDS) = 0x3f;
 529
 530         CSRARC(fc, TOPO_MAP + 8) = 0;
 531         fc->irm = -1;
 532
 533         fc->max_node = -1;
 534
 535         for(i = 2; i < 0x100/4 - 2 ; i++){
 536                 CSRARC(fc, SPED_MAP + i * 4) = 0;
 537         }
 538         CSRARC(fc, STATE_CLEAR) = 1 << 23 | 0 << 17 | 1 << 16 | 1 << 15 | 1 << 14 ;
 539         CSRARC(fc, STATE_SET) = CSRARC(fc, STATE_CLEAR);
 540         CSRARC(fc, RESET_START) = 0;
 541         CSRARC(fc, SPLIT_TIMEOUT_HI) = 0;
 542         CSRARC(fc, SPLIT_TIMEOUT_LO) = 800 << 19;
 543         CSRARC(fc, CYCLE_TIME) = 0x0;
 544         CSRARC(fc, BUS_TIME) = 0x0;
 545         CSRARC(fc, BUS_MGR_ID) = 0x3f;
 546         CSRARC(fc, BANDWIDTH_AV) = 4915;
 547         CSRARC(fc, CHANNELS_AV_HI) = 0xffffffff;
 548         CSRARC(fc, CHANNELS_AV_LO) = 0xffffffff;
 549         CSRARC(fc, IP_CHANNELS) = (1 << 31);
 550
 551         CSRARC(fc, CONF_ROM) = 0x04 << 24;
 552         CSRARC(fc, CONF_ROM + 4) = 0x31333934; /* means strings 1394 */
 553         CSRARC(fc, CONF_ROM + 8) = 1 << 31 | 1 << 30 | 1 << 29 |
 554                                 1 << 28 | 0xff << 16 | 0x09 << 8;
 555         CSRARC(fc, CONF_ROM + 0xc) = 0;
 556
 557 /* DV depend CSRs see blue book */
 558         CSRARC(fc, oPCR) &= ~DV_BROADCAST_ON;
 559         CSRARC(fc, iPCR) &= ~DV_BROADCAST_ON;
 560
 561         CSRARC(fc, STATE_CLEAR) &= ~(1 << 23 | 1 << 15 | 1 << 14 );
 562         CSRARC(fc, STATE_SET) = CSRARC(fc, STATE_CLEAR);
 563
 564         if (device_get_children(fc->bdev, &devlistp, &devcnt) == 0) {
 565                 for( i = 0 ; i < devcnt ; i++)
 566                         if (device_get_state(devlistp[i]) >= DS_ATTACHED)  {
 567                                 fdc = device_get_softc(devlistp[i]);
 568                                 if (fdc->post_busreset != NULL)
 569                                         fdc->post_busreset(fdc);
 570                         }
 571                 free(devlistp, M_TEMP);
 572         }
 573 }
 574
 575 /* Call once after reboot */
 576 void fw_init(struct firewire_comm *fc)
 577 {
 578         int i;
 579         struct csrdir *csrd;
 580 #ifdef FW_VMACCESS
 581         struct fw_xfer *xfer;
 582         struct fw_bind *fwb;
 583 #endif
 584
 585         fc->max_asyretry = FW_MAXASYRTY;
 586
 587         fc->arq->queued = 0;
 588         fc->ars->queued = 0;
 589         fc->atq->queued = 0;
 590         fc->ats->queued = 0;
 591
 592         fc->arq->buf = NULL;
 593         fc->ars->buf = NULL;
 594         fc->atq->buf = NULL;
 595         fc->ats->buf = NULL;
 596
 597         fc->arq->flag = 0;
 598         fc->ars->flag = 0;
 599         fc->atq->flag = 0;
 600         fc->ats->flag = 0;
 601
 602         STAILQ_INIT(&fc->atq->q);
 603         STAILQ_INIT(&fc->ats->q);
 604
 605         for( i = 0 ; i < fc->nisodma ; i ++ ){
 606                 fc->it[i]->queued = 0;
 607                 fc->ir[i]->queued = 0;
 608
 609                 fc->it[i]->start = NULL;
 610                 fc->ir[i]->start = NULL;
 611
 612                 fc->it[i]->buf = NULL;
 613                 fc->ir[i]->buf = NULL;
 614
 615                 fc->it[i]->flag = FWXFERQ_STREAM;
 616                 fc->ir[i]->flag = FWXFERQ_STREAM;
 617
 618                 STAILQ_INIT(&fc->it[i]->q);
 619                 STAILQ_INIT(&fc->ir[i]->q);
 620
 621                 STAILQ_INIT(&fc->it[i]->binds);
 622                 STAILQ_INIT(&fc->ir[i]->binds);
 623         }
 624
 625         fc->arq->maxq = FWMAXQUEUE;
 626         fc->ars->maxq = FWMAXQUEUE;
 627         fc->atq->maxq = FWMAXQUEUE;
 628         fc->ats->maxq = FWMAXQUEUE;
 629
 630         for( i = 0 ; i < fc->nisodma ; i++){
 631                 fc->ir[i]->maxq = FWMAXQUEUE;
 632                 fc->it[i]->maxq = FWMAXQUEUE;
 633         }
 634 /* Initialize csr registers */
 635         fc->topology_map = (struct fw_topology_map *)malloc(
 636                                 sizeof(struct fw_topology_map),
 637                                 M_FW, M_NOWAIT | M_ZERO);
 638         fc->speed_map = (struct fw_speed_map *)malloc(
 639                                 sizeof(struct fw_speed_map),
 640                                 M_FW, M_NOWAIT | M_ZERO);
 641         CSRARC(fc, TOPO_MAP) = 0x3f1 << 16;
 642         CSRARC(fc, TOPO_MAP + 4) = 1;
 643         CSRARC(fc, SPED_MAP) = 0x3f1 << 16;
 644         CSRARC(fc, SPED_MAP + 4) = 1;
 645
 646         STAILQ_INIT(&fc->devices);
 647         STAILQ_INIT(&fc->pending);
 648
 649 /* Initialize csr ROM work space */
 650         SLIST_INIT(&fc->ongocsr);
 651         SLIST_INIT(&fc->csrfree);
 652         for( i = 0 ; i < FWMAXCSRDIR ; i++){
 653                 csrd = (struct csrdir *) malloc(sizeof(struct csrdir), M_FW,M_NOWAIT);
 654                 if(csrd == NULL) break;
 655                 SLIST_INSERT_HEAD(&fc->csrfree, csrd, link);
 656         }
 657
 658 /* Initialize Async handlers */
 659         STAILQ_INIT(&fc->binds);
 660         for( i = 0 ; i < 0x40 ; i++){
 661                 STAILQ_INIT(&fc->tlabels[i]);
 662         }
 663
 664 /* DV depend CSRs see blue book */
 665 #if 0
 666         CSRARC(fc, oMPR) = 0x3fff0001; /* # output channel = 1 */
 667         CSRARC(fc, oPCR) = 0x8000007a;
 668         for(i = 4 ; i < 0x7c/4 ; i+=4){
 669                 CSRARC(fc, i + oPCR) = 0x8000007a;
 670         }
 671
 672         CSRARC(fc, iMPR) = 0x00ff0001; /* # input channel = 1 */
 673         CSRARC(fc, iPCR) = 0x803f0000;
 674         for(i = 4 ; i < 0x7c/4 ; i+=4){
 675                 CSRARC(fc, i + iPCR) = 0x0;
 676         }
 677 #endif
 678
 679
 680 #ifdef FW_VMACCESS
 681         xfer = fw_xfer_alloc();
 682         if(xfer == NULL) return;
 683
 684         fwb = (struct fw_bind *)malloc(sizeof (struct fw_bind), M_FW, M_NOWAIT);
 685         if(fwb == NULL){
 686                 fw_xfer_free(xfer);
 687         }
 688         xfer->act.hand = fw_vmaccess;
 689         xfer->fc = fc;
 690         xfer->sc = NULL;
 691
 692         fwb->start_hi = 0x2;
 693         fwb->start_lo = 0;
 694         fwb->addrlen = 0xffffffff;
 695         fwb->xfer = xfer;
 696         fw_bindadd(fc, fwb);
 697 #endif
 698 }
 699
 700 /*
 701  * To lookup binded process from IEEE1394 address.
 702  */
 703 struct fw_bind *
 704 fw_bindlookup(struct firewire_comm *fc, u_int32_t dest_hi, u_int32_t dest_lo)
 705 {
 706         struct fw_bind *tfw;
 707         for(tfw = STAILQ_FIRST(&fc->binds) ; tfw != NULL ;
 708                 tfw = STAILQ_NEXT(tfw, fclist)){
 709                 if (tfw->act_type != FWACT_NULL &&
 710                         tfw->start_hi == dest_hi &&
 711                         tfw->start_lo <= dest_lo &&
 712                         (tfw->start_lo + tfw->addrlen) > dest_lo){
 713                         return(tfw);
 714                 }
 715         }
 716         return(NULL);
 717 }
 718
 719 /*
 720  * To bind IEEE1394 address block to process.
 721  */
 722 int
 723 fw_bindadd(struct firewire_comm *fc, struct fw_bind *fwb)
 724 {
 725         struct fw_bind *tfw, *tfw2 = NULL;
 726         int err = 0;
 727         tfw = STAILQ_FIRST(&fc->binds);
 728         if(tfw == NULL){
 729                 STAILQ_INSERT_HEAD(&fc->binds, fwb, fclist);
 730                 goto out;
 731         }
 732         if((tfw->start_hi > fwb->start_hi) ||
 733                 (tfw->start_hi == fwb->start_hi &&
 734                 (tfw->start_lo > (fwb->start_lo + fwb->addrlen)))){
 735                 STAILQ_INSERT_HEAD(&fc->binds, fwb, fclist);
 736                 goto out;
 737         }
 738         for(; tfw != NULL; tfw = STAILQ_NEXT(tfw, fclist)){
 739                 if((tfw->start_hi < fwb->start_hi) ||
 740                    (tfw->start_hi == fwb->start_hi &&
 741                     (tfw->start_lo + tfw->addrlen) < fwb->start_lo)){
 742                    tfw2 = STAILQ_NEXT(tfw, fclist);
 743                         if(tfw2 == NULL)
 744                                 break;
 745                         if((tfw2->start_hi > fwb->start_hi) ||
 746                            (tfw2->start_hi == fwb->start_hi &&
 747                             tfw2->start_lo > (fwb->start_lo + fwb->addrlen))){
 748                                 break;
 749                         }else{
 750                                 err = EBUSY;
 751                                 goto out;
 752                         }
 753                 }
 754         }
 755         if(tfw != NULL){
 756                 STAILQ_INSERT_AFTER(&fc->binds, tfw, fwb, fclist);
 757         }else{
 758                 STAILQ_INSERT_TAIL(&fc->binds, fwb, fclist);
 759         }
 760 out:
 761         if (!err && fwb->act_type == FWACT_CH)
 762                 STAILQ_INSERT_HEAD(&fc->ir[fwb->sub]->binds, fwb, chlist);
 763         return err;
 764 }
 765
 766 /*
 767  * To free IEEE1394 address block.
 768  */
 769 int
 770 fw_bindremove(struct firewire_comm *fc, struct fw_bind *fwb)
 771 {
 772         int s;
 773         struct fw_xfer *xfer, *next;
 774
 775         s = splfw();
 776         /* shall we check the existance? */
 777         STAILQ_REMOVE(&fc->binds, fwb, fw_bind, fclist);
 778         /* shall we do this? */
 779         for (xfer = STAILQ_FIRST(&fwb->xferlist); xfer != NULL; xfer = next) {
 780                 next = STAILQ_NEXT(xfer, link);
 781                 fw_xfer_free(xfer);
 782         }
 783         STAILQ_INIT(&fwb->xferlist);
 784
 785         splx(s);
 786         return 0;
 787 }
 788
 789 /*
 790  * To free transaction label.
 791  */
 792 static void
 793 fw_tl_free(struct firewire_comm *fc, struct fw_xfer *xfer)
 794 {
 795         struct tlabel *tl;
 796         int s = splfw();
 797
 798         for( tl = STAILQ_FIRST(&fc->tlabels[xfer->tl]); tl != NULL;
 799                 tl = STAILQ_NEXT(tl, link)){
 800                 if(tl->xfer == xfer){
 801                         STAILQ_REMOVE(&fc->tlabels[xfer->tl], tl, tlabel, link);
 802                         free(tl, M_FW);
 803                         splx(s);
 804                         return;
 805                 }
 806         }
 807         splx(s);
 808         return;
 809 }
 810
 811 /*
 812  * To obtain XFER structure by transaction label.
 813  */
 814 static struct fw_xfer *
 815 fw_tl2xfer(struct firewire_comm *fc, int node, int tlabel)
 816 {
 817         struct fw_xfer *xfer;
 818         struct tlabel *tl;
 819         int s = splfw();
 820
 821         for( tl = STAILQ_FIRST(&fc->tlabels[tlabel]); tl != NULL;
 822                 tl = STAILQ_NEXT(tl, link)){
 823                 if(tl->xfer->dst == node){
 824                         xfer = tl->xfer;
 825                         splx(s);
 826                         if (firewire_debug > 2)
 827                                 printf("fw_tl2xfer: found tl=%d\n", tlabel);
 828                         return(xfer);
 829                 }
 830         }
 831         if (firewire_debug > 1)
 832                 printf("fw_tl2xfer: not found tl=%d\n", tlabel);
 833         splx(s);
 834         return(NULL);
 835 }
 836
 837 /*
 838  * To allocate IEEE1394 XFER structure.
 839  */
 840 struct fw_xfer *
 841 fw_xfer_alloc(struct malloc_type *type)
 842 {
 843         struct fw_xfer *xfer;
 844
 845         xfer = malloc(sizeof(struct fw_xfer), type, M_NOWAIT | M_ZERO);
 846         if (xfer == NULL)
 847                 return xfer;
 848
 849         microtime(&xfer->tv);
 850         xfer->malloc = type;
 851
 852         return xfer;
 853 }
 854
 855 struct fw_xfer *
 856 fw_xfer_alloc_buf(struct malloc_type *type, int send_len, int recv_len)
 857 {
 858         struct fw_xfer *xfer;
 859
 860         xfer = fw_xfer_alloc(type);
 861         xfer->send.len = send_len;
 862         xfer->recv.len = recv_len;
 863         if (xfer == NULL)
 864                 return(NULL);
 865         if (send_len) {
 866                 xfer->send.buf = malloc(send_len, type, M_NOWAIT | M_ZERO);
 867                 if (xfer->send.buf == NULL) {
 868                         fw_xfer_free(xfer);
 869                         return(NULL);
 870                 }
 871         }
 872         if (recv_len) {
 873                 xfer->recv.buf = malloc(recv_len, type, M_NOWAIT);
 874                 if (xfer->recv.buf == NULL) {
 875                         if (xfer->send.buf != NULL)
 876                                 free(xfer->send.buf, type);
 877                         fw_xfer_free(xfer);
 878                         return(NULL);
 879                 }
 880         }
 881         return(xfer);
 882 }
 883
 884 /*
 885  * IEEE1394 XFER post process.
 886  */
 887 void
 888 fw_xfer_done(struct fw_xfer *xfer)
 889 {
 890         if (xfer->act.hand == NULL)
 891                 return;
 892
 893         if (xfer->fc->status != FWBUSRESET)
 894                 xfer->act.hand(xfer);
 895         else {
 896                 printf("fw_xfer_done: pending\n");
 897                 if (xfer->fc != NULL)
 898                         STAILQ_INSERT_TAIL(&xfer->fc->pending, xfer, link);
 899                 else
 900                         panic("fw_xfer_done: why xfer->fc is NULL?");
 901         }
 902 }
 903
 904 void
 905 fw_xfer_unload(struct fw_xfer* xfer)
 906 {
 907         int s;
 908
 909         if(xfer == NULL ) return;
 910         if(xfer->state == FWXF_INQ){
 911                 printf("fw_xfer_free FWXF_INQ\n");
 912                 s = splfw();
 913                 STAILQ_REMOVE(&xfer->q->q, xfer, fw_xfer, link);
 914                 xfer->q->queued --;
 915                 splx(s);
 916         }
 917         if (xfer->fc != NULL) {
 918 #if 1
 919                 if(xfer->state == FWXF_START)
 920                         /*
 921                          * This could happen if:
 922                          *  1. We call fwohci_arcv() before fwohci_txd().
 923                          *  2. firewire_watch() is called.
 924                          */
 925                         printf("fw_xfer_free FWXF_START\n");
 926 #endif
 927                 fw_tl_free(xfer->fc, xfer);
 928         }
 929         xfer->state = FWXF_INIT;
 930         xfer->resp = 0;
 931         xfer->retry = 0;
 932 }
 933 /*
 934  * To free IEEE1394 XFER structure.
 935  */
 936 void
 937 fw_xfer_free( struct fw_xfer* xfer)
 938 {
 939         if(xfer == NULL ) return;
 940         fw_xfer_unload(xfer);
 941         if(xfer->send.buf != NULL){
 942                 free(xfer->send.buf, xfer->malloc);
 943         }
 944         if(xfer->recv.buf != NULL){
 945                 free(xfer->recv.buf, xfer->malloc);
 946         }
 947         free(xfer, xfer->malloc);
 948 }
 949
 950 static void
 951 fw_asy_callback_free(struct fw_xfer *xfer)
 952 {
 953 #if 0
 954         printf("asyreq done state=%d resp=%d\n",
 955                                 xfer->state, xfer->resp);
 956 #endif
 957         fw_xfer_free(xfer);
 958 }
 959
 960 /*
 961  * To configure PHY.
 962  */
 963 static void
 964 fw_phy_config(struct firewire_comm *fc, int root_node, int gap_count)
 965 {
 966         struct fw_xfer *xfer;
 967         struct fw_pkt *fp;
 968
 969         fc->status = FWBUSPHYCONF;
 970
 971         xfer = fw_xfer_alloc_buf(M_FWXFER, 12, 0);
 972         if (xfer == NULL)
 973                 return;
 974         xfer->fc = fc;
 975         xfer->retry_req = fw_asybusy;
 976         xfer->act.hand = fw_asy_callback_free;
 977
 978         fp = (struct fw_pkt *)xfer->send.buf;
 979         fp->mode.ld[1] = 0;
 980         if (root_node >= 0)
 981                 fp->mode.ld[1] |= (root_node & 0x3f) << 24 | 1 << 23;
 982         if (gap_count >= 0)
 983                 fp->mode.ld[1] |= 1 << 22 | (gap_count & 0x3f) << 16;
 984         fp->mode.ld[2] = ~fp->mode.ld[1];
 985 /* XXX Dangerous, how to pass PHY packet to device driver */
 986         fp->mode.common.tcode |= FWTCODE_PHY;
 987
 988         if (firewire_debug)
 989                 printf("send phy_config root_node=%d gap_count=%d\n",
 990                                                 root_node, gap_count);
 991         fw_asyreq(fc, -1, xfer);
 992 }
 993
 994 #if 0
 995 /*
 996  * Dump self ID.
 997  */
 998 static void
 999 fw_print_sid(u_int32_t sid)
1000 {
1001         union fw_self_id *s;
1002         s = (union fw_self_id *) &sid;
1003         printf("node:%d link:%d gap:%d spd:%d del:%d con:%d pwr:%d"
1004                 " p0:%d p1:%d p2:%d i:%d m:%d\n",
1005                 s->p0.phy_id, s->p0.link_active, s->p0.gap_count,
1006                 s->p0.phy_speed, s->p0.phy_delay, s->p0.contender,
1007                 s->p0.power_class, s->p0.port0, s->p0.port1,
1008                 s->p0.port2, s->p0.initiated_reset, s->p0.more_packets);
1009 }
1010 #endif
1011
1012 /*
1013  * To receive self ID.
1014  */
1015 void fw_sidrcv(struct firewire_comm* fc, u_int32_t *sid, u_int len)
1016 {
1017         u_int32_t *p;
1018         union fw_self_id *self_id;
1019         u_int i, j, node, c_port = 0, i_branch = 0;
1020
1021         fc->sid_cnt = len /(sizeof(u_int32_t) * 2);
1022         fc->status = FWBUSINIT;
1023         fc->max_node = fc->nodeid & 0x3f;
1024         CSRARC(fc, NODE_IDS) = ((u_int32_t)fc->nodeid) << 16;
1025         fc->status = FWBUSCYMELECT;
1026         fc->topology_map->crc_len = 2;
1027         fc->topology_map->generation ++;
1028         fc->topology_map->self_id_count = 0;
1029         fc->topology_map->node_count = 0;
1030         fc->speed_map->generation ++;
1031         fc->speed_map->crc_len = 1 + (64*64 + 3) / 4;
1032         self_id = &fc->topology_map->self_id[0];
1033         for(i = 0; i < fc->sid_cnt; i ++){
1034                 if (sid[1] != ~sid[0]) {
1035                         printf("fw_sidrcv: invalid self-id packet\n");
1036                         sid += 2;
1037                         continue;
1038                 }
1039                 *self_id = *((union fw_self_id *)sid);
1040                 fc->topology_map->crc_len++;
1041                 if(self_id->p0.sequel == 0){
1042                         fc->topology_map->node_count ++;
1043                         c_port = 0;
1044 #if 0
1045                         fw_print_sid(sid[0]);
1046 #endif
1047                         node = self_id->p0.phy_id;
1048                         if(fc->max_node < node){
1049                                 fc->max_node = self_id->p0.phy_id;
1050                         }
1051                         /* XXX I'm not sure this is the right speed_map */
1052                         fc->speed_map->speed[node][node]
1053                                         = self_id->p0.phy_speed;
1054                         for (j = 0; j < node; j ++) {
1055                                 fc->speed_map->speed[j][node]
1056                                         = fc->speed_map->speed[node][j]
1057                                         = min(fc->speed_map->speed[j][j],
1058                                                         self_id->p0.phy_speed);
1059                         }
1060                         if ((fc->irm == -1 || self_id->p0.phy_id > fc->irm) &&
1061                           (self_id->p0.link_active && self_id->p0.contender)) {
1062                                 fc->irm = self_id->p0.phy_id;
1063                         }
1064                         if(self_id->p0.port0 >= 0x2){
1065                                 c_port++;
1066                         }
1067                         if(self_id->p0.port1 >= 0x2){
1068                                 c_port++;
1069                         }
1070                         if(self_id->p0.port2 >= 0x2){
1071                                 c_port++;
1072                         }
1073                 }
1074                 if(c_port > 2){
1075                         i_branch += (c_port - 2);
1076                 }
1077                 sid += 2;
1078                 self_id++;
1079                 fc->topology_map->self_id_count ++;
1080         }
1081         device_printf(fc->bdev, "%d nodes", fc->max_node + 1);
1082         /* CRC */
1083         fc->topology_map->crc = fw_crc16(
1084                         (u_int32_t *)&fc->topology_map->generation,
1085                         fc->topology_map->crc_len * 4);
1086         fc->speed_map->crc = fw_crc16(
1087                         (u_int32_t *)&fc->speed_map->generation,
1088                         fc->speed_map->crc_len * 4);
1089         /* byteswap and copy to CSR */
1090         p = (u_int32_t *)fc->topology_map;
1091         for (i = 0; i <= fc->topology_map->crc_len; i++)
1092                 CSRARC(fc, TOPO_MAP + i * 4) = htonl(*p++);
1093         p = (u_int32_t *)fc->speed_map;
1094         CSRARC(fc, SPED_MAP) = htonl(*p++);
1095         CSRARC(fc, SPED_MAP + 4) = htonl(*p++);
1096         /* don't byte-swap u_int8_t array */
1097         bcopy(p, &CSRARC(fc, SPED_MAP + 8), (fc->speed_map->crc_len - 1)*4);
1098
1099         fc->max_hop = fc->max_node - i_branch;
1100         printf(", maxhop <= %d", fc->max_hop);
1101
1102         if(fc->irm == -1 ){
1103                 printf(", Not found IRM capable node");
1104         }else{
1105                 printf(", cable IRM = %d", fc->irm);
1106                 if (fc->irm == fc->nodeid)
1107                         printf(" (me)");
1108         }
1109         printf("\n");
1110
1111         if (try_bmr && (fc->irm != -1) && (CSRARC(fc, BUS_MGR_ID) == 0x3f)) {
1112                 if (fc->irm == fc->nodeid) {
1113                         fc->status = FWBUSMGRDONE;
1114                         CSRARC(fc, BUS_MGR_ID) = fc->set_bmr(fc, fc->irm);
1115                         fw_bmr(fc);
1116                 } else {
1117                         fc->status = FWBUSMGRELECT;
1118                         callout_reset(&fc->bmr_callout, hz/8,
1119                                 (void *)fw_try_bmr, (void *)fc);
1120                 }
1121         } else
1122                 fc->status = FWBUSMGRDONE;
1123
1124         callout_reset(&fc->busprobe_callout, hz/4,
1125                         (void *)fw_bus_probe, (void *)fc);
1126 }
1127
1128 /*
1129  * To probe devices on the IEEE1394 bus.
1130  */
1131 static void
1132 fw_bus_probe(struct firewire_comm *fc)
1133 {
1134         int s;
1135         struct fw_device *fwdev, *next;
1136
1137         s = splfw();
1138         fc->status = FWBUSEXPLORE;
1139         fc->retry_count = 0;
1140
1141 /*
1142  * Invalidate all devices, just after bus reset. Devices
1143  * to be removed has not been seen longer time.
1144  */
1145         for (fwdev = STAILQ_FIRST(&fc->devices); fwdev != NULL; fwdev = next) {
1146                 next = STAILQ_NEXT(fwdev, link);
1147                 if (fwdev->status != FWDEVINVAL) {
1148                         fwdev->status = FWDEVINVAL;
1149                         fwdev->rcnt = 0;
1150                 } else if(fwdev->rcnt < FW_MAXDEVRCNT) {
1151                         fwdev->rcnt ++;
1152                 } else {
1153                         STAILQ_REMOVE(&fc->devices, fwdev, fw_device, link);
1154                         free(fwdev, M_FW);
1155                 }
1156         }
1157         fc->ongonode = 0;
1158         fc->ongoaddr = CSRROMOFF;
1159         fc->ongodev = NULL;
1160         fc->ongoeui.hi = 0xffffffff; fc->ongoeui.lo = 0xffffffff;
1161         fw_bus_explore(fc);
1162         splx(s);
1163 }
1164
1165 /*
1166  * To collect device informations on the IEEE1394 bus.
1167  */
1168 static void
1169 fw_bus_explore(struct firewire_comm *fc )
1170 {
1171         int err = 0;
1172         struct fw_device *fwdev, *pfwdev, *tfwdev;
1173         u_int32_t addr;
1174         struct fw_xfer *xfer;
1175         struct fw_pkt *fp;
1176
1177         if(fc->status != FWBUSEXPLORE)
1178                 return;
1179
1180 loop:
1181         if(fc->ongonode == fc->nodeid) fc->ongonode++;
1182
1183         if(fc->ongonode > fc->max_node) goto done;
1184         if(fc->ongonode >= 0x3f) goto done;
1185
1186         /* check link */
1187         /* XXX we need to check phy_id first */
1188         if (!fc->topology_map->self_id[fc->ongonode].p0.link_active) {
1189                 if (firewire_debug)
1190                         printf("node%d: link down\n", fc->ongonode);
1191                 fc->ongonode++;
1192                 goto loop;
1193         }
1194
1195         if(fc->ongoaddr <= CSRROMOFF &&
1196                 fc->ongoeui.hi == 0xffffffff &&
1197                 fc->ongoeui.lo == 0xffffffff ){
1198                 fc->ongoaddr = CSRROMOFF;
1199                 addr = 0xf0000000 | fc->ongoaddr;
1200         }else if(fc->ongoeui.hi == 0xffffffff ){
1201                 fc->ongoaddr = CSRROMOFF + 0xc;
1202                 addr = 0xf0000000 | fc->ongoaddr;
1203         }else if(fc->ongoeui.lo == 0xffffffff ){
1204                 fc->ongoaddr = CSRROMOFF + 0x10;
1205                 addr = 0xf0000000 | fc->ongoaddr;
1206         }else if(fc->ongodev == NULL){
1207                 STAILQ_FOREACH(fwdev, &fc->devices, link)
1208                         if (FW_EUI64_EQUAL(fwdev->eui, fc->ongoeui))
1209                                 break;
1210                 if(fwdev != NULL){
1211                         fwdev->dst = fc->ongonode;
1212                         fwdev->status = FWDEVATTACHED;
1213                         fc->ongonode++;
1214                         fc->ongoaddr = CSRROMOFF;
1215                         fc->ongodev = NULL;
1216                         fc->ongoeui.hi = 0xffffffff; fc->ongoeui.lo = 0xffffffff;
1217                         goto loop;
1218                 }
1219                 fwdev = malloc(sizeof(struct fw_device), M_FW, M_NOWAIT);
1220                 if(fwdev == NULL)
1221                         return;
1222                 fwdev->fc = fc;
1223                 fwdev->rommax = 0;
1224                 fwdev->dst = fc->ongonode;
1225                 fwdev->eui.hi = fc->ongoeui.hi; fwdev->eui.lo = fc->ongoeui.lo;
1226                 fwdev->status = FWDEVINIT;
1227                 fwdev->speed = fc->speed_map->speed[fc->nodeid][fc->ongonode];
1228
1229                 pfwdev = NULL;
1230                 STAILQ_FOREACH(tfwdev, &fc->devices, link) {
1231                         if (tfwdev->eui.hi > fwdev->eui.hi ||
1232                                         (tfwdev->eui.hi == fwdev->eui.hi &&
1233                                         tfwdev->eui.lo > fwdev->eui.lo))
1234                                 break;
1235                         pfwdev = tfwdev;
1236                 }
1237                 if (pfwdev == NULL)
1238                         STAILQ_INSERT_HEAD(&fc->devices, fwdev, link);
1239                 else
1240                         STAILQ_INSERT_AFTER(&fc->devices, pfwdev, fwdev, link);
1241
1242                 device_printf(fc->bdev, "New %s device ID:%08x%08x\n",
1243                         linkspeed[fwdev->speed],
1244                         fc->ongoeui.hi, fc->ongoeui.lo);
1245
1246                 fc->ongodev = fwdev;
1247                 fc->ongoaddr = CSRROMOFF;
1248                 addr = 0xf0000000 | fc->ongoaddr;
1249         }else{
1250                 addr = 0xf0000000 | fc->ongoaddr;
1251         }
1252 #if 0
1253         xfer = asyreqq(fc, FWSPD_S100, 0, 0,
1254                 ((FWLOCALBUS | fc->ongonode) << 16) | 0xffff , addr,
1255                 fw_bus_explore_callback);
1256         if(xfer == NULL) goto done;
1257 #else
1258         xfer = fw_xfer_alloc_buf(M_FWXFER, 16, 16);
1259         if(xfer == NULL){
1260                 goto done;
1261         }
1262         xfer->spd = 0;
1263         fp = (struct fw_pkt *)xfer->send.buf;
1264         fp->mode.rreqq.dest_hi = 0xffff;
1265         fp->mode.rreqq.tlrt = 0;
1266         fp->mode.rreqq.tcode = FWTCODE_RREQQ;
1267         fp->mode.rreqq.pri = 0;
1268         fp->mode.rreqq.src = 0;
1269         xfer->dst = FWLOCALBUS | fc->ongonode;
1270         fp->mode.rreqq.dst = xfer->dst;
1271         fp->mode.rreqq.dest_lo = addr;
1272         xfer->act.hand = fw_bus_explore_callback;
1273
1274         if (firewire_debug)
1275                 printf("node%d: explore addr=0x%x\n",
1276                                 fc->ongonode, fc->ongoaddr);
1277         err = fw_asyreq(fc, -1, xfer);
1278         if(err){
1279                 fw_xfer_free( xfer);
1280                 return;
1281         }
1282 #endif
1283         return;
1284 done:
1285         /* fw_attach_devs */
1286         fc->status = FWBUSEXPDONE;
1287         if (firewire_debug)
1288                 printf("bus_explore done\n");
1289         fw_attach_dev(fc);
1290         return;
1291
1292 }
1293
1294 /* Portable Async. request read quad */
1295 struct fw_xfer *
1296 asyreqq(struct firewire_comm *fc, u_int8_t spd, u_int8_t tl, u_int8_t rt,
1297         u_int32_t addr_hi, u_int32_t addr_lo,
1298         void (*hand) __P((struct fw_xfer*)))
1299 {
1300         struct fw_xfer *xfer;
1301         struct fw_pkt *fp;
1302         int err;
1303
1304         xfer = fw_xfer_alloc_buf(M_FWXFER, 16, 16);
1305         if (xfer == NULL)
1306                 return NULL;
1307
1308         xfer->spd = spd; /* XXX:min(spd, fc->spd) */
1309         fp = (struct fw_pkt *)xfer->send.buf;
1310         fp->mode.rreqq.dest_hi = addr_hi & 0xffff;
1311         if(tl & FWP_TL_VALID){
1312                 fp->mode.rreqq.tlrt = (tl & 0x3f) << 2;
1313         }else{
1314                 fp->mode.rreqq.tlrt = 0;
1315         }
1316         fp->mode.rreqq.tlrt |= rt & 0x3;
1317         fp->mode.rreqq.tcode = FWTCODE_RREQQ;
1318         fp->mode.rreqq.pri = 0;
1319         fp->mode.rreqq.src = 0;
1320         xfer->dst = addr_hi >> 16;
1321         fp->mode.rreqq.dst = xfer->dst;
1322         fp->mode.rreqq.dest_lo = addr_lo;
1323         xfer->act.hand = hand;
1324
1325         err = fw_asyreq(fc, -1, xfer);
1326         if(err){
1327                 fw_xfer_free( xfer);
1328                 return NULL;
1329         }
1330         return xfer;
1331 }
1332
1333 /*
1334  * Callback for the IEEE1394 bus information collection.
1335  */
1336 static void
1337 fw_bus_explore_callback(struct fw_xfer *xfer)
1338 {
1339         struct firewire_comm *fc;
1340         struct fw_pkt *sfp,*rfp;
1341         struct csrhdr *chdr;
1342         struct csrdir *csrd;
1343         struct csrreg *csrreg;
1344         u_int32_t offset;
1345
1346
1347         if(xfer == NULL) {
1348                 printf("xfer == NULL\n");
1349                 return;
1350         }
1351         fc = xfer->fc;
1352
1353         if (firewire_debug)
1354                 printf("node%d: callback addr=0x%x\n",
1355                         fc->ongonode, fc->ongoaddr);
1356
1357         if(xfer->resp != 0){
1358                 printf("node%d: resp=%d addr=0x%x\n",
1359                         fc->ongonode, xfer->resp, fc->ongoaddr);
1360                 goto errnode;
1361         }
1362
1363         if(xfer->send.buf == NULL){
1364                 printf("node%d: send.buf=NULL addr=0x%x\n",
1365                         fc->ongonode, fc->ongoaddr);
1366                 goto errnode;
1367         }
1368         sfp = (struct fw_pkt *)xfer->send.buf;
1369
1370         if(xfer->recv.buf == NULL){
1371                 printf("node%d: recv.buf=NULL addr=0x%x\n",
1372                         fc->ongonode, fc->ongoaddr);
1373                 goto errnode;
1374         }
1375         rfp = (struct fw_pkt *)xfer->recv.buf;
1376 #if 0
1377         {
1378                 u_int32_t *qld;
1379                 int i;
1380                 qld = (u_int32_t *)xfer->recv.buf;
1381                 printf("len:%d\n", xfer->recv.len);
1382                 for( i = 0 ; i <= xfer->recv.len && i < 32; i+= 4){
1383                         printf("0x%08x ", rfp->mode.ld[i/4]);
1384                         if((i % 16) == 15) printf("\n");
1385                 }
1386                 if((i % 16) != 15) printf("\n");
1387         }
1388 #endif
1389         if(fc->ongodev == NULL){
1390                 if(sfp->mode.rreqq.dest_lo == (0xf0000000 | CSRROMOFF)){
1391                         rfp->mode.rresq.data = ntohl(rfp->mode.rresq.data);
1392                         chdr = (struct csrhdr *)(&rfp->mode.rresq.data);
1393 /* If CSR is minimal confinguration, more investgation is not needed. */
1394                         if(chdr->info_len == 1){
1395                                 if (firewire_debug)
1396                                         printf("node%d: minimal config\n",
1397                                                                 fc->ongonode);
1398                                 goto nextnode;
1399                         }else{
1400                                 fc->ongoaddr = CSRROMOFF + 0xc;
1401                         }
1402                 }else if(sfp->mode.rreqq.dest_lo == (0xf0000000 |(CSRROMOFF + 0xc))){
1403                         fc->ongoeui.hi = ntohl(rfp->mode.rresq.data);
1404                         fc->ongoaddr = CSRROMOFF + 0x10;
1405                 }else if(sfp->mode.rreqq.dest_lo == (0xf0000000 |(CSRROMOFF + 0x10))){
1406                         fc->ongoeui.lo = ntohl(rfp->mode.rresq.data);
1407                         if (fc->ongoeui.hi == 0 && fc->ongoeui.lo == 0) {
1408                                 if (firewire_debug)
1409                                         printf("node%d: eui64 is zero.\n",
1410                                                         fc->ongonode);
1411                                 goto nextnode;
1412                         }
1413                         fc->ongoaddr = CSRROMOFF;
1414                 }
1415         }else{
1416                 fc->ongodev->csrrom[(fc->ongoaddr - CSRROMOFF)/4] = ntohl(rfp->mode.rresq.data);
1417                 if(fc->ongoaddr > fc->ongodev->rommax){
1418                         fc->ongodev->rommax = fc->ongoaddr;
1419                 }
1420                 csrd = SLIST_FIRST(&fc->ongocsr);
1421                 if((csrd = SLIST_FIRST(&fc->ongocsr)) == NULL){
1422                         chdr = (struct csrhdr *)(fc->ongodev->csrrom);
1423                         offset = CSRROMOFF;
1424                 }else{
1425                         chdr = (struct csrhdr *)&fc->ongodev->csrrom[(csrd->off - CSRROMOFF)/4];
1426                         offset = csrd->off;
1427                 }
1428                 if(fc->ongoaddr > (CSRROMOFF + 0x14) && fc->ongoaddr != offset){
1429                         csrreg = (struct csrreg *)&fc->ongodev->csrrom[(fc->ongoaddr - CSRROMOFF)/4];
1430                         if( csrreg->key == 0x81 || csrreg->key == 0xd1){
1431                                 csrd = SLIST_FIRST(&fc->csrfree);
1432                                 if(csrd == NULL){
1433                                         goto nextnode;
1434                                 }else{
1435                                         csrd->ongoaddr = fc->ongoaddr;
1436                                         fc->ongoaddr += csrreg->val * 4;
1437                                         csrd->off = fc->ongoaddr;
1438                                         SLIST_REMOVE_HEAD(&fc->csrfree, link);
1439                                         SLIST_INSERT_HEAD(&fc->ongocsr, csrd, link);
1440                                         goto nextaddr;
1441                                 }
1442                         }
1443                 }
1444                 fc->ongoaddr += 4;
1445                 if(((fc->ongoaddr - offset)/4 > chdr->crc_len) &&
1446                                 (fc->ongodev->rommax < 0x414)){
1447                         if(fc->ongodev->rommax <= 0x414){
1448                                 csrd = SLIST_FIRST(&fc->csrfree);
1449                                 if(csrd == NULL) goto nextnode;
1450                                 csrd->off = fc->ongoaddr;
1451                                 csrd->ongoaddr = fc->ongoaddr;
1452                                 SLIST_REMOVE_HEAD(&fc->csrfree, link);
1453                                 SLIST_INSERT_HEAD(&fc->ongocsr, csrd, link);
1454                         }
1455                         goto nextaddr;
1456                 }
1457
1458                 while(((fc->ongoaddr - offset)/4 > chdr->crc_len)){
1459                         if(csrd == NULL){
1460                                 goto nextnode;
1461                         };
1462                         fc->ongoaddr = csrd->ongoaddr + 4;
1463                         SLIST_REMOVE_HEAD(&fc->ongocsr, link);
1464                         SLIST_INSERT_HEAD(&fc->csrfree, csrd, link);
1465                         csrd = SLIST_FIRST(&fc->ongocsr);
1466                         if((csrd = SLIST_FIRST(&fc->ongocsr)) == NULL){
1467                                 chdr = (struct csrhdr *)(fc->ongodev->csrrom);
1468                                 offset = CSRROMOFF;
1469                         }else{
1470                                 chdr = (struct csrhdr *)&(fc->ongodev->csrrom[(csrd->off - CSRROMOFF)/4]);
1471                                 offset = csrd->off;
1472                         }
1473                 }
1474                 if((fc->ongoaddr - CSRROMOFF) > CSRROMSIZE){
1475                         goto nextnode;
1476                 }
1477         }
1478 nextaddr:
1479         fw_xfer_free( xfer);
1480         fw_bus_explore(fc);
1481         return;
1482 errnode:
1483         fc->retry_count++;
1484         if (fc->ongodev != NULL)
1485                 fc->ongodev->status = FWDEVINVAL;
1486 nextnode:
1487         fw_xfer_free( xfer);
1488         fc->ongonode++;
1489 /* housekeeping work space */
1490         fc->ongoaddr = CSRROMOFF;
1491         fc->ongodev = NULL;
1492         fc->ongoeui.hi = 0xffffffff; fc->ongoeui.lo = 0xffffffff;
1493         while((csrd = SLIST_FIRST(&fc->ongocsr)) != NULL){
1494                 SLIST_REMOVE_HEAD(&fc->ongocsr, link);
1495                 SLIST_INSERT_HEAD(&fc->csrfree, csrd, link);
1496         }
1497         fw_bus_explore(fc);
1498         return;
1499 }
1500
1501 /*
1502  * To attach sub-devices layer onto IEEE1394 bus.
1503  */
1504 static void
1505 fw_attach_dev(struct firewire_comm *fc)
1506 {
1507         struct fw_device *fwdev;
1508         struct fw_xfer *xfer;
1509         int i, err;
1510         device_t *devlistp;
1511         int devcnt;
1512         struct firewire_dev_comm *fdc;
1513
1514         STAILQ_FOREACH(fwdev, &fc->devices, link)
1515                 if (fwdev->status == FWDEVINIT)
1516                         fwdev->status = FWDEVATTACHED;
1517
1518         err = device_get_children(fc->bdev, &devlistp, &devcnt);
1519         if( err != 0 )
1520                 return;
1521         for( i = 0 ; i < devcnt ; i++){
1522                 if (device_get_state(devlistp[i]) >= DS_ATTACHED)  {
1523                         fdc = device_get_softc(devlistp[i]);
1524                         if (fdc->post_explore != NULL)
1525                                 fdc->post_explore(fdc);
1526                 }
1527         }
1528         free(devlistp, M_TEMP);
1529
1530         /* call pending handlers */
1531         i = 0;
1532         while ((xfer = STAILQ_FIRST(&fc->pending))) {
1533                 STAILQ_REMOVE_HEAD(&fc->pending, link);
1534                 i++;
1535                 if (xfer->act.hand)
1536                         xfer->act.hand(xfer);
1537         }
1538         if (i > 0)
1539                 printf("fw_attach_dev: %d pending handlers called\n", i);
1540         if (fc->retry_count > 0) {
1541                 printf("probe failed for %d node\n", fc->retry_count);
1542 #if 0
1543                 callout_reset(&fc->retry_probe_callout, hz*2,
1544                                         (void *)fc->ibr, (void *)fc);
1545 #endif
1546         }
1547         return;
1548 }
1549
1550 /*
1551  * To allocate uniq transaction label.
1552  */
1553 static int
1554 fw_get_tlabel(struct firewire_comm *fc, struct fw_xfer *xfer)
1555 {
1556         u_int i;
1557         struct tlabel *tl, *tmptl;
1558         int s;
1559         static u_int32_t label = 0;
1560
1561         s = splfw();
1562         for( i = 0 ; i < 0x40 ; i ++){
1563                 label = (label + 1) & 0x3f;
1564                 for(tmptl = STAILQ_FIRST(&fc->tlabels[label]);
1565                         tmptl != NULL; tmptl = STAILQ_NEXT(tmptl, link)){
1566                         if(tmptl->xfer->dst == xfer->dst) break;
1567                 }
1568                 if(tmptl == NULL) {
1569                         tl = malloc(sizeof(struct tlabel),M_FW,M_NOWAIT);
1570                         if (tl == NULL) {
1571                                 splx(s);
1572                                 return (-1);
1573                         }
1574                         tl->xfer = xfer;
1575                         STAILQ_INSERT_TAIL(&fc->tlabels[label], tl, link);
1576                         splx(s);
1577                         if (firewire_debug > 1)
1578                                 printf("fw_get_tlabel: dst=%d tl=%d\n",
1579                                                 xfer->dst, label);
1580                         return(label);
1581                 }
1582         }
1583         splx(s);
1584
1585         printf("fw_get_tlabel: no free tlabel\n");
1586         return(-1);
1587 }
1588
1589 static void
1590 fw_rcv_copy(struct fw_xfer *xfer, struct iovec *vec, int nvec)
1591 {
1592         char *p;
1593         int res, i, len;
1594
1595         p = xfer->recv.buf;
1596         res = xfer->recv.len;
1597         for (i = 0; i < nvec; i++, vec++) {
1598                 len = vec->iov_len;
1599                 if (res < len) {
1600                         printf("rcv buffer(%d) is %d bytes short.\n",
1601                                                 xfer->recv.len, len - res);
1602                         len = res;
1603                 }
1604                 bcopy(vec->iov_base, p, len);
1605                 p += len;
1606                 res -= len;
1607                 if (res <= 0)
1608                         break;
1609         }
1610         xfer->recv.len -= res;
1611 }
1612
1613 /*
1614  * Generic packet receving process.
1615  */
1616 void
1617 fw_rcv(struct firewire_comm *fc, struct iovec *vec, int nvec, u_int sub, u_int spd)
1618 {
1619         struct fw_pkt *fp, *resfp;
1620         struct fw_xfer *xfer;
1621         struct fw_bind *bind;
1622         struct firewire_softc *sc;
1623         int tcode, s;
1624         int i, len, oldstate;
1625 #if 0
1626         {
1627                 u_int32_t *qld;
1628                 int i;
1629                 qld = (u_int32_t *)buf;
1630                 printf("spd %d len:%d\n", spd, len);
1631                 for( i = 0 ; i <= len && i < 32; i+= 4){
1632                         printf("0x%08x ", ntohl(qld[i/4]));
1633                         if((i % 16) == 15) printf("\n");
1634                 }
1635                 if((i % 16) != 15) printf("\n");
1636         }
1637 #endif
1638         fp = (struct fw_pkt *)vec[0].iov_base;
1639         tcode = fp->mode.common.tcode;
1640 #if 0 /* XXX this check is not valid for RRESQ and WREQQ */
1641         if (vec[0].iov_len < fc->tcode[tcode].hdr_len) {
1642 #if __FreeBSD_version >= 500000
1643                 printf("fw_rcv: iov_len(%zu) is less than"
1644 #else
1645                 printf("fw_rcv: iov_len(%u) is less than"
1646 #endif
1647                         " hdr_len(%d:tcode=%d)\n", vec[0].iov_len,
1648                         fc->tcode[tcode].hdr_len, tcode);
1649         }
1650 #endif
1651         switch (tcode) {
1652         case FWTCODE_WRES:
1653         case FWTCODE_RRESQ:
1654         case FWTCODE_RRESB:
1655         case FWTCODE_LRES:
1656                 xfer = fw_tl2xfer(fc, fp->mode.hdr.src,
1657                                         fp->mode.hdr.tlrt >> 2);
1658                 if(xfer == NULL) {
1659                         printf("fw_rcv: unknown response "
1660                                         "tcode=%d src=0x%x tl=0x%x rt=%d data=0x%x\n",
1661                                         tcode,
1662                                         fp->mode.hdr.src,
1663                                         fp->mode.hdr.tlrt >> 2,
1664                                         fp->mode.hdr.tlrt & 3,
1665                                         fp->mode.rresq.data);
1666 #if 1
1667                         printf("try ad-hoc work around!!\n");
1668                         xfer = fw_tl2xfer(fc, fp->mode.hdr.src,
1669                                         (fp->mode.hdr.tlrt >> 2)^3);
1670                         if (xfer == NULL) {
1671                                 printf("no use...\n");
1672                                 goto err;
1673                         }
1674 #else
1675                         goto err;
1676 #endif
1677                 }
1678                 fw_rcv_copy(xfer, vec, nvec);
1679                 xfer->resp = 0;
1680                 /* make sure the packet is drained in AT queue */
1681                 oldstate = xfer->state;
1682                 xfer->state = FWXF_RCVD;
1683                 switch (oldstate) {
1684                 case FWXF_SENT:
1685                         fw_xfer_done(xfer);
1686                         break;
1687                 case FWXF_START:
1688                         if (firewire_debug)
1689                                 printf("not sent yet\n");
1690                         break;
1691                 default:
1692                         printf("unexpected state %d\n", xfer->state);
1693                 }
1694                 return;
1695         case FWTCODE_WREQQ:
1696         case FWTCODE_WREQB:
1697         case FWTCODE_RREQQ:
1698         case FWTCODE_RREQB:
1699         case FWTCODE_LREQ:
1700                 bind = fw_bindlookup(fc, fp->mode.rreqq.dest_hi,
1701                         fp->mode.rreqq.dest_lo);
1702                 if(bind == NULL){
1703 #if __FreeBSD_version >= 500000
1704                         printf("Unknown service addr 0x%08x:0x%08x tcode=%x src=0x%x data=%x\n",
1705 #else
1706                         printf("Unknown service addr 0x%08x:0x%08x tcode=%x src=0x%x data=%lx\n",
1707 #endif
1708                                 fp->mode.wreqq.dest_hi,
1709                                 fp->mode.wreqq.dest_lo,
1710                                 tcode,
1711                                 fp->mode.hdr.src,
1712                                 ntohl(fp->mode.wreqq.data));
1713                         if (fc->status == FWBUSRESET) {
1714                                 printf("fw_rcv: cannot respond(bus reset)!\n");
1715                                 goto err;
1716                         }
1717                         xfer = fw_xfer_alloc_buf(M_FWXFER, 16, 0);
1718                         if(xfer == NULL){
1719                                 return;
1720                         }
1721                         xfer->spd = spd;
1722                         resfp = (struct fw_pkt *)xfer->send.buf;
1723                         switch (tcode) {
1724                         case FWTCODE_WREQQ:
1725                         case FWTCODE_WREQB:
1726                                 resfp->mode.hdr.tcode = FWTCODE_WRES;
1727                                 xfer->send.len = 12;
1728                                 break;
1729                         case FWTCODE_RREQQ:
1730                                 resfp->mode.hdr.tcode = FWTCODE_RRESQ;
1731                                 xfer->send.len = 16;
1732                                 break;
1733                         case FWTCODE_RREQB:
1734                                 resfp->mode.hdr.tcode = FWTCODE_RRESB;
1735                                 xfer->send.len = 16;
1736                                 break;
1737                         case FWTCODE_LREQ:
1738                                 resfp->mode.hdr.tcode = FWTCODE_LRES;
1739                                 xfer->send.len = 16;
1740                                 break;
1741                         }
1742                         resfp->mode.hdr.dst = fp->mode.hdr.src;
1743                         resfp->mode.hdr.tlrt = fp->mode.hdr.tlrt;
1744                         resfp->mode.hdr.pri = fp->mode.hdr.pri;
1745                         resfp->mode.rresb.rtcode = 7;
1746                         resfp->mode.rresb.extcode = 0;
1747                         resfp->mode.rresb.len = 0;
1748 /*
1749                         xfer->act.hand = fw_asy_callback;
1750 */
1751                         xfer->act.hand = fw_xfer_free;
1752                         if(fw_asyreq(fc, -1, xfer)){
1753                                 fw_xfer_free( xfer);
1754                                 return;
1755                         }
1756                         goto err;
1757                 }
1758                 len = 0;
1759                 for (i = 0; i < nvec; i ++)
1760                         len += vec[i].iov_len;
1761                 switch(bind->act_type){
1762                 case FWACT_XFER:
1763                         /* splfw()?? */
1764                         xfer = STAILQ_FIRST(&bind->xferlist);
1765                         if (xfer == NULL) {
1766                                 printf("Discard a packet for this bind.\n");
1767                                 goto err;
1768                         }
1769                         STAILQ_REMOVE_HEAD(&bind->xferlist, link);
1770                         fw_rcv_copy(xfer, vec, nvec);
1771                         xfer->spd = spd;
1772                         if (fc->status != FWBUSRESET)
1773                                 xfer->act.hand(xfer);
1774                         else
1775                                 STAILQ_INSERT_TAIL(&fc->pending, xfer, link);
1776                         return;
1777                         break;
1778                 case FWACT_CH:
1779                         if(fc->ir[bind->sub]->queued >=
1780                                 fc->ir[bind->sub]->maxq){
1781                                 device_printf(fc->bdev,
1782                                         "Discard a packet %x %d\n",
1783                                         bind->sub,
1784                                         fc->ir[bind->sub]->queued);
1785                                 goto err;
1786                         }
1787                         xfer = STAILQ_FIRST(&bind->xferlist);
1788                         if (xfer == NULL) {
1789                                 printf("Discard packet for this bind\n");
1790                                 goto err;
1791                         }
1792                         STAILQ_REMOVE_HEAD(&bind->xferlist, link);
1793                         fw_rcv_copy(xfer, vec, nvec);
1794                         xfer->spd = spd;
1795                         s = splfw();
1796                         fc->ir[bind->sub]->queued++;
1797                         STAILQ_INSERT_TAIL(&fc->ir[bind->sub]->q, xfer, link);
1798                         splx(s);
1799
1800                         wakeup((caddr_t)fc->ir[bind->sub]);
1801
1802                         return;
1803                         break;
1804                 default:
1805                         goto err;
1806                         break;
1807                 }
1808                 break;
1809         case FWTCODE_STREAM:
1810         {
1811                 struct fw_xferq *xferq;
1812
1813                 xferq = fc->ir[sub];
1814 #if 0
1815                 printf("stream rcv dma %d len %d off %d spd %d\n",
1816                         sub, len, off, spd);
1817 #endif
1818                 if(xferq->queued >= xferq->maxq) {
1819                         printf("receive queue is full\n");
1820                         goto err;
1821                 }
1822                 /* XXX get xfer from xfer queue, we don't need copy for
1823                         per packet mode */
1824                 xfer = fw_xfer_alloc_buf(M_FWXFER, 0, /* XXX */
1825                                                 vec[0].iov_len);
1826                 if(xfer == NULL) goto err;
1827                 fw_rcv_copy(xfer, vec, nvec);
1828                 xfer->spd = spd;
1829                 s = splfw();
1830                 xferq->queued++;
1831                 STAILQ_INSERT_TAIL(&xferq->q, xfer, link);
1832                 splx(s);
1833                 sc = device_get_softc(fc->bdev);
1834 #if __FreeBSD_version >= 500000
1835                 if (SEL_WAITING(&xferq->rsel))
1836 #else
1837                 if (&xferq->rsel.si_pid != 0)
1838 #endif
1839                         selwakeup(&xferq->rsel);
1840                 if (xferq->flag & FWXFERQ_WAKEUP) {
1841                         xferq->flag &= ~FWXFERQ_WAKEUP;
1842                         wakeup((caddr_t)xferq);
1843                 }
1844                 if (xferq->flag & FWXFERQ_HANDLER) {
1845                         xferq->hand(xferq);
1846                 }
1847                 return;
1848                 break;
1849         }
1850         default:
1851                 printf("fw_rcv: unknow tcode %d\n", tcode);
1852                 break;
1853         }
1854 err:
1855         return;
1856 }
1857
1858 /*
1859  * Post process for Bus Manager election process.
1860  */
1861 static void
1862 fw_try_bmr_callback(struct fw_xfer *xfer)
1863 {
1864         struct fw_pkt *rfp;
1865         struct firewire_comm *fc;
1866         int bmr;
1867
1868         if (xfer == NULL)
1869                 return;
1870         fc = xfer->fc;
1871         if (xfer->resp != 0)
1872                 goto error;
1873         if (xfer->send.buf == NULL)
1874                 goto error;
1875         if (xfer->recv.buf == NULL)
1876                 goto error;
1877         rfp = (struct fw_pkt *)xfer->recv.buf;
1878         if (rfp->mode.lres.rtcode != FWRCODE_COMPLETE)
1879                 goto error;
1880
1881         bmr = ntohl(rfp->mode.lres.payload[0]);
1882         if (bmr == 0x3f)
1883                 bmr = fc->nodeid;
1884
1885         CSRARC(fc, BUS_MGR_ID) = fc->set_bmr(fc, bmr & 0x3f);
1886         fw_xfer_free(xfer);
1887         fw_bmr(fc);
1888         return;
1889
1890 error:
1891         device_printf(fc->bdev, "bus manager election failed\n");
1892         fw_xfer_free(xfer);
1893 }
1894
1895
1896 /*
1897  * To candidate Bus Manager election process.
1898  */
1899 static void
1900 fw_try_bmr(void *arg)
1901 {
1902         struct fw_xfer *xfer;
1903         struct firewire_comm *fc = (struct firewire_comm *)arg;
1904         struct fw_pkt *fp;
1905         int err = 0;
1906
1907         xfer = fw_xfer_alloc_buf(M_FWXFER, 24, 20);
1908         if(xfer == NULL){
1909                 return;
1910         }
1911         xfer->spd = 0;
1912         fc->status = FWBUSMGRELECT;
1913
1914         fp = (struct fw_pkt *)xfer->send.buf;
1915         fp->mode.lreq.dest_hi = 0xffff;
1916         fp->mode.lreq.tlrt = 0;
1917         fp->mode.lreq.tcode = FWTCODE_LREQ;
1918         fp->mode.lreq.pri = 0;
1919         fp->mode.lreq.src = 0;
1920         fp->mode.lreq.len = 8;
1921         fp->mode.lreq.extcode = FW_LREQ_CMPSWAP;
1922         xfer->dst = FWLOCALBUS | fc->irm;
1923         fp->mode.lreq.dst = xfer->dst;
1924         fp->mode.lreq.dest_lo = 0xf0000000 | BUS_MGR_ID;
1925         fp->mode.lreq.payload[0] = htonl(0x3f);
1926         fp->mode.lreq.payload[1] = htonl(fc->nodeid);
1927         xfer->act.hand = fw_try_bmr_callback;
1928
1929         err = fw_asyreq(fc, -1, xfer);
1930         if(err){
1931                 fw_xfer_free( xfer);
1932                 return;
1933         }
1934         return;
1935 }
1936
1937 #ifdef FW_VMACCESS
1938 /*
1939  * Software implementation for physical memory block access.
1940  * XXX:Too slow, usef for debug purpose only.
1941  */
1942 static void
1943 fw_vmaccess(struct fw_xfer *xfer){
1944         struct fw_pkt *rfp, *sfp = NULL;
1945         u_int32_t *ld = (u_int32_t *)xfer->recv.buf;
1946
1947         printf("vmaccess spd:%2x len:%03x data:%08x %08x %08x %08x\n",
1948                         xfer->spd, xfer->recv.len, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]), ntohl(ld[3]));
1949         printf("vmaccess          data:%08x %08x %08x %08x\n", ntohl(ld[4]), ntohl(ld[5]), ntohl(ld[6]), ntohl(ld[7]));
1950         if(xfer->resp != 0){
1951                 fw_xfer_free( xfer);
1952                 return;
1953         }
1954         if(xfer->recv.buf == NULL){
1955                 fw_xfer_free( xfer);
1956                 return;
1957         }
1958         rfp = (struct fw_pkt *)xfer->recv.buf;
1959         switch(rfp->mode.hdr.tcode){
1960                 /* XXX need fix for 64bit arch */
1961                 case FWTCODE_WREQB:
1962                         xfer->send.buf = malloc(12, M_FW, M_NOWAIT);
1963                         xfer->send.len = 12;
1964                         sfp = (struct fw_pkt *)xfer->send.buf;
1965                         bcopy(rfp->mode.wreqb.payload,
1966                                 (caddr_t)ntohl(rfp->mode.wreqb.dest_lo), ntohs(rfp->mode.wreqb.len));
1967                         sfp->mode.wres.tcode = FWTCODE_WRES;
1968                         sfp->mode.wres.rtcode = 0;
1969                         break;
1970                 case FWTCODE_WREQQ:
1971                         xfer->send.buf = malloc(12, M_FW, M_NOWAIT);
1972                         xfer->send.len = 12;
1973                         sfp->mode.wres.tcode = FWTCODE_WRES;
1974                         *((u_int32_t *)(ntohl(rfp->mode.wreqb.dest_lo))) = rfp->mode.wreqq.data;
1975                         sfp->mode.wres.rtcode = 0;
1976                         break;
1977                 case FWTCODE_RREQB:
1978                         xfer->send.buf = malloc(16 + rfp->mode.rreqb.len, M_FW, M_NOWAIT);
1979                         xfer->send.len = 16 + ntohs(rfp->mode.rreqb.len);
1980                         sfp = (struct fw_pkt *)xfer->send.buf;
1981                         bcopy((caddr_t)ntohl(rfp->mode.rreqb.dest_lo),
1982                                 sfp->mode.rresb.payload, (u_int16_t)ntohs(rfp->mode.rreqb.len));
1983                         sfp->mode.rresb.tcode = FWTCODE_RRESB;
1984                         sfp->mode.rresb.len = rfp->mode.rreqb.len;
1985                         sfp->mode.rresb.rtcode = 0;
1986                         sfp->mode.rresb.extcode = 0;
1987                         break;
1988                 case FWTCODE_RREQQ:
1989                         xfer->send.buf = malloc(16, M_FW, M_NOWAIT);
1990                         xfer->send.len = 16;
1991                         sfp = (struct fw_pkt *)xfer->send.buf;
1992                         sfp->mode.rresq.data = *(u_int32_t *)(ntohl(rfp->mode.rreqq.dest_lo));
1993                         sfp->mode.wres.tcode = FWTCODE_RRESQ;
1994                         sfp->mode.rresb.rtcode = 0;
1995                         break;
1996                 default:
1997                         fw_xfer_free( xfer);
1998                         return;
1999         }
2000         sfp->mode.hdr.dst = rfp->mode.hdr.src;
2001         xfer->dst = ntohs(rfp->mode.hdr.src);
2002         xfer->act.hand = fw_xfer_free;
2003         xfer->retry_req = fw_asybusy;
2004
2005         sfp->mode.hdr.tlrt = rfp->mode.hdr.tlrt;
2006         sfp->mode.hdr.pri = 0;
2007
2008         fw_asyreq(xfer->fc, -1, xfer);
2009 /**/
2010         return;
2011 }
2012 #endif
2013
2014 /*
2015  * CRC16 check-sum for IEEE1394 register blocks.
2016  */
2017 u_int16_t
2018 fw_crc16(u_int32_t *ptr, u_int32_t len){
2019         u_int32_t i, sum, crc = 0;
2020         int shift;
2021         len = (len + 3) & ~3;
2022         for(i = 0 ; i < len ; i+= 4){
2023                 for( shift = 28 ; shift >= 0 ; shift -= 4){
2024                         sum = ((crc >> 12) ^ (ptr[i/4] >> shift)) & 0xf;
2025                         crc = (crc << 4) ^ ( sum << 12 ) ^ ( sum << 5) ^ sum;
2026                 }
2027                 crc &= 0xffff;
2028         }
2029         return((u_int16_t) crc);
2030 }
2031
2032 static int
2033 fw_bmr(struct firewire_comm *fc)
2034 {
2035         struct fw_device fwdev;
2036         union fw_self_id *self_id;
2037         int cmstr;
2038
2039         /* Check to see if the current root node is cycle master capable */
2040         self_id = &fc->topology_map->self_id[fc->max_node];
2041         if (fc->max_node > 0) {
2042                 /* XXX check cmc bit of businfo block rather than contender */
2043                 if (self_id->p0.link_active && self_id->p0.contender)
2044                         cmstr = fc->max_node;
2045                 else {
2046                         device_printf(fc->bdev,
2047                                 "root node is not cycle master capable\n");
2048                         /* XXX shall we be the cycle master? */
2049                         cmstr = fc->nodeid;
2050                         /* XXX need bus reset */
2051                 }
2052         } else
2053                 cmstr = -1;
2054
2055         device_printf(fc->bdev, "bus manager %d ", CSRARC(fc, BUS_MGR_ID));
2056         if(CSRARC(fc, BUS_MGR_ID) != fc->nodeid) {
2057                 /* We are not the bus manager */
2058                 printf("\n");
2059                 return(0);
2060         }
2061         printf("(me)\n");
2062
2063         /* Optimize gapcount */
2064         if(fc->max_hop <= MAX_GAPHOP )
2065                 fw_phy_config(fc, cmstr, gap_cnt[fc->max_hop]);
2066         /* If we are the cycle master, nothing to do */
2067         if (cmstr == fc->nodeid || cmstr == -1)
2068                 return 0;
2069         /* Bus probe has not finished, make dummy fwdev for cmstr */
2070         bzero(&fwdev, sizeof(fwdev));
2071         fwdev.fc = fc;
2072         fwdev.dst = cmstr;
2073         fwdev.speed = 0;
2074         fwdev.maxrec = 8; /* 512 */
2075         fwdev.status = FWDEVINIT;
2076         /* Set cmstr bit on the cycle master */
2077         fwmem_write_quad(&fwdev, NULL, 0/*spd*/,
2078                 0xffff, 0xf0000000 | STATE_SET, htonl(1 << 8),
2079                 fw_asy_callback_free);
2080
2081         return 0;
2082 }
2083
2084 DRIVER_MODULE(firewire,fwohci,firewire_driver,firewire_devclass,0,0);
2085 MODULE_VERSION(firewire, 1);