1 /*-
2 * SPDX-License-Identifier: BSD-4-Clause
3 *
4 * Copyright (c) 2003 Hidetoshi Shimokawa
5 * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the acknowledgement as bellow:
18 *
19 * This product includes software developed by K. Kobayashi and H. Shimokawa
20 *
21 * 4. The name of the author may not be used to endorse or promote products
22 * derived from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
26 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
28 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
29 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
32 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37 #include <sys/param.h>
38 #include <sys/conf.h>
39 #include <sys/eventhandler.h>
40 #include <sys/jail.h>
41 #include <sys/kernel.h>
42 #include <sys/kthread.h>
43 #include <sys/malloc.h>
44 #include <sys/module.h>
45 #include <sys/sysctl.h>
46 #include <sys/systm.h>
47
48 #include <sys/kdb.h>
49 #include <sys/bus.h> /* used by smbus and newbus */
50 #include <machine/bus.h>
51
52 #include <dev/firewire/firewire.h>
53 #include <dev/firewire/firewirereg.h>
54 #include <dev/firewire/fwmem.h>
55 #include <dev/firewire/iec13213.h>
56 #include <dev/firewire/iec68113.h>
57
58 struct crom_src_buf {
59 struct crom_src src;
60 struct crom_chunk root;
61 struct crom_chunk vendor;
62 struct crom_chunk hw;
63 };
64
65 int firewire_debug = 0, try_bmr = 1, hold_count = 0;
66 SYSCTL_INT(_debug, OID_AUTO, firewire_debug, CTLFLAG_RW, &firewire_debug, 0,
67 "FireWire driver debug flag");
68 SYSCTL_NODE(_hw, OID_AUTO, firewire, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
69 "FireWire Subsystem");
70 SYSCTL_INT(_hw_firewire, OID_AUTO, try_bmr, CTLFLAG_RW, &try_bmr, 0,
71 "Try to be a bus manager");
72 SYSCTL_INT(_hw_firewire, OID_AUTO, hold_count, CTLFLAG_RW, &hold_count, 0,
73 "Number of count of bus resets for removing lost device information");
74
75 MALLOC_DEFINE(M_FW, "firewire", "FireWire");
76 MALLOC_DEFINE(M_FWXFER, "fw_xfer", "XFER/FireWire");
77
78 #define FW_MAXASYRTY 4
79
80 /* Split timeout: 800 cycles (see IEEE 1394-1995 8.3.2.2.2) */
81 #define FW_SPLIT_TIMEOUT_CYCLES 800
82 /* Default available isochronous bandwidth units (IEEE 1394-1995 Table 8-4) */
83 #define FW_BANDWIDTH_AVAILABLE 4915
84 /* ROM header size in quads: bus info block (4) + CRC quad (1) */
85 #define FW_ROM_HEADER_QUADS 5
86 /* Maximum retries when exploring a remote node's CSR ROM */
87 #define FW_EXPLORE_MAX_RETRIES 3
88 /* maxrec value encoding 512-byte payload (2^(maxrec+1) = 512 => maxrec=8) */
89 #define FW_MAXREC_512 8
90
91 /* PHY configuration packet bit fields (IEEE 1394-1995 4.3.4.1) */
92 #define FW_PHY_ROOT_BIT (1 << 23)
93 #define FW_PHY_ROOT_SHIFT 24
94 #define FW_PHY_GAP_BIT (1 << 22)
95 #define FW_PHY_GAP_SHIFT 16
96
97 devclass_t firewire_devclass;
98
99 static void firewire_identify(driver_t *, device_t);
100 static int firewire_probe(device_t);
101 static int firewire_attach(device_t);
102 static int firewire_detach(device_t);
103 static int firewire_resume(device_t);
104 static void firewire_xfer_timeout(void *, int);
105 static device_t firewire_add_child(device_t, u_int, const char *, int);
106 static void firewire_child_deleted(device_t, device_t);
107 static void fw_try_bmr(void *);
108 static void fw_try_bmr_callback(struct fw_xfer *);
109 static void fw_asystart(struct fw_xfer *);
110 static int fw_get_tlabel(struct firewire_comm *, struct fw_xfer *);
111 static void fw_bus_probe(void *);
112 static void fw_attach_dev(struct firewire_comm *);
113 static void fw_parse_units(struct fw_device *);
114 static void fw_create_unit_children(struct firewire_comm *, struct fw_device *);
115 static int fw_remove_unit_children(struct firewire_comm *, struct fw_device *);
116 static void fw_bus_probe_thread(void *);
117 #ifdef FW_VMACCESS
118 static void fw_vmaccess (struct fw_xfer *);
119 #endif
120 static int fw_bmr (struct firewire_comm *);
121 static void fw_dump_hdr(struct fw_pkt *, char *);
122
123 static device_method_t firewire_methods[] = {
124 /* Device interface */
125 DEVMETHOD(device_identify, firewire_identify),
126 DEVMETHOD(device_probe, firewire_probe),
127 DEVMETHOD(device_attach, firewire_attach),
128 DEVMETHOD(device_detach, firewire_detach),
129 DEVMETHOD(device_suspend, bus_generic_suspend),
130 DEVMETHOD(device_resume, firewire_resume),
131 DEVMETHOD(device_shutdown, bus_generic_shutdown),
132
133 /* Bus interface */
134 DEVMETHOD(bus_add_child, firewire_add_child),
135 DEVMETHOD(bus_child_deleted, firewire_child_deleted),
136
137 DEVMETHOD_END
138 };
139
140 char *linkspeed[] = {
141 "S100", "S200", "S400", "S800",
142 "S1600", "S3200", "undef", "undef"
143 };
144
145 static char *tcode_str[] = {
146 "WREQQ", "WREQB", "WRES", "undef",
147 "RREQQ", "RREQB", "RRESQ", "RRESB",
148 "CYCS", "LREQ", "STREAM", "LRES",
149 "undef", "undef", "PHY", "undef"
150 };
151
152 /* IEEE-1394a Table C-2 Gap count as a function of hops*/
153 #define MAX_GAPHOP 15
154 u_int gap_cnt[] = { 5, 5, 7, 8, 10, 13, 16, 18,
155 21, 24, 26, 29, 32, 35, 37, 40};
156
157 static driver_t firewire_driver = {
158 "firewire",
159 firewire_methods,
160 sizeof(struct firewire_softc),
161 };
162
163 /*
164 * Lookup fwdev by node id.
165 */
166 struct fw_device *
fw_noderesolve_nodeid(struct firewire_comm * fc,int dst)167 fw_noderesolve_nodeid(struct firewire_comm *fc, int dst)
168 {
169 struct fw_device *fwdev;
170
171 FW_GLOCK(fc);
172 STAILQ_FOREACH(fwdev, &fc->devices, link)
173 if (fwdev->dst == dst && fwdev->status != FWDEVINVAL)
174 break;
175 FW_GUNLOCK(fc);
176
177 return fwdev;
178 }
179
180 /*
181 * Lookup fwdev by EUI64.
182 */
183 struct fw_device *
fw_noderesolve_eui64(struct firewire_comm * fc,struct fw_eui64 * eui)184 fw_noderesolve_eui64(struct firewire_comm *fc, struct fw_eui64 *eui)
185 {
186 struct fw_device *fwdev;
187
188 FW_GLOCK(fc);
189 STAILQ_FOREACH(fwdev, &fc->devices, link)
190 if (FW_EUI64_EQUAL(fwdev->eui, *eui))
191 break;
192 FW_GUNLOCK(fc);
193
194 if (fwdev == NULL)
195 return NULL;
196 if (fwdev->status == FWDEVINVAL)
197 return NULL;
198 return fwdev;
199 }
200
201 /*
202 * Async. request procedure for userland application.
203 */
204 int
fw_asyreq(struct firewire_comm * fc,int sub,struct fw_xfer * xfer)205 fw_asyreq(struct firewire_comm *fc, int sub, struct fw_xfer *xfer)
206 {
207 int err = 0;
208 struct fw_xferq *xferq;
209 int len;
210 struct fw_pkt *fp;
211 int tcode;
212 struct tcode_info *info;
213
214 if (xfer == NULL)
215 return EINVAL;
216 if (xfer->hand == NULL) {
217 printf("hand == NULL\n");
218 return EINVAL;
219 }
220 fp = &xfer->send.hdr;
221
222 tcode = fp->mode.common.tcode & 0xf;
223 info = &fc->tcode[tcode];
224 if (info->flag == 0) {
225 printf("invalid tcode=%x\n", tcode);
226 return EINVAL;
227 }
228
229 /* Reject non-CSR transactions until bus exploration completes */
230 if ((fc->status < FWBUSEXPLORE) &&
231 ((tcode != FWTCODE_RREQQ) || (fp->mode.rreqq.dest_hi != 0xffff) ||
232 (fp->mode.rreqq.dest_lo < 0xf0000000) ||
233 (fp->mode.rreqq.dest_lo >= 0xf0001000))) {
234 xfer->resp = EAGAIN;
235 xfer->flag = FWXF_BUSY;
236 return (EAGAIN);
237 }
238
239 if (info->flag & FWTI_REQ)
240 xferq = fc->atq;
241 else
242 xferq = fc->ats;
243 len = info->hdr_len;
244 if (xfer->send.pay_len > MAXREC(fc->maxrec)) {
245 printf("send.pay_len > maxrec\n");
246 return EINVAL;
247 }
248 if (info->flag & FWTI_BLOCK_STR)
249 len = fp->mode.stream.len;
250 else if (info->flag & FWTI_BLOCK_ASY)
251 len = fp->mode.rresb.len;
252 else
253 len = 0;
254 if (len != xfer->send.pay_len) {
255 printf("len(%d) != send.pay_len(%d) %s(%x)\n",
256 len, xfer->send.pay_len, tcode_str[tcode], tcode);
257 return EINVAL;
258 }
259
260 if (xferq->start == NULL) {
261 printf("xferq->start == NULL\n");
262 return EINVAL;
263 }
264 if (!(xferq->queued < xferq->maxq)) {
265 device_printf(fc->bdev, "Discard a packet (queued=%d)\n",
266 xferq->queued);
267 return EAGAIN;
268 }
269
270 xfer->tl = -1;
271 if (info->flag & FWTI_TLABEL) {
272 if (fw_get_tlabel(fc, xfer) < 0)
273 return EAGAIN;
274 }
275
276 xfer->resp = 0;
277 xfer->fc = fc;
278 xfer->q = xferq;
279
280 fw_asystart(xfer);
281 return err;
282 }
283
284 /*
285 * Wakeup blocked process.
286 */
287 void
fw_xferwake(struct fw_xfer * xfer)288 fw_xferwake(struct fw_xfer *xfer)
289 {
290 struct mtx *lock = &xfer->fc->wait_lock;
291
292 mtx_lock(lock);
293 xfer->flag |= FWXF_WAKE;
294 mtx_unlock(lock);
295
296 wakeup(xfer);
297 return;
298 }
299
300 int
fw_xferwait(struct fw_xfer * xfer)301 fw_xferwait(struct fw_xfer *xfer)
302 {
303 struct mtx *lock = &xfer->fc->wait_lock;
304 int err = 0;
305
306 mtx_lock(lock);
307 while ((xfer->flag & FWXF_WAKE) == 0)
308 err = msleep(xfer, lock, PWAIT|PCATCH, "fw_xferwait", 0);
309 mtx_unlock(lock);
310
311 return (err);
312 }
313
314 /*
315 * Async. request with given xfer structure.
316 */
317 static void
fw_asystart(struct fw_xfer * xfer)318 fw_asystart(struct fw_xfer *xfer)
319 {
320 struct firewire_comm *fc = xfer->fc;
321
322 /* Protect from interrupt/timeout */
323 FW_GLOCK(fc);
324 xfer->flag = FWXF_INQ;
325 STAILQ_INSERT_TAIL(&xfer->q->q, xfer, link);
326 FW_GUNLOCK(fc);
327 /* Kick DMA for non-mbuf xfers */
328 if (xfer->mbuf == NULL)
329 xfer->q->start(fc);
330 return;
331 }
332
333 static void
firewire_identify(driver_t * driver,device_t parent)334 firewire_identify(driver_t *driver, device_t parent)
335 {
336 BUS_ADD_CHILD(parent, 0, "firewire", DEVICE_UNIT_ANY);
337 }
338
339 static int
firewire_probe(device_t dev)340 firewire_probe(device_t dev)
341 {
342 device_set_desc(dev, "IEEE1394(FireWire) bus");
343 return (0);
344 }
345
346 /* Just use a per-packet callout? */
347 static void
firewire_xfer_timeout(void * arg,int pending)348 firewire_xfer_timeout(void *arg, int pending)
349 {
350 struct firewire_comm *fc = (struct firewire_comm *)arg;
351 struct fw_xfer *xfer, *txfer;
352 struct timeval tv;
353 struct timeval split_timeout;
354 STAILQ_HEAD(, fw_xfer) xfer_timeout;
355 int i;
356
357 split_timeout.tv_sec = 0;
358 split_timeout.tv_usec = 200 * 1000; /* 200 msec */
359
360 microtime(&tv);
361 timevalsub(&tv, &split_timeout);
362 STAILQ_INIT(&xfer_timeout);
363
364 mtx_lock(&fc->tlabel_lock);
365 for (i = 0; i < nitems(fc->tlabels); i++) {
366 while ((xfer = STAILQ_FIRST(&fc->tlabels[i])) != NULL) {
367 if ((xfer->flag & FWXF_SENT) == 0)
368 /* not sent yet */
369 break;
370 if (timevalcmp(&xfer->tv, &tv, >))
371 /* the rests are newer than this */
372 break;
373 device_printf(fc->bdev,
374 "split transaction timeout: tl=0x%x flag=0x%02x\n",
375 i, xfer->flag);
376 fw_dump_hdr(&xfer->send.hdr, "send");
377 xfer->resp = ETIMEDOUT;
378 xfer->tl = -1;
379 STAILQ_REMOVE_HEAD(&fc->tlabels[i], tlabel);
380 STAILQ_INSERT_TAIL(&xfer_timeout, xfer, tlabel);
381 }
382 }
383 mtx_unlock(&fc->tlabel_lock);
384 fc->timeout(fc);
385
386 STAILQ_FOREACH_SAFE(xfer, &xfer_timeout, tlabel, txfer)
387 xfer->hand(xfer);
388 }
389
390 #define WATCHDOG_HZ 10
391 static void
firewire_watchdog(void * arg)392 firewire_watchdog(void *arg)
393 {
394 struct firewire_softc *sc = arg;
395 struct firewire_comm *fc = sc->fc;
396
397 /*
398 * At boot stage, the device interrupt is disabled and
399 * we encounter a timeout easily. To avoid this,
400 * ignore clock ticks for a while.
401 */
402 if (sc->watchdog_clock > WATCHDOG_HZ * 15)
403 taskqueue_enqueue(fc->taskqueue, &fc->task_timeout);
404 else
405 sc->watchdog_clock++;
406
407 callout_reset(&fc->timeout_callout, hz / WATCHDOG_HZ,
408 firewire_watchdog, sc);
409 }
410
411 /*
412 * The attach routine.
413 */
414 static int
firewire_attach(device_t dev)415 firewire_attach(device_t dev)
416 {
417 int unit;
418 struct firewire_softc *sc = device_get_softc(dev);
419 device_t pa = device_get_parent(dev);
420 struct firewire_comm *fc;
421
422 fc = device_get_softc(pa);
423 sc->fc = fc;
424 fc->status = FWBUSNOTREADY;
425
426 unit = device_get_unit(dev);
427 if (fc->nisodma > FWMAXNDMA)
428 fc->nisodma = FWMAXNDMA;
429
430 fwdev_makedev(sc);
431
432 fc->crom_src_buf = malloc(sizeof(struct crom_src_buf),
433 M_FW, M_NOWAIT | M_ZERO);
434 if (fc->crom_src_buf == NULL) {
435 device_printf(fc->dev,
436 "%s: unable to allocate crom src buffer\n", __func__);
437 return ENOMEM;
438 }
439 fc->topology_map = malloc(sizeof(struct fw_topology_map),
440 M_FW, M_NOWAIT | M_ZERO);
441 if (fc->topology_map == NULL) {
442 device_printf(fc->dev, "%s: unable to allocate topology map\n",
443 __func__);
444 free(fc->crom_src_buf, M_FW);
445 return ENOMEM;
446 }
447 fc->speed_map = malloc(sizeof(struct fw_speed_map),
448 M_FW, M_NOWAIT | M_ZERO);
449 if (fc->speed_map == NULL) {
450 device_printf(fc->dev, "%s: unable to allocate speed map\n",
451 __func__);
452 free(fc->crom_src_buf, M_FW);
453 free(fc->topology_map, M_FW);
454 return ENOMEM;
455 }
456
457 mtx_init(&fc->wait_lock, "fwwait", NULL, MTX_DEF);
458 mtx_init(&fc->tlabel_lock, "fwtlabel", NULL, MTX_DEF);
459 CALLOUT_INIT(&fc->timeout_callout);
460 CALLOUT_INIT(&fc->bmr_callout);
461 CALLOUT_INIT(&fc->busprobe_callout);
462 TASK_INIT(&fc->task_timeout, 0, firewire_xfer_timeout, fc);
463
464 sc->watchdog_clock = 0;
465 callout_reset(&sc->fc->timeout_callout, hz,
466 firewire_watchdog, sc);
467
468 /* create thread */
469 kproc_create(fw_bus_probe_thread, fc, &fc->probe_thread,
470 0, 0, "fw%d_probe", unit);
471
472 /* Locate our children */
473 bus_identify_children(dev);
474
475 /* launch attachement of the added children */
476 bus_attach_children(dev);
477
478 /* bus_reset */
479 FW_GLOCK(fc);
480 fw_busreset(fc, FWBUSNOTREADY);
481 FW_GUNLOCK(fc);
482 fc->ibr(fc);
483
484 return 0;
485 }
486
487 /*
488 * Attach it as child.
489 */
490 static device_t
firewire_add_child(device_t dev,u_int order,const char * name,int unit)491 firewire_add_child(device_t dev, u_int order, const char *name, int unit)
492 {
493 device_t child;
494 struct firewire_softc *sc;
495 struct fw_child_ivars *iv;
496
497 sc = device_get_softc(dev);
498 child = device_add_child(dev, name, unit);
499 if (child) {
500 iv = malloc(sizeof(*iv), M_FW, M_NOWAIT | M_ZERO);
501 if (iv == NULL) {
502 device_delete_child(dev, child);
503 return (NULL);
504 }
505 iv->type = FW_CHILD_BUS;
506 iv->u.fc = sc->fc;
507 device_set_ivars(child, iv);
508 device_probe_and_attach(child);
509 }
510
511 return child;
512 }
513
514 static void
firewire_child_deleted(device_t dev,device_t child)515 firewire_child_deleted(device_t dev, device_t child)
516 {
517 struct fw_child_ivars *iv;
518
519 iv = device_get_ivars(child);
520 if (iv != NULL) {
521 if (iv->type == FW_CHILD_UNIT && iv->u.unit != NULL)
522 iv->u.unit->dev = NULL;
523 free(iv, M_FW);
524 device_set_ivars(child, NULL);
525 }
526 }
527
528 static int
firewire_resume(device_t dev)529 firewire_resume(device_t dev)
530 {
531 struct firewire_softc *sc;
532
533 sc = device_get_softc(dev);
534 sc->fc->status = FWBUSNOTREADY;
535
536 bus_generic_resume(dev);
537
538 return (0);
539 }
540
541 /*
542 * Detach it.
543 */
544 static int
firewire_detach(device_t dev)545 firewire_detach(device_t dev)
546 {
547 struct firewire_softc *sc;
548 struct firewire_comm *fc;
549 struct fw_device *fwdev, *fwdev_next;
550 int err;
551
552 sc = device_get_softc(dev);
553 fc = sc->fc;
554 mtx_lock(&fc->wait_lock);
555 fc->status = FWBUSDETACH;
556 wakeup(fc);
557 if (msleep(fc->probe_thread, &fc->wait_lock, PWAIT, "fwthr", hz * 60))
558 printf("firewire probe thread didn't die\n");
559 mtx_unlock(&fc->wait_lock);
560
561 if (fc->arq != 0 && fc->arq->maxq > 0)
562 fw_drain_txq(fc);
563
564 if ((err = fwdev_destroydev(sc)) != 0)
565 return err;
566
567 /* Remove unit children before bus_generic_detach */
568 for (fwdev = STAILQ_FIRST(&fc->devices); fwdev != NULL;
569 fwdev = fwdev_next) {
570 fwdev_next = STAILQ_NEXT(fwdev, link);
571 fw_remove_unit_children(fc, fwdev);
572 }
573
574 if ((err = bus_generic_detach(dev)) != 0)
575 return err;
576
577 callout_stop(&fc->timeout_callout);
578 callout_stop(&fc->bmr_callout);
579 callout_stop(&fc->busprobe_callout);
580
581 /* Drain xfers queued by children during detach or pending callouts. */
582 fw_drain_txq(fc);
583
584 for (fwdev = STAILQ_FIRST(&fc->devices); fwdev != NULL;
585 fwdev = fwdev_next) {
586 fwdev_next = STAILQ_NEXT(fwdev, link);
587 free(fwdev, M_FW);
588 }
589 free(fc->topology_map, M_FW);
590 free(fc->speed_map, M_FW);
591 free(fc->crom_src_buf, M_FW);
592
593 mtx_destroy(&fc->tlabel_lock);
594 mtx_destroy(&fc->wait_lock);
595 return (0);
596 }
597
598 static void
fw_xferq_drain(struct fw_xferq * xferq)599 fw_xferq_drain(struct fw_xferq *xferq)
600 {
601 struct fw_xfer *xfer;
602
603 while ((xfer = STAILQ_FIRST(&xferq->q)) != NULL) {
604 STAILQ_REMOVE_HEAD(&xferq->q, link);
605 xfer->resp = EAGAIN;
606 xfer->flag = FWXF_SENTERR;
607 fw_xfer_done(xfer);
608 }
609 }
610
611 void
fw_drain_txq(struct firewire_comm * fc)612 fw_drain_txq(struct firewire_comm *fc)
613 {
614 struct fw_xfer *xfer, *txfer;
615 STAILQ_HEAD(, fw_xfer) xfer_drain;
616 int i;
617
618 STAILQ_INIT(&xfer_drain);
619
620 FW_GLOCK(fc);
621 fw_xferq_drain(fc->atq);
622 fw_xferq_drain(fc->ats);
623 for (i = 0; i < fc->nisodma; i++)
624 fw_xferq_drain(fc->it[i]);
625 FW_GUNLOCK(fc);
626
627 mtx_lock(&fc->tlabel_lock);
628 for (i = 0; i < FW_NUM_TLABELS; i++)
629 while ((xfer = STAILQ_FIRST(&fc->tlabels[i])) != NULL) {
630 if (firewire_debug)
631 printf("tl=%d flag=%d\n", i, xfer->flag);
632 xfer->tl = -1;
633 xfer->resp = EAGAIN;
634 STAILQ_REMOVE_HEAD(&fc->tlabels[i], tlabel);
635 STAILQ_INSERT_TAIL(&xfer_drain, xfer, tlabel);
636 }
637 mtx_unlock(&fc->tlabel_lock);
638
639 STAILQ_FOREACH_SAFE(xfer, &xfer_drain, tlabel, txfer)
640 xfer->hand(xfer);
641 }
642
643 static void
fw_reset_csr(struct firewire_comm * fc)644 fw_reset_csr(struct firewire_comm *fc)
645 {
646 int i;
647
648 CSRARC(fc, STATE_CLEAR)
649 = 1 << 23 | 0 << 17 | 1 << 16 | 1 << 15 | 1 << 14;
650 CSRARC(fc, STATE_SET) = CSRARC(fc, STATE_CLEAR);
651 CSRARC(fc, NODE_IDS) = 0x3f;
652
653 CSRARC(fc, TOPO_MAP + 8) = 0;
654 fc->irm = -1;
655
656 fc->max_node = -1;
657
658 for (i = 2; i < FW_MAX_NODES - 2; i++) {
659 CSRARC(fc, SPED_MAP + i * 4) = 0;
660 }
661 CSRARC(fc, STATE_CLEAR) = 1 << 23 | 0 << 17 | 1 << 16 | 1 << 15 | 1 << 14;
662 CSRARC(fc, STATE_SET) = CSRARC(fc, STATE_CLEAR);
663 CSRARC(fc, RESET_START) = 0;
664 CSRARC(fc, SPLIT_TIMEOUT_HI) = 0;
665 CSRARC(fc, SPLIT_TIMEOUT_LO) = FW_SPLIT_TIMEOUT_CYCLES << 19;
666 CSRARC(fc, CYCLE_TIME) = 0x0;
667 CSRARC(fc, BUS_TIME) = 0x0;
668 CSRARC(fc, BUS_MGR_ID) = FW_NO_BUS_MANAGER;
669 CSRARC(fc, BANDWIDTH_AV) = FW_BANDWIDTH_AVAILABLE;
670 CSRARC(fc, CHANNELS_AV_HI) = 0xffffffff;
671 CSRARC(fc, CHANNELS_AV_LO) = 0xffffffff;
672 CSRARC(fc, IP_CHANNELS) = (1U << 31);
673
674 CSRARC(fc, CONF_ROM) = 0x04 << 24;
675 CSRARC(fc, CONF_ROM + 4) = 0x31333934; /* means strings 1394 */
676 CSRARC(fc, CONF_ROM + 8) = 1 << 31 | 1 << 30 | 1 << 29 |
677 1 << 28 | 0xff << 16 | 0x09 << 8;
678 CSRARC(fc, CONF_ROM + 0xc) = 0;
679
680 /* DV depend CSRs see blue book */
681 CSRARC(fc, oPCR) &= ~DV_BROADCAST_ON;
682 CSRARC(fc, iPCR) &= ~DV_BROADCAST_ON;
683
684 CSRARC(fc, STATE_CLEAR) &= ~(1 << 23 | 1 << 15 | 1 << 14);
685 CSRARC(fc, STATE_SET) = CSRARC(fc, STATE_CLEAR);
686 }
687
688 static void
fw_init_crom(struct firewire_comm * fc)689 fw_init_crom(struct firewire_comm *fc)
690 {
691 struct crom_src *src;
692
693 src = &fc->crom_src_buf->src;
694 bzero(src, sizeof(struct crom_src));
695
696 /* BUS info sample */
697 src->hdr.info_len = 4;
698
699 src->businfo.bus_name = CSR_BUS_NAME_IEEE1394;
700
701 src->businfo.irmc = 1;
702 src->businfo.cmc = 1;
703 src->businfo.isc = 1;
704 src->businfo.bmc = 1;
705 src->businfo.pmc = 0;
706 src->businfo.cyc_clk_acc = 100;
707 src->businfo.max_rec = fc->maxrec;
708 src->businfo.max_rom = MAXROM_4;
709 #define FW_GENERATION_CHANGEABLE 2
710 src->businfo.generation = FW_GENERATION_CHANGEABLE;
711 src->businfo.link_spd = fc->speed;
712
713 src->businfo.eui64.hi = fc->eui.hi;
714 src->businfo.eui64.lo = fc->eui.lo;
715
716 STAILQ_INIT(&src->chunk_list);
717
718 fc->crom_src = src;
719 fc->crom_root = &fc->crom_src_buf->root;
720 }
721
722 static void
fw_reset_crom(struct firewire_comm * fc)723 fw_reset_crom(struct firewire_comm *fc)
724 {
725 struct crom_src_buf *buf;
726 struct crom_src *src;
727 struct crom_chunk *root;
728
729 buf = fc->crom_src_buf;
730 src = fc->crom_src;
731 root = fc->crom_root;
732
733 STAILQ_INIT(&src->chunk_list);
734
735 bzero(root, sizeof(struct crom_chunk));
736 crom_add_chunk(src, NULL, root, 0);
737 crom_add_entry(root, CSRKEY_NCAP, 0x0083c0);
738 /* private company_id */
739 crom_add_entry(root, CSRKEY_VENDOR, CSRVAL_VENDOR_PRIVATE);
740 crom_add_simple_text(src, root, &buf->vendor, "FreeBSD Project");
741 crom_add_entry(root, CSRKEY_HW, __FreeBSD_version);
742 mtx_lock(&prison0.pr_mtx);
743 crom_add_simple_text(src, root, &buf->hw, prison0.pr_hostname);
744 mtx_unlock(&prison0.pr_mtx);
745 }
746
747 /*
748 * Called after bus reset.
749 */
750 void
fw_busreset(struct firewire_comm * fc,uint32_t new_status)751 fw_busreset(struct firewire_comm *fc, uint32_t new_status)
752 {
753 struct firewire_dev_comm *fdc;
754 struct crom_src *src;
755 device_t *devlistp;
756 uint32_t *newrom;
757 int i, devcnt;
758
759 FW_GLOCK_ASSERT(fc);
760 if (fc->status == FWBUSMGRELECT)
761 callout_stop(&fc->bmr_callout);
762
763 fc->status = new_status;
764 fw_reset_csr(fc);
765
766 if (fc->status == FWBUSNOTREADY)
767 fw_init_crom(fc);
768
769 fw_reset_crom(fc);
770
771 /*
772 * Skip unit children; only bus-level children have post_busreset.
773 */
774 if (device_get_children(fc->bdev, &devlistp, &devcnt) == 0) {
775 for (i = 0; i < devcnt; i++) {
776 struct fw_child_ivars *iv;
777
778 if (device_get_state(devlistp[i]) < DS_ATTACHED)
779 continue;
780 iv = fw_get_ivars(devlistp[i]);
781 if (iv == NULL || iv->type != FW_CHILD_BUS)
782 continue;
783 fdc = device_get_softc(devlistp[i]);
784 if (fdc->post_busreset != NULL)
785 fdc->post_busreset(fdc);
786 }
787 free(devlistp, M_TEMP);
788 }
789
790 src = &fc->crom_src_buf->src;
791 /*
792 * If the old config rom needs to be overwritten,
793 * bump the businfo.generation indicator to
794 * indicate that we need to be reprobed
795 * See 1394a-2000 8.3.2.5.4 for more details.
796 * generation starts at 2 and rolls over at 0xF
797 * back to 2.
798 *
799 * A generation of 0 indicates a device
800 * that is not 1394a-2000 compliant.
801 * A generation of 1 indicates a device that
802 * does not change it's Bus Info Block or
803 * Configuration ROM.
804 */
805 #define FW_MAX_GENERATION 0xF
806 newrom = malloc(CROMSIZE, M_FW, M_NOWAIT | M_ZERO);
807 if (newrom == NULL)
808 goto out;
809 src = &fc->crom_src_buf->src;
810 crom_load(src, newrom, CROMSIZE);
811 if (bcmp(newrom, fc->config_rom, CROMSIZE) != 0) {
812 /* Bump generation and reload. */
813 src->businfo.generation++;
814
815 /* Handle generation count wraps. */
816 if (src->businfo.generation < FW_GENERATION_CHANGEABLE)
817 src->businfo.generation = FW_GENERATION_CHANGEABLE;
818
819 /* Recalculate CRC to account for generation change. */
820 crom_load(src, newrom, CROMSIZE);
821 bcopy(newrom, fc->config_rom, CROMSIZE);
822 }
823 free(newrom, M_FW);
824 out:;
825 }
826
827 /* Call once after reboot */
fw_init(struct firewire_comm * fc)828 void fw_init(struct firewire_comm *fc)
829 {
830 int i;
831 #ifdef FW_VMACCESS
832 struct fw_xfer *xfer;
833 struct fw_bind *fwb;
834 #endif
835
836 fc->arq->queued = 0;
837 fc->ars->queued = 0;
838 fc->atq->queued = 0;
839 fc->ats->queued = 0;
840
841 fc->arq->buf = NULL;
842 fc->ars->buf = NULL;
843 fc->atq->buf = NULL;
844 fc->ats->buf = NULL;
845
846 fc->arq->flag = 0;
847 fc->ars->flag = 0;
848 fc->atq->flag = 0;
849 fc->ats->flag = 0;
850
851 STAILQ_INIT(&fc->atq->q);
852 STAILQ_INIT(&fc->ats->q);
853
854 for (i = 0; i < fc->nisodma; i++) {
855 fc->it[i]->queued = 0;
856 fc->ir[i]->queued = 0;
857
858 fc->it[i]->start = NULL;
859 fc->ir[i]->start = NULL;
860
861 fc->it[i]->buf = NULL;
862 fc->ir[i]->buf = NULL;
863
864 fc->it[i]->flag = FWXFERQ_STREAM;
865 fc->ir[i]->flag = FWXFERQ_STREAM;
866
867 STAILQ_INIT(&fc->it[i]->q);
868 STAILQ_INIT(&fc->ir[i]->q);
869 }
870
871 fc->arq->maxq = FWMAXQUEUE;
872 fc->ars->maxq = FWMAXQUEUE;
873 fc->atq->maxq = FWMAXQUEUE;
874 fc->ats->maxq = FWMAXQUEUE;
875
876 for (i = 0; i < fc->nisodma; i++) {
877 fc->ir[i]->maxq = FWMAXQUEUE;
878 fc->it[i]->maxq = FWMAXQUEUE;
879 }
880
881 CSRARC(fc, TOPO_MAP) = 0x3f1 << 16;
882 CSRARC(fc, TOPO_MAP + 4) = 1;
883 CSRARC(fc, SPED_MAP) = 0x3f1 << 16;
884 CSRARC(fc, SPED_MAP + 4) = 1;
885
886 STAILQ_INIT(&fc->devices);
887
888 /* Initialize Async handlers */
889 STAILQ_INIT(&fc->binds);
890 for (i = 0; i < FW_NUM_TLABELS; i++) {
891 STAILQ_INIT(&fc->tlabels[i]);
892 }
893
894 fc->crom_src_buf = NULL;
895
896 #ifdef FW_VMACCESS
897 xfer = fw_xfer_alloc();
898 if (xfer == NULL)
899 return;
900
901 fwb = malloc(sizeof(struct fw_bind), M_FW, M_NOWAIT);
902 if (fwb == NULL) {
903 fw_xfer_free(xfer);
904 return;
905 }
906 xfer->hand = fw_vmaccess;
907 xfer->fc = fc;
908 xfer->sc = NULL;
909
910 fwb->start_hi = 0x2;
911 fwb->start_lo = 0;
912 fwb->addrlen = 0xffffffff;
913 fwb->xfer = xfer;
914 fw_bindadd(fc, fwb);
915 #endif
916 }
917
918 #define BIND_CMP(addr, fwb) (((addr) < (fwb)->start)? -1 : \
919 ((fwb)->end < (addr)) ? 1 : 0)
920
921 /*
922 * To lookup bound process from IEEE1394 address.
923 */
924 struct fw_bind *
fw_bindlookup(struct firewire_comm * fc,uint16_t dest_hi,uint32_t dest_lo)925 fw_bindlookup(struct firewire_comm *fc, uint16_t dest_hi, uint32_t dest_lo)
926 {
927 u_int64_t addr;
928 struct fw_bind *tfw, *r = NULL;
929
930 addr = ((u_int64_t)dest_hi << 32) | dest_lo;
931 FW_GLOCK(fc);
932 STAILQ_FOREACH(tfw, &fc->binds, fclist)
933 if (BIND_CMP(addr, tfw) == 0) {
934 r = tfw;
935 break;
936 }
937 FW_GUNLOCK(fc);
938 return (r);
939 }
940
941 /*
942 * To bind IEEE1394 address block to process.
943 */
944 int
fw_bindadd(struct firewire_comm * fc,struct fw_bind * fwb)945 fw_bindadd(struct firewire_comm *fc, struct fw_bind *fwb)
946 {
947 struct fw_bind *tfw, *prev = NULL;
948 int r = 0;
949
950 if (fwb->start > fwb->end) {
951 printf("%s: invalid range\n", __func__);
952 return EINVAL;
953 }
954
955 FW_GLOCK(fc);
956 STAILQ_FOREACH(tfw, &fc->binds, fclist) {
957 if (fwb->end < tfw->start)
958 break;
959 prev = tfw;
960 }
961 if (prev == NULL)
962 STAILQ_INSERT_HEAD(&fc->binds, fwb, fclist);
963 else if (prev->end < fwb->start)
964 STAILQ_INSERT_AFTER(&fc->binds, prev, fwb, fclist);
965 else {
966 printf("%s: bind failed\n", __func__);
967 r = EBUSY;
968 }
969 FW_GUNLOCK(fc);
970 return (r);
971 }
972
973 /*
974 * To free IEEE1394 address block.
975 */
976 int
fw_bindremove(struct firewire_comm * fc,struct fw_bind * fwb)977 fw_bindremove(struct firewire_comm *fc, struct fw_bind *fwb)
978 {
979 struct fw_bind *tfw;
980
981 FW_GLOCK(fc);
982 STAILQ_FOREACH(tfw, &fc->binds, fclist)
983 if (tfw == fwb) {
984 STAILQ_REMOVE(&fc->binds, fwb, fw_bind, fclist);
985 goto found;
986 }
987
988 printf("%s: no such binding\n", __func__);
989 FW_GUNLOCK(fc);
990 return (1);
991 found:
992 FW_GUNLOCK(fc);
993
994 return 0;
995 }
996
997 int
fw_xferlist_add(struct fw_xferlist * q,struct malloc_type * type,int slen,int rlen,int n,struct firewire_comm * fc,void * sc,void (* hand)(struct fw_xfer *))998 fw_xferlist_add(struct fw_xferlist *q, struct malloc_type *type,
999 int slen, int rlen, int n,
1000 struct firewire_comm *fc, void *sc, void (*hand)(struct fw_xfer *))
1001 {
1002 int i;
1003 struct fw_xfer *xfer;
1004
1005 for (i = 0; i < n; i++) {
1006 xfer = fw_xfer_alloc_buf(type, slen, rlen);
1007 if (xfer == NULL)
1008 return (i);
1009 xfer->fc = fc;
1010 xfer->sc = sc;
1011 xfer->hand = hand;
1012 STAILQ_INSERT_TAIL(q, xfer, link);
1013 }
1014 return (n);
1015 }
1016
1017 void
fw_xferlist_remove(struct fw_xferlist * q)1018 fw_xferlist_remove(struct fw_xferlist *q)
1019 {
1020 struct fw_xfer *xfer, *next;
1021
1022 for (xfer = STAILQ_FIRST(q); xfer != NULL; xfer = next) {
1023 next = STAILQ_NEXT(xfer, link);
1024 fw_xfer_free_buf(xfer);
1025 }
1026 STAILQ_INIT(q);
1027 }
1028 /*
1029 * dump packet header
1030 */
1031 static void
fw_dump_hdr(struct fw_pkt * fp,char * prefix)1032 fw_dump_hdr(struct fw_pkt *fp, char *prefix)
1033 {
1034 printf("%s: dst=0x%02x tl=0x%02x rt=%d tcode=0x%x pri=0x%x "
1035 "src=0x%03x\n", prefix,
1036 fp->mode.hdr.dst & 0x3f,
1037 fp->mode.hdr.tlrt >> 2, fp->mode.hdr.tlrt & 3,
1038 fp->mode.hdr.tcode, fp->mode.hdr.pri,
1039 fp->mode.hdr.src);
1040 }
1041
1042 /*
1043 * To free transaction label.
1044 */
1045 static void
fw_tl_free(struct firewire_comm * fc,struct fw_xfer * xfer)1046 fw_tl_free(struct firewire_comm *fc, struct fw_xfer *xfer)
1047 {
1048 struct fw_xfer *txfer;
1049
1050 mtx_lock(&fc->tlabel_lock);
1051 if (xfer->tl < 0) {
1052 mtx_unlock(&fc->tlabel_lock);
1053 return;
1054 }
1055 /* make sure the label is allocated */
1056 STAILQ_FOREACH(txfer, &fc->tlabels[xfer->tl], tlabel)
1057 if (txfer == xfer)
1058 break;
1059 if (txfer == NULL) {
1060 printf("%s: the xfer is not in the queue "
1061 "(tlabel=%d, flag=0x%x)\n",
1062 __FUNCTION__, xfer->tl, xfer->flag);
1063 fw_dump_hdr(&xfer->send.hdr, "send");
1064 fw_dump_hdr(&xfer->recv.hdr, "recv");
1065 kdb_backtrace();
1066 mtx_unlock(&fc->tlabel_lock);
1067 return;
1068 }
1069
1070 STAILQ_REMOVE(&fc->tlabels[xfer->tl], xfer, fw_xfer, tlabel);
1071 xfer->tl = -1;
1072 mtx_unlock(&fc->tlabel_lock);
1073 return;
1074 }
1075
1076 /*
1077 * Look up an XFER by transaction label.
1078 * Removes the xfer from fc->tlabels only when AT transmit has completed
1079 * (FWXF_SENT); FWXF_START xfers remain so fw_drain_txq() can find them
1080 * on a bus reset.
1081 */
1082 static struct fw_xfer *
fw_tl2xfer(struct firewire_comm * fc,int node,int tlabel,int tcode)1083 fw_tl2xfer(struct firewire_comm *fc, int node, int tlabel, int tcode)
1084 {
1085 struct fw_xfer *xfer;
1086 int req;
1087
1088 mtx_lock(&fc->tlabel_lock);
1089 STAILQ_FOREACH(xfer, &fc->tlabels[tlabel], tlabel) {
1090 if (xfer->send.hdr.mode.hdr.dst != node)
1091 continue;
1092 /* Validate tcode match before claiming the xfer. */
1093 req = xfer->send.hdr.mode.hdr.tcode;
1094 if (xfer->fc->tcode[req].valid_res != tcode) {
1095 printf("%s: invalid response tcode "
1096 "(0x%x for 0x%x)\n", __func__, tcode, req);
1097 mtx_unlock(&fc->tlabel_lock);
1098 return (NULL);
1099 }
1100 /*
1101 * Remove from tlabels only after AT transmit completes
1102 * (FWXF_SENT). Early responses (FWXF_START) must stay
1103 * in the list until fwohci_txd() drains the descriptor.
1104 */
1105 if (xfer->flag & FWXF_SENT) {
1106 STAILQ_REMOVE(&fc->tlabels[tlabel], xfer,
1107 fw_xfer, tlabel);
1108 xfer->tl = -1;
1109 }
1110 mtx_unlock(&fc->tlabel_lock);
1111 if (firewire_debug > 2)
1112 printf("fw_tl2xfer: found tl=%d\n", tlabel);
1113 return (xfer);
1114 }
1115 mtx_unlock(&fc->tlabel_lock);
1116 if (firewire_debug > 1)
1117 printf("fw_tl2xfer: not found tl=%d\n", tlabel);
1118 return (NULL);
1119 }
1120
1121 /*
1122 * To allocate IEEE1394 XFER structure.
1123 */
1124 struct fw_xfer *
fw_xfer_alloc(struct malloc_type * type)1125 fw_xfer_alloc(struct malloc_type *type)
1126 {
1127 struct fw_xfer *xfer;
1128
1129 xfer = malloc(sizeof(struct fw_xfer), type, M_NOWAIT | M_ZERO);
1130 if (xfer == NULL)
1131 return xfer;
1132
1133 xfer->malloc = type;
1134 xfer->tl = -1;
1135
1136 return xfer;
1137 }
1138
1139 struct fw_xfer *
fw_xfer_alloc_buf(struct malloc_type * type,int send_len,int recv_len)1140 fw_xfer_alloc_buf(struct malloc_type *type, int send_len, int recv_len)
1141 {
1142 struct fw_xfer *xfer;
1143
1144 xfer = fw_xfer_alloc(type);
1145 if (xfer == NULL)
1146 return (NULL);
1147 xfer->send.pay_len = send_len;
1148 xfer->recv.pay_len = recv_len;
1149 if (send_len > 0) {
1150 xfer->send.payload = malloc(send_len, type, M_NOWAIT | M_ZERO);
1151 if (xfer->send.payload == NULL) {
1152 fw_xfer_free(xfer);
1153 return (NULL);
1154 }
1155 }
1156 if (recv_len > 0) {
1157 xfer->recv.payload = malloc(recv_len, type, M_NOWAIT);
1158 if (xfer->recv.payload == NULL) {
1159 if (xfer->send.payload != NULL)
1160 free(xfer->send.payload, type);
1161 fw_xfer_free(xfer);
1162 return (NULL);
1163 }
1164 }
1165 return (xfer);
1166 }
1167
1168 /*
1169 * IEEE1394 XFER post process.
1170 */
1171 void
fw_xfer_done(struct fw_xfer * xfer)1172 fw_xfer_done(struct fw_xfer *xfer)
1173 {
1174 if (xfer->hand == NULL) {
1175 printf("hand == NULL\n");
1176 return;
1177 }
1178
1179 if (xfer->fc == NULL)
1180 panic("fw_xfer_done: why xfer->fc is NULL?");
1181
1182 fw_tl_free(xfer->fc, xfer);
1183 xfer->hand(xfer);
1184 }
1185
1186 void
fw_xfer_unload(struct fw_xfer * xfer)1187 fw_xfer_unload(struct fw_xfer *xfer)
1188 {
1189
1190 if (xfer == NULL)
1191 return;
1192
1193 if (xfer->fc != NULL) {
1194 FW_GLOCK(xfer->fc);
1195 if (xfer->flag & FWXF_INQ) {
1196 STAILQ_REMOVE(&xfer->q->q, xfer, fw_xfer, link);
1197 xfer->flag &= ~FWXF_INQ;
1198 }
1199 FW_GUNLOCK(xfer->fc);
1200
1201 /*
1202 * Ensure that any tlabel owner can't access this
1203 * xfer after it's freed.
1204 */
1205 fw_tl_free(xfer->fc, xfer);
1206 if (firewire_debug && (xfer->flag & FWXF_START))
1207 printf("fw_xfer_free FWXF_START\n");
1208 }
1209 xfer->flag = FWXF_INIT;
1210 xfer->resp = 0;
1211 }
1212
1213 /*
1214 * To free IEEE1394 XFER structure.
1215 */
1216 void
fw_xfer_free_buf(struct fw_xfer * xfer)1217 fw_xfer_free_buf(struct fw_xfer *xfer)
1218 {
1219 if (xfer == NULL) {
1220 printf("%s: xfer == NULL\n", __func__);
1221 return;
1222 }
1223 fw_xfer_unload(xfer);
1224 if (xfer->send.payload != NULL)
1225 free(xfer->send.payload, xfer->malloc);
1226 if (xfer->recv.payload != NULL)
1227 free(xfer->recv.payload, xfer->malloc);
1228 free(xfer, xfer->malloc);
1229 }
1230
1231 void
fw_xfer_free(struct fw_xfer * xfer)1232 fw_xfer_free(struct fw_xfer *xfer)
1233 {
1234 if (xfer == NULL) {
1235 printf("%s: xfer == NULL\n", __func__);
1236 return;
1237 }
1238 fw_xfer_unload(xfer);
1239 free(xfer, xfer->malloc);
1240 }
1241
1242 void
fw_asy_callback_free(struct fw_xfer * xfer)1243 fw_asy_callback_free(struct fw_xfer *xfer)
1244 {
1245 fw_xfer_free(xfer);
1246 }
1247
1248 /*
1249 * To configure PHY.
1250 */
1251 static void
fw_phy_config(struct firewire_comm * fc,int root_node,int gap_count)1252 fw_phy_config(struct firewire_comm *fc, int root_node, int gap_count)
1253 {
1254 struct fw_xfer *xfer;
1255 struct fw_pkt *fp;
1256
1257 fc->status = FWBUSPHYCONF;
1258
1259 xfer = fw_xfer_alloc(M_FWXFER);
1260 if (xfer == NULL)
1261 return;
1262 xfer->fc = fc;
1263 xfer->hand = fw_asy_callback_free;
1264
1265 fp = &xfer->send.hdr;
1266 fp->mode.ld[1] = 0;
1267 if (root_node >= 0)
1268 fp->mode.ld[1] |= FW_PHY_ROOT_BIT |
1269 (root_node & FW_NODE_MASK) << FW_PHY_ROOT_SHIFT;
1270 if (gap_count >= 0)
1271 fp->mode.ld[1] |= FW_PHY_GAP_BIT |
1272 (gap_count & FW_NODE_MASK) << FW_PHY_GAP_SHIFT;
1273 fp->mode.ld[2] = ~fp->mode.ld[1];
1274 fp->mode.common.tcode |= FWTCODE_PHY;
1275
1276 if (firewire_debug)
1277 device_printf(fc->bdev, "%s: root_node=%d gap_count=%d\n",
1278 __func__, root_node, gap_count);
1279 fw_asyreq(fc, -1, xfer);
1280 }
1281
1282 /*
1283 * Dump self ID.
1284 */
1285 static void
fw_print_sid(uint32_t sid)1286 fw_print_sid(uint32_t sid)
1287 {
1288 union fw_self_id *s;
1289 s = (union fw_self_id *) &sid;
1290 if (s->p0.sequel) {
1291 if (s->p1.sequence_num == FW_SELF_ID_PAGE0) {
1292 printf("node:%d p3:%d p4:%d p5:%d p6:%d p7:%d"
1293 "p8:%d p9:%d p10:%d\n",
1294 s->p1.phy_id, s->p1.port3, s->p1.port4,
1295 s->p1.port5, s->p1.port6, s->p1.port7,
1296 s->p1.port8, s->p1.port9, s->p1.port10);
1297 } else if (s->p2.sequence_num == FW_SELF_ID_PAGE1) {
1298 printf("node:%d p11:%d p12:%d p13:%d p14:%d p15:%d\n",
1299 s->p2.phy_id, s->p2.port11, s->p2.port12,
1300 s->p2.port13, s->p2.port14, s->p2.port15);
1301 } else {
1302 printf("node:%d Unknown Self ID Page number %d\n",
1303 s->p1.phy_id, s->p1.sequence_num);
1304 }
1305 } else {
1306 printf("node:%d link:%d gap:%d spd:%d con:%d pwr:%d"
1307 " p0:%d p1:%d p2:%d i:%d m:%d\n",
1308 s->p0.phy_id, s->p0.link_active, s->p0.gap_count,
1309 s->p0.phy_speed, s->p0.contender,
1310 s->p0.power_class, s->p0.port0, s->p0.port1,
1311 s->p0.port2, s->p0.initiated_reset, s->p0.more_packets);
1312 }
1313 }
1314
1315 /*
1316 * To receive self ID.
1317 */
fw_sidrcv(struct firewire_comm * fc,uint32_t * sid,u_int len)1318 void fw_sidrcv(struct firewire_comm *fc, uint32_t *sid, u_int len)
1319 {
1320 uint32_t *p;
1321 union fw_self_id *self_id;
1322 u_int i, j, node, c_port = 0, i_branch = 0;
1323
1324 fc->sid_cnt = len / (sizeof(uint32_t) * 2);
1325 fc->max_node = fc->nodeid & FW_NODE_MASK;
1326 CSRARC(fc, NODE_IDS) = ((uint32_t)fc->nodeid) << 16;
1327 fc->status = FWBUSCYMELECT;
1328 fc->topology_map->crc_len = 2;
1329 fc->topology_map->generation++;
1330 fc->topology_map->self_id_count = 0;
1331 fc->topology_map->node_count= 0;
1332 fc->speed_map->generation++;
1333 fc->speed_map->crc_len = 1 + (FW_MAX_NODES * FW_MAX_NODES + 3) / 4;
1334 self_id = &fc->topology_map->self_id[0];
1335 for (i = 0; i < fc->sid_cnt; i++) {
1336 if (sid[1] != ~sid[0]) {
1337 device_printf(fc->bdev,
1338 "%s: ERROR invalid self-id packet\n", __func__);
1339 sid += 2;
1340 continue;
1341 }
1342 *self_id = *((union fw_self_id *)sid);
1343 fc->topology_map->crc_len++;
1344 if (self_id->p0.sequel == 0) {
1345 fc->topology_map->node_count++;
1346 c_port = 0;
1347 if (firewire_debug)
1348 fw_print_sid(sid[0]);
1349 node = self_id->p0.phy_id;
1350 if (fc->max_node < node)
1351 fc->max_node = self_id->p0.phy_id;
1352 fc->speed_map->speed[node][node] =
1353 self_id->p0.phy_speed;
1354 for (j = 0; j < node; j++) {
1355 fc->speed_map->speed[j][node] =
1356 fc->speed_map->speed[node][j] =
1357 min(fc->speed_map->speed[j][j],
1358 self_id->p0.phy_speed);
1359 }
1360 if ((fc->irm == -1 || self_id->p0.phy_id > fc->irm) &&
1361 (self_id->p0.link_active && self_id->p0.contender))
1362 fc->irm = self_id->p0.phy_id;
1363 if (self_id->p0.port0 >= 0x2)
1364 c_port++;
1365 if (self_id->p0.port1 >= 0x2)
1366 c_port++;
1367 if (self_id->p0.port2 >= 0x2)
1368 c_port++;
1369 }
1370 if (c_port > 2)
1371 i_branch += (c_port - 2);
1372 sid += 2;
1373 self_id++;
1374 fc->topology_map->self_id_count++;
1375 }
1376 /* CRC */
1377 fc->topology_map->crc = fw_crc16(
1378 (uint32_t *)&fc->topology_map->generation,
1379 fc->topology_map->crc_len * 4);
1380 fc->speed_map->crc = fw_crc16(
1381 (uint32_t *)&fc->speed_map->generation,
1382 fc->speed_map->crc_len * 4);
1383 /* byteswap and copy to CSR */
1384 p = (uint32_t *)fc->topology_map;
1385 for (i = 0; i <= fc->topology_map->crc_len; i++)
1386 CSRARC(fc, TOPO_MAP + i * 4) = htonl(*p++);
1387 p = (uint32_t *)fc->speed_map;
1388 CSRARC(fc, SPED_MAP) = htonl(*p++);
1389 CSRARC(fc, SPED_MAP + 4) = htonl(*p++);
1390 /* don't byte-swap uint8_t array */
1391 bcopy(p, &CSRARC(fc, SPED_MAP + 8), (fc->speed_map->crc_len - 1) * 4);
1392
1393 fc->max_hop = fc->max_node - i_branch;
1394 device_printf(fc->bdev, "%d nodes, maxhop <= %d %s irm(%d) %s\n",
1395 fc->max_node + 1, fc->max_hop,
1396 (fc->irm == -1) ? "Not IRM capable" : "cable IRM",
1397 fc->irm, (fc->irm == fc->nodeid) ? " (me) " : "");
1398
1399 if (try_bmr && (fc->irm != -1) && (CSRARC(fc, BUS_MGR_ID) == FW_NO_BUS_MANAGER)) {
1400 if (fc->irm == fc->nodeid) {
1401 fc->status = FWBUSMGRDONE;
1402 CSRARC(fc, BUS_MGR_ID) = fc->set_bmr(fc, fc->irm);
1403 fw_bmr(fc);
1404 } else {
1405 fc->status = FWBUSMGRELECT;
1406 callout_reset(&fc->bmr_callout, hz / 8,
1407 fw_try_bmr, fc);
1408 }
1409 } else
1410 fc->status = FWBUSMGRDONE;
1411
1412 callout_reset(&fc->busprobe_callout, hz / 4, fw_bus_probe, fc);
1413 }
1414
1415 /*
1416 * To probe devices on the IEEE1394 bus.
1417 */
1418 static void
fw_bus_probe(void * arg)1419 fw_bus_probe(void *arg)
1420 {
1421 struct firewire_comm *fc;
1422 struct fw_device *fwdev;
1423
1424 fc = arg;
1425 fc->status = FWBUSEXPLORE;
1426
1427 /* Invalidate all devices, just after bus reset. */
1428 if (firewire_debug)
1429 device_printf(fc->bdev, "%s:"
1430 "iterate and invalidate all nodes\n",
1431 __func__);
1432 STAILQ_FOREACH(fwdev, &fc->devices, link)
1433 if (fwdev->status != FWDEVINVAL) {
1434 fwdev->status = FWDEVINVAL;
1435 fwdev->rcnt = 0;
1436 if (firewire_debug)
1437 device_printf(fc->bdev, "%s:"
1438 "Invalidate Dev ID: %08x%08x\n",
1439 __func__, fwdev->eui.hi, fwdev->eui.lo);
1440 } else {
1441 if (firewire_debug)
1442 device_printf(fc->bdev, "%s:"
1443 "Dev ID: %08x%08x already invalid\n",
1444 __func__, fwdev->eui.hi, fwdev->eui.lo);
1445 }
1446
1447 wakeup(fc);
1448 }
1449
1450 static int
fw_explore_read_quads(struct fw_device * fwdev,int offset,uint32_t * quad,int length)1451 fw_explore_read_quads(struct fw_device *fwdev, int offset,
1452 uint32_t *quad, int length)
1453 {
1454 struct fw_xfer *xfer;
1455 uint32_t tmp;
1456 int i, error;
1457
1458 for (i = 0; i < length; i++, offset += sizeof(uint32_t)) {
1459 xfer = fwmem_read_quad(fwdev, NULL, -1, 0xffff,
1460 0xf0000000 | offset, &tmp, fw_xferwake);
1461 if (xfer == NULL)
1462 return (-1);
1463 fw_xferwait(xfer);
1464
1465 if (xfer->resp == 0)
1466 quad[i] = ntohl(tmp);
1467
1468 error = xfer->resp;
1469 fw_xfer_free(xfer);
1470 if (error)
1471 return (error);
1472 }
1473 return (0);
1474 }
1475
1476
1477 static int
fw_explore_csrblock(struct fw_device * fwdev,int offset,int recur)1478 fw_explore_csrblock(struct fw_device *fwdev, int offset, int recur)
1479 {
1480 int err, i, off;
1481 struct csrdirectory *dir;
1482 struct csrreg *reg;
1483
1484 dir = (struct csrdirectory *)&fwdev->csrrom[offset / sizeof(uint32_t)];
1485 err = fw_explore_read_quads(fwdev, CSRROMOFF + offset,
1486 (uint32_t *)dir, 1);
1487 if (err)
1488 return (-1);
1489
1490 offset += sizeof(uint32_t);
1491 reg = (struct csrreg *)&fwdev->csrrom[offset / sizeof(uint32_t)];
1492 err = fw_explore_read_quads(fwdev, CSRROMOFF + offset,
1493 (uint32_t *)reg, dir->crc_len);
1494 if (err)
1495 return (-1);
1496
1497 if (!crom_crc_valid((uint32_t *)reg, dir->crc_len, dir->crc)) {
1498 if (firewire_debug)
1499 printf("%s: bad CRC in directory at 0x%x\n",
1500 __func__, offset - (int)sizeof(uint32_t));
1501 }
1502
1503 off = CSRROMOFF + offset + sizeof(uint32_t) * (dir->crc_len - 1);
1504 if (fwdev->rommax < off)
1505 fwdev->rommax = off;
1506
1507 if (recur == 0)
1508 return (0);
1509
1510 for (i = 0; i < dir->crc_len; i++, offset += sizeof(uint32_t)) {
1511 if ((reg[i].key & CSRTYPE_MASK) == CSRTYPE_D)
1512 recur = 1;
1513 else if ((reg[i].key & CSRTYPE_MASK) == CSRTYPE_L)
1514 recur = 0;
1515 else
1516 continue;
1517
1518 off = offset + reg[i].val * sizeof(uint32_t);
1519 if (off > CROMSIZE) {
1520 printf("%s: invalid offset %d\n", __FUNCTION__, off);
1521 return (-1);
1522 }
1523 err = fw_explore_csrblock(fwdev, off, recur);
1524 if (err)
1525 return (-1);
1526 }
1527 return (0);
1528 }
1529
1530 static int
fw_explore_node(struct fw_device * dfwdev)1531 fw_explore_node(struct fw_device *dfwdev)
1532 {
1533 struct firewire_comm *fc;
1534 struct fw_device *fwdev, *pfwdev, *tfwdev;
1535 uint32_t *csr;
1536 struct csrhdr *hdr;
1537 struct bus_info *binfo;
1538 int err, node;
1539 uint32_t speed_test = 0;
1540
1541 fc = dfwdev->fc;
1542 csr = dfwdev->csrrom;
1543 node = dfwdev->dst;
1544
1545 /* First quad */
1546 err = fw_explore_read_quads(dfwdev, CSRROMOFF, &csr[0], 1);
1547 if (err) {
1548 dfwdev->status = FWDEVINVAL;
1549 return (-1);
1550 }
1551 hdr = (struct csrhdr *)&csr[0];
1552 if (hdr->info_len != 4) {
1553 if (firewire_debug)
1554 device_printf(fc->bdev,
1555 "%s: node%d: wrong bus info len(%d)\n",
1556 __func__, node, hdr->info_len);
1557 dfwdev->status = FWDEVINVAL;
1558 return (-1);
1559 }
1560
1561 /* bus info */
1562 err = fw_explore_read_quads(dfwdev, CSRROMOFF + 0x04, &csr[1], 4);
1563 if (err) {
1564 dfwdev->status = FWDEVINVAL;
1565 return (-1);
1566 }
1567 binfo = (struct bus_info *)&csr[1];
1568 /* Root header CRC spans entire ROM; validated per-directory below. */
1569 if (binfo->bus_name != CSR_BUS_NAME_IEEE1394) {
1570 dfwdev->status = FWDEVINVAL;
1571 return (-1);
1572 }
1573
1574 if (firewire_debug)
1575 device_printf(fc->bdev, "%s: node(%d) BUS INFO BLOCK:\n"
1576 "irmc(%d) cmc(%d) isc(%d) bmc(%d) pmc(%d) "
1577 "cyc_clk_acc(%d) max_rec(%d) max_rom(%d) "
1578 "generation(%d) link_spd(%d)\n",
1579 __func__, node,
1580 binfo->irmc, binfo->cmc, binfo->isc,
1581 binfo->bmc, binfo->pmc, binfo->cyc_clk_acc,
1582 binfo->max_rec, binfo->max_rom,
1583 binfo->generation, binfo->link_spd);
1584
1585 STAILQ_FOREACH(fwdev, &fc->devices, link)
1586 if (FW_EUI64_EQUAL(fwdev->eui, binfo->eui64))
1587 break;
1588 if (fwdev == NULL) {
1589 /* new device */
1590 fwdev = malloc(sizeof(struct fw_device), M_FW,
1591 M_NOWAIT | M_ZERO);
1592 if (fwdev == NULL) {
1593 device_printf(fc->bdev, "%s: node%d: no memory\n",
1594 __func__, node);
1595 return (-1);
1596 }
1597 fwdev->fc = fc;
1598 fwdev->eui = binfo->eui64;
1599 fwdev->dst = dfwdev->dst;
1600 fwdev->maxrec = dfwdev->maxrec;
1601 fwdev->status = dfwdev->status;
1602 STAILQ_INIT(&fwdev->units);
1603
1604 /*
1605 * Pre-1394a-2000 didn't have link_spd in
1606 * the Bus Info block, so try and use the
1607 * speed map value.
1608 * 1394a-2000 compliant devices only use
1609 * the Bus Info Block link spd value, so
1610 * ignore the speed map altogether. SWB
1611 */
1612 if (binfo->link_spd == FWSPD_S100 /* 0 */) {
1613 device_printf(fc->bdev, "%s: "
1614 "Pre 1394a-2000 detected\n", __func__);
1615 fwdev->speed = fc->speed_map->speed[fc->nodeid][node];
1616 } else
1617 fwdev->speed = binfo->link_spd;
1618 /*
1619 * Test this speed with a read to the CSRROM.
1620 * If it fails, slow down the speed and retry.
1621 */
1622 while (fwdev->speed > FWSPD_S100 /* 0 */) {
1623 err = fw_explore_read_quads(fwdev, CSRROMOFF,
1624 &speed_test, 1);
1625 if (err) {
1626 device_printf(fc->bdev,
1627 "%s: fwdev->speed(%s) decremented due to negotiation\n",
1628 __func__, linkspeed[fwdev->speed]);
1629 fwdev->speed--;
1630 } else
1631 break;
1632
1633 }
1634
1635 /*
1636 * If the fwdev is not found in the
1637 * fc->devices TAILQ, then we will add it.
1638 */
1639 pfwdev = NULL;
1640 STAILQ_FOREACH(tfwdev, &fc->devices, link) {
1641 if (tfwdev->eui.hi > fwdev->eui.hi ||
1642 (tfwdev->eui.hi == fwdev->eui.hi &&
1643 tfwdev->eui.lo > fwdev->eui.lo))
1644 break;
1645 pfwdev = tfwdev;
1646 }
1647 if (pfwdev == NULL)
1648 STAILQ_INSERT_HEAD(&fc->devices, fwdev, link);
1649 else
1650 STAILQ_INSERT_AFTER(&fc->devices, pfwdev, fwdev, link);
1651 } else {
1652 fwdev->dst = node;
1653 fwdev->status = FWDEVINIT;
1654 /* unchanged ? */
1655 if (bcmp(&csr[0], &fwdev->csrrom[0], sizeof(uint32_t) * FW_ROM_HEADER_QUADS) == 0) {
1656 if (!STAILQ_EMPTY(&fwdev->units)) {
1657 if (firewire_debug)
1658 device_printf(fc->dev,
1659 "node%d: crom unchanged\n", node);
1660 fwdev->rom_changed = 0;
1661 return (0);
1662 }
1663 /* Units lost after detach/reattach; re-parse. */
1664 fwdev->rom_changed = 0;
1665 } else {
1666 fwdev->rom_changed = 1;
1667 }
1668 }
1669
1670 bzero(&fwdev->csrrom[0], CROMSIZE);
1671
1672 /* copy first quad and bus info block */
1673 bcopy(&csr[0], &fwdev->csrrom[0], sizeof(uint32_t) * FW_ROM_HEADER_QUADS);
1674 fwdev->rommax = CSRROMOFF + sizeof(uint32_t) * 4;
1675
1676 err = fw_explore_csrblock(fwdev, 0x14, 1); /* root directory */
1677
1678 if (err) {
1679 if (firewire_debug)
1680 device_printf(fc->dev, "%s: explore csrblock failed err(%d)\n",
1681 __func__, err);
1682 fwdev->status = FWDEVINVAL;
1683 fwdev->csrrom[0] = 0;
1684 }
1685 return (err);
1686
1687 }
1688
1689 /*
1690 * Find the self_id packet for a node, ignoring sequels.
1691 */
1692 static union fw_self_id *
fw_find_self_id(struct firewire_comm * fc,int node)1693 fw_find_self_id(struct firewire_comm *fc, int node)
1694 {
1695 uint32_t i;
1696 union fw_self_id *s;
1697
1698 for (i = 0; i < fc->topology_map->self_id_count; i++) {
1699 s = &fc->topology_map->self_id[i];
1700 if (s->p0.sequel)
1701 continue;
1702 if (s->p0.phy_id == node)
1703 return s;
1704 }
1705 return 0;
1706 }
1707
1708 static void
fw_explore(struct firewire_comm * fc)1709 fw_explore(struct firewire_comm *fc)
1710 {
1711 int node, err, i, todo, todo2, trys;
1712 char nodes[FW_MAX_NODES - 1];
1713 struct fw_device dfwdev;
1714 union fw_self_id *fwsid;
1715
1716 todo = 0;
1717 /* setup dummy fwdev */
1718 dfwdev.fc = fc;
1719 dfwdev.speed = 0;
1720 dfwdev.maxrec = FW_MAXREC_512;
1721 dfwdev.status = FWDEVINIT;
1722
1723 for (node = 0; node <= fc->max_node; node++) {
1724 /* We don't probe myself and linkdown nodes */
1725 if (node == fc->nodeid) {
1726 if (firewire_debug)
1727 device_printf(fc->bdev, "%s:"
1728 "found myself node(%d) fc->nodeid(%d) fc->max_node(%d)\n",
1729 __func__, node, fc->nodeid, fc->max_node);
1730 continue;
1731 } else if (firewire_debug) {
1732 device_printf(fc->bdev, "%s:"
1733 "node(%d) fc->max_node(%d) found\n",
1734 __func__, node, fc->max_node);
1735 }
1736 fwsid = fw_find_self_id(fc, node);
1737 if (!fwsid || !fwsid->p0.link_active) {
1738 if (firewire_debug)
1739 device_printf(fc->bdev,
1740 "%s: node%d: link down\n",
1741 __func__, node);
1742 continue;
1743 }
1744 nodes[todo++] = node;
1745 }
1746
1747 for (trys = 0; todo > 0 && trys < FW_EXPLORE_MAX_RETRIES; trys++) {
1748 todo2 = 0;
1749 for (i = 0; i < todo; i++) {
1750 dfwdev.dst = nodes[i];
1751 err = fw_explore_node(&dfwdev);
1752 if (err)
1753 nodes[todo2++] = nodes[i];
1754 if (firewire_debug)
1755 device_printf(fc->bdev,
1756 "%s: node %d, err = %d\n",
1757 __func__, node, err);
1758 }
1759 todo = todo2;
1760 }
1761 }
1762
1763 static void
fw_bus_probe_thread(void * arg)1764 fw_bus_probe_thread(void *arg)
1765 {
1766 struct firewire_comm *fc;
1767
1768 fc = arg;
1769
1770 mtx_lock(&fc->wait_lock);
1771 while (fc->status != FWBUSDETACH) {
1772 if (fc->status == FWBUSEXPLORE) {
1773 mtx_unlock(&fc->wait_lock);
1774 fw_explore(fc);
1775 fc->status = FWBUSEXPDONE;
1776 if (firewire_debug)
1777 printf("bus_explore done\n");
1778 fw_attach_dev(fc);
1779 mtx_lock(&fc->wait_lock);
1780 }
1781 msleep((void *)fc, &fc->wait_lock, PWAIT|PCATCH, "-", 0);
1782 }
1783 mtx_unlock(&fc->wait_lock);
1784 kproc_exit(0);
1785 }
1786
1787 static void
fw_parse_units(struct fw_device * fwdev)1788 fw_parse_units(struct fw_device *fwdev)
1789 {
1790 struct csrhdr *hdr;
1791 struct csrdirectory *rootdir, *udir;
1792 struct csrreg *ureg;
1793 struct fw_unit *unit;
1794 uint32_t spec_id, sw_version;
1795 uint32_t rom_quads, root_off, root_len;
1796 uint32_t reg_off, udir_qoff, udir_len;
1797 int ri, ui, uindex;
1798
1799 rom_quads = CSRROMSIZE / 4;
1800 hdr = (struct csrhdr *)fwdev->csrrom;
1801 if (hdr->info_len <= 1)
1802 return;
1803
1804 root_off = 1 + hdr->info_len;
1805 if (root_off >= rom_quads)
1806 return;
1807 rootdir = (struct csrdirectory *)&fwdev->csrrom[root_off];
1808 root_len = rootdir->crc_len;
1809 if (root_off + 1 + root_len > rom_quads)
1810 return;
1811 if (!crom_crc_valid((uint32_t *)&rootdir->entry[0], root_len,
1812 rootdir->crc) && firewire_debug)
1813 device_printf(fwdev->fc->bdev,
1814 "fw_parse_units: bad root directory CRC\n");
1815
1816 uindex = 0;
1817 for (ri = 0; ri < (int)root_len; ri++) {
1818 reg_off = root_off + 1 + ri;
1819 if (reg_off >= rom_quads)
1820 break;
1821 if (rootdir->entry[ri].key != CROM_UDIR)
1822 continue;
1823
1824 udir_qoff = reg_off + rootdir->entry[ri].val;
1825 if (udir_qoff >= rom_quads)
1826 continue;
1827 udir = (struct csrdirectory *)&fwdev->csrrom[udir_qoff];
1828 udir_len = udir->crc_len;
1829 if (udir_qoff + 1 + udir_len > rom_quads)
1830 continue;
1831 if (!crom_crc_valid((uint32_t *)&udir->entry[0], udir_len,
1832 udir->crc) && firewire_debug)
1833 printf("fw_parse_units: bad CRC in unit dir at 0x%x\n",
1834 udir_qoff);
1835
1836 spec_id = 0;
1837 sw_version = 0;
1838 for (ui = 0; ui < (int)udir_len; ui++) {
1839 if (udir_qoff + 1 + ui >= rom_quads)
1840 break;
1841 ureg = &udir->entry[ui];
1842 if (ureg->key == CSRKEY_SPEC)
1843 spec_id = ureg->val;
1844 else if (ureg->key == CSRKEY_VER)
1845 sw_version = ureg->val;
1846 }
1847 if (spec_id == 0 && sw_version == 0)
1848 continue;
1849
1850 unit = malloc(sizeof(*unit), M_FW, M_NOWAIT | M_ZERO);
1851 if (unit == NULL)
1852 continue;
1853 unit->fwdev = fwdev;
1854 unit->spec_id = spec_id;
1855 unit->sw_version = sw_version;
1856 unit->dir_offset = udir_qoff * 4;
1857 STAILQ_INSERT_TAIL(&fwdev->units, unit, link);
1858 uindex++;
1859 }
1860 if (firewire_debug && uindex > 0)
1861 device_printf(fwdev->fc->bdev,
1862 "node %d: %d unit director%s found\n",
1863 fwdev->dst, uindex, uindex == 1 ? "y" : "ies");
1864 }
1865
1866 static void
fw_create_unit_children(struct firewire_comm * fc,struct fw_device * fwdev)1867 fw_create_unit_children(struct firewire_comm *fc, struct fw_device *fwdev)
1868 {
1869 struct fw_unit *unit;
1870 struct fw_child_ivars *iv;
1871
1872 bus_topo_lock();
1873 STAILQ_FOREACH(unit, &fwdev->units, link) {
1874 if (unit->dev != NULL)
1875 continue;
1876 unit->dev = device_add_child(fc->bdev, NULL, DEVICE_UNIT_ANY);
1877 if (unit->dev == NULL) {
1878 device_printf(fc->bdev,
1879 "failed to add unit child for node %d\n",
1880 fwdev->dst);
1881 continue;
1882 }
1883 iv = malloc(sizeof(*iv), M_FW, M_NOWAIT | M_ZERO);
1884 if (iv == NULL) {
1885 device_delete_child(fc->bdev, unit->dev);
1886 unit->dev = NULL;
1887 continue;
1888 }
1889 iv->type = FW_CHILD_UNIT;
1890 iv->u.unit = unit;
1891 device_set_ivars(unit->dev, iv);
1892 if (firewire_debug)
1893 device_printf(fc->bdev,
1894 "node %d: unit spec=0x%06x ver=0x%06x\n",
1895 fwdev->dst, unit->spec_id, unit->sw_version);
1896 device_probe_and_attach(unit->dev);
1897 }
1898 bus_topo_unlock();
1899 }
1900
1901 static int
fw_remove_unit_children(struct firewire_comm * fc,struct fw_device * fwdev)1902 fw_remove_unit_children(struct firewire_comm *fc, struct fw_device *fwdev)
1903 {
1904 struct fw_unit *unit, *next;
1905 int err, ret;
1906
1907 ret = 0;
1908 bus_topo_lock();
1909 STAILQ_FOREACH_SAFE(unit, &fwdev->units, link, next) {
1910 if (unit->dev != NULL) {
1911 err = device_delete_child(fc->bdev, unit->dev);
1912 if (err != 0) {
1913 ret = err;
1914 continue;
1915 }
1916 unit->dev = NULL;
1917 }
1918 STAILQ_REMOVE(&fwdev->units, unit, fw_unit, link);
1919 free(unit, M_FW);
1920 }
1921 bus_topo_unlock();
1922 return (ret);
1923 }
1924
1925 /*
1926 * To attach sub-devices layer onto IEEE1394 bus.
1927 */
1928 static void
fw_attach_dev(struct firewire_comm * fc)1929 fw_attach_dev(struct firewire_comm *fc)
1930 {
1931 struct fw_device *fwdev, *next;
1932 int i, err;
1933 device_t *devlistp;
1934 int devcnt;
1935 struct firewire_dev_comm *fdc;
1936
1937 for (fwdev = STAILQ_FIRST(&fc->devices); fwdev != NULL; fwdev = next) {
1938 next = STAILQ_NEXT(fwdev, link);
1939 if (fwdev->status == FWDEVINIT) {
1940 fwdev->status = FWDEVATTACHED;
1941 if (fwdev->rom_changed &&
1942 !STAILQ_EMPTY(&fwdev->units)) {
1943 if (fw_remove_unit_children(fc, fwdev) == 0)
1944 fwdev->rom_changed = 0;
1945 }
1946 if (STAILQ_EMPTY(&fwdev->units)) {
1947 fw_parse_units(fwdev);
1948 }
1949 fw_create_unit_children(fc, fwdev);
1950 } else if (fwdev->status == FWDEVINVAL) {
1951 fwdev->rcnt++;
1952 if (firewire_debug)
1953 device_printf(fc->bdev, "%s:"
1954 "fwdev->rcnt(%d), hold_count(%d)\n",
1955 __func__, fwdev->rcnt, hold_count);
1956 if (fwdev->rcnt > hold_count) {
1957 /*
1958 * Remove devices which have not been seen
1959 * for a while.
1960 */
1961 if (fw_remove_unit_children(fc, fwdev) != 0)
1962 continue;
1963 STAILQ_REMOVE(&fc->devices, fwdev, fw_device,
1964 link);
1965 free(fwdev, M_FW);
1966 }
1967 }
1968 }
1969
1970 err = device_get_children(fc->bdev, &devlistp, &devcnt);
1971 if (err == 0) {
1972 for (i = 0; i < devcnt; i++) {
1973 struct fw_child_ivars *iv;
1974
1975 if (device_get_state(devlistp[i]) < DS_ATTACHED)
1976 continue;
1977 iv = fw_get_ivars(devlistp[i]);
1978 if (iv == NULL || iv->type != FW_CHILD_BUS)
1979 continue;
1980 fdc = device_get_softc(devlistp[i]);
1981 if (fdc->post_explore != NULL)
1982 fdc->post_explore(fdc);
1983 }
1984 free(devlistp, M_TEMP);
1985 }
1986
1987 return;
1988 }
1989
1990 /*
1991 * To allocate unique transaction label.
1992 */
1993 static int
fw_get_tlabel(struct firewire_comm * fc,struct fw_xfer * xfer)1994 fw_get_tlabel(struct firewire_comm *fc, struct fw_xfer *xfer)
1995 {
1996 u_int dst, new_tlabel;
1997 struct fw_xfer *txfer;
1998
1999 dst = xfer->send.hdr.mode.hdr.dst & FW_NODE_MASK;
2000 mtx_lock(&fc->tlabel_lock);
2001 new_tlabel = (fc->last_tlabel[dst] + 1) & FW_TLABEL_MASK;
2002 STAILQ_FOREACH(txfer, &fc->tlabels[new_tlabel], tlabel)
2003 if ((txfer->send.hdr.mode.hdr.dst & FW_NODE_MASK) == dst)
2004 break;
2005 if (txfer == NULL) {
2006 fc->last_tlabel[dst] = new_tlabel;
2007 STAILQ_INSERT_TAIL(&fc->tlabels[new_tlabel], xfer, tlabel);
2008 mtx_unlock(&fc->tlabel_lock);
2009 xfer->tl = new_tlabel;
2010 xfer->send.hdr.mode.hdr.tlrt = new_tlabel << 2;
2011 if (firewire_debug > 1)
2012 printf("fw_get_tlabel: dst=%d tl=%d\n", dst, new_tlabel);
2013 return (new_tlabel);
2014 }
2015 mtx_unlock(&fc->tlabel_lock);
2016
2017 if (firewire_debug > 1)
2018 printf("fw_get_tlabel: no free tlabel\n");
2019 return (-1);
2020 }
2021
2022 static void
fw_rcv_copy(struct fw_rcv_buf * rb)2023 fw_rcv_copy(struct fw_rcv_buf *rb)
2024 {
2025 struct fw_pkt *pkt;
2026 u_char *p;
2027 struct tcode_info *tinfo;
2028 u_int res, i, len, plen;
2029
2030 rb->xfer->recv.spd = rb->spd;
2031
2032 pkt = (struct fw_pkt *)rb->vec->iov_base;
2033 tinfo = &rb->fc->tcode[pkt->mode.hdr.tcode];
2034
2035 /* Copy header */
2036 p = (u_char *)&rb->xfer->recv.hdr;
2037 bcopy(rb->vec->iov_base, p, tinfo->hdr_len);
2038 rb->vec->iov_base = (u_char *)rb->vec->iov_base + tinfo->hdr_len;
2039 rb->vec->iov_len -= tinfo->hdr_len;
2040
2041 /* Copy payload */
2042 p = (u_char *)rb->xfer->recv.payload;
2043 res = rb->xfer->recv.pay_len;
2044
2045 /* special handling for RRESQ */
2046 if (pkt->mode.hdr.tcode == FWTCODE_RRESQ &&
2047 p != NULL && res >= sizeof(uint32_t)) {
2048 *(uint32_t *)p = pkt->mode.rresq.data;
2049 rb->xfer->recv.pay_len = sizeof(uint32_t);
2050 return;
2051 }
2052
2053 if ((tinfo->flag & FWTI_BLOCK_ASY) == 0)
2054 return;
2055
2056 plen = pkt->mode.rresb.len;
2057
2058 for (i = 0; i < rb->nvec; i++, rb->vec++) {
2059 len = MIN(rb->vec->iov_len, plen);
2060 if (res < len) {
2061 device_printf(rb->fc->bdev, "%s:"
2062 " rcv buffer(%d) is %d bytes short.\n",
2063 __func__, rb->xfer->recv.pay_len, len - res);
2064 len = res;
2065 }
2066 bcopy(rb->vec->iov_base, p, len);
2067 p += len;
2068 res -= len;
2069 plen -= len;
2070 if (res == 0 || plen == 0)
2071 break;
2072 }
2073 rb->xfer->recv.pay_len -= res;
2074 }
2075
2076 /*
2077 * Generic packet receiving process.
2078 */
2079 void
fw_rcv(struct fw_rcv_buf * rb)2080 fw_rcv(struct fw_rcv_buf *rb)
2081 {
2082 struct fw_pkt *fp, *resfp;
2083 struct fw_bind *bind;
2084 int tcode;
2085 int oldstate;
2086
2087 fp = (struct fw_pkt *)rb->vec[0].iov_base;
2088 tcode = fp->mode.common.tcode;
2089 switch (tcode) {
2090 case FWTCODE_WRES:
2091 case FWTCODE_RRESQ:
2092 case FWTCODE_RRESB:
2093 case FWTCODE_LRES:
2094 rb->xfer = fw_tl2xfer(rb->fc, fp->mode.hdr.src,
2095 fp->mode.hdr.tlrt >> 2, fp->mode.hdr.tcode);
2096 if (rb->xfer == NULL) {
2097 device_printf(rb->fc->bdev, "%s: unknown response "
2098 "%s(%x) src=0x%x tl=0x%x rt=%d data=0x%x\n",
2099 __func__,
2100 tcode_str[tcode], tcode,
2101 fp->mode.hdr.src,
2102 fp->mode.hdr.tlrt >> 2,
2103 fp->mode.hdr.tlrt & 3,
2104 fp->mode.rresq.data);
2105 return;
2106 }
2107 fw_rcv_copy(rb);
2108 if (rb->xfer->recv.hdr.mode.wres.rtcode != RESP_CMP)
2109 rb->xfer->resp = EIO;
2110 else
2111 rb->xfer->resp = 0;
2112 /* make sure the packet is drained in AT queue */
2113 oldstate = rb->xfer->flag;
2114 rb->xfer->flag = FWXF_RCVD;
2115 switch (oldstate) {
2116 case FWXF_SENT:
2117 fw_xfer_done(rb->xfer);
2118 break;
2119 case FWXF_START:
2120 break;
2121 default:
2122 device_printf(rb->fc->bdev, "%s: "
2123 "unexpected flag 0x%02x\n", __func__,
2124 rb->xfer->flag);
2125 }
2126 return;
2127 case FWTCODE_WREQQ:
2128 case FWTCODE_WREQB:
2129 case FWTCODE_RREQQ:
2130 case FWTCODE_RREQB:
2131 case FWTCODE_LREQ:
2132 bind = fw_bindlookup(rb->fc, fp->mode.rreqq.dest_hi,
2133 fp->mode.rreqq.dest_lo);
2134 if (bind == NULL) {
2135 device_printf(rb->fc->bdev, "%s: "
2136 "Unknown service addr 0x%04x:0x%08x %s(%x)"
2137 " src=0x%x data=%x\n",
2138 __func__,
2139 fp->mode.wreqq.dest_hi,
2140 fp->mode.wreqq.dest_lo,
2141 tcode_str[tcode], tcode,
2142 fp->mode.hdr.src,
2143 ntohl(fp->mode.wreqq.data));
2144
2145 if (rb->fc->status == FWBUSINIT) {
2146 device_printf(rb->fc->bdev,
2147 "%s: cannot respond(bus reset)!\n",
2148 __func__);
2149 return;
2150 }
2151 rb->xfer = fw_xfer_alloc(M_FWXFER);
2152 if (rb->xfer == NULL) {
2153 return;
2154 }
2155 rb->xfer->send.spd = rb->spd;
2156 rb->xfer->send.pay_len = 0;
2157 resfp = &rb->xfer->send.hdr;
2158 switch (tcode) {
2159 case FWTCODE_WREQQ:
2160 case FWTCODE_WREQB:
2161 resfp->mode.hdr.tcode = FWTCODE_WRES;
2162 break;
2163 case FWTCODE_RREQQ:
2164 resfp->mode.hdr.tcode = FWTCODE_RRESQ;
2165 break;
2166 case FWTCODE_RREQB:
2167 resfp->mode.hdr.tcode = FWTCODE_RRESB;
2168 break;
2169 case FWTCODE_LREQ:
2170 resfp->mode.hdr.tcode = FWTCODE_LRES;
2171 break;
2172 }
2173 resfp->mode.hdr.dst = fp->mode.hdr.src;
2174 resfp->mode.hdr.tlrt = fp->mode.hdr.tlrt;
2175 resfp->mode.hdr.pri = fp->mode.hdr.pri;
2176 resfp->mode.rresb.rtcode = RESP_ADDRESS_ERROR;
2177 resfp->mode.rresb.extcode = 0;
2178 resfp->mode.rresb.len = 0;
2179 rb->xfer->hand = fw_xfer_free;
2180 if (fw_asyreq(rb->fc, -1, rb->xfer))
2181 fw_xfer_free(rb->xfer);
2182 return;
2183 }
2184 rb->xfer = STAILQ_FIRST(&bind->xferlist);
2185 if (rb->xfer == NULL) {
2186 device_printf(rb->fc->bdev, "%s: "
2187 "Discard a packet for this bind.\n", __func__);
2188 return;
2189 }
2190 STAILQ_REMOVE_HEAD(&bind->xferlist, link);
2191 fw_rcv_copy(rb);
2192 rb->xfer->hand(rb->xfer);
2193 return;
2194 default:
2195 device_printf(rb->fc->bdev,"%s: unknown tcode %d\n",
2196 __func__, tcode);
2197 break;
2198 }
2199 }
2200
2201 /*
2202 * Post process for Bus Manager election process.
2203 */
2204 static void
fw_try_bmr_callback(struct fw_xfer * xfer)2205 fw_try_bmr_callback(struct fw_xfer *xfer)
2206 {
2207 struct firewire_comm *fc;
2208 int bmr;
2209
2210 if (xfer == NULL)
2211 return;
2212 fc = xfer->fc;
2213 if (xfer->resp != 0)
2214 goto error;
2215 if (xfer->recv.payload == NULL)
2216 goto error;
2217 if (xfer->recv.hdr.mode.lres.rtcode != FWRCODE_COMPLETE)
2218 goto error;
2219
2220 bmr = ntohl(xfer->recv.payload[0]);
2221 if (bmr == 0x3f)
2222 bmr = fc->nodeid;
2223
2224 CSRARC(fc, BUS_MGR_ID) = fc->set_bmr(fc, bmr & 0x3f);
2225 fw_xfer_free_buf(xfer);
2226 fw_bmr(fc);
2227 return;
2228
2229 error:
2230 device_printf(fc->bdev, "bus manager election failed\n");
2231 fw_xfer_free_buf(xfer);
2232 }
2233
2234
2235 /*
2236 * To candidate Bus Manager election process.
2237 */
2238 static void
fw_try_bmr(void * arg)2239 fw_try_bmr(void *arg)
2240 {
2241 struct fw_xfer *xfer;
2242 struct firewire_comm *fc = arg;
2243 struct fw_pkt *fp;
2244 int err = 0;
2245
2246 xfer = fw_xfer_alloc_buf(M_FWXFER, 8, 4);
2247 if (xfer == NULL)
2248 return;
2249 xfer->send.spd = 0;
2250 fc->status = FWBUSMGRELECT;
2251
2252 fp = &xfer->send.hdr;
2253 fp->mode.lreq.dest_hi = 0xffff;
2254 fp->mode.lreq.tlrt = 0;
2255 fp->mode.lreq.tcode = FWTCODE_LREQ;
2256 fp->mode.lreq.pri = 0;
2257 fp->mode.lreq.src = 0;
2258 fp->mode.lreq.len = 8;
2259 fp->mode.lreq.extcode = EXTCODE_CMP_SWAP;
2260 fp->mode.lreq.dst = FWLOCALBUS | fc->irm;
2261 fp->mode.lreq.dest_lo = 0xf0000000 | BUS_MGR_ID;
2262 xfer->send.payload[0] = htonl(0x3f);
2263 xfer->send.payload[1] = htonl(fc->nodeid);
2264 xfer->hand = fw_try_bmr_callback;
2265
2266 err = fw_asyreq(fc, -1, xfer);
2267 if (err) {
2268 fw_xfer_free_buf(xfer);
2269 return;
2270 }
2271 return;
2272 }
2273
2274 #ifdef FW_VMACCESS
2275 /*
2276 * Software implementation for physical memory block access.
2277 * Debug only, too slow for production use.
2278 */
2279 static void
fw_vmaccess(struct fw_xfer * xfer)2280 fw_vmaccess(struct fw_xfer *xfer)
2281 {
2282 struct fw_pkt *rfp, *sfp = NULL;
2283 uint32_t *ld = (uint32_t *)xfer->recv.buf;
2284
2285 printf("vmaccess spd:%2x len:%03x data:%08x %08x %08x %08x\n",
2286 xfer->spd, xfer->recv.len, ntohl(ld[0]), ntohl(ld[1]), ntohl(ld[2]),
2287 ntohl(ld[3]));
2288 printf("vmaccess data:%08x %08x %08x %08x\n", ntohl(ld[4]),
2289 ntohl(ld[5]), ntohl(ld[6]), ntohl(ld[7]));
2290 if (xfer->resp != 0) {
2291 fw_xfer_free(xfer);
2292 return;
2293 }
2294 if (xfer->recv.buf == NULL) {
2295 fw_xfer_free(xfer);
2296 return;
2297 }
2298 rfp = (struct fw_pkt *)xfer->recv.buf;
2299 switch (rfp->mode.hdr.tcode) {
2300 case FWTCODE_WREQB:
2301 xfer->send.buf = malloc(12, M_FW, M_NOWAIT);
2302 xfer->send.len = 12;
2303 sfp = (struct fw_pkt *)xfer->send.buf;
2304 bcopy(rfp->mode.wreqb.payload,
2305 (caddr_t)ntohl(rfp->mode.wreqb.dest_lo),s
2306 ntohs(rfp->mode.wreqb.len));
2307 sfp->mode.wres.tcode = FWTCODE_WRES;
2308 sfp->mode.wres.rtcode = 0;
2309 break;
2310 case FWTCODE_WREQQ:
2311 xfer->send.buf = malloc(12, M_FW, M_NOWAIT);
2312 xfer->send.len = 12;
2313 sfp->mode.wres.tcode = FWTCODE_WRES;
2314 *((uint32_t *)(ntohl(rfp->mode.wreqb.dest_lo))) =
2315 rfp->mode.wreqq.data;
2316 sfp->mode.wres.rtcode = 0;
2317 break;
2318 case FWTCODE_RREQB:
2319 xfer->send.buf = malloc(16 + rfp->mode.rreqb.len,
2320 M_FW, M_NOWAIT);
2321 xfer->send.len = 16 + ntohs(rfp->mode.rreqb.len);
2322 sfp = (struct fw_pkt *)xfer->send.buf;
2323 bcopy((caddr_t)ntohl(rfp->mode.rreqb.dest_lo),
2324 sfp->mode.rresb.payload,
2325 ntohs(rfp->mode.rreqb.len));
2326 sfp->mode.rresb.tcode = FWTCODE_RRESB;
2327 sfp->mode.rresb.len = rfp->mode.rreqb.len;
2328 sfp->mode.rresb.rtcode = 0;
2329 sfp->mode.rresb.extcode = 0;
2330 break;
2331 case FWTCODE_RREQQ:
2332 xfer->send.buf = malloc(16, M_FW, M_NOWAIT);
2333 xfer->send.len = 16;
2334 sfp = (struct fw_pkt *)xfer->send.buf;
2335 sfp->mode.rresq.data =
2336 *(uint32_t *)(ntohl(rfp->mode.rreqq.dest_lo));
2337 sfp->mode.wres.tcode = FWTCODE_RRESQ;
2338 sfp->mode.rresb.rtcode = 0;
2339 break;
2340 default:
2341 fw_xfer_free(xfer);
2342 return;
2343 }
2344 sfp->mode.hdr.dst = rfp->mode.hdr.src;
2345 xfer->dst = ntohs(rfp->mode.hdr.src);
2346 xfer->hand = fw_xfer_free;
2347
2348 sfp->mode.hdr.tlrt = rfp->mode.hdr.tlrt;
2349 sfp->mode.hdr.pri = 0;
2350
2351 fw_asyreq(xfer->fc, -1, xfer);
2352 /**/
2353 return;
2354 }
2355 #endif
2356
2357 /*
2358 * CRC16 check-sum for IEEE1394 register blocks.
2359 */
2360 uint16_t
fw_crc16(uint32_t * ptr,uint32_t len)2361 fw_crc16(uint32_t *ptr, uint32_t len)
2362 {
2363 uint32_t i, sum, crc = 0;
2364 int shift;
2365 len = (len + 3) & ~3;
2366 for (i = 0; i < len; i += 4) {
2367 for (shift = 28; shift >= 0; shift -= 4) {
2368 sum = ((crc >> 12) ^ (ptr[i/4] >> shift)) & 0xf;
2369 crc = (crc << 4) ^ (sum << 12) ^ (sum << 5) ^ sum;
2370 }
2371 crc &= 0xffff;
2372 }
2373 return ((uint16_t) crc);
2374 }
2375
2376 /*
2377 * Find the root node, if it is not
2378 * Cycle Master Capable, then we should
2379 * override this and become the Cycle
2380 * Master
2381 */
2382 static int
fw_bmr(struct firewire_comm * fc)2383 fw_bmr(struct firewire_comm *fc)
2384 {
2385 struct fw_device fwdev;
2386 union fw_self_id *self_id;
2387 int cmstr;
2388 uint32_t quad;
2389
2390 /* Check to see if the current root node is cycle master capable */
2391 self_id = fw_find_self_id(fc, fc->max_node);
2392 if (fc->max_node > 0) {
2393 if (self_id->p0.link_active && self_id->p0.contender)
2394 cmstr = fc->max_node;
2395 else {
2396 device_printf(fc->bdev,
2397 "root node is not cycle master capable, "
2398 "forcing root to node %d\n", fc->nodeid);
2399 fw_phy_config(fc, fc->nodeid, -1);
2400 return 0;
2401 }
2402 } else
2403 cmstr = -1;
2404
2405 device_printf(fc->bdev, "bus manager %d %s\n",
2406 CSRARC(fc, BUS_MGR_ID),
2407 (CSRARC(fc, BUS_MGR_ID) != fc->nodeid) ? "(me)" : "");
2408 if (CSRARC(fc, BUS_MGR_ID) != fc->nodeid) {
2409 /* We are not the bus manager */
2410 return (0);
2411 }
2412
2413 /* Optimize gapcount */
2414 if (fc->max_hop <= MAX_GAPHOP)
2415 fw_phy_config(fc, cmstr, gap_cnt[fc->max_hop]);
2416 /* If we are the cycle master, nothing to do */
2417 if (cmstr == fc->nodeid || cmstr == -1)
2418 return 0;
2419 /* Bus probe has not finished, make dummy fwdev for cmstr */
2420 bzero(&fwdev, sizeof(fwdev));
2421 fwdev.fc = fc;
2422 fwdev.dst = cmstr;
2423 fwdev.speed = 0;
2424 fwdev.maxrec = 8; /* 512 */
2425 fwdev.status = FWDEVINIT;
2426 /* Set cmstr bit on the cycle master */
2427 quad = htonl(1 << 8);
2428 fwmem_write_quad(&fwdev, NULL, 0/*spd*/,
2429 0xffff, 0xf0000000 | STATE_SET, &quad, fw_asy_callback_free);
2430
2431 return 0;
2432 }
2433
2434 int
fw_open_isodma(struct firewire_comm * fc,int tx)2435 fw_open_isodma(struct firewire_comm *fc, int tx)
2436 {
2437 struct fw_xferq **xferqa;
2438 struct fw_xferq *xferq;
2439 int i;
2440
2441 if (tx)
2442 xferqa = &fc->it[0];
2443 else
2444 xferqa = &fc->ir[0];
2445
2446 FW_GLOCK(fc);
2447 for (i = 0; i < fc->nisodma; i++) {
2448 xferq = xferqa[i];
2449 if ((xferq->flag & FWXFERQ_OPEN) == 0) {
2450 xferq->flag |= FWXFERQ_OPEN;
2451 break;
2452 }
2453 }
2454 if (i == fc->nisodma) {
2455 printf("no free dma channel (tx=%d)\n", tx);
2456 i = -1;
2457 }
2458 FW_GUNLOCK(fc);
2459 return (i);
2460 }
2461
2462 static int
fw_modevent(module_t mode,int type,void * data)2463 fw_modevent(module_t mode, int type, void *data)
2464 {
2465 int err = 0;
2466 static eventhandler_tag fwdev_ehtag = NULL;
2467
2468 switch (type) {
2469 case MOD_LOAD:
2470 firewire_devclass = devclass_create("firewire");
2471 fwdev_ehtag = EVENTHANDLER_REGISTER(dev_clone,
2472 fwdev_clone, 0, 1000);
2473 break;
2474 case MOD_UNLOAD:
2475 if (fwdev_ehtag != NULL)
2476 EVENTHANDLER_DEREGISTER(dev_clone, fwdev_ehtag);
2477 break;
2478 case MOD_SHUTDOWN:
2479 break;
2480 default:
2481 return (EOPNOTSUPP);
2482 }
2483 return (err);
2484 }
2485
2486
2487 DRIVER_MODULE(firewire, fwohci, firewire_driver, fw_modevent, NULL);
2488 MODULE_VERSION(firewire, 1);
2489