xref: /freebsd/sys/dev/firewire/fwohci.c (revision 1f2361f8f8560ab812dbd4c7a795f986ce2fefd0)
13c60ba66SKatsushi Kobayashi /*
23c60ba66SKatsushi Kobayashi  * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa
33c60ba66SKatsushi Kobayashi  * All rights reserved.
43c60ba66SKatsushi Kobayashi  *
53c60ba66SKatsushi Kobayashi  * Redistribution and use in source and binary forms, with or without
63c60ba66SKatsushi Kobayashi  * modification, are permitted provided that the following conditions
73c60ba66SKatsushi Kobayashi  * are met:
83c60ba66SKatsushi Kobayashi  * 1. Redistributions of source code must retain the above copyright
93c60ba66SKatsushi Kobayashi  *    notice, this list of conditions and the following disclaimer.
103c60ba66SKatsushi Kobayashi  * 2. Redistributions in binary form must reproduce the above copyright
113c60ba66SKatsushi Kobayashi  *    notice, this list of conditions and the following disclaimer in the
123c60ba66SKatsushi Kobayashi  *    documentation and/or other materials provided with the distribution.
133c60ba66SKatsushi Kobayashi  * 3. All advertising materials mentioning features or use of this software
143c60ba66SKatsushi Kobayashi  *    must display the acknowledgement as bellow:
153c60ba66SKatsushi Kobayashi  *
168da326fdSHidetoshi Shimokawa  *    This product includes software developed by K. Kobayashi and H. Shimokawa
173c60ba66SKatsushi Kobayashi  *
183c60ba66SKatsushi Kobayashi  * 4. The name of the author may not be used to endorse or promote products
193c60ba66SKatsushi Kobayashi  *    derived from this software without specific prior written permission.
203c60ba66SKatsushi Kobayashi  *
213c60ba66SKatsushi Kobayashi  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
223c60ba66SKatsushi Kobayashi  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
233c60ba66SKatsushi Kobayashi  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
243c60ba66SKatsushi Kobayashi  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
253c60ba66SKatsushi Kobayashi  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
263c60ba66SKatsushi Kobayashi  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
273c60ba66SKatsushi Kobayashi  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
283c60ba66SKatsushi Kobayashi  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
293c60ba66SKatsushi Kobayashi  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
303c60ba66SKatsushi Kobayashi  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
313c60ba66SKatsushi Kobayashi  * POSSIBILITY OF SUCH DAMAGE.
323c60ba66SKatsushi Kobayashi  *
333c60ba66SKatsushi Kobayashi  * $FreeBSD$
343c60ba66SKatsushi Kobayashi  *
353c60ba66SKatsushi Kobayashi  */
368da326fdSHidetoshi Shimokawa 
373c60ba66SKatsushi Kobayashi #define ATRQ_CH 0
383c60ba66SKatsushi Kobayashi #define ATRS_CH 1
393c60ba66SKatsushi Kobayashi #define ARRQ_CH 2
403c60ba66SKatsushi Kobayashi #define ARRS_CH 3
413c60ba66SKatsushi Kobayashi #define ITX_CH 4
423c60ba66SKatsushi Kobayashi #define IRX_CH 0x24
433c60ba66SKatsushi Kobayashi 
443c60ba66SKatsushi Kobayashi #include <sys/param.h>
453c60ba66SKatsushi Kobayashi #include <sys/systm.h>
463c60ba66SKatsushi Kobayashi #include <sys/types.h>
473c60ba66SKatsushi Kobayashi #include <sys/mbuf.h>
483c60ba66SKatsushi Kobayashi #include <sys/mman.h>
493c60ba66SKatsushi Kobayashi #include <sys/socket.h>
503c60ba66SKatsushi Kobayashi #include <sys/socketvar.h>
513c60ba66SKatsushi Kobayashi #include <sys/signalvar.h>
523c60ba66SKatsushi Kobayashi #include <sys/malloc.h>
533c60ba66SKatsushi Kobayashi #include <sys/uio.h>
543c60ba66SKatsushi Kobayashi #include <sys/sockio.h>
553c60ba66SKatsushi Kobayashi #include <sys/bus.h>
563c60ba66SKatsushi Kobayashi #include <sys/kernel.h>
573c60ba66SKatsushi Kobayashi #include <sys/conf.h>
583c60ba66SKatsushi Kobayashi 
593c60ba66SKatsushi Kobayashi #include <machine/bus.h>
603c60ba66SKatsushi Kobayashi #include <machine/resource.h>
613c60ba66SKatsushi Kobayashi #include <sys/rman.h>
623c60ba66SKatsushi Kobayashi 
633c60ba66SKatsushi Kobayashi #include <machine/cpufunc.h>            /* for rdtsc proto for clock.h below */
643c60ba66SKatsushi Kobayashi #include <machine/clock.h>
653c60ba66SKatsushi Kobayashi #include <pci/pcivar.h>
663c60ba66SKatsushi Kobayashi #include <pci/pcireg.h>
673c60ba66SKatsushi Kobayashi #include <vm/vm.h>
683c60ba66SKatsushi Kobayashi #include <vm/vm_extern.h>
693c60ba66SKatsushi Kobayashi #include <vm/pmap.h>            /* for vtophys proto */
703c60ba66SKatsushi Kobayashi 
713c60ba66SKatsushi Kobayashi #include <dev/firewire/firewire.h>
723c60ba66SKatsushi Kobayashi #include <dev/firewire/firewirebusreg.h>
733c60ba66SKatsushi Kobayashi #include <dev/firewire/firewirereg.h>
743c60ba66SKatsushi Kobayashi #include <dev/firewire/fwohcireg.h>
753c60ba66SKatsushi Kobayashi #include <dev/firewire/fwohcivar.h>
763c60ba66SKatsushi Kobayashi #include <dev/firewire/firewire_phy.h>
773c60ba66SKatsushi Kobayashi 
783c60ba66SKatsushi Kobayashi #undef OHCI_DEBUG
798da326fdSHidetoshi Shimokawa 
803c60ba66SKatsushi Kobayashi static char dbcode[16][0x10]={"OUTM", "OUTL","INPM","INPL",
813c60ba66SKatsushi Kobayashi 		"STOR","LOAD","NOP ","STOP",};
823c60ba66SKatsushi Kobayashi static char dbkey[8][0x10]={"ST0", "ST1","ST2","ST3",
833c60ba66SKatsushi Kobayashi 		"UNDEF","REG","SYS","DEV"};
843c60ba66SKatsushi Kobayashi char fwohcicode[32][0x20]={
853c60ba66SKatsushi Kobayashi 	"No stat","Undef","long","miss Ack err",
863c60ba66SKatsushi Kobayashi 	"underrun","overrun","desc err", "data read err",
873c60ba66SKatsushi Kobayashi 	"data write err","bus reset","timeout","tcode err",
883c60ba66SKatsushi Kobayashi 	"Undef","Undef","unknown event","flushed",
893c60ba66SKatsushi Kobayashi 	"Undef","ack complete","ack pend","Undef",
903c60ba66SKatsushi Kobayashi 	"ack busy_X","ack busy_A","ack busy_B","Undef",
913c60ba66SKatsushi Kobayashi 	"Undef","Undef","Undef","ack tardy",
923c60ba66SKatsushi Kobayashi 	"Undef","ack data_err","ack type_err",""};
933c60ba66SKatsushi Kobayashi #define MAX_SPEED 2
943c60ba66SKatsushi Kobayashi extern char linkspeed[MAX_SPEED+1][0x10];
953c60ba66SKatsushi Kobayashi extern int maxrec[MAX_SPEED+1];
963c60ba66SKatsushi Kobayashi static char dbcond[4][0x10]={"NEV","C=1", "C=0", "ALL"};
973c60ba66SKatsushi Kobayashi u_int32_t tagbit[4] = { 1 << 28, 1 << 29, 1 << 30, 1 << 31};
983c60ba66SKatsushi Kobayashi 
993c60ba66SKatsushi Kobayashi static struct tcode_info tinfo[] = {
1003c60ba66SKatsushi Kobayashi /*		hdr_len block 	flag*/
1013c60ba66SKatsushi Kobayashi /* 0 WREQQ  */ {16,	FWTI_REQ | FWTI_TLABEL},
1023c60ba66SKatsushi Kobayashi /* 1 WREQB  */ {16,	FWTI_REQ | FWTI_TLABEL | FWTI_BLOCK_ASY},
1033c60ba66SKatsushi Kobayashi /* 2 WRES   */ {12,	FWTI_RES},
1043c60ba66SKatsushi Kobayashi /* 3 XXX    */ { 0,	0},
1053c60ba66SKatsushi Kobayashi /* 4 RREQQ  */ {12,	FWTI_REQ | FWTI_TLABEL},
1063c60ba66SKatsushi Kobayashi /* 5 RREQB  */ {16,	FWTI_REQ | FWTI_TLABEL},
1073c60ba66SKatsushi Kobayashi /* 6 RRESQ  */ {16,	FWTI_RES},
1083c60ba66SKatsushi Kobayashi /* 7 RRESB  */ {16,	FWTI_RES | FWTI_BLOCK_ASY},
1093c60ba66SKatsushi Kobayashi /* 8 CYCS   */ { 0,	0},
1103c60ba66SKatsushi Kobayashi /* 9 LREQ   */ {16,	FWTI_REQ | FWTI_TLABEL | FWTI_BLOCK_ASY},
1113c60ba66SKatsushi Kobayashi /* a STREAM */ { 4,	FWTI_REQ | FWTI_BLOCK_STR},
1123c60ba66SKatsushi Kobayashi /* b LRES   */ {16,	FWTI_RES | FWTI_BLOCK_ASY},
1133c60ba66SKatsushi Kobayashi /* c XXX    */ { 0,	0},
1143c60ba66SKatsushi Kobayashi /* d XXX    */ { 0, 	0},
1153c60ba66SKatsushi Kobayashi /* e PHY    */ {12,	FWTI_REQ},
1163c60ba66SKatsushi Kobayashi /* f XXX    */ { 0,	0}
1173c60ba66SKatsushi Kobayashi };
1183c60ba66SKatsushi Kobayashi 
1193c60ba66SKatsushi Kobayashi #define OHCI_WRITE_SIGMASK 0xffff0000
1203c60ba66SKatsushi Kobayashi #define OHCI_READ_SIGMASK 0xffff0000
1213c60ba66SKatsushi Kobayashi 
1223c60ba66SKatsushi Kobayashi #define OWRITE(sc, r, x) bus_space_write_4((sc)->bst, (sc)->bsh, (r), (x))
1233c60ba66SKatsushi Kobayashi #define OREAD(sc, r) bus_space_read_4((sc)->bst, (sc)->bsh, (r))
1243c60ba66SKatsushi Kobayashi 
1253c60ba66SKatsushi Kobayashi static void fwohci_ibr __P((struct firewire_comm *));
1263c60ba66SKatsushi Kobayashi static void fwohci_db_init __P((struct fwohci_dbch *));
1273c60ba66SKatsushi Kobayashi static void fwohci_db_free __P((struct fwohci_dbch *));
128783058faSHidetoshi Shimokawa static void fwohci_arcv __P((struct fwohci_softc *, struct fwohci_dbch *, int));
129783058faSHidetoshi Shimokawa static void fwohci_ircv __P((struct fwohci_softc *, struct fwohci_dbch *, int));
1303c60ba66SKatsushi Kobayashi static void fwohci_txd __P((struct fwohci_softc *, struct fwohci_dbch *));
1313c60ba66SKatsushi Kobayashi static void fwohci_start_atq __P((struct firewire_comm *));
1323c60ba66SKatsushi Kobayashi static void fwohci_start_ats __P((struct firewire_comm *));
1333c60ba66SKatsushi Kobayashi static void fwohci_start __P((struct fwohci_softc *, struct fwohci_dbch *));
1343c60ba66SKatsushi Kobayashi static void fwohci_drain_atq __P((struct firewire_comm *, struct fw_xfer *));
1353c60ba66SKatsushi Kobayashi static void fwohci_drain_ats __P((struct firewire_comm *, struct fw_xfer *));
1363c60ba66SKatsushi Kobayashi static void fwohci_drain __P((struct firewire_comm *, struct fw_xfer *, struct fwohci_dbch *));
1373c60ba66SKatsushi Kobayashi static u_int32_t fwphy_wrdata __P(( struct fwohci_softc *, u_int32_t, u_int32_t));
1383c60ba66SKatsushi Kobayashi static u_int32_t fwphy_rddata __P(( struct fwohci_softc *, u_int32_t));
1393c60ba66SKatsushi Kobayashi static int fwohci_rx_enable __P((struct fwohci_softc *, struct fwohci_dbch *));
1403c60ba66SKatsushi Kobayashi static int fwohci_tx_enable __P((struct fwohci_softc *, struct fwohci_dbch *));
1413c60ba66SKatsushi Kobayashi static int fwohci_irx_enable __P((struct firewire_comm *, int));
1423c60ba66SKatsushi Kobayashi static int fwohci_irxpp_enable __P((struct firewire_comm *, int));
1433c60ba66SKatsushi Kobayashi static int fwohci_irxbuf_enable __P((struct firewire_comm *, int));
1443c60ba66SKatsushi Kobayashi static int fwohci_irx_disable __P((struct firewire_comm *, int));
1453c60ba66SKatsushi Kobayashi static void fwohci_irx_post __P((struct firewire_comm *, u_int32_t *));
1463c60ba66SKatsushi Kobayashi static int fwohci_itxbuf_enable __P((struct firewire_comm *, int));
1473c60ba66SKatsushi Kobayashi static int fwohci_itx_disable __P((struct firewire_comm *, int));
1483c60ba66SKatsushi Kobayashi static void fwohci_timeout __P((void *));
1493c60ba66SKatsushi Kobayashi static void fwohci_poll __P((struct firewire_comm *, int, int));
1503c60ba66SKatsushi Kobayashi static void fwohci_set_intr __P((struct firewire_comm *, int));
1513c60ba66SKatsushi Kobayashi static int fwohci_add_rx_buf __P((struct fwohcidb_tr *, unsigned short, int, void *, void *));
1523c60ba66SKatsushi Kobayashi static int fwohci_add_tx_buf __P((struct fwohcidb_tr *, unsigned short, int, void *));
1533c60ba66SKatsushi Kobayashi static void	dump_db __P((struct fwohci_softc *, u_int32_t));
1543c60ba66SKatsushi Kobayashi static void 	print_db __P((volatile struct fwohcidb *, u_int32_t , u_int32_t));
1553c60ba66SKatsushi Kobayashi static void	dump_dma __P((struct fwohci_softc *, u_int32_t));
1563c60ba66SKatsushi Kobayashi static u_int32_t fwohci_cyctimer __P((struct firewire_comm *));
1573c60ba66SKatsushi Kobayashi static void fwohci_rbuf_update __P((struct fwohci_softc *, int));
1583c60ba66SKatsushi Kobayashi static void fwohci_tbuf_update __P((struct fwohci_softc *, int));
1593c60ba66SKatsushi Kobayashi void fwohci_txbufdb __P((struct fwohci_softc *, int , struct fw_bulkxfer *));
1603c60ba66SKatsushi Kobayashi 
1613c60ba66SKatsushi Kobayashi /*
1623c60ba66SKatsushi Kobayashi  * memory allocated for DMA programs
1633c60ba66SKatsushi Kobayashi  */
1643c60ba66SKatsushi Kobayashi #define DMA_PROG_ALLOC		(8 * PAGE_SIZE)
1653c60ba66SKatsushi Kobayashi 
1663c60ba66SKatsushi Kobayashi /* #define NDB 1024 */
1673c60ba66SKatsushi Kobayashi #define NDB FWMAXQUEUE
1683c60ba66SKatsushi Kobayashi #define NDVDB (DVBUF * NDB)
1693c60ba66SKatsushi Kobayashi 
1703c60ba66SKatsushi Kobayashi #define	OHCI_VERSION		0x00
1713c60ba66SKatsushi Kobayashi #define	OHCI_CROMHDR		0x18
1723c60ba66SKatsushi Kobayashi #define	OHCI_BUS_OPT		0x20
1733c60ba66SKatsushi Kobayashi #define	OHCI_BUSIRMC		(1 << 31)
1743c60ba66SKatsushi Kobayashi #define	OHCI_BUSCMC		(1 << 30)
1753c60ba66SKatsushi Kobayashi #define	OHCI_BUSISC		(1 << 29)
1763c60ba66SKatsushi Kobayashi #define	OHCI_BUSBMC		(1 << 28)
1773c60ba66SKatsushi Kobayashi #define	OHCI_BUSPMC		(1 << 27)
1783c60ba66SKatsushi Kobayashi #define OHCI_BUSFNC		OHCI_BUSIRMC | OHCI_BUSCMC | OHCI_BUSISC |\
1793c60ba66SKatsushi Kobayashi 				OHCI_BUSBMC | OHCI_BUSPMC
1803c60ba66SKatsushi Kobayashi 
1813c60ba66SKatsushi Kobayashi #define	OHCI_EUID_HI		0x24
1823c60ba66SKatsushi Kobayashi #define	OHCI_EUID_LO		0x28
1833c60ba66SKatsushi Kobayashi 
1843c60ba66SKatsushi Kobayashi #define	OHCI_CROMPTR		0x34
1853c60ba66SKatsushi Kobayashi #define	OHCI_HCCCTL		0x50
1863c60ba66SKatsushi Kobayashi #define	OHCI_HCCCTLCLR		0x54
1873c60ba66SKatsushi Kobayashi #define	OHCI_AREQHI		0x100
1883c60ba66SKatsushi Kobayashi #define	OHCI_AREQHICLR		0x104
1893c60ba66SKatsushi Kobayashi #define	OHCI_AREQLO		0x108
1903c60ba66SKatsushi Kobayashi #define	OHCI_AREQLOCLR		0x10c
1913c60ba66SKatsushi Kobayashi #define	OHCI_PREQHI		0x110
1923c60ba66SKatsushi Kobayashi #define	OHCI_PREQHICLR		0x114
1933c60ba66SKatsushi Kobayashi #define	OHCI_PREQLO		0x118
1943c60ba66SKatsushi Kobayashi #define	OHCI_PREQLOCLR		0x11c
1953c60ba66SKatsushi Kobayashi #define	OHCI_PREQUPPER		0x120
1963c60ba66SKatsushi Kobayashi 
1973c60ba66SKatsushi Kobayashi #define	OHCI_SID_BUF		0x64
1983c60ba66SKatsushi Kobayashi #define	OHCI_SID_CNT		0x68
1993c60ba66SKatsushi Kobayashi #define OHCI_SID_CNT_MASK	0xffc
2003c60ba66SKatsushi Kobayashi 
2013c60ba66SKatsushi Kobayashi #define	OHCI_IT_STAT		0x90
2023c60ba66SKatsushi Kobayashi #define	OHCI_IT_STATCLR		0x94
2033c60ba66SKatsushi Kobayashi #define	OHCI_IT_MASK		0x98
2043c60ba66SKatsushi Kobayashi #define	OHCI_IT_MASKCLR		0x9c
2053c60ba66SKatsushi Kobayashi 
2063c60ba66SKatsushi Kobayashi #define	OHCI_IR_STAT		0xa0
2073c60ba66SKatsushi Kobayashi #define	OHCI_IR_STATCLR		0xa4
2083c60ba66SKatsushi Kobayashi #define	OHCI_IR_MASK		0xa8
2093c60ba66SKatsushi Kobayashi #define	OHCI_IR_MASKCLR		0xac
2103c60ba66SKatsushi Kobayashi 
2113c60ba66SKatsushi Kobayashi #define	OHCI_LNKCTL		0xe0
2123c60ba66SKatsushi Kobayashi #define	OHCI_LNKCTLCLR		0xe4
2133c60ba66SKatsushi Kobayashi 
2143c60ba66SKatsushi Kobayashi #define	OHCI_PHYACCESS		0xec
2153c60ba66SKatsushi Kobayashi #define	OHCI_CYCLETIMER		0xf0
2163c60ba66SKatsushi Kobayashi 
2173c60ba66SKatsushi Kobayashi #define	OHCI_DMACTL(off)	(off)
2183c60ba66SKatsushi Kobayashi #define	OHCI_DMACTLCLR(off)	(off + 4)
2193c60ba66SKatsushi Kobayashi #define	OHCI_DMACMD(off)	(off + 0xc)
2203c60ba66SKatsushi Kobayashi #define	OHCI_DMAMATCH(off)	(off + 0x10)
2213c60ba66SKatsushi Kobayashi 
2223c60ba66SKatsushi Kobayashi #define OHCI_ATQOFF		0x180
2233c60ba66SKatsushi Kobayashi #define OHCI_ATQCTL		OHCI_ATQOFF
2243c60ba66SKatsushi Kobayashi #define OHCI_ATQCTLCLR		(OHCI_ATQOFF + 4)
2253c60ba66SKatsushi Kobayashi #define OHCI_ATQCMD		(OHCI_ATQOFF + 0xc)
2263c60ba66SKatsushi Kobayashi #define OHCI_ATQMATCH		(OHCI_ATQOFF + 0x10)
2273c60ba66SKatsushi Kobayashi 
2283c60ba66SKatsushi Kobayashi #define OHCI_ATSOFF		0x1a0
2293c60ba66SKatsushi Kobayashi #define OHCI_ATSCTL		OHCI_ATSOFF
2303c60ba66SKatsushi Kobayashi #define OHCI_ATSCTLCLR		(OHCI_ATSOFF + 4)
2313c60ba66SKatsushi Kobayashi #define OHCI_ATSCMD		(OHCI_ATSOFF + 0xc)
2323c60ba66SKatsushi Kobayashi #define OHCI_ATSMATCH		(OHCI_ATSOFF + 0x10)
2333c60ba66SKatsushi Kobayashi 
2343c60ba66SKatsushi Kobayashi #define OHCI_ARQOFF		0x1c0
2353c60ba66SKatsushi Kobayashi #define OHCI_ARQCTL		OHCI_ARQOFF
2363c60ba66SKatsushi Kobayashi #define OHCI_ARQCTLCLR		(OHCI_ARQOFF + 4)
2373c60ba66SKatsushi Kobayashi #define OHCI_ARQCMD		(OHCI_ARQOFF + 0xc)
2383c60ba66SKatsushi Kobayashi #define OHCI_ARQMATCH		(OHCI_ARQOFF + 0x10)
2393c60ba66SKatsushi Kobayashi 
2403c60ba66SKatsushi Kobayashi #define OHCI_ARSOFF		0x1e0
2413c60ba66SKatsushi Kobayashi #define OHCI_ARSCTL		OHCI_ARSOFF
2423c60ba66SKatsushi Kobayashi #define OHCI_ARSCTLCLR		(OHCI_ARSOFF + 4)
2433c60ba66SKatsushi Kobayashi #define OHCI_ARSCMD		(OHCI_ARSOFF + 0xc)
2443c60ba66SKatsushi Kobayashi #define OHCI_ARSMATCH		(OHCI_ARSOFF + 0x10)
2453c60ba66SKatsushi Kobayashi 
2463c60ba66SKatsushi Kobayashi #define OHCI_ITOFF(CH)		(0x200 + 0x10 * (CH))
2473c60ba66SKatsushi Kobayashi #define OHCI_ITCTL(CH)		(OHCI_ITOFF(CH))
2483c60ba66SKatsushi Kobayashi #define OHCI_ITCTLCLR(CH)	(OHCI_ITOFF(CH) + 4)
2493c60ba66SKatsushi Kobayashi #define OHCI_ITCMD(CH)		(OHCI_ITOFF(CH) + 0xc)
2503c60ba66SKatsushi Kobayashi 
2513c60ba66SKatsushi Kobayashi #define OHCI_IROFF(CH)		(0x400 + 0x20 * (CH))
2523c60ba66SKatsushi Kobayashi #define OHCI_IRCTL(CH)		(OHCI_IROFF(CH))
2533c60ba66SKatsushi Kobayashi #define OHCI_IRCTLCLR(CH)	(OHCI_IROFF(CH) + 4)
2543c60ba66SKatsushi Kobayashi #define OHCI_IRCMD(CH)		(OHCI_IROFF(CH) + 0xc)
2553c60ba66SKatsushi Kobayashi #define OHCI_IRMATCH(CH)	(OHCI_IROFF(CH) + 0x10)
2563c60ba66SKatsushi Kobayashi 
2573c60ba66SKatsushi Kobayashi d_ioctl_t fwohci_ioctl;
2583c60ba66SKatsushi Kobayashi 
2593c60ba66SKatsushi Kobayashi /*
2603c60ba66SKatsushi Kobayashi  * Communication with PHY device
2613c60ba66SKatsushi Kobayashi  */
262c572b810SHidetoshi Shimokawa static u_int32_t
263c572b810SHidetoshi Shimokawa fwphy_wrdata( struct fwohci_softc *sc, u_int32_t addr, u_int32_t data)
2643c60ba66SKatsushi Kobayashi {
2653c60ba66SKatsushi Kobayashi 	u_int32_t fun;
2663c60ba66SKatsushi Kobayashi 
2673c60ba66SKatsushi Kobayashi 	addr &= 0xf;
2683c60ba66SKatsushi Kobayashi 	data &= 0xff;
2693c60ba66SKatsushi Kobayashi 
2703c60ba66SKatsushi Kobayashi 	fun = (PHYDEV_WRCMD | (addr << PHYDEV_REGADDR) | (data << PHYDEV_WRDATA));
2713c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_PHYACCESS, fun);
2723c60ba66SKatsushi Kobayashi 	DELAY(100);
2733c60ba66SKatsushi Kobayashi 
2743c60ba66SKatsushi Kobayashi 	return(fwphy_rddata( sc, addr));
2753c60ba66SKatsushi Kobayashi }
2763c60ba66SKatsushi Kobayashi 
2773c60ba66SKatsushi Kobayashi static u_int32_t
2783c60ba66SKatsushi Kobayashi fwohci_set_bus_manager(struct firewire_comm *fc, u_int node)
2793c60ba66SKatsushi Kobayashi {
2803c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
2813c60ba66SKatsushi Kobayashi 	int i;
2823c60ba66SKatsushi Kobayashi 	u_int32_t bm;
2833c60ba66SKatsushi Kobayashi 
2843c60ba66SKatsushi Kobayashi #define OHCI_CSR_DATA	0x0c
2853c60ba66SKatsushi Kobayashi #define OHCI_CSR_COMP	0x10
2863c60ba66SKatsushi Kobayashi #define OHCI_CSR_CONT	0x14
2873c60ba66SKatsushi Kobayashi #define OHCI_BUS_MANAGER_ID	0
2883c60ba66SKatsushi Kobayashi 
2893c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_CSR_DATA, node);
2903c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_CSR_COMP, 0x3f);
2913c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_CSR_CONT, OHCI_BUS_MANAGER_ID);
2923c60ba66SKatsushi Kobayashi  	for (i = 0; !(OREAD(sc, OHCI_CSR_CONT) & (1<<31)) && (i < 1000); i++)
2933c60ba66SKatsushi Kobayashi 		DELAY(100);
2943c60ba66SKatsushi Kobayashi 	bm = OREAD(sc, OHCI_CSR_DATA);
29517c3d42cSHidetoshi Shimokawa 	if((bm & 0x3f) == 0x3f)
2963c60ba66SKatsushi Kobayashi 		bm = node;
29717c3d42cSHidetoshi Shimokawa 	if (bootverbose)
29817c3d42cSHidetoshi Shimokawa 		device_printf(sc->fc.dev,
29917c3d42cSHidetoshi Shimokawa 			"fw_set_bus_manager: %d->%d (loop=%d)\n", bm, node, i);
3003c60ba66SKatsushi Kobayashi 
3013c60ba66SKatsushi Kobayashi 	return(bm);
3023c60ba66SKatsushi Kobayashi }
3033c60ba66SKatsushi Kobayashi 
304c572b810SHidetoshi Shimokawa static u_int32_t
305c572b810SHidetoshi Shimokawa fwphy_rddata(struct fwohci_softc *sc,  u_int addr)
3063c60ba66SKatsushi Kobayashi {
307e4b13179SHidetoshi Shimokawa 	u_int32_t fun, stat;
308e4b13179SHidetoshi Shimokawa 	u_int i, retry = 0;
3093c60ba66SKatsushi Kobayashi 
3103c60ba66SKatsushi Kobayashi 	addr &= 0xf;
311e4b13179SHidetoshi Shimokawa #define MAX_RETRY 100
312e4b13179SHidetoshi Shimokawa again:
313e4b13179SHidetoshi Shimokawa 	OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_REG_FAIL);
3143c60ba66SKatsushi Kobayashi 	fun = PHYDEV_RDCMD | (addr << PHYDEV_REGADDR);
3153c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_PHYACCESS, fun);
316e4b13179SHidetoshi Shimokawa 	for ( i = 0 ; i < MAX_RETRY ; i ++ ){
3173c60ba66SKatsushi Kobayashi 		fun = OREAD(sc, OHCI_PHYACCESS);
3183c60ba66SKatsushi Kobayashi 		if ((fun & PHYDEV_RDCMD) == 0 && (fun & PHYDEV_RDDONE) != 0)
3193c60ba66SKatsushi Kobayashi 			break;
3203c60ba66SKatsushi Kobayashi 		DELAY(1000);
3213c60ba66SKatsushi Kobayashi 	}
322e4b13179SHidetoshi Shimokawa 	if(i >= MAX_RETRY) {
3233c60ba66SKatsushi Kobayashi 		device_printf(sc->fc.dev, "cannot read phy\n");
3241f2361f8SHidetoshi Shimokawa #if 0
325e4b13179SHidetoshi Shimokawa 		return 0; /* XXX */
3261f2361f8SHidetoshi Shimokawa #else
3271f2361f8SHidetoshi Shimokawa 		if (++retry < MAX_RETRY) {
3281f2361f8SHidetoshi Shimokawa 			DELAY(1000);
3291f2361f8SHidetoshi Shimokawa 			goto again;
3301f2361f8SHidetoshi Shimokawa 		}
3311f2361f8SHidetoshi Shimokawa #endif
332e4b13179SHidetoshi Shimokawa 	}
333e4b13179SHidetoshi Shimokawa 	/* Make sure that SCLK is started */
334e4b13179SHidetoshi Shimokawa 	stat = OREAD(sc, FWOHCI_INTSTAT);
335e4b13179SHidetoshi Shimokawa 	if ((stat & OHCI_INT_REG_FAIL) != 0 ||
336e4b13179SHidetoshi Shimokawa 			((fun >> PHYDEV_REGADDR) & 0xf) != addr) {
337e4b13179SHidetoshi Shimokawa 		if (++retry < MAX_RETRY) {
338e4b13179SHidetoshi Shimokawa 			DELAY(1000);
339e4b13179SHidetoshi Shimokawa 			goto again;
340e4b13179SHidetoshi Shimokawa 		}
341e4b13179SHidetoshi Shimokawa 	}
342e4b13179SHidetoshi Shimokawa 	if (bootverbose || retry >= MAX_RETRY)
343e4b13179SHidetoshi Shimokawa 		device_printf(sc->fc.dev,
344e4b13179SHidetoshi Shimokawa 			"fwphy_rddata: loop=%d, retry=%d\n", i, retry);
345e4b13179SHidetoshi Shimokawa #undef MAX_RETRY
3463c60ba66SKatsushi Kobayashi 	return((fun >> PHYDEV_RDDATA )& 0xff);
3473c60ba66SKatsushi Kobayashi }
3483c60ba66SKatsushi Kobayashi /* Device specific ioctl. */
3493c60ba66SKatsushi Kobayashi int
3503c60ba66SKatsushi Kobayashi fwohci_ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, fw_proc *td)
3513c60ba66SKatsushi Kobayashi {
3523c60ba66SKatsushi Kobayashi 	struct firewire_softc *sc;
3533c60ba66SKatsushi Kobayashi 	struct fwohci_softc *fc;
3543c60ba66SKatsushi Kobayashi 	int unit = DEV2UNIT(dev);
3553c60ba66SKatsushi Kobayashi 	int err = 0;
3563c60ba66SKatsushi Kobayashi 	struct fw_reg_req_t *reg  = (struct fw_reg_req_t *) data;
3573c60ba66SKatsushi Kobayashi 	u_int32_t *dmach = (u_int32_t *) data;
3583c60ba66SKatsushi Kobayashi 
3593c60ba66SKatsushi Kobayashi 	sc = devclass_get_softc(firewire_devclass, unit);
3603c60ba66SKatsushi Kobayashi 	if(sc == NULL){
3613c60ba66SKatsushi Kobayashi 		return(EINVAL);
3623c60ba66SKatsushi Kobayashi 	}
3633c60ba66SKatsushi Kobayashi 	fc = (struct fwohci_softc *)sc->fc;
3643c60ba66SKatsushi Kobayashi 
3653c60ba66SKatsushi Kobayashi 	if (!data)
3663c60ba66SKatsushi Kobayashi 		return(EINVAL);
3673c60ba66SKatsushi Kobayashi 
3683c60ba66SKatsushi Kobayashi 	switch (cmd) {
3693c60ba66SKatsushi Kobayashi 	case FWOHCI_WRREG:
3703c60ba66SKatsushi Kobayashi #define OHCI_MAX_REG 0x800
3713c60ba66SKatsushi Kobayashi 		if(reg->addr <= OHCI_MAX_REG){
3723c60ba66SKatsushi Kobayashi 			OWRITE(fc, reg->addr, reg->data);
3733c60ba66SKatsushi Kobayashi 			reg->data = OREAD(fc, reg->addr);
3743c60ba66SKatsushi Kobayashi 		}else{
3753c60ba66SKatsushi Kobayashi 			err = EINVAL;
3763c60ba66SKatsushi Kobayashi 		}
3773c60ba66SKatsushi Kobayashi 		break;
3783c60ba66SKatsushi Kobayashi 	case FWOHCI_RDREG:
3793c60ba66SKatsushi Kobayashi 		if(reg->addr <= OHCI_MAX_REG){
3803c60ba66SKatsushi Kobayashi 			reg->data = OREAD(fc, reg->addr);
3813c60ba66SKatsushi Kobayashi 		}else{
3823c60ba66SKatsushi Kobayashi 			err = EINVAL;
3833c60ba66SKatsushi Kobayashi 		}
3843c60ba66SKatsushi Kobayashi 		break;
3853c60ba66SKatsushi Kobayashi /* Read DMA descriptors for debug  */
3863c60ba66SKatsushi Kobayashi 	case DUMPDMA:
3873c60ba66SKatsushi Kobayashi 		if(*dmach <= OHCI_MAX_DMA_CH ){
3883c60ba66SKatsushi Kobayashi 			dump_dma(fc, *dmach);
3893c60ba66SKatsushi Kobayashi 			dump_db(fc, *dmach);
3903c60ba66SKatsushi Kobayashi 		}else{
3913c60ba66SKatsushi Kobayashi 			err = EINVAL;
3923c60ba66SKatsushi Kobayashi 		}
3933c60ba66SKatsushi Kobayashi 		break;
3943c60ba66SKatsushi Kobayashi 	default:
3953c60ba66SKatsushi Kobayashi 		break;
3963c60ba66SKatsushi Kobayashi 	}
3973c60ba66SKatsushi Kobayashi 	return err;
3983c60ba66SKatsushi Kobayashi }
399c572b810SHidetoshi Shimokawa 
400c572b810SHidetoshi Shimokawa int
401c572b810SHidetoshi Shimokawa fwohci_init(struct fwohci_softc *sc, device_t dev)
4023c60ba66SKatsushi Kobayashi {
4033c60ba66SKatsushi Kobayashi 	int err = 0;
4043c60ba66SKatsushi Kobayashi 	int i;
4053c60ba66SKatsushi Kobayashi 	u_int32_t reg, reg2;
4063c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
4073c60ba66SKatsushi Kobayashi 	int e1394a = 1;
4083c60ba66SKatsushi Kobayashi 
4093c60ba66SKatsushi Kobayashi 	reg = OREAD(sc, OHCI_VERSION);
4103c60ba66SKatsushi Kobayashi 	device_printf(dev, "OHCI version %x.%x (ROM=%d)\n",
4113c60ba66SKatsushi Kobayashi 			(reg>>16) & 0xff, reg & 0xff, (reg>>24) & 1);
4123c60ba66SKatsushi Kobayashi 
4133c60ba66SKatsushi Kobayashi /* XXX: Available Isochrounous DMA channel probe */
4143c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < 0x20 ; i ++ ){
4153c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_IRCTL(i), OHCI_CNTL_DMA_RUN);
4163c60ba66SKatsushi Kobayashi 		reg = OREAD(sc, OHCI_IRCTL(i));
4173c60ba66SKatsushi Kobayashi 		if(!(reg & OHCI_CNTL_DMA_RUN)) break;
4183c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_ITCTL(i), OHCI_CNTL_DMA_RUN);
4193c60ba66SKatsushi Kobayashi 		reg = OREAD(sc, OHCI_ITCTL(i));
4203c60ba66SKatsushi Kobayashi 		if(!(reg & OHCI_CNTL_DMA_RUN)) break;
4213c60ba66SKatsushi Kobayashi 	}
4223c60ba66SKatsushi Kobayashi 	sc->fc.nisodma = i;
4233c60ba66SKatsushi Kobayashi 	device_printf(dev, "No. of Isochronous channel is %d.\n", i);
4243c60ba66SKatsushi Kobayashi 
4253c60ba66SKatsushi Kobayashi 	sc->fc.arq = &sc->arrq.xferq;
4263c60ba66SKatsushi Kobayashi 	sc->fc.ars = &sc->arrs.xferq;
4273c60ba66SKatsushi Kobayashi 	sc->fc.atq = &sc->atrq.xferq;
4283c60ba66SKatsushi Kobayashi 	sc->fc.ats = &sc->atrs.xferq;
4293c60ba66SKatsushi Kobayashi 
4303c60ba66SKatsushi Kobayashi 	sc->arrq.xferq.start = NULL;
4313c60ba66SKatsushi Kobayashi 	sc->arrs.xferq.start = NULL;
4323c60ba66SKatsushi Kobayashi 	sc->atrq.xferq.start = fwohci_start_atq;
4333c60ba66SKatsushi Kobayashi 	sc->atrs.xferq.start = fwohci_start_ats;
4343c60ba66SKatsushi Kobayashi 
4353c60ba66SKatsushi Kobayashi 	sc->arrq.xferq.drain = NULL;
4363c60ba66SKatsushi Kobayashi 	sc->arrs.xferq.drain = NULL;
4373c60ba66SKatsushi Kobayashi 	sc->atrq.xferq.drain = fwohci_drain_atq;
4383c60ba66SKatsushi Kobayashi 	sc->atrs.xferq.drain = fwohci_drain_ats;
4393c60ba66SKatsushi Kobayashi 
4403c60ba66SKatsushi Kobayashi 	sc->arrq.ndesc = 1;
4413c60ba66SKatsushi Kobayashi 	sc->arrs.ndesc = 1;
4423c60ba66SKatsushi Kobayashi 	sc->atrq.ndesc = 10;
4433c60ba66SKatsushi Kobayashi 	sc->atrs.ndesc = 10 / 2;
4443c60ba66SKatsushi Kobayashi 
4453c60ba66SKatsushi Kobayashi 	sc->arrq.ndb = NDB;
4463c60ba66SKatsushi Kobayashi 	sc->arrs.ndb = NDB / 2;
4473c60ba66SKatsushi Kobayashi 	sc->atrq.ndb = NDB;
4483c60ba66SKatsushi Kobayashi 	sc->atrs.ndb = NDB / 2;
4493c60ba66SKatsushi Kobayashi 
4503c60ba66SKatsushi Kobayashi 	sc->arrq.dummy = NULL;
4513c60ba66SKatsushi Kobayashi 	sc->arrs.dummy = NULL;
4523c60ba66SKatsushi Kobayashi 	sc->atrq.dummy = NULL;
4533c60ba66SKatsushi Kobayashi 	sc->atrs.dummy = NULL;
4543c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < sc->fc.nisodma ; i ++ ){
4553c60ba66SKatsushi Kobayashi 		sc->fc.it[i] = &sc->it[i].xferq;
4563c60ba66SKatsushi Kobayashi 		sc->fc.ir[i] = &sc->ir[i].xferq;
4573c60ba66SKatsushi Kobayashi 		sc->it[i].ndb = 0;
4583c60ba66SKatsushi Kobayashi 		sc->ir[i].ndb = 0;
4593c60ba66SKatsushi Kobayashi 	}
4603c60ba66SKatsushi Kobayashi 
4613c60ba66SKatsushi Kobayashi 	sc->fc.tcode = tinfo;
4623c60ba66SKatsushi Kobayashi 
4633c60ba66SKatsushi Kobayashi 	sc->cromptr = (u_int32_t *)
4643c60ba66SKatsushi Kobayashi 		contigmalloc(CROMSIZE * 2, M_DEVBUF, M_NOWAIT, 0, ~0, 1<<10, 0);
4653c60ba66SKatsushi Kobayashi 
4663c60ba66SKatsushi Kobayashi 	if(sc->cromptr == NULL){
4671f2361f8SHidetoshi Shimokawa 		device_printf(dev, "cromptr alloc failed.");
4683c60ba66SKatsushi Kobayashi 		return ENOMEM;
4693c60ba66SKatsushi Kobayashi 	}
4703c60ba66SKatsushi Kobayashi 	sc->fc.dev = dev;
4713c60ba66SKatsushi Kobayashi 	sc->fc.config_rom = &(sc->cromptr[CROMSIZE/4]);
4723c60ba66SKatsushi Kobayashi 
4733c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[1] = 0x31333934;
4743c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[2] = 0xf000a002;
4753c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[3] = OREAD(sc, OHCI_EUID_HI);
4763c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[4] = OREAD(sc, OHCI_EUID_LO);
4773c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[5] = 0;
4783c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[0] = (4 << 24) | (5 << 16);
4793c60ba66SKatsushi Kobayashi 
4803c60ba66SKatsushi Kobayashi 	sc->fc.config_rom[0] |= fw_crc16(&sc->fc.config_rom[1], 5*4);
4813c60ba66SKatsushi Kobayashi 
4823c60ba66SKatsushi Kobayashi 
4833c60ba66SKatsushi Kobayashi 	fw_init(&sc->fc);
4843c60ba66SKatsushi Kobayashi 
485ac9f6692SHidetoshi Shimokawa /* Disable interrupt */
486ac9f6692SHidetoshi Shimokawa 	OWRITE(sc, FWOHCI_INTMASKCLR, ~0);
487ac9f6692SHidetoshi Shimokawa 
4883c60ba66SKatsushi Kobayashi /* Now stopping all DMA channel */
4893c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ARQCTLCLR, OHCI_CNTL_DMA_RUN);
4903c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ARSCTLCLR, OHCI_CNTL_DMA_RUN);
4913c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ATQCTLCLR, OHCI_CNTL_DMA_RUN);
4923c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ATSCTLCLR, OHCI_CNTL_DMA_RUN);
4933c60ba66SKatsushi Kobayashi 
4943c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_IR_MASKCLR, ~0);
4953c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < sc->fc.nisodma ; i ++ ){
4963c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_IRCTLCLR(i), OHCI_CNTL_DMA_RUN);
4973c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_ITCTLCLR(i), OHCI_CNTL_DMA_RUN);
4983c60ba66SKatsushi Kobayashi 	}
4993c60ba66SKatsushi Kobayashi 
5003c60ba66SKatsushi Kobayashi /* FLUSH FIFO and reset Transmitter/Reciever */
5013c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_HCCCTL, OHCI_HCC_RESET);
50217c3d42cSHidetoshi Shimokawa 	if (bootverbose)
5033c60ba66SKatsushi Kobayashi 		device_printf(dev, "resetting OHCI...");
5043c60ba66SKatsushi Kobayashi 	i = 0;
5053c60ba66SKatsushi Kobayashi 	while(OREAD(sc, OHCI_HCCCTL) & OHCI_HCC_RESET) {
5063c60ba66SKatsushi Kobayashi 		if (i++ > 100) break;
5073c60ba66SKatsushi Kobayashi 		DELAY(1000);
5083c60ba66SKatsushi Kobayashi 	}
50917c3d42cSHidetoshi Shimokawa 	if (bootverbose)
510ac9f6692SHidetoshi Shimokawa 		printf("done (loop=%d)\n", i);
5113c60ba66SKatsushi Kobayashi 
5123c60ba66SKatsushi Kobayashi 	reg = OREAD(sc,  OHCI_BUS_OPT);
5133c60ba66SKatsushi Kobayashi 	reg2 = reg | OHCI_BUSFNC;
5143c60ba66SKatsushi Kobayashi 	/* XXX  */
5153c60ba66SKatsushi Kobayashi 	if (((reg & 0x0000f000) >> 12) < 10)
5163c60ba66SKatsushi Kobayashi 		reg2 = (reg2 & 0xffff0fff) | (10 << 12);
51717c3d42cSHidetoshi Shimokawa 	if (bootverbose)
5183c60ba66SKatsushi Kobayashi 		device_printf(dev, "BUS_OPT 0x%x -> 0x%x\n", reg, reg2);
5193c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_BUS_OPT, reg2);
5203c60ba66SKatsushi Kobayashi 
5213c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_CROMHDR, sc->fc.config_rom[0]);
5223c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_CROMPTR, vtophys(&sc->fc.config_rom[0]));
5233c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_HCCCTLCLR, OHCI_HCC_BIGEND);
5243c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_HCCCTL, OHCI_HCC_POSTWR);
5253c60ba66SKatsushi Kobayashi 
5263c60ba66SKatsushi Kobayashi /*
5273c60ba66SKatsushi Kobayashi  * probe PHY parameters
5283c60ba66SKatsushi Kobayashi  * 0. to prove PHY version, whether compliance of 1394a.
5293c60ba66SKatsushi Kobayashi  * 1. to probe maximum speed supported by the PHY and
5303c60ba66SKatsushi Kobayashi  *    number of port supported by core-logic.
5313c60ba66SKatsushi Kobayashi  *    It is not actually available port on your PC .
5323c60ba66SKatsushi Kobayashi  */
533ac9f6692SHidetoshi Shimokawa 	OWRITE(sc, OHCI_HCCCTL, OHCI_HCC_LPS);
5343c60ba66SKatsushi Kobayashi #if 0
535ac9f6692SHidetoshi Shimokawa 	/* XXX wait for SCLK. */
536ac9f6692SHidetoshi Shimokawa 	DELAY(100000);
5373c60ba66SKatsushi Kobayashi #endif
538ac9f6692SHidetoshi Shimokawa 	reg = fwphy_rddata(sc, FW_PHY_SPD_REG);
539ac9f6692SHidetoshi Shimokawa 
5403c60ba66SKatsushi Kobayashi 	if((reg >> 5) != 7 ){
5413c60ba66SKatsushi Kobayashi 		sc->fc.mode &= ~FWPHYASYST;
5423c60ba66SKatsushi Kobayashi 		sc->fc.nport = reg & FW_PHY_NP;
5433c60ba66SKatsushi Kobayashi 		sc->fc.speed = reg & FW_PHY_SPD >> 6;
5443c60ba66SKatsushi Kobayashi 		if (sc->fc.speed > MAX_SPEED) {
5453c60ba66SKatsushi Kobayashi 			device_printf(dev, "invalid speed %d (fixed to %d).\n",
5463c60ba66SKatsushi Kobayashi 				sc->fc.speed, MAX_SPEED);
5473c60ba66SKatsushi Kobayashi 			sc->fc.speed = MAX_SPEED;
5483c60ba66SKatsushi Kobayashi 		}
5493c60ba66SKatsushi Kobayashi 		sc->fc.maxrec = maxrec[sc->fc.speed];
5503c60ba66SKatsushi Kobayashi 		device_printf(dev,
5513c60ba66SKatsushi Kobayashi 			"Link 1394 only %s, %d ports, maxrec %d bytes.\n",
5523c60ba66SKatsushi Kobayashi 			linkspeed[sc->fc.speed], sc->fc.nport, sc->fc.maxrec);
5533c60ba66SKatsushi Kobayashi 	}else{
5543c60ba66SKatsushi Kobayashi 		reg2 = fwphy_rddata(sc, FW_PHY_ESPD_REG);
5553c60ba66SKatsushi Kobayashi 		sc->fc.mode |= FWPHYASYST;
5563c60ba66SKatsushi Kobayashi 		sc->fc.nport = reg & FW_PHY_NP;
5573c60ba66SKatsushi Kobayashi 		sc->fc.speed = (reg2 & FW_PHY_ESPD) >> 5;
5583c60ba66SKatsushi Kobayashi 		if (sc->fc.speed > MAX_SPEED) {
5593c60ba66SKatsushi Kobayashi 			device_printf(dev, "invalid speed %d (fixed to %d).\n",
5603c60ba66SKatsushi Kobayashi 				sc->fc.speed, MAX_SPEED);
5613c60ba66SKatsushi Kobayashi 			sc->fc.speed = MAX_SPEED;
5623c60ba66SKatsushi Kobayashi 		}
5633c60ba66SKatsushi Kobayashi 		sc->fc.maxrec = maxrec[sc->fc.speed];
5643c60ba66SKatsushi Kobayashi 		device_printf(dev,
5653c60ba66SKatsushi Kobayashi 			"Link 1394a available %s, %d ports, maxrec %d bytes.\n",
5663c60ba66SKatsushi Kobayashi 			linkspeed[sc->fc.speed], sc->fc.nport, sc->fc.maxrec);
5673c60ba66SKatsushi Kobayashi 
5683c60ba66SKatsushi Kobayashi 		/* check programPhyEnable */
5693c60ba66SKatsushi Kobayashi 		reg2 = fwphy_rddata(sc, 5);
5703c60ba66SKatsushi Kobayashi #if 0
5713c60ba66SKatsushi Kobayashi 		if (e1394a && (OREAD(sc, OHCI_HCCCTL) & OHCI_HCC_PRPHY)) {
572c572b810SHidetoshi Shimokawa #else	/* XXX force to enable 1394a */
5733c60ba66SKatsushi Kobayashi 		if (e1394a) {
5743c60ba66SKatsushi Kobayashi #endif
57517c3d42cSHidetoshi Shimokawa 			if (bootverbose)
57617c3d42cSHidetoshi Shimokawa 				device_printf(dev,
57717c3d42cSHidetoshi Shimokawa 					"Enable 1394a Enhancements\n");
5783c60ba66SKatsushi Kobayashi 			/* enable EAA EMC */
5793c60ba66SKatsushi Kobayashi 			reg2 |= 0x03;
5803c60ba66SKatsushi Kobayashi 			/* set aPhyEnhanceEnable */
5813c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_HCCCTL, OHCI_HCC_PHYEN);
5823c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_HCCCTLCLR, OHCI_HCC_PRPHY);
5833c60ba66SKatsushi Kobayashi 		} else {
5843c60ba66SKatsushi Kobayashi 			/* for safe */
5853c60ba66SKatsushi Kobayashi 			reg2 &= ~0x83;
5863c60ba66SKatsushi Kobayashi 		}
5873c60ba66SKatsushi Kobayashi 		reg2 = fwphy_wrdata(sc, 5, reg2);
5883c60ba66SKatsushi Kobayashi 	}
5893c60ba66SKatsushi Kobayashi 
5903c60ba66SKatsushi Kobayashi 	reg = fwphy_rddata(sc, FW_PHY_SPD_REG);
5913c60ba66SKatsushi Kobayashi 	if((reg >> 5) == 7 ){
5923c60ba66SKatsushi Kobayashi 		reg = fwphy_rddata(sc, 4);
5933c60ba66SKatsushi Kobayashi 		reg |= 1 << 6;
5943c60ba66SKatsushi Kobayashi 		fwphy_wrdata(sc, 4, reg);
5953c60ba66SKatsushi Kobayashi 		reg = fwphy_rddata(sc, 4);
5963c60ba66SKatsushi Kobayashi 	}
5973c60ba66SKatsushi Kobayashi 
5983c60ba66SKatsushi Kobayashi /* SID recieve buffer must allign 2^11 */
5993c60ba66SKatsushi Kobayashi #define	OHCI_SIDSIZE	(1 << 11)
6003c60ba66SKatsushi Kobayashi 	sc->fc.sid_buf = (u_int32_t *) vm_page_alloc_contig( OHCI_SIDSIZE,
6013c60ba66SKatsushi Kobayashi 					0x10000, 0xffffffff, OHCI_SIDSIZE);
6021f2361f8SHidetoshi Shimokawa 	if (sc->fc.sid_buf == NULL) {
6031f2361f8SHidetoshi Shimokawa 		device_printf(dev, "sid_buf alloc failed.\n");
6041f2361f8SHidetoshi Shimokawa 		return ENOMEM;
6051f2361f8SHidetoshi Shimokawa 	}
6061f2361f8SHidetoshi Shimokawa 
6073c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_SID_BUF, vtophys(sc->fc.sid_buf));
6083c60ba66SKatsushi Kobayashi 	sc->fc.sid_buf++;
6093c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_LNKCTL, OHCI_CNTL_SID);
6103c60ba66SKatsushi Kobayashi 
6113c60ba66SKatsushi Kobayashi 	fwohci_db_init(&sc->arrq);
6121f2361f8SHidetoshi Shimokawa 	if ((sc->arrq.flags & FWOHCI_DBCH_INIT) == 0)
6131f2361f8SHidetoshi Shimokawa 		return ENOMEM;
6141f2361f8SHidetoshi Shimokawa 
6153c60ba66SKatsushi Kobayashi 	fwohci_db_init(&sc->arrs);
6161f2361f8SHidetoshi Shimokawa 	if ((sc->arrs.flags & FWOHCI_DBCH_INIT) == 0)
6171f2361f8SHidetoshi Shimokawa 		return ENOMEM;
6183c60ba66SKatsushi Kobayashi 
6193c60ba66SKatsushi Kobayashi 	fwohci_db_init(&sc->atrq);
6201f2361f8SHidetoshi Shimokawa 	if ((sc->atrq.flags & FWOHCI_DBCH_INIT) == 0)
6211f2361f8SHidetoshi Shimokawa 		return ENOMEM;
6221f2361f8SHidetoshi Shimokawa 
6233c60ba66SKatsushi Kobayashi 	fwohci_db_init(&sc->atrs);
6241f2361f8SHidetoshi Shimokawa 	if ((sc->atrs.flags & FWOHCI_DBCH_INIT) == 0)
6251f2361f8SHidetoshi Shimokawa 		return ENOMEM;
6263c60ba66SKatsushi Kobayashi 
6273c60ba66SKatsushi Kobayashi 	reg = OREAD(sc, FWOHCIGUID_H);
6283c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < 4 ; i ++){
6293c60ba66SKatsushi Kobayashi 		sc->fc.eui[3 - i] = reg & 0xff;
6303c60ba66SKatsushi Kobayashi 		reg = reg >> 8;
6313c60ba66SKatsushi Kobayashi 	}
6323c60ba66SKatsushi Kobayashi 	reg = OREAD(sc, FWOHCIGUID_L);
6333c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < 4 ; i ++){
6343c60ba66SKatsushi Kobayashi 		sc->fc.eui[7 - i] = reg & 0xff;
6353c60ba66SKatsushi Kobayashi 		reg = reg >> 8;
6363c60ba66SKatsushi Kobayashi 	}
6373c60ba66SKatsushi Kobayashi 	device_printf(dev, "EUI64 %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
6383c60ba66SKatsushi Kobayashi 		sc->fc.eui[0], sc->fc.eui[1], sc->fc.eui[2], sc->fc.eui[3],
6393c60ba66SKatsushi Kobayashi 		sc->fc.eui[4], sc->fc.eui[5], sc->fc.eui[6], sc->fc.eui[7]);
6403c60ba66SKatsushi Kobayashi 	sc->fc.ioctl = fwohci_ioctl;
6413c60ba66SKatsushi Kobayashi 	sc->fc.cyctimer = fwohci_cyctimer;
6423c60ba66SKatsushi Kobayashi 	sc->fc.set_bmr = fwohci_set_bus_manager;
6433c60ba66SKatsushi Kobayashi 	sc->fc.ibr = fwohci_ibr;
6443c60ba66SKatsushi Kobayashi 	sc->fc.irx_enable = fwohci_irx_enable;
6453c60ba66SKatsushi Kobayashi 	sc->fc.irx_disable = fwohci_irx_disable;
6463c60ba66SKatsushi Kobayashi 
6473c60ba66SKatsushi Kobayashi 	sc->fc.itx_enable = fwohci_itxbuf_enable;
6483c60ba66SKatsushi Kobayashi 	sc->fc.itx_disable = fwohci_itx_disable;
6493c60ba66SKatsushi Kobayashi 	sc->fc.irx_post = fwohci_irx_post;
6503c60ba66SKatsushi Kobayashi 	sc->fc.itx_post = NULL;
6513c60ba66SKatsushi Kobayashi 	sc->fc.timeout = fwohci_timeout;
6523c60ba66SKatsushi Kobayashi 	sc->fc.poll = fwohci_poll;
6533c60ba66SKatsushi Kobayashi 	sc->fc.set_intr = fwohci_set_intr;
654c572b810SHidetoshi Shimokawa 
6553c60ba66SKatsushi Kobayashi 	/* enable link */
6563c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_HCCCTL, OHCI_HCC_LINKEN);
6573c60ba66SKatsushi Kobayashi 	fw_busreset(&sc->fc);
6583c60ba66SKatsushi Kobayashi 	fwohci_rx_enable(sc, &sc->arrq);
6593c60ba66SKatsushi Kobayashi 	fwohci_rx_enable(sc, &sc->arrs);
6603c60ba66SKatsushi Kobayashi 
6613c60ba66SKatsushi Kobayashi 	for( i = 0, db_tr = sc->atrq.top; i < sc->atrq.ndb ;
6623c60ba66SKatsushi Kobayashi 				i ++, db_tr = STAILQ_NEXT(db_tr, link)){
6633c60ba66SKatsushi Kobayashi 		db_tr->xfer = NULL;
6643c60ba66SKatsushi Kobayashi 	}
6653c60ba66SKatsushi Kobayashi 	for( i = 0, db_tr = sc->atrs.top; i < sc->atrs.ndb ;
6663c60ba66SKatsushi Kobayashi 				i ++, db_tr = STAILQ_NEXT(db_tr, link)){
6673c60ba66SKatsushi Kobayashi 		db_tr->xfer = NULL;
6683c60ba66SKatsushi Kobayashi 	}
6693c60ba66SKatsushi Kobayashi 
6703c60ba66SKatsushi Kobayashi 	OWRITE(sc, FWOHCI_RETRY,
6713c60ba66SKatsushi Kobayashi 		(0xffff << 16 )| (0x0f << 8) | (0x0f << 4) | 0x0f) ;
6723c60ba66SKatsushi Kobayashi 	OWRITE(sc, FWOHCI_INTMASK,
6733c60ba66SKatsushi Kobayashi 			OHCI_INT_ERR  | OHCI_INT_PHY_SID
6743c60ba66SKatsushi Kobayashi 			| OHCI_INT_DMA_ATRQ | OHCI_INT_DMA_ATRS
6753c60ba66SKatsushi Kobayashi 			| OHCI_INT_DMA_PRRQ | OHCI_INT_DMA_PRRS
6763c60ba66SKatsushi Kobayashi 			| OHCI_INT_PHY_BUS_R | OHCI_INT_PW_ERR);
6773c60ba66SKatsushi Kobayashi 	fwohci_set_intr(&sc->fc, 1);
6783c60ba66SKatsushi Kobayashi 
6793c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_ATQCTLCLR, OHCI_CNTL_DMA_RUN | OHCI_CNTL_DMA_DEAD);
6803c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_ATSCTLCLR, OHCI_CNTL_DMA_RUN | OHCI_CNTL_DMA_DEAD);
6813c60ba66SKatsushi Kobayashi 
6823c60ba66SKatsushi Kobayashi 	return err;
6833c60ba66SKatsushi Kobayashi }
684c572b810SHidetoshi Shimokawa 
685c572b810SHidetoshi Shimokawa void
686c572b810SHidetoshi Shimokawa fwohci_timeout(void *arg)
6873c60ba66SKatsushi Kobayashi {
6883c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc;
6893c60ba66SKatsushi Kobayashi 
6903c60ba66SKatsushi Kobayashi 	sc = (struct fwohci_softc *)arg;
6913c60ba66SKatsushi Kobayashi 	sc->fc.timeouthandle = timeout(fwohci_timeout,
6923c60ba66SKatsushi Kobayashi 				(void *)sc, FW_XFERTIMEOUT * hz * 10);
6933c60ba66SKatsushi Kobayashi }
694c572b810SHidetoshi Shimokawa 
695c572b810SHidetoshi Shimokawa u_int32_t
696c572b810SHidetoshi Shimokawa fwohci_cyctimer(struct firewire_comm *fc)
6973c60ba66SKatsushi Kobayashi {
6983c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
6993c60ba66SKatsushi Kobayashi 	return(OREAD(sc, OHCI_CYCLETIMER));
7003c60ba66SKatsushi Kobayashi }
7013c60ba66SKatsushi Kobayashi 
7023c60ba66SKatsushi Kobayashi #define LAST_DB(dbtr, db) do {						\
7033c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *_dbtr = (dbtr);				\
7043c60ba66SKatsushi Kobayashi 	int _cnt = _dbtr->dbcnt;					\
7053c60ba66SKatsushi Kobayashi 	db = &_dbtr->db[ (_cnt > 2) ? (_cnt -1) : 0];			\
7063c60ba66SKatsushi Kobayashi } while (0)
7073c60ba66SKatsushi Kobayashi 
7081f2361f8SHidetoshi Shimokawa int
7091f2361f8SHidetoshi Shimokawa fwohci_detach(struct fwohci_softc *sc, device_t dev)
7101f2361f8SHidetoshi Shimokawa {
7111f2361f8SHidetoshi Shimokawa 	int i;
7121f2361f8SHidetoshi Shimokawa 
7131f2361f8SHidetoshi Shimokawa 	if (sc->fc.sid_buf != NULL)
7141f2361f8SHidetoshi Shimokawa 		contigfree((void *)(uintptr_t)sc->fc.sid_buf,
7151f2361f8SHidetoshi Shimokawa 					OHCI_SIDSIZE, M_DEVBUF);
7161f2361f8SHidetoshi Shimokawa 	if (sc->cromptr != NULL)
7171f2361f8SHidetoshi Shimokawa 		contigfree((void *)sc->cromptr, CROMSIZE * 2, M_DEVBUF);
7181f2361f8SHidetoshi Shimokawa 
7191f2361f8SHidetoshi Shimokawa 	fwohci_db_free(&sc->arrq);
7201f2361f8SHidetoshi Shimokawa 	fwohci_db_free(&sc->arrs);
7211f2361f8SHidetoshi Shimokawa 
7221f2361f8SHidetoshi Shimokawa 	fwohci_db_free(&sc->atrq);
7231f2361f8SHidetoshi Shimokawa 	fwohci_db_free(&sc->atrs);
7241f2361f8SHidetoshi Shimokawa 
7251f2361f8SHidetoshi Shimokawa 	for( i = 0 ; i < sc->fc.nisodma ; i ++ ){
7261f2361f8SHidetoshi Shimokawa 		fwohci_db_free(&sc->it[i]);
7271f2361f8SHidetoshi Shimokawa 		fwohci_db_free(&sc->ir[i]);
7281f2361f8SHidetoshi Shimokawa 	}
7291f2361f8SHidetoshi Shimokawa 
7301f2361f8SHidetoshi Shimokawa 	return 0;
7311f2361f8SHidetoshi Shimokawa }
7321f2361f8SHidetoshi Shimokawa 
733c572b810SHidetoshi Shimokawa static void
734c572b810SHidetoshi Shimokawa fwohci_start(struct fwohci_softc *sc, struct fwohci_dbch *dbch)
7353c60ba66SKatsushi Kobayashi {
7363c60ba66SKatsushi Kobayashi 	int i, s;
7373c60ba66SKatsushi Kobayashi 	int tcode, hdr_len, hdr_off, len;
7383c60ba66SKatsushi Kobayashi 	int fsegment = -1;
7393c60ba66SKatsushi Kobayashi 	u_int32_t off;
7403c60ba66SKatsushi Kobayashi 	struct fw_xfer *xfer;
7413c60ba66SKatsushi Kobayashi 	struct fw_pkt *fp;
7423c60ba66SKatsushi Kobayashi 	volatile struct fwohci_txpkthdr *ohcifp;
7433c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
7443c60ba66SKatsushi Kobayashi 	volatile struct fwohcidb *db;
7453c60ba66SKatsushi Kobayashi 	struct mbuf *m;
7463c60ba66SKatsushi Kobayashi 	struct tcode_info *info;
7473c60ba66SKatsushi Kobayashi 
7483c60ba66SKatsushi Kobayashi 	if(&sc->atrq == dbch){
7493c60ba66SKatsushi Kobayashi 		off = OHCI_ATQOFF;
7503c60ba66SKatsushi Kobayashi 	}else if(&sc->atrs == dbch){
7513c60ba66SKatsushi Kobayashi 		off = OHCI_ATSOFF;
7523c60ba66SKatsushi Kobayashi 	}else{
7533c60ba66SKatsushi Kobayashi 		return;
7543c60ba66SKatsushi Kobayashi 	}
7553c60ba66SKatsushi Kobayashi 
7563c60ba66SKatsushi Kobayashi 	if (dbch->flags & FWOHCI_DBCH_FULL)
7573c60ba66SKatsushi Kobayashi 		return;
7583c60ba66SKatsushi Kobayashi 
7593c60ba66SKatsushi Kobayashi 	s = splfw();
7603c60ba66SKatsushi Kobayashi 	db_tr = dbch->top;
7613c60ba66SKatsushi Kobayashi txloop:
7623c60ba66SKatsushi Kobayashi 	xfer = STAILQ_FIRST(&dbch->xferq.q);
7633c60ba66SKatsushi Kobayashi 	if(xfer == NULL){
7643c60ba66SKatsushi Kobayashi 		goto kick;
7653c60ba66SKatsushi Kobayashi 	}
7663c60ba66SKatsushi Kobayashi 	if(dbch->xferq.queued == 0 ){
7673c60ba66SKatsushi Kobayashi 		device_printf(sc->fc.dev, "TX queue empty\n");
7683c60ba66SKatsushi Kobayashi 	}
7693c60ba66SKatsushi Kobayashi 	STAILQ_REMOVE_HEAD(&dbch->xferq.q, link);
7703c60ba66SKatsushi Kobayashi 	db_tr->xfer = xfer;
7713c60ba66SKatsushi Kobayashi 	xfer->state = FWXF_START;
7723c60ba66SKatsushi Kobayashi 	dbch->xferq.packets++;
7733c60ba66SKatsushi Kobayashi 
7743c60ba66SKatsushi Kobayashi 	fp = (struct fw_pkt *)(xfer->send.buf + xfer->send.off);
7753c60ba66SKatsushi Kobayashi 	tcode = fp->mode.common.tcode;
7763c60ba66SKatsushi Kobayashi 
7773c60ba66SKatsushi Kobayashi 	ohcifp = (volatile struct fwohci_txpkthdr *) db_tr->db[1].db.immed;
7783c60ba66SKatsushi Kobayashi 	info = &tinfo[tcode];
7793c60ba66SKatsushi Kobayashi 	hdr_len = hdr_off = info->hdr_len;
7803c60ba66SKatsushi Kobayashi 	/* fw_asyreq must pass valid send.len */
7813c60ba66SKatsushi Kobayashi 	len = xfer->send.len;
7823c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < hdr_off ; i+= 4){
7833c60ba66SKatsushi Kobayashi 		ohcifp->mode.ld[i/4] = ntohl(fp->mode.ld[i/4]);
7843c60ba66SKatsushi Kobayashi 	}
7853c60ba66SKatsushi Kobayashi 	ohcifp->mode.common.spd = xfer->spd;
7863c60ba66SKatsushi Kobayashi 	if (tcode == FWTCODE_STREAM ){
7873c60ba66SKatsushi Kobayashi 		hdr_len = 8;
7883c60ba66SKatsushi Kobayashi 		ohcifp->mode.stream.len = ntohs(fp->mode.stream.len);
7893c60ba66SKatsushi Kobayashi 	} else if (tcode == FWTCODE_PHY) {
7903c60ba66SKatsushi Kobayashi 		hdr_len = 12;
7913c60ba66SKatsushi Kobayashi 		ohcifp->mode.ld[1] = ntohl(fp->mode.ld[1]);
7923c60ba66SKatsushi Kobayashi 		ohcifp->mode.ld[2] = ntohl(fp->mode.ld[2]);
7933c60ba66SKatsushi Kobayashi 		ohcifp->mode.common.spd = 0;
7943c60ba66SKatsushi Kobayashi 		ohcifp->mode.common.tcode = FWOHCITCODE_PHY;
7953c60ba66SKatsushi Kobayashi 	} else {
7963c60ba66SKatsushi Kobayashi 		ohcifp->mode.asycomm.dst = ntohs(fp->mode.hdr.dst);
7973c60ba66SKatsushi Kobayashi 		ohcifp->mode.asycomm.srcbus = OHCI_ASYSRCBUS;
7983c60ba66SKatsushi Kobayashi 		ohcifp->mode.asycomm.tlrt |= FWRETRY_X;
7993c60ba66SKatsushi Kobayashi 	}
8003c60ba66SKatsushi Kobayashi 	db = &db_tr->db[0];
8013c60ba66SKatsushi Kobayashi  	db->db.desc.cmd = OHCI_OUTPUT_MORE | OHCI_KEY_ST2 | hdr_len;
8023c60ba66SKatsushi Kobayashi  	db->db.desc.status = 0;
8033c60ba66SKatsushi Kobayashi /* Specify bound timer of asy. responce */
8043c60ba66SKatsushi Kobayashi 	if(&sc->atrs == dbch){
8053c60ba66SKatsushi Kobayashi  		db->db.desc.count
8063c60ba66SKatsushi Kobayashi 			 = (OREAD(sc, OHCI_CYCLETIMER) >> 12) + (1 << 13);
8073c60ba66SKatsushi Kobayashi 	}
8083c60ba66SKatsushi Kobayashi 
8093c60ba66SKatsushi Kobayashi 	db_tr->dbcnt = 2;
8103c60ba66SKatsushi Kobayashi 	db = &db_tr->db[db_tr->dbcnt];
8113c60ba66SKatsushi Kobayashi 	if(len > hdr_off){
8123c60ba66SKatsushi Kobayashi 		if (xfer->mbuf == NULL) {
8133c60ba66SKatsushi Kobayashi 			db->db.desc.addr
8143c60ba66SKatsushi Kobayashi 				= vtophys(xfer->send.buf + xfer->send.off) + hdr_off;
8153c60ba66SKatsushi Kobayashi 			db->db.desc.cmd
8163c60ba66SKatsushi Kobayashi 				= OHCI_OUTPUT_MORE | ((len - hdr_off) & 0xffff);
8173c60ba66SKatsushi Kobayashi  			db->db.desc.status = 0;
8183c60ba66SKatsushi Kobayashi 
8193c60ba66SKatsushi Kobayashi 			db_tr->dbcnt++;
8203c60ba66SKatsushi Kobayashi 		} else {
8213c60ba66SKatsushi Kobayashi 			/* XXX we assume mbuf chain is shorter than ndesc */
8223c60ba66SKatsushi Kobayashi 			m = xfer->mbuf;
8233c60ba66SKatsushi Kobayashi 			do {
8243c60ba66SKatsushi Kobayashi 				db->db.desc.addr
8253c60ba66SKatsushi Kobayashi 					= vtophys(mtod(m, caddr_t));
8263c60ba66SKatsushi Kobayashi 				db->db.desc.cmd = OHCI_OUTPUT_MORE | m->m_len;
8273c60ba66SKatsushi Kobayashi  				db->db.desc.status = 0;
8283c60ba66SKatsushi Kobayashi 				db++;
8293c60ba66SKatsushi Kobayashi 				db_tr->dbcnt++;
8303c60ba66SKatsushi Kobayashi 				m = m->m_next;
8313c60ba66SKatsushi Kobayashi 			} while (m != NULL);
8323c60ba66SKatsushi Kobayashi 		}
8333c60ba66SKatsushi Kobayashi 	}
8343c60ba66SKatsushi Kobayashi 	/* last db */
8353c60ba66SKatsushi Kobayashi 	LAST_DB(db_tr, db);
8363c60ba66SKatsushi Kobayashi  	db->db.desc.cmd |= OHCI_OUTPUT_LAST
8373c60ba66SKatsushi Kobayashi 			| OHCI_INTERRUPT_ALWAYS
8383c60ba66SKatsushi Kobayashi 			| OHCI_BRANCH_ALWAYS;
8393c60ba66SKatsushi Kobayashi  	db->db.desc.depend = vtophys(STAILQ_NEXT(db_tr, link)->db);
8403c60ba66SKatsushi Kobayashi 
8413c60ba66SKatsushi Kobayashi 	if(fsegment == -1 )
8423c60ba66SKatsushi Kobayashi 		fsegment = db_tr->dbcnt;
8433c60ba66SKatsushi Kobayashi 	if (dbch->pdb_tr != NULL) {
8443c60ba66SKatsushi Kobayashi 		LAST_DB(dbch->pdb_tr, db);
8453c60ba66SKatsushi Kobayashi  		db->db.desc.depend |= db_tr->dbcnt;
8463c60ba66SKatsushi Kobayashi 	}
8473c60ba66SKatsushi Kobayashi 	dbch->pdb_tr = db_tr;
8483c60ba66SKatsushi Kobayashi 	db_tr = STAILQ_NEXT(db_tr, link);
8493c60ba66SKatsushi Kobayashi 	if(db_tr != dbch->bottom){
8503c60ba66SKatsushi Kobayashi 		goto txloop;
8513c60ba66SKatsushi Kobayashi 	} else {
85217c3d42cSHidetoshi Shimokawa 		device_printf(sc->fc.dev, "fwohci_start: lack of db_trq\n");
8533c60ba66SKatsushi Kobayashi 		dbch->flags |= FWOHCI_DBCH_FULL;
8543c60ba66SKatsushi Kobayashi 	}
8553c60ba66SKatsushi Kobayashi kick:
8563c60ba66SKatsushi Kobayashi 	if (firewire_debug) printf("kick\n");
8573c60ba66SKatsushi Kobayashi 	/* kick asy q */
8583c60ba66SKatsushi Kobayashi 
8593c60ba66SKatsushi Kobayashi 	if(dbch->xferq.flag & FWXFERQ_RUNNING) {
8603c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_DMACTL(off), OHCI_CNTL_DMA_WAKE);
8613c60ba66SKatsushi Kobayashi 	} else {
86217c3d42cSHidetoshi Shimokawa 		if (bootverbose)
86317c3d42cSHidetoshi Shimokawa 			device_printf(sc->fc.dev, "start AT DMA status=%x\n",
8643c60ba66SKatsushi Kobayashi 					OREAD(sc, OHCI_DMACTL(off)));
8653c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_DMACMD(off), vtophys(dbch->top->db) | fsegment);
8663c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_DMACTL(off), OHCI_CNTL_DMA_RUN);
8673c60ba66SKatsushi Kobayashi 		dbch->xferq.flag |= FWXFERQ_RUNNING;
8683c60ba66SKatsushi Kobayashi 	}
869c572b810SHidetoshi Shimokawa 
8703c60ba66SKatsushi Kobayashi 	dbch->top = db_tr;
8713c60ba66SKatsushi Kobayashi 	splx(s);
8723c60ba66SKatsushi Kobayashi 	return;
8733c60ba66SKatsushi Kobayashi }
874c572b810SHidetoshi Shimokawa 
875c572b810SHidetoshi Shimokawa static void
876c572b810SHidetoshi Shimokawa fwohci_drain_atq(struct firewire_comm *fc, struct fw_xfer *xfer)
8773c60ba66SKatsushi Kobayashi {
8783c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
8793c60ba66SKatsushi Kobayashi 	fwohci_drain(&sc->fc, xfer, &(sc->atrq));
8803c60ba66SKatsushi Kobayashi 	return;
8813c60ba66SKatsushi Kobayashi }
882c572b810SHidetoshi Shimokawa 
883c572b810SHidetoshi Shimokawa static void
884c572b810SHidetoshi Shimokawa fwohci_drain_ats(struct firewire_comm *fc, struct fw_xfer *xfer)
8853c60ba66SKatsushi Kobayashi {
8863c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
8873c60ba66SKatsushi Kobayashi 	fwohci_drain(&sc->fc, xfer, &(sc->atrs));
8883c60ba66SKatsushi Kobayashi 	return;
8893c60ba66SKatsushi Kobayashi }
890c572b810SHidetoshi Shimokawa 
891c572b810SHidetoshi Shimokawa static void
892c572b810SHidetoshi Shimokawa fwohci_start_atq(struct firewire_comm *fc)
8933c60ba66SKatsushi Kobayashi {
8943c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
8953c60ba66SKatsushi Kobayashi 	fwohci_start( sc, &(sc->atrq));
8963c60ba66SKatsushi Kobayashi 	return;
8973c60ba66SKatsushi Kobayashi }
898c572b810SHidetoshi Shimokawa 
899c572b810SHidetoshi Shimokawa static void
900c572b810SHidetoshi Shimokawa fwohci_start_ats(struct firewire_comm *fc)
9013c60ba66SKatsushi Kobayashi {
9023c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
9033c60ba66SKatsushi Kobayashi 	fwohci_start( sc, &(sc->atrs));
9043c60ba66SKatsushi Kobayashi 	return;
9053c60ba66SKatsushi Kobayashi }
906c572b810SHidetoshi Shimokawa 
907c572b810SHidetoshi Shimokawa void
908c572b810SHidetoshi Shimokawa fwohci_txd(struct fwohci_softc *sc, struct fwohci_dbch *dbch)
9093c60ba66SKatsushi Kobayashi {
9103c60ba66SKatsushi Kobayashi 	int s, err = 0;
9113c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *tr;
9123c60ba66SKatsushi Kobayashi 	volatile struct fwohcidb *db;
9133c60ba66SKatsushi Kobayashi 	struct fw_xfer *xfer;
9143c60ba66SKatsushi Kobayashi 	u_int32_t off;
9153c60ba66SKatsushi Kobayashi 	u_int stat;
9163c60ba66SKatsushi Kobayashi 	int	packets;
9173c60ba66SKatsushi Kobayashi 	struct firewire_comm *fc = (struct firewire_comm *)sc;
9183c60ba66SKatsushi Kobayashi 	if(&sc->atrq == dbch){
9193c60ba66SKatsushi Kobayashi 		off = OHCI_ATQOFF;
9203c60ba66SKatsushi Kobayashi 	}else if(&sc->atrs == dbch){
9213c60ba66SKatsushi Kobayashi 		off = OHCI_ATSOFF;
9223c60ba66SKatsushi Kobayashi 	}else{
9233c60ba66SKatsushi Kobayashi 		return;
9243c60ba66SKatsushi Kobayashi 	}
9253c60ba66SKatsushi Kobayashi 	s = splfw();
9263c60ba66SKatsushi Kobayashi 	tr = dbch->bottom;
9273c60ba66SKatsushi Kobayashi 	packets = 0;
9283c60ba66SKatsushi Kobayashi 	while(dbch->xferq.queued > 0){
9293c60ba66SKatsushi Kobayashi 		LAST_DB(tr, db);
9303c60ba66SKatsushi Kobayashi 		if(!(db->db.desc.status & OHCI_CNTL_DMA_ACTIVE)){
9313c60ba66SKatsushi Kobayashi 			if (fc->status != FWBUSRESET)
9323c60ba66SKatsushi Kobayashi 				/* maybe out of order?? */
9333c60ba66SKatsushi Kobayashi 				goto out;
9343c60ba66SKatsushi Kobayashi 		}
9353c60ba66SKatsushi Kobayashi 		if(db->db.desc.status & OHCI_CNTL_DMA_DEAD) {
9363c60ba66SKatsushi Kobayashi #ifdef OHCI_DEBUG
9373c60ba66SKatsushi Kobayashi 			dump_dma(sc, ch);
9383c60ba66SKatsushi Kobayashi 			dump_db(sc, ch);
9393c60ba66SKatsushi Kobayashi #endif
9403c60ba66SKatsushi Kobayashi /* Stop DMA */
9413c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_DMACTLCLR(off), OHCI_CNTL_DMA_RUN);
9423c60ba66SKatsushi Kobayashi 			device_printf(sc->fc.dev, "force reset AT FIFO\n");
9433c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_HCCCTLCLR, OHCI_HCC_LINKEN);
9443c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_HCCCTL, OHCI_HCC_LPS | OHCI_HCC_LINKEN);
9453c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_DMACTLCLR(off), OHCI_CNTL_DMA_RUN);
9463c60ba66SKatsushi Kobayashi 		}
9473c60ba66SKatsushi Kobayashi 		stat = db->db.desc.status & FWOHCIEV_MASK;
9483c60ba66SKatsushi Kobayashi 		switch(stat){
9493c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKCOMPL:
9503c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKPEND:
9513c60ba66SKatsushi Kobayashi 			err = 0;
9523c60ba66SKatsushi Kobayashi 			break;
9533c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKBSA:
9543c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKBSB:
9553c60ba66SKatsushi Kobayashi 			device_printf(sc->fc.dev, "txd err=%2x %s\n", stat, fwohcicode[stat]);
9563c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKBSX:
9573c60ba66SKatsushi Kobayashi 			err = EBUSY;
9583c60ba66SKatsushi Kobayashi 			break;
9593c60ba66SKatsushi Kobayashi 		case FWOHCIEV_FLUSHED:
9603c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKTARD:
9613c60ba66SKatsushi Kobayashi 			device_printf(sc->fc.dev, "txd err=%2x %s\n", stat, fwohcicode[stat]);
9623c60ba66SKatsushi Kobayashi 			err = EAGAIN;
9633c60ba66SKatsushi Kobayashi 			break;
9643c60ba66SKatsushi Kobayashi 		case FWOHCIEV_MISSACK:
9653c60ba66SKatsushi Kobayashi 		case FWOHCIEV_UNDRRUN:
9663c60ba66SKatsushi Kobayashi 		case FWOHCIEV_OVRRUN:
9673c60ba66SKatsushi Kobayashi 		case FWOHCIEV_DESCERR:
9683c60ba66SKatsushi Kobayashi 		case FWOHCIEV_DTRDERR:
9693c60ba66SKatsushi Kobayashi 		case FWOHCIEV_TIMEOUT:
9703c60ba66SKatsushi Kobayashi 		case FWOHCIEV_TCODERR:
9713c60ba66SKatsushi Kobayashi 		case FWOHCIEV_UNKNOWN:
9723c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKDERR:
9733c60ba66SKatsushi Kobayashi 		case FWOHCIEV_ACKTERR:
9743c60ba66SKatsushi Kobayashi 		default:
9753c60ba66SKatsushi Kobayashi 			device_printf(sc->fc.dev, "txd err=%2x %s\n",
9763c60ba66SKatsushi Kobayashi 							stat, fwohcicode[stat]);
9773c60ba66SKatsushi Kobayashi 			err = EINVAL;
9783c60ba66SKatsushi Kobayashi 			break;
9793c60ba66SKatsushi Kobayashi 		}
9803c60ba66SKatsushi Kobayashi 		if(tr->xfer != NULL){
9813c60ba66SKatsushi Kobayashi 			xfer = tr->xfer;
9823c60ba66SKatsushi Kobayashi 			xfer->state = FWXF_SENT;
9833c60ba66SKatsushi Kobayashi 			if(err == EBUSY && fc->status != FWBUSRESET){
9843c60ba66SKatsushi Kobayashi 				xfer->state = FWXF_BUSY;
9853c60ba66SKatsushi Kobayashi 				switch(xfer->act_type){
9863c60ba66SKatsushi Kobayashi 				case FWACT_XFER:
9873c60ba66SKatsushi Kobayashi 					xfer->resp = err;
9883c60ba66SKatsushi Kobayashi 					if(xfer->retry_req != NULL){
9893c60ba66SKatsushi Kobayashi 						xfer->retry_req(xfer);
9903c60ba66SKatsushi Kobayashi 					}
9913c60ba66SKatsushi Kobayashi 					break;
9923c60ba66SKatsushi Kobayashi 				default:
9933c60ba66SKatsushi Kobayashi 					break;
9943c60ba66SKatsushi Kobayashi 				}
9953c60ba66SKatsushi Kobayashi 			} else if( stat != FWOHCIEV_ACKPEND){
9963c60ba66SKatsushi Kobayashi 				if (stat != FWOHCIEV_ACKCOMPL)
9973c60ba66SKatsushi Kobayashi 					xfer->state = FWXF_SENTERR;
9983c60ba66SKatsushi Kobayashi 				xfer->resp = err;
9993c60ba66SKatsushi Kobayashi 				switch(xfer->act_type){
10003c60ba66SKatsushi Kobayashi 				case FWACT_XFER:
10013c60ba66SKatsushi Kobayashi 					fw_xfer_done(xfer);
10023c60ba66SKatsushi Kobayashi 					break;
10033c60ba66SKatsushi Kobayashi 				default:
10043c60ba66SKatsushi Kobayashi 					break;
10053c60ba66SKatsushi Kobayashi 				}
10063c60ba66SKatsushi Kobayashi 			}
10073c60ba66SKatsushi Kobayashi 			dbch->xferq.queued --;
10083c60ba66SKatsushi Kobayashi 		}
10093c60ba66SKatsushi Kobayashi 		tr->xfer = NULL;
10103c60ba66SKatsushi Kobayashi 
10113c60ba66SKatsushi Kobayashi 		packets ++;
10123c60ba66SKatsushi Kobayashi 		tr = STAILQ_NEXT(tr, link);
10133c60ba66SKatsushi Kobayashi 		dbch->bottom = tr;
10143c60ba66SKatsushi Kobayashi 	}
10153c60ba66SKatsushi Kobayashi out:
10163c60ba66SKatsushi Kobayashi 	if ((dbch->flags & FWOHCI_DBCH_FULL) && packets > 0) {
10173c60ba66SKatsushi Kobayashi 		printf("make free slot\n");
10183c60ba66SKatsushi Kobayashi 		dbch->flags &= ~FWOHCI_DBCH_FULL;
10193c60ba66SKatsushi Kobayashi 		fwohci_start(sc, dbch);
10203c60ba66SKatsushi Kobayashi 	}
10213c60ba66SKatsushi Kobayashi 	splx(s);
10223c60ba66SKatsushi Kobayashi }
1023c572b810SHidetoshi Shimokawa 
1024c572b810SHidetoshi Shimokawa static void
1025c572b810SHidetoshi Shimokawa fwohci_drain(struct firewire_comm *fc, struct fw_xfer *xfer, struct fwohci_dbch *dbch)
10263c60ba66SKatsushi Kobayashi {
10273c60ba66SKatsushi Kobayashi 	int i, s;
10283c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *tr;
10293c60ba66SKatsushi Kobayashi 
10303c60ba66SKatsushi Kobayashi 	if(xfer->state != FWXF_START) return;
10313c60ba66SKatsushi Kobayashi 
10323c60ba66SKatsushi Kobayashi 	s = splfw();
10333c60ba66SKatsushi Kobayashi 	tr = dbch->bottom;
10343c60ba66SKatsushi Kobayashi 	for( i = 0 ; i <= dbch->xferq.queued  ; i ++){
10353c60ba66SKatsushi Kobayashi 		if(tr->xfer == xfer){
10363c60ba66SKatsushi Kobayashi 			s = splfw();
10373c60ba66SKatsushi Kobayashi 			tr->xfer = NULL;
10383c60ba66SKatsushi Kobayashi 			dbch->xferq.queued --;
10393c60ba66SKatsushi Kobayashi #if 1
10403c60ba66SKatsushi Kobayashi 			/* XXX */
10413c60ba66SKatsushi Kobayashi 			if (tr == dbch->bottom)
10423c60ba66SKatsushi Kobayashi 				dbch->bottom = STAILQ_NEXT(tr, link);
10433c60ba66SKatsushi Kobayashi #endif
10443c60ba66SKatsushi Kobayashi 			if (dbch->flags & FWOHCI_DBCH_FULL) {
10453c60ba66SKatsushi Kobayashi 				printf("fwohci_drain: make slot\n");
10463c60ba66SKatsushi Kobayashi 				dbch->flags &= ~FWOHCI_DBCH_FULL;
10473c60ba66SKatsushi Kobayashi 				fwohci_start((struct fwohci_softc *)fc, dbch);
10483c60ba66SKatsushi Kobayashi 			}
10493c60ba66SKatsushi Kobayashi 
10503c60ba66SKatsushi Kobayashi 			splx(s);
10513c60ba66SKatsushi Kobayashi 			break;
10523c60ba66SKatsushi Kobayashi 		}
10533c60ba66SKatsushi Kobayashi 		tr = STAILQ_NEXT(tr, link);
10543c60ba66SKatsushi Kobayashi 	}
10553c60ba66SKatsushi Kobayashi 	splx(s);
10563c60ba66SKatsushi Kobayashi 	return;
10573c60ba66SKatsushi Kobayashi }
10583c60ba66SKatsushi Kobayashi 
1059c572b810SHidetoshi Shimokawa static void
1060c572b810SHidetoshi Shimokawa fwohci_db_free(struct fwohci_dbch *dbch)
10613c60ba66SKatsushi Kobayashi {
10623c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
10633c60ba66SKatsushi Kobayashi 	int idb;
10643c60ba66SKatsushi Kobayashi 
10651f2361f8SHidetoshi Shimokawa 	if ((dbch->flags & FWOHCI_DBCH_INIT) == 0)
10661f2361f8SHidetoshi Shimokawa 		return;
10671f2361f8SHidetoshi Shimokawa 
10683c60ba66SKatsushi Kobayashi 	if(!(dbch->xferq.flag & FWXFERQ_EXTBUF)){
10693c60ba66SKatsushi Kobayashi 		for(db_tr = STAILQ_FIRST(&dbch->db_trq), idb = 0;
10703c60ba66SKatsushi Kobayashi 			idb < dbch->ndb;
10713c60ba66SKatsushi Kobayashi 			db_tr = STAILQ_NEXT(db_tr, link), idb++){
10721f2361f8SHidetoshi Shimokawa 			if (db_tr->buf != NULL) {
10733c60ba66SKatsushi Kobayashi 				free(db_tr->buf, M_DEVBUF);
10743c60ba66SKatsushi Kobayashi 				db_tr->buf = NULL;
10753c60ba66SKatsushi Kobayashi 			}
10763c60ba66SKatsushi Kobayashi 		}
10771f2361f8SHidetoshi Shimokawa 	}
10783c60ba66SKatsushi Kobayashi 	dbch->ndb = 0;
10793c60ba66SKatsushi Kobayashi 	db_tr = STAILQ_FIRST(&dbch->db_trq);
10803c60ba66SKatsushi Kobayashi 	contigfree((void *)(uintptr_t)(volatile void *)db_tr->db,
10813c60ba66SKatsushi Kobayashi 		sizeof(struct fwohcidb) * dbch->ndesc * dbch->ndb, M_DEVBUF);
10823c60ba66SKatsushi Kobayashi 	free(db_tr, M_DEVBUF);
10833c60ba66SKatsushi Kobayashi 	STAILQ_INIT(&dbch->db_trq);
10841f2361f8SHidetoshi Shimokawa 	dbch->flags &= ~FWOHCI_DBCH_INIT;
10853c60ba66SKatsushi Kobayashi }
1086c572b810SHidetoshi Shimokawa 
1087c572b810SHidetoshi Shimokawa static void
1088c572b810SHidetoshi Shimokawa fwohci_db_init(struct fwohci_dbch *dbch)
10893c60ba66SKatsushi Kobayashi {
10903c60ba66SKatsushi Kobayashi 	int	idb;
10913c60ba66SKatsushi Kobayashi 	struct fwohcidb *db;
10923c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
10933c60ba66SKatsushi Kobayashi 	/* allocate DB entries and attach one to each DMA channels */
10943c60ba66SKatsushi Kobayashi 	/* DB entry must start at 16 bytes bounary. */
10953c60ba66SKatsushi Kobayashi 	dbch->frag.buf = NULL;
10963c60ba66SKatsushi Kobayashi 	dbch->frag.len = 0;
10973c60ba66SKatsushi Kobayashi 	dbch->frag.plen = 0;
10983c60ba66SKatsushi Kobayashi 	dbch->xferq.queued = 0;
10993c60ba66SKatsushi Kobayashi 	dbch->pdb_tr = NULL;
11003c60ba66SKatsushi Kobayashi 
11013c60ba66SKatsushi Kobayashi 	STAILQ_INIT(&dbch->db_trq);
11023c60ba66SKatsushi Kobayashi 	db_tr = (struct fwohcidb_tr *)
11033c60ba66SKatsushi Kobayashi 		malloc(sizeof(struct fwohcidb_tr) * dbch->ndb,
11041f2361f8SHidetoshi Shimokawa 		M_DEVBUF, M_DONTWAIT | M_ZERO);
11053c60ba66SKatsushi Kobayashi 	if(db_tr == NULL){
11061f2361f8SHidetoshi Shimokawa 		printf("fwochi_db_init: malloc failed\n");
11073c60ba66SKatsushi Kobayashi 		return;
11083c60ba66SKatsushi Kobayashi 	}
11093c60ba66SKatsushi Kobayashi 	db = (struct fwohcidb *)
11103c60ba66SKatsushi Kobayashi 		contigmalloc(sizeof (struct fwohcidb) * dbch->ndesc * dbch->ndb,
11113c60ba66SKatsushi Kobayashi 		M_DEVBUF, M_DONTWAIT, 0x10000, 0xffffffff, PAGE_SIZE, 0ul);
11123c60ba66SKatsushi Kobayashi 	if(db == NULL){
11133c60ba66SKatsushi Kobayashi 		printf("fwochi_db_init: contigmalloc failed\n");
11141f2361f8SHidetoshi Shimokawa 		free(db_tr, M_DEVBUF);
11153c60ba66SKatsushi Kobayashi 		return;
11163c60ba66SKatsushi Kobayashi 	}
11173c60ba66SKatsushi Kobayashi 	bzero(db, sizeof (struct fwohcidb) * dbch->ndesc * dbch->ndb);
11183c60ba66SKatsushi Kobayashi 	/* Attach DB to DMA ch. */
11193c60ba66SKatsushi Kobayashi 	for(idb = 0 ; idb < dbch->ndb ; idb++){
11203c60ba66SKatsushi Kobayashi 		db_tr->dbcnt = 0;
11213c60ba66SKatsushi Kobayashi 		db_tr->db = &db[idb * dbch->ndesc];
11223c60ba66SKatsushi Kobayashi 		STAILQ_INSERT_TAIL(&dbch->db_trq, db_tr, link);
11233c60ba66SKatsushi Kobayashi 		if(!(dbch->xferq.flag & FWXFERQ_PACKET) &&
11243c60ba66SKatsushi Kobayashi 			(idb % dbch->xferq.bnpacket == 0)){
11253c60ba66SKatsushi Kobayashi 			dbch->xferq.bulkxfer[idb/dbch->xferq.bnpacket].start
11263c60ba66SKatsushi Kobayashi 				= (caddr_t)db_tr;
11273c60ba66SKatsushi Kobayashi 		}
11283c60ba66SKatsushi Kobayashi 		if((!(dbch->xferq.flag & FWXFERQ_PACKET)) &&
11293c60ba66SKatsushi Kobayashi 			((idb + 1)% dbch->xferq.bnpacket == 0)){
11303c60ba66SKatsushi Kobayashi 			dbch->xferq.bulkxfer[idb/dbch->xferq.bnpacket].end
11313c60ba66SKatsushi Kobayashi 				= (caddr_t)db_tr;
11323c60ba66SKatsushi Kobayashi 		}
11333c60ba66SKatsushi Kobayashi 		db_tr++;
11343c60ba66SKatsushi Kobayashi 	}
11353c60ba66SKatsushi Kobayashi 	STAILQ_LAST(&dbch->db_trq, fwohcidb_tr,link)->link.stqe_next
11363c60ba66SKatsushi Kobayashi 			= STAILQ_FIRST(&dbch->db_trq);
11373c60ba66SKatsushi Kobayashi 	dbch->top = STAILQ_FIRST(&dbch->db_trq);
11383c60ba66SKatsushi Kobayashi 	dbch->bottom = dbch->top;
11391f2361f8SHidetoshi Shimokawa 	dbch->flags = FWOHCI_DBCH_INIT;
11403c60ba66SKatsushi Kobayashi }
1141c572b810SHidetoshi Shimokawa 
1142c572b810SHidetoshi Shimokawa static int
1143c572b810SHidetoshi Shimokawa fwohci_itx_disable(struct firewire_comm *fc, int dmach)
11443c60ba66SKatsushi Kobayashi {
11453c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
11463c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_ITCTLCLR(dmach), OHCI_CNTL_DMA_RUN);
11473c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IT_MASKCLR, 1 << dmach);
11483c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IT_STATCLR, 1 << dmach);
11493c60ba66SKatsushi Kobayashi 	fwohci_db_free(&sc->it[dmach]);
11503c60ba66SKatsushi Kobayashi 	sc->it[dmach].xferq.flag &= ~FWXFERQ_RUNNING;
11513c60ba66SKatsushi Kobayashi 	return 0;
11523c60ba66SKatsushi Kobayashi }
1153c572b810SHidetoshi Shimokawa 
1154c572b810SHidetoshi Shimokawa static int
1155c572b810SHidetoshi Shimokawa fwohci_irx_disable(struct firewire_comm *fc, int dmach)
11563c60ba66SKatsushi Kobayashi {
11573c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
11583c60ba66SKatsushi Kobayashi 
11593c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IRCTLCLR(dmach), OHCI_CNTL_DMA_RUN);
11603c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IR_MASKCLR, 1 << dmach);
11613c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IR_STATCLR, 1 << dmach);
11623c60ba66SKatsushi Kobayashi 	if(sc->ir[dmach].dummy != NULL){
11633c60ba66SKatsushi Kobayashi 		free(sc->ir[dmach].dummy, M_DEVBUF);
11643c60ba66SKatsushi Kobayashi 	}
11653c60ba66SKatsushi Kobayashi 	sc->ir[dmach].dummy = NULL;
11663c60ba66SKatsushi Kobayashi 	fwohci_db_free(&sc->ir[dmach]);
11673c60ba66SKatsushi Kobayashi 	sc->ir[dmach].xferq.flag &= ~FWXFERQ_RUNNING;
11683c60ba66SKatsushi Kobayashi 	return 0;
11693c60ba66SKatsushi Kobayashi }
1170c572b810SHidetoshi Shimokawa 
1171c572b810SHidetoshi Shimokawa static void
1172c572b810SHidetoshi Shimokawa fwohci_irx_post (struct firewire_comm *fc , u_int32_t *qld)
11733c60ba66SKatsushi Kobayashi {
11743c60ba66SKatsushi Kobayashi 	qld[0] = ntohl(qld[0]);
11753c60ba66SKatsushi Kobayashi 	return;
11763c60ba66SKatsushi Kobayashi }
1177c572b810SHidetoshi Shimokawa 
1178c572b810SHidetoshi Shimokawa static int
1179c572b810SHidetoshi Shimokawa fwohci_irxpp_enable(struct firewire_comm *fc, int dmach)
11803c60ba66SKatsushi Kobayashi {
11813c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
11823c60ba66SKatsushi Kobayashi 	int err = 0;
11833c60ba66SKatsushi Kobayashi 	unsigned short tag, ich;
11843c60ba66SKatsushi Kobayashi 
11853c60ba66SKatsushi Kobayashi 	tag = (sc->ir[dmach].xferq.flag >> 6) & 3;
11863c60ba66SKatsushi Kobayashi 	ich = sc->ir[dmach].xferq.flag & 0x3f;
11873c60ba66SKatsushi Kobayashi 
11883c60ba66SKatsushi Kobayashi #if 0
11893c60ba66SKatsushi Kobayashi 	if(STAILQ_FIRST(&fc->ir[dmach]->q) != NULL){
11903c60ba66SKatsushi Kobayashi 		wakeup(fc->ir[dmach]);
11913c60ba66SKatsushi Kobayashi 		return err;
11923c60ba66SKatsushi Kobayashi 	}
11933c60ba66SKatsushi Kobayashi #endif
11943c60ba66SKatsushi Kobayashi 
11953c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IRMATCH(dmach), tagbit[tag] | ich);
11963c60ba66SKatsushi Kobayashi 	if(!(sc->ir[dmach].xferq.flag & FWXFERQ_RUNNING)){
11973c60ba66SKatsushi Kobayashi 		sc->ir[dmach].xferq.queued = 0;
11983c60ba66SKatsushi Kobayashi 		sc->ir[dmach].ndb = NDB;
11993c60ba66SKatsushi Kobayashi 		sc->ir[dmach].xferq.psize = FWPMAX_S400;
12003c60ba66SKatsushi Kobayashi 		sc->ir[dmach].ndesc = 1;
12013c60ba66SKatsushi Kobayashi 		fwohci_db_init(&sc->ir[dmach]);
12023c60ba66SKatsushi Kobayashi 		err = fwohci_rx_enable(sc, &sc->ir[dmach]);
12033c60ba66SKatsushi Kobayashi 	}
12043c60ba66SKatsushi Kobayashi 	if(err){
12053c60ba66SKatsushi Kobayashi 		device_printf(sc->fc.dev, "err in IRX setting\n");
12063c60ba66SKatsushi Kobayashi 		return err;
12073c60ba66SKatsushi Kobayashi 	}
12083c60ba66SKatsushi Kobayashi 	if(!(OREAD(sc, OHCI_IRCTL(dmach)) & OHCI_CNTL_DMA_ACTIVE)){
12093c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTLCLR(dmach), OHCI_CNTL_DMA_RUN);
12103c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_MASKCLR, 1 << dmach);
12113c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_STATCLR, 1 << dmach);
12123c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_MASK, 1 << dmach);
12133c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTLCLR(dmach), 0xf8000000);
12143c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTL(dmach), OHCI_CNTL_ISOHDR);
12153c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCMD(dmach),
12163c60ba66SKatsushi Kobayashi 			vtophys(sc->ir[dmach].top->db) | 1);
12173c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTL(dmach), OHCI_CNTL_DMA_RUN);
12183c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTMASK, OHCI_INT_DMA_IR);
12193c60ba66SKatsushi Kobayashi 	}
12203c60ba66SKatsushi Kobayashi 	return err;
12213c60ba66SKatsushi Kobayashi }
1222c572b810SHidetoshi Shimokawa 
1223c572b810SHidetoshi Shimokawa static int
1224c572b810SHidetoshi Shimokawa fwohci_tx_enable(struct fwohci_softc *sc, struct fwohci_dbch *dbch)
12253c60ba66SKatsushi Kobayashi {
12263c60ba66SKatsushi Kobayashi 	int err = 0;
12273c60ba66SKatsushi Kobayashi 	int idb, z, i, dmach = 0;
12283c60ba66SKatsushi Kobayashi 	u_int32_t off = NULL;
12293c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
12303c60ba66SKatsushi Kobayashi 
12313c60ba66SKatsushi Kobayashi 	if(!(dbch->xferq.flag & FWXFERQ_EXTBUF)){
12323c60ba66SKatsushi Kobayashi 		err = EINVAL;
12333c60ba66SKatsushi Kobayashi 		return err;
12343c60ba66SKatsushi Kobayashi 	}
12353c60ba66SKatsushi Kobayashi 	z = dbch->ndesc;
12363c60ba66SKatsushi Kobayashi 	for(dmach = 0 ; dmach < sc->fc.nisodma ; dmach++){
12373c60ba66SKatsushi Kobayashi 		if( &sc->it[dmach] == dbch){
12383c60ba66SKatsushi Kobayashi 			off = OHCI_ITOFF(dmach);
12393c60ba66SKatsushi Kobayashi 			break;
12403c60ba66SKatsushi Kobayashi 		}
12413c60ba66SKatsushi Kobayashi 	}
12423c60ba66SKatsushi Kobayashi 	if(off == NULL){
12433c60ba66SKatsushi Kobayashi 		err = EINVAL;
12443c60ba66SKatsushi Kobayashi 		return err;
12453c60ba66SKatsushi Kobayashi 	}
12463c60ba66SKatsushi Kobayashi 	if(dbch->xferq.flag & FWXFERQ_RUNNING)
12473c60ba66SKatsushi Kobayashi 		return err;
12483c60ba66SKatsushi Kobayashi 	dbch->xferq.flag |= FWXFERQ_RUNNING;
12493c60ba66SKatsushi Kobayashi 	for( i = 0, dbch->bottom = dbch->top; i < (dbch->ndb - 1); i++){
12503c60ba66SKatsushi Kobayashi 		dbch->bottom = STAILQ_NEXT(dbch->bottom, link);
12513c60ba66SKatsushi Kobayashi 	}
12523c60ba66SKatsushi Kobayashi 	db_tr = dbch->top;
12533c60ba66SKatsushi Kobayashi 	for( idb = 0 ; idb < dbch->ndb ; idb ++){
12543c60ba66SKatsushi Kobayashi 		fwohci_add_tx_buf(db_tr,
12553c60ba66SKatsushi Kobayashi 			dbch->xferq.psize, dbch->xferq.flag,
12563c60ba66SKatsushi Kobayashi 			dbch->xferq.buf + dbch->xferq.psize * idb);
12573c60ba66SKatsushi Kobayashi 		if(STAILQ_NEXT(db_tr, link) == NULL){
12583c60ba66SKatsushi Kobayashi 			break;
12593c60ba66SKatsushi Kobayashi 		}
12603c60ba66SKatsushi Kobayashi 		db_tr->db[0].db.desc.depend
12613c60ba66SKatsushi Kobayashi 			= vtophys(STAILQ_NEXT(db_tr, link)->db) | z;
12623c60ba66SKatsushi Kobayashi 		db_tr->db[db_tr->dbcnt - 1].db.desc.depend
12633c60ba66SKatsushi Kobayashi 			= vtophys(STAILQ_NEXT(db_tr, link)->db) | z;
12643c60ba66SKatsushi Kobayashi 		if(dbch->xferq.flag & FWXFERQ_EXTBUF){
12653c60ba66SKatsushi Kobayashi 			if(((idb + 1 ) % dbch->xferq.bnpacket) == 0){
12663c60ba66SKatsushi Kobayashi 				db_tr->db[db_tr->dbcnt - 1].db.desc.cmd
12673c60ba66SKatsushi Kobayashi 					|= OHCI_INTERRUPT_ALWAYS;
12683c60ba66SKatsushi Kobayashi 				db_tr->db[0].db.desc.depend &= ~0xf;
12693c60ba66SKatsushi Kobayashi 				db_tr->db[db_tr->dbcnt - 1].db.desc.depend &=
12703c60ba66SKatsushi Kobayashi 						~0xf;
12713c60ba66SKatsushi Kobayashi 			}
12723c60ba66SKatsushi Kobayashi 		}
12733c60ba66SKatsushi Kobayashi 		db_tr = STAILQ_NEXT(db_tr, link);
12743c60ba66SKatsushi Kobayashi 	}
12753c60ba66SKatsushi Kobayashi 	dbch->bottom->db[db_tr->dbcnt - 1].db.desc.depend &= 0xfffffff0;
12763c60ba66SKatsushi Kobayashi 	return err;
12773c60ba66SKatsushi Kobayashi }
1278c572b810SHidetoshi Shimokawa 
1279c572b810SHidetoshi Shimokawa static int
1280c572b810SHidetoshi Shimokawa fwohci_rx_enable(struct fwohci_softc *sc, struct fwohci_dbch *dbch)
12813c60ba66SKatsushi Kobayashi {
12823c60ba66SKatsushi Kobayashi 	int err = 0;
12833c60ba66SKatsushi Kobayashi 	int idb, z, i, dmach = 0;
12843c60ba66SKatsushi Kobayashi 	u_int32_t off = NULL;
12853c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
12863c60ba66SKatsushi Kobayashi 
12873c60ba66SKatsushi Kobayashi 	z = dbch->ndesc;
12883c60ba66SKatsushi Kobayashi 	if(&sc->arrq == dbch){
12893c60ba66SKatsushi Kobayashi 		off = OHCI_ARQOFF;
12903c60ba66SKatsushi Kobayashi 	}else if(&sc->arrs == dbch){
12913c60ba66SKatsushi Kobayashi 		off = OHCI_ARSOFF;
12923c60ba66SKatsushi Kobayashi 	}else{
12933c60ba66SKatsushi Kobayashi 		for(dmach = 0 ; dmach < sc->fc.nisodma ; dmach++){
12943c60ba66SKatsushi Kobayashi 			if( &sc->ir[dmach] == dbch){
12953c60ba66SKatsushi Kobayashi 				off = OHCI_IROFF(dmach);
12963c60ba66SKatsushi Kobayashi 				break;
12973c60ba66SKatsushi Kobayashi 			}
12983c60ba66SKatsushi Kobayashi 		}
12993c60ba66SKatsushi Kobayashi 	}
13003c60ba66SKatsushi Kobayashi 	if(off == NULL){
13013c60ba66SKatsushi Kobayashi 		err = EINVAL;
13023c60ba66SKatsushi Kobayashi 		return err;
13033c60ba66SKatsushi Kobayashi 	}
13043c60ba66SKatsushi Kobayashi 	if(dbch->xferq.flag & FWXFERQ_STREAM){
13053c60ba66SKatsushi Kobayashi 		if(dbch->xferq.flag & FWXFERQ_RUNNING)
13063c60ba66SKatsushi Kobayashi 			return err;
13073c60ba66SKatsushi Kobayashi 	}else{
13083c60ba66SKatsushi Kobayashi 		if(dbch->xferq.flag & FWXFERQ_RUNNING){
13093c60ba66SKatsushi Kobayashi 			err = EBUSY;
13103c60ba66SKatsushi Kobayashi 			return err;
13113c60ba66SKatsushi Kobayashi 		}
13123c60ba66SKatsushi Kobayashi 	}
13133c60ba66SKatsushi Kobayashi 	dbch->xferq.flag |= FWXFERQ_RUNNING;
13143c60ba66SKatsushi Kobayashi 	for( i = 0, dbch->bottom = dbch->top; i < (dbch->ndb - 1); i++){
13153c60ba66SKatsushi Kobayashi 		dbch->bottom = STAILQ_NEXT(dbch->bottom, link);
13163c60ba66SKatsushi Kobayashi 	}
13173c60ba66SKatsushi Kobayashi 	db_tr = dbch->top;
13183c60ba66SKatsushi Kobayashi 	for( idb = 0 ; idb < dbch->ndb ; idb ++){
13193c60ba66SKatsushi Kobayashi 		if(!(dbch->xferq.flag & FWXFERQ_EXTBUF)){
13203c60ba66SKatsushi Kobayashi 			fwohci_add_rx_buf(db_tr,
13213c60ba66SKatsushi Kobayashi 				dbch->xferq.psize, dbch->xferq.flag, 0, NULL);
13223c60ba66SKatsushi Kobayashi 		}else{
13233c60ba66SKatsushi Kobayashi 			fwohci_add_rx_buf(db_tr,
13243c60ba66SKatsushi Kobayashi 				dbch->xferq.psize, dbch->xferq.flag,
13253c60ba66SKatsushi Kobayashi 				dbch->xferq.buf + dbch->xferq.psize * idb,
13263c60ba66SKatsushi Kobayashi 				dbch->dummy + sizeof(u_int32_t) * idb);
13273c60ba66SKatsushi Kobayashi 		}
13283c60ba66SKatsushi Kobayashi 		if(STAILQ_NEXT(db_tr, link) == NULL){
13293c60ba66SKatsushi Kobayashi 			break;
13303c60ba66SKatsushi Kobayashi 		}
13313c60ba66SKatsushi Kobayashi 		db_tr->db[db_tr->dbcnt - 1].db.desc.depend
13323c60ba66SKatsushi Kobayashi 			= vtophys(STAILQ_NEXT(db_tr, link)->db) | z;
13333c60ba66SKatsushi Kobayashi 		if(dbch->xferq.flag & FWXFERQ_EXTBUF){
13343c60ba66SKatsushi Kobayashi 			if(((idb + 1 ) % dbch->xferq.bnpacket) == 0){
13353c60ba66SKatsushi Kobayashi 				db_tr->db[db_tr->dbcnt - 1].db.desc.cmd
13363c60ba66SKatsushi Kobayashi 					|= OHCI_INTERRUPT_ALWAYS;
13373c60ba66SKatsushi Kobayashi 				db_tr->db[db_tr->dbcnt - 1].db.desc.depend &=
13383c60ba66SKatsushi Kobayashi 						~0xf;
13393c60ba66SKatsushi Kobayashi 			}
13403c60ba66SKatsushi Kobayashi 		}
13413c60ba66SKatsushi Kobayashi 		db_tr = STAILQ_NEXT(db_tr, link);
13423c60ba66SKatsushi Kobayashi 	}
13433c60ba66SKatsushi Kobayashi 	dbch->bottom->db[db_tr->dbcnt - 1].db.desc.depend &= 0xfffffff0;
13443c60ba66SKatsushi Kobayashi 	dbch->buf_offset = 0;
13453c60ba66SKatsushi Kobayashi 	if(dbch->xferq.flag & FWXFERQ_STREAM){
13463c60ba66SKatsushi Kobayashi 		return err;
13473c60ba66SKatsushi Kobayashi 	}else{
13483c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_DMACMD(off), vtophys(dbch->top->db) | z);
13493c60ba66SKatsushi Kobayashi 	}
13503c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_DMACTL(off), OHCI_CNTL_DMA_RUN);
13513c60ba66SKatsushi Kobayashi 	return err;
13523c60ba66SKatsushi Kobayashi }
1353c572b810SHidetoshi Shimokawa 
1354c572b810SHidetoshi Shimokawa static int
1355c572b810SHidetoshi Shimokawa fwohci_itxbuf_enable(struct firewire_comm *fc, int dmach)
13563c60ba66SKatsushi Kobayashi {
13573c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
13583c60ba66SKatsushi Kobayashi 	int err = 0;
13593c60ba66SKatsushi Kobayashi 	unsigned short tag, ich;
13603c60ba66SKatsushi Kobayashi 	struct fwohci_dbch *dbch;
13613c60ba66SKatsushi Kobayashi 	struct fw_pkt *fp;
13623c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
13633c60ba66SKatsushi Kobayashi 
13643c60ba66SKatsushi Kobayashi 	tag = (sc->it[dmach].xferq.flag >> 6) & 3;
13653c60ba66SKatsushi Kobayashi 	ich = sc->it[dmach].xferq.flag & 0x3f;
13663c60ba66SKatsushi Kobayashi 	dbch = &sc->it[dmach];
13673c60ba66SKatsushi Kobayashi 	if(dbch->ndb == 0){
13683c60ba66SKatsushi Kobayashi 		dbch->xferq.queued = 0;
13693c60ba66SKatsushi Kobayashi 		dbch->ndb = dbch->xferq.bnpacket * dbch->xferq.bnchunk;
13703c60ba66SKatsushi Kobayashi 		dbch->ndesc = 3;
13713c60ba66SKatsushi Kobayashi 		fwohci_db_init(dbch);
13723c60ba66SKatsushi Kobayashi 		err = fwohci_tx_enable(sc, dbch);
13733c60ba66SKatsushi Kobayashi 	}
13743c60ba66SKatsushi Kobayashi 	if(err)
13753c60ba66SKatsushi Kobayashi 		return err;
13763c60ba66SKatsushi Kobayashi 	if(OREAD(sc, OHCI_ITCTL(dmach)) & OHCI_CNTL_DMA_ACTIVE){
13773c60ba66SKatsushi Kobayashi 		if(dbch->xferq.stdma2 != NULL){
13783c60ba66SKatsushi Kobayashi 			fwohci_txbufdb(sc, dmach, dbch->xferq.stdma2);
13793c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)
13803c60ba66SKatsushi Kobayashi 		(dbch->xferq.stdma->end))->db[dbch->ndesc - 1].db.desc.cmd
13813c60ba66SKatsushi Kobayashi 			|= OHCI_BRANCH_ALWAYS;
13823c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)
13833c60ba66SKatsushi Kobayashi 		(dbch->xferq.stdma->end))->db[dbch->ndesc - 1].db.desc.depend =
13843c60ba66SKatsushi Kobayashi 	    vtophys(((struct fwohcidb_tr *)(dbch->xferq.stdma2->start))->db) | dbch->ndesc;
13853c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(dbch->xferq.stdma->end))->db[0].db.desc.depend =
13863c60ba66SKatsushi Kobayashi 	    vtophys(((struct fwohcidb_tr *)(dbch->xferq.stdma2->start))->db) | dbch->ndesc;
13873c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(dbch->xferq.stdma2->end))->db[dbch->ndesc - 1].db.desc.depend &= ~0xf;
13883c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(dbch->xferq.stdma2->end))->db[0].db.desc.depend &= ~0xf;
13893c60ba66SKatsushi Kobayashi 		}
13903c60ba66SKatsushi Kobayashi 	}else if(!(OREAD(sc, OHCI_ITCTL(dmach)) & OHCI_CNTL_DMA_ACTIVE)){
13913c60ba66SKatsushi Kobayashi 		fw_tbuf_update(&sc->fc, dmach, 0);
13923c60ba66SKatsushi Kobayashi 		if(dbch->xferq.stdma == NULL){
13933c60ba66SKatsushi Kobayashi 			return err;
13943c60ba66SKatsushi Kobayashi 		}
13953c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_ITCTLCLR(dmach), OHCI_CNTL_DMA_RUN);
13963c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IT_MASKCLR, 1 << dmach);
13973c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IT_STATCLR, 1 << dmach);
13983c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IT_MASK, 1 << dmach);
13993c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_ITCTLCLR(dmach), 0xf0000000);
14003c60ba66SKatsushi Kobayashi 		fwohci_txbufdb(sc, dmach, dbch->xferq.stdma);
14013c60ba66SKatsushi Kobayashi 		if(dbch->xferq.stdma2 != NULL){
14023c60ba66SKatsushi Kobayashi 			fwohci_txbufdb(sc, dmach, dbch->xferq.stdma2);
14033c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)
14043c60ba66SKatsushi Kobayashi 		(dbch->xferq.stdma->end))->db[dbch->ndesc - 1].db.desc.cmd
14053c60ba66SKatsushi Kobayashi 			|= OHCI_BRANCH_ALWAYS;
14063c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(dbch->xferq.stdma->end))->db[dbch->ndesc - 1].db.desc.depend =
14073c60ba66SKatsushi Kobayashi 		    vtophys(((struct fwohcidb_tr *)(dbch->xferq.stdma2->start))->db) | dbch->ndesc;
14083c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(dbch->xferq.stdma->end))->db[0].db.desc.depend =
14093c60ba66SKatsushi Kobayashi 		    vtophys(((struct fwohcidb_tr *)(dbch->xferq.stdma2->start))->db) | dbch->ndesc;
14103c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(dbch->xferq.stdma2->end))->db[dbch->ndesc - 1].db.desc.depend &= ~0xf;
14113c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *) (dbch->xferq.stdma2->end))->db[0].db.desc.depend &= ~0xf;
14123c60ba66SKatsushi Kobayashi 		}else{
14133c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *) (dbch->xferq.stdma->end))->db[dbch->ndesc - 1].db.desc.depend &= ~0xf;
14143c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *) (dbch->xferq.stdma->end))->db[0].db.desc.depend &= ~0xf;
14153c60ba66SKatsushi Kobayashi 		}
14163c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_ITCMD(dmach),
14173c60ba66SKatsushi Kobayashi 			vtophys(((struct fwohcidb_tr *)
14183c60ba66SKatsushi Kobayashi 				(dbch->xferq.stdma->start))->db) | dbch->ndesc);
14193c60ba66SKatsushi Kobayashi 		if(dbch->xferq.flag & FWXFERQ_DV){
14203c60ba66SKatsushi Kobayashi 			db_tr = (struct fwohcidb_tr *)dbch->xferq.stdma->start;
14213c60ba66SKatsushi Kobayashi 			fp = (struct fw_pkt *)db_tr->buf;
14223c60ba66SKatsushi Kobayashi 			fp->mode.ld[2] = htonl(0x80000000 +
14233c60ba66SKatsushi Kobayashi 				((fc->cyctimer(fc) + 0x3000) & 0xf000));
14243c60ba66SKatsushi Kobayashi 		}
14253c60ba66SKatsushi Kobayashi 
14263c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_ITCTL(dmach), OHCI_CNTL_DMA_RUN);
14273c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTMASK, OHCI_INT_DMA_IT);
14283c60ba66SKatsushi Kobayashi 	}
14293c60ba66SKatsushi Kobayashi 	return err;
14303c60ba66SKatsushi Kobayashi }
1431c572b810SHidetoshi Shimokawa 
1432c572b810SHidetoshi Shimokawa static int
1433c572b810SHidetoshi Shimokawa fwohci_irxbuf_enable(struct firewire_comm *fc, int dmach)
14343c60ba66SKatsushi Kobayashi {
14353c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
14363c60ba66SKatsushi Kobayashi 	int err = 0;
14373c60ba66SKatsushi Kobayashi 	unsigned short tag, ich;
14383c60ba66SKatsushi Kobayashi 	tag = (sc->ir[dmach].xferq.flag >> 6) & 3;
14393c60ba66SKatsushi Kobayashi 	ich = sc->ir[dmach].xferq.flag & 0x3f;
14403c60ba66SKatsushi Kobayashi 	OWRITE(sc, OHCI_IRMATCH(dmach), tagbit[tag] | ich);
14413c60ba66SKatsushi Kobayashi 
14423c60ba66SKatsushi Kobayashi 	if(!(sc->ir[dmach].xferq.flag & FWXFERQ_RUNNING)){
14433c60ba66SKatsushi Kobayashi 		sc->ir[dmach].xferq.queued = 0;
14443c60ba66SKatsushi Kobayashi 		sc->ir[dmach].ndb = sc->ir[dmach].xferq.bnpacket *
14453c60ba66SKatsushi Kobayashi 				sc->ir[dmach].xferq.bnchunk;
14463c60ba66SKatsushi Kobayashi 		sc->ir[dmach].dummy =
14473c60ba66SKatsushi Kobayashi 			malloc(sizeof(u_int32_t) * sc->ir[dmach].ndb,
14483c60ba66SKatsushi Kobayashi 			   M_DEVBUF, M_DONTWAIT);
14493c60ba66SKatsushi Kobayashi 		if(sc->ir[dmach].dummy == NULL){
14503c60ba66SKatsushi Kobayashi 			err = ENOMEM;
14513c60ba66SKatsushi Kobayashi 			return err;
14523c60ba66SKatsushi Kobayashi 		}
14533c60ba66SKatsushi Kobayashi 		sc->ir[dmach].ndesc = 2;
14543c60ba66SKatsushi Kobayashi 		fwohci_db_init(&sc->ir[dmach]);
14553c60ba66SKatsushi Kobayashi 		err = fwohci_rx_enable(sc, &sc->ir[dmach]);
14563c60ba66SKatsushi Kobayashi 	}
14573c60ba66SKatsushi Kobayashi 	if(err)
14583c60ba66SKatsushi Kobayashi 		return err;
14593c60ba66SKatsushi Kobayashi 
14603c60ba66SKatsushi Kobayashi 	if(OREAD(sc, OHCI_IRCTL(dmach)) & OHCI_CNTL_DMA_ACTIVE){
14613c60ba66SKatsushi Kobayashi 		if(sc->ir[dmach].xferq.stdma2 != NULL){
14623c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->end))->db[sc->ir[dmach].ndesc - 1].db.desc.depend =
14633c60ba66SKatsushi Kobayashi 	    vtophys(((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->start))->db) | sc->ir[dmach].ndesc;
14643c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->end))->db[0].db.desc.depend =
14653c60ba66SKatsushi Kobayashi 	    vtophys(((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->start))->db);
14663c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->end))->db[sc->ir[dmach].ndesc - 1].db.desc.depend &= ~0xf;
14673c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->end))->db[0].db.desc.depend &= ~0xf;
14683c60ba66SKatsushi Kobayashi 		}
14693c60ba66SKatsushi Kobayashi 	}else if(!(OREAD(sc, OHCI_IRCTL(dmach)) & OHCI_CNTL_DMA_ACTIVE)
14703c60ba66SKatsushi Kobayashi 		&& !(sc->ir[dmach].xferq.flag & FWXFERQ_PACKET)){
14713c60ba66SKatsushi Kobayashi 		fw_rbuf_update(&sc->fc, dmach, 0);
14723c60ba66SKatsushi Kobayashi 
14733c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTLCLR(dmach), OHCI_CNTL_DMA_RUN);
14743c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_MASKCLR, 1 << dmach);
14753c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_STATCLR, 1 << dmach);
14763c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_MASK, 1 << dmach);
14773c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTLCLR(dmach), 0xf0000000);
14783c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTL(dmach), OHCI_CNTL_ISOHDR);
14793c60ba66SKatsushi Kobayashi 		if(sc->ir[dmach].xferq.stdma2 != NULL){
14803c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->end))->db[sc->ir[dmach].ndesc - 1].db.desc.depend =
14813c60ba66SKatsushi Kobayashi 		    vtophys(((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->start))->db) | sc->ir[dmach].ndesc;
14823c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->end))->db[0].db.desc.depend =
14833c60ba66SKatsushi Kobayashi 		    vtophys(((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->start))->db);
14843c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma2->end))->db[sc->ir[dmach].ndesc - 1].db.desc.depend &= ~0xf;
14853c60ba66SKatsushi Kobayashi 		}else{
14863c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->end))->db[sc->ir[dmach].ndesc - 1].db.desc.depend &= ~0xf;
14873c60ba66SKatsushi Kobayashi 			((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->end))->db[0].db.desc.depend &= ~0xf;
14883c60ba66SKatsushi Kobayashi 		}
14893c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCMD(dmach),
14903c60ba66SKatsushi Kobayashi 			vtophys(((struct fwohcidb_tr *)(sc->ir[dmach].xferq.stdma->start))->db) | sc->ir[dmach].ndesc);
14913c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IRCTL(dmach), OHCI_CNTL_DMA_RUN);
14923c60ba66SKatsushi Kobayashi 	}
14933c60ba66SKatsushi Kobayashi 	OWRITE(sc, FWOHCI_INTMASK, OHCI_INT_DMA_IR);
14943c60ba66SKatsushi Kobayashi 	return err;
14953c60ba66SKatsushi Kobayashi }
1496c572b810SHidetoshi Shimokawa 
1497c572b810SHidetoshi Shimokawa static int
1498c572b810SHidetoshi Shimokawa fwohci_irx_enable(struct firewire_comm *fc, int dmach)
14993c60ba66SKatsushi Kobayashi {
15003c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)fc;
15013c60ba66SKatsushi Kobayashi 	int err = 0;
15023c60ba66SKatsushi Kobayashi 
15033c60ba66SKatsushi Kobayashi 	if(sc->ir[dmach].xferq.flag & FWXFERQ_PACKET){
15043c60ba66SKatsushi Kobayashi 		err = fwohci_irxpp_enable(fc, dmach);
15053c60ba66SKatsushi Kobayashi 		return err;
15063c60ba66SKatsushi Kobayashi 	}else{
15073c60ba66SKatsushi Kobayashi 		err = fwohci_irxbuf_enable(fc, dmach);
15083c60ba66SKatsushi Kobayashi 		return err;
15093c60ba66SKatsushi Kobayashi 	}
15103c60ba66SKatsushi Kobayashi }
1511c572b810SHidetoshi Shimokawa 
1512c572b810SHidetoshi Shimokawa int
1513c572b810SHidetoshi Shimokawa fwohci_shutdown(device_t dev)
15143c60ba66SKatsushi Kobayashi {
15153c60ba66SKatsushi Kobayashi 	u_int i;
15163c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = device_get_softc(dev);
15173c60ba66SKatsushi Kobayashi 
15183c60ba66SKatsushi Kobayashi /* Now stopping all DMA channel */
15193c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ARQCTLCLR, OHCI_CNTL_DMA_RUN);
15203c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ARSCTLCLR, OHCI_CNTL_DMA_RUN);
15213c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ATQCTLCLR, OHCI_CNTL_DMA_RUN);
15223c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_ATSCTLCLR, OHCI_CNTL_DMA_RUN);
15233c60ba66SKatsushi Kobayashi 
15243c60ba66SKatsushi Kobayashi 	for( i = 0 ; i < sc->fc.nisodma ; i ++ ){
15253c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_IRCTLCLR(i), OHCI_CNTL_DMA_RUN);
15263c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_ITCTLCLR(i), OHCI_CNTL_DMA_RUN);
15273c60ba66SKatsushi Kobayashi 	}
15283c60ba66SKatsushi Kobayashi 
15293c60ba66SKatsushi Kobayashi /* FLUSH FIFO and reset Transmitter/Reciever */
15303c60ba66SKatsushi Kobayashi 	OWRITE(sc,  OHCI_HCCCTL, OHCI_HCC_RESET);
15313c60ba66SKatsushi Kobayashi 
15323c60ba66SKatsushi Kobayashi /* Stop interrupt */
15333c60ba66SKatsushi Kobayashi 	OWRITE(sc, FWOHCI_INTMASKCLR,
15343c60ba66SKatsushi Kobayashi 			OHCI_INT_EN | OHCI_INT_ERR | OHCI_INT_PHY_SID
15353c60ba66SKatsushi Kobayashi 			| OHCI_INT_PHY_INT
15363c60ba66SKatsushi Kobayashi 			| OHCI_INT_DMA_ATRQ | OHCI_INT_DMA_ATRS
15373c60ba66SKatsushi Kobayashi 			| OHCI_INT_DMA_PRRQ | OHCI_INT_DMA_PRRS
15383c60ba66SKatsushi Kobayashi 			| OHCI_INT_DMA_ARRQ | OHCI_INT_DMA_ARRS
15393c60ba66SKatsushi Kobayashi 			| OHCI_INT_PHY_BUS_R);
15403c60ba66SKatsushi Kobayashi 	return 0;
15413c60ba66SKatsushi Kobayashi }
15423c60ba66SKatsushi Kobayashi 
15433c60ba66SKatsushi Kobayashi #define ACK_ALL
15443c60ba66SKatsushi Kobayashi static void
1545783058faSHidetoshi Shimokawa fwohci_intr_body(struct fwohci_softc *sc, u_int32_t stat, int count)
15463c60ba66SKatsushi Kobayashi {
15473c60ba66SKatsushi Kobayashi 	u_int32_t irstat, itstat;
15483c60ba66SKatsushi Kobayashi 	u_int i;
15493c60ba66SKatsushi Kobayashi 	struct firewire_comm *fc = (struct firewire_comm *)sc;
15503c60ba66SKatsushi Kobayashi 
15513c60ba66SKatsushi Kobayashi #ifdef OHCI_DEBUG
15523c60ba66SKatsushi Kobayashi 	if(stat & OREAD(sc, FWOHCI_INTMASK))
15533c60ba66SKatsushi Kobayashi 		device_printf(fc->dev, "INTERRUPT < %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s> 0x%08x, 0x%08x\n",
15543c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_EN ? "DMA_EN ":"",
15553c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_PHY_REG ? "PHY_REG ":"",
15563c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_CYC_LONG ? "CYC_LONG ":"",
15573c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_ERR ? "INT_ERR ":"",
15583c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_CYC_ERR ? "CYC_ERR ":"",
15593c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_CYC_LOST ? "CYC_LOST ":"",
15603c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_CYC_64SECOND ? "CYC_64SECOND ":"",
15613c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_CYC_START ? "CYC_START ":"",
15623c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_PHY_INT ? "PHY_INT ":"",
15633c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_PHY_BUS_R ? "BUS_RESET ":"",
15643c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_PHY_SID ? "SID ":"",
15653c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_LR_ERR ? "DMA_LR_ERR ":"",
15663c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_PW_ERR ? "DMA_PW_ERR ":"",
15673c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_IR ? "DMA_IR ":"",
15683c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_IT  ? "DMA_IT " :"",
15693c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_PRRS  ? "DMA_PRRS " :"",
15703c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_PRRQ  ? "DMA_PRRQ " :"",
15713c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_ARRS  ? "DMA_ARRS " :"",
15723c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_ARRQ  ? "DMA_ARRQ " :"",
15733c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_ATRS  ? "DMA_ATRS " :"",
15743c60ba66SKatsushi Kobayashi 			stat & OHCI_INT_DMA_ATRQ  ? "DMA_ATRQ " :"",
15753c60ba66SKatsushi Kobayashi 			stat, OREAD(sc, FWOHCI_INTMASK)
15763c60ba66SKatsushi Kobayashi 		);
15773c60ba66SKatsushi Kobayashi #endif
15783c60ba66SKatsushi Kobayashi /* Bus reset */
15793c60ba66SKatsushi Kobayashi 	if(stat & OHCI_INT_PHY_BUS_R ){
15803c60ba66SKatsushi Kobayashi 		device_printf(fc->dev, "BUS reset\n");
15813c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTMASKCLR,  OHCI_INT_CYC_LOST);
15823c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_LNKCTLCLR, OHCI_CNTL_CYCSRC);
15833c60ba66SKatsushi Kobayashi 
15843c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_ATQCTLCLR, OHCI_CNTL_DMA_RUN);
15853c60ba66SKatsushi Kobayashi 		sc->atrq.xferq.flag &= ~FWXFERQ_RUNNING;
15863c60ba66SKatsushi Kobayashi 		OWRITE(sc,  OHCI_ATSCTLCLR, OHCI_CNTL_DMA_RUN);
15873c60ba66SKatsushi Kobayashi 		sc->atrs.xferq.flag &= ~FWXFERQ_RUNNING;
15883c60ba66SKatsushi Kobayashi 
15893c60ba66SKatsushi Kobayashi #if 0
15903c60ba66SKatsushi Kobayashi 		for( i = 0 ; i < fc->nisodma ; i ++ ){
15913c60ba66SKatsushi Kobayashi 			OWRITE(sc,  OHCI_IRCTLCLR(i), OHCI_CNTL_DMA_RUN);
15923c60ba66SKatsushi Kobayashi 			OWRITE(sc,  OHCI_ITCTLCLR(i), OHCI_CNTL_DMA_RUN);
15933c60ba66SKatsushi Kobayashi 		}
15943c60ba66SKatsushi Kobayashi 
15953c60ba66SKatsushi Kobayashi #endif
15963c60ba66SKatsushi Kobayashi 		fw_busreset(fc);
15973c60ba66SKatsushi Kobayashi 
15983c60ba66SKatsushi Kobayashi 		/* XXX need to wait DMA to stop */
15993c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
16003c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_PHY_BUS_R);
16013c60ba66SKatsushi Kobayashi #endif
16023c60ba66SKatsushi Kobayashi #if 1
16033c60ba66SKatsushi Kobayashi 		/* pending all pre-bus_reset packets */
16043c60ba66SKatsushi Kobayashi 		fwohci_txd(sc, &sc->atrq);
16053c60ba66SKatsushi Kobayashi 		fwohci_txd(sc, &sc->atrs);
1606783058faSHidetoshi Shimokawa 		fwohci_arcv(sc, &sc->arrs, -1);
1607783058faSHidetoshi Shimokawa 		fwohci_arcv(sc, &sc->arrq, -1);
16083c60ba66SKatsushi Kobayashi #endif
16093c60ba66SKatsushi Kobayashi 
16103c60ba66SKatsushi Kobayashi 
16113c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_AREQHI, 1 << 31);
16123c60ba66SKatsushi Kobayashi 		/* XXX insecure ?? */
16133c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_PREQHI, 0x7fffffff);
16143c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_PREQLO, 0xffffffff);
16153c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_PREQUPPER, 0x10000);
16163c60ba66SKatsushi Kobayashi 
16173c60ba66SKatsushi Kobayashi 	}
16183c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_DMA_IR )){
16193c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
16203c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_DMA_IR);
16213c60ba66SKatsushi Kobayashi #endif
16223c60ba66SKatsushi Kobayashi 		irstat = OREAD(sc, OHCI_IR_STAT);
16233c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IR_STATCLR, ~0);
16243c60ba66SKatsushi Kobayashi 		for(i = 0; i < fc->nisodma ; i++){
16253c60ba66SKatsushi Kobayashi 			if((irstat & (1 << i)) != 0){
16263c60ba66SKatsushi Kobayashi 				if(sc->ir[i].xferq.flag & FWXFERQ_PACKET){
1627783058faSHidetoshi Shimokawa 					fwohci_ircv(sc, &sc->ir[i], count);
16283c60ba66SKatsushi Kobayashi 				}else{
16293c60ba66SKatsushi Kobayashi 					fwohci_rbuf_update(sc, i);
16303c60ba66SKatsushi Kobayashi 				}
16313c60ba66SKatsushi Kobayashi 			}
16323c60ba66SKatsushi Kobayashi 		}
16333c60ba66SKatsushi Kobayashi 	}
16343c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_DMA_IT )){
16353c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
16363c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_DMA_IT);
16373c60ba66SKatsushi Kobayashi #endif
16383c60ba66SKatsushi Kobayashi 		itstat = OREAD(sc, OHCI_IT_STAT);
16393c60ba66SKatsushi Kobayashi 		OWRITE(sc, OHCI_IT_STATCLR, ~0);
16403c60ba66SKatsushi Kobayashi 		for(i = 0; i < fc->nisodma ; i++){
16413c60ba66SKatsushi Kobayashi 			if((itstat & (1 << i)) != 0){
16423c60ba66SKatsushi Kobayashi 				fwohci_tbuf_update(sc, i);
16433c60ba66SKatsushi Kobayashi 			}
16443c60ba66SKatsushi Kobayashi 		}
16453c60ba66SKatsushi Kobayashi 	}
16463c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_DMA_PRRS )){
16473c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
16483c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_DMA_PRRS);
16493c60ba66SKatsushi Kobayashi #endif
16503c60ba66SKatsushi Kobayashi #if 0
16513c60ba66SKatsushi Kobayashi 		dump_dma(sc, ARRS_CH);
16523c60ba66SKatsushi Kobayashi 		dump_db(sc, ARRS_CH);
16533c60ba66SKatsushi Kobayashi #endif
1654783058faSHidetoshi Shimokawa 		fwohci_arcv(sc, &sc->arrs, count);
16553c60ba66SKatsushi Kobayashi 	}
16563c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_DMA_PRRQ )){
16573c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
16583c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_DMA_PRRQ);
16593c60ba66SKatsushi Kobayashi #endif
16603c60ba66SKatsushi Kobayashi #if 0
16613c60ba66SKatsushi Kobayashi 		dump_dma(sc, ARRQ_CH);
16623c60ba66SKatsushi Kobayashi 		dump_db(sc, ARRQ_CH);
16633c60ba66SKatsushi Kobayashi #endif
1664783058faSHidetoshi Shimokawa 		fwohci_arcv(sc, &sc->arrq, count);
16653c60ba66SKatsushi Kobayashi 	}
16663c60ba66SKatsushi Kobayashi 	if(stat & OHCI_INT_PHY_SID){
16673c60ba66SKatsushi Kobayashi 		caddr_t buf;
16683c60ba66SKatsushi Kobayashi 		int plen;
16693c60ba66SKatsushi Kobayashi 
16703c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
16713c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_PHY_SID);
16723c60ba66SKatsushi Kobayashi #endif
16733c60ba66SKatsushi Kobayashi /*
16743c60ba66SKatsushi Kobayashi ** Checking whether the node is root or not. If root, turn on
16753c60ba66SKatsushi Kobayashi ** cycle master.
16763c60ba66SKatsushi Kobayashi */
16773c60ba66SKatsushi Kobayashi 		device_printf(fc->dev, "node_id = 0x%08x, ", OREAD(sc, FWOHCI_NODEID));
16783c60ba66SKatsushi Kobayashi 		if(!(OREAD(sc, FWOHCI_NODEID) & OHCI_NODE_VALID)){
16793c60ba66SKatsushi Kobayashi 			printf("Bus reset failure\n");
16803c60ba66SKatsushi Kobayashi 			goto sidout;
16813c60ba66SKatsushi Kobayashi 		}
16823c60ba66SKatsushi Kobayashi 		if( OREAD(sc, FWOHCI_NODEID) & OHCI_NODE_ROOT ){
16833c60ba66SKatsushi Kobayashi 			printf("CYCLEMASTER mode\n");
16843c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_LNKCTL,
16853c60ba66SKatsushi Kobayashi 				OHCI_CNTL_CYCMTR | OHCI_CNTL_CYCTIMER);
16863c60ba66SKatsushi Kobayashi 		}else{
16873c60ba66SKatsushi Kobayashi 			printf("non CYCLEMASTER mode\n");
16883c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_LNKCTLCLR, OHCI_CNTL_CYCMTR);
16893c60ba66SKatsushi Kobayashi 			OWRITE(sc, OHCI_LNKCTL, OHCI_CNTL_CYCTIMER);
16903c60ba66SKatsushi Kobayashi 		}
16913c60ba66SKatsushi Kobayashi 		fc->nodeid = OREAD(sc, FWOHCI_NODEID) & 0x3f;
16923c60ba66SKatsushi Kobayashi 
16933c60ba66SKatsushi Kobayashi 		plen = OREAD(sc, OHCI_SID_CNT) & OHCI_SID_CNT_MASK;
16943c60ba66SKatsushi Kobayashi 		plen -= 4; /* chop control info */
16953c60ba66SKatsushi Kobayashi 		buf = malloc( FWPMAX_S400, M_DEVBUF, M_NOWAIT);
16963c60ba66SKatsushi Kobayashi 		if(buf == NULL) goto sidout;
16973c60ba66SKatsushi Kobayashi 		bcopy((void *)(uintptr_t)(volatile void *)fc->sid_buf,
16983c60ba66SKatsushi Kobayashi 								buf, plen);
16993c60ba66SKatsushi Kobayashi 		fw_sidrcv(fc, buf, plen, 0);
17003c60ba66SKatsushi Kobayashi 	}
17013c60ba66SKatsushi Kobayashi sidout:
17023c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_DMA_ATRQ )){
17033c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
17043c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_DMA_ATRQ);
17053c60ba66SKatsushi Kobayashi #endif
17063c60ba66SKatsushi Kobayashi 		fwohci_txd(sc, &(sc->atrq));
17073c60ba66SKatsushi Kobayashi 	}
17083c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_DMA_ATRS )){
17093c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
17103c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_DMA_ATRS);
17113c60ba66SKatsushi Kobayashi #endif
17123c60ba66SKatsushi Kobayashi 		fwohci_txd(sc, &(sc->atrs));
17133c60ba66SKatsushi Kobayashi 	}
17143c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_PW_ERR )){
17153c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
17163c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_PW_ERR);
17173c60ba66SKatsushi Kobayashi #endif
17183c60ba66SKatsushi Kobayashi 		device_printf(fc->dev, "posted write error\n");
17193c60ba66SKatsushi Kobayashi 	}
17203c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_ERR )){
17213c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
17223c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_ERR);
17233c60ba66SKatsushi Kobayashi #endif
17243c60ba66SKatsushi Kobayashi 		device_printf(fc->dev, "unrecoverable error\n");
17253c60ba66SKatsushi Kobayashi 	}
17263c60ba66SKatsushi Kobayashi 	if((stat & OHCI_INT_PHY_INT)) {
17273c60ba66SKatsushi Kobayashi #ifndef ACK_ALL
17283c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, OHCI_INT_PHY_INT);
17293c60ba66SKatsushi Kobayashi #endif
17303c60ba66SKatsushi Kobayashi 		device_printf(fc->dev, "phy int\n");
17313c60ba66SKatsushi Kobayashi 	}
17323c60ba66SKatsushi Kobayashi 
17333c60ba66SKatsushi Kobayashi 	return;
17343c60ba66SKatsushi Kobayashi }
17353c60ba66SKatsushi Kobayashi 
17363c60ba66SKatsushi Kobayashi void
17373c60ba66SKatsushi Kobayashi fwohci_intr(void *arg)
17383c60ba66SKatsushi Kobayashi {
17393c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc = (struct fwohci_softc *)arg;
17403c60ba66SKatsushi Kobayashi 	u_int32_t stat;
17413c60ba66SKatsushi Kobayashi 
17423c60ba66SKatsushi Kobayashi 	if (!(sc->intmask & OHCI_INT_EN)) {
17433c60ba66SKatsushi Kobayashi 		/* polling mode */
17443c60ba66SKatsushi Kobayashi 		return;
17453c60ba66SKatsushi Kobayashi 	}
17463c60ba66SKatsushi Kobayashi 
17473c60ba66SKatsushi Kobayashi 	while ((stat = OREAD(sc, FWOHCI_INTSTAT)) != 0) {
17483c60ba66SKatsushi Kobayashi 		if (stat == 0xffffffff) {
17493c60ba66SKatsushi Kobayashi 			device_printf(sc->fc.dev,
17503c60ba66SKatsushi Kobayashi 				"device physically ejected?\n");
17513c60ba66SKatsushi Kobayashi 			return;
17523c60ba66SKatsushi Kobayashi 		}
17533c60ba66SKatsushi Kobayashi #ifdef ACK_ALL
17543c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, stat);
17553c60ba66SKatsushi Kobayashi #endif
1756783058faSHidetoshi Shimokawa 		fwohci_intr_body(sc, stat, -1);
17573c60ba66SKatsushi Kobayashi 	}
17583c60ba66SKatsushi Kobayashi }
17593c60ba66SKatsushi Kobayashi 
17603c60ba66SKatsushi Kobayashi static void
17613c60ba66SKatsushi Kobayashi fwohci_poll(struct firewire_comm *fc, int quick, int count)
17623c60ba66SKatsushi Kobayashi {
17633c60ba66SKatsushi Kobayashi 	int s;
17643c60ba66SKatsushi Kobayashi 	u_int32_t stat;
17653c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc;
17663c60ba66SKatsushi Kobayashi 
17673c60ba66SKatsushi Kobayashi 
17683c60ba66SKatsushi Kobayashi 	sc = (struct fwohci_softc *)fc;
17693c60ba66SKatsushi Kobayashi 	stat = OHCI_INT_DMA_IR | OHCI_INT_DMA_IT |
17703c60ba66SKatsushi Kobayashi 		OHCI_INT_DMA_PRRS | OHCI_INT_DMA_PRRQ |
17713c60ba66SKatsushi Kobayashi 		OHCI_INT_DMA_ATRQ | OHCI_INT_DMA_ATRS;
17723c60ba66SKatsushi Kobayashi #if 0
17733c60ba66SKatsushi Kobayashi 	if (!quick) {
17743c60ba66SKatsushi Kobayashi #else
17753c60ba66SKatsushi Kobayashi 	if (1) {
17763c60ba66SKatsushi Kobayashi #endif
17773c60ba66SKatsushi Kobayashi 		stat = OREAD(sc, FWOHCI_INTSTAT);
17783c60ba66SKatsushi Kobayashi 		if (stat == 0)
17793c60ba66SKatsushi Kobayashi 			return;
17803c60ba66SKatsushi Kobayashi 		if (stat == 0xffffffff) {
17813c60ba66SKatsushi Kobayashi 			device_printf(sc->fc.dev,
17823c60ba66SKatsushi Kobayashi 				"device physically ejected?\n");
17833c60ba66SKatsushi Kobayashi 			return;
17843c60ba66SKatsushi Kobayashi 		}
17853c60ba66SKatsushi Kobayashi #ifdef ACK_ALL
17863c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTSTATCLR, stat);
17873c60ba66SKatsushi Kobayashi #endif
17883c60ba66SKatsushi Kobayashi 	}
17893c60ba66SKatsushi Kobayashi 	s = splfw();
1790783058faSHidetoshi Shimokawa 	fwohci_intr_body(sc, stat, count);
17913c60ba66SKatsushi Kobayashi 	splx(s);
17923c60ba66SKatsushi Kobayashi }
17933c60ba66SKatsushi Kobayashi 
17943c60ba66SKatsushi Kobayashi static void
17953c60ba66SKatsushi Kobayashi fwohci_set_intr(struct firewire_comm *fc, int enable)
17963c60ba66SKatsushi Kobayashi {
17973c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc;
17983c60ba66SKatsushi Kobayashi 
17993c60ba66SKatsushi Kobayashi 	sc = (struct fwohci_softc *)fc;
180017c3d42cSHidetoshi Shimokawa 	if (bootverbose)
180117c3d42cSHidetoshi Shimokawa 		device_printf(sc->fc.dev, "fwochi_set_intr: %d\n", enable);
18023c60ba66SKatsushi Kobayashi 	if (enable) {
18033c60ba66SKatsushi Kobayashi 		sc->intmask |= OHCI_INT_EN;
18043c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTMASK, OHCI_INT_EN);
18053c60ba66SKatsushi Kobayashi 	} else {
18063c60ba66SKatsushi Kobayashi 		sc->intmask &= ~OHCI_INT_EN;
18073c60ba66SKatsushi Kobayashi 		OWRITE(sc, FWOHCI_INTMASKCLR, OHCI_INT_EN);
18083c60ba66SKatsushi Kobayashi 	}
18093c60ba66SKatsushi Kobayashi }
18103c60ba66SKatsushi Kobayashi 
1811c572b810SHidetoshi Shimokawa static void
1812c572b810SHidetoshi Shimokawa fwohci_tbuf_update(struct fwohci_softc *sc, int dmach)
18133c60ba66SKatsushi Kobayashi {
18143c60ba66SKatsushi Kobayashi 	int stat;
18153c60ba66SKatsushi Kobayashi 	struct firewire_comm *fc = &sc->fc;
18163c60ba66SKatsushi Kobayashi 	struct fw_pkt *fp;
18173c60ba66SKatsushi Kobayashi 	struct fwohci_dbch *dbch;
18183c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
18193c60ba66SKatsushi Kobayashi 
18203c60ba66SKatsushi Kobayashi 	dbch = &sc->it[dmach];
18213c60ba66SKatsushi Kobayashi 	if((dbch->xferq.flag & FWXFERQ_DV) && (dbch->xferq.stdma2 != NULL)){
18223c60ba66SKatsushi Kobayashi 		db_tr = (struct fwohcidb_tr *)dbch->xferq.stdma2->start;
18233c60ba66SKatsushi Kobayashi /*
18243c60ba66SKatsushi Kobayashi  * Overwrite highest significant 4 bits timestamp information
18253c60ba66SKatsushi Kobayashi  */
18263c60ba66SKatsushi Kobayashi 		fp = (struct fw_pkt *)db_tr->buf;
18273c60ba66SKatsushi Kobayashi 		fp->mode.ld[2] |= htonl(0x80000000 |
18283c60ba66SKatsushi Kobayashi 				((fc->cyctimer(fc) + 0x4000) & 0xf000));
18293c60ba66SKatsushi Kobayashi 	}
18303c60ba66SKatsushi Kobayashi 	stat = OREAD(sc, OHCI_ITCTL(dmach)) & 0x1f;
18313c60ba66SKatsushi Kobayashi 	switch(stat){
18323c60ba66SKatsushi Kobayashi 	case FWOHCIEV_ACKCOMPL:
18333c60ba66SKatsushi Kobayashi 		fw_tbuf_update(fc, dmach, 1);
18343c60ba66SKatsushi Kobayashi 		break;
18353c60ba66SKatsushi Kobayashi 	default:
18363c60ba66SKatsushi Kobayashi 		fw_tbuf_update(fc, dmach, 0);
18373c60ba66SKatsushi Kobayashi 		break;
18383c60ba66SKatsushi Kobayashi 	}
18393c60ba66SKatsushi Kobayashi 	fwohci_itxbuf_enable(&sc->fc, dmach);
18403c60ba66SKatsushi Kobayashi }
1841c572b810SHidetoshi Shimokawa 
1842c572b810SHidetoshi Shimokawa static void
1843c572b810SHidetoshi Shimokawa fwohci_rbuf_update(struct fwohci_softc *sc, int dmach)
18443c60ba66SKatsushi Kobayashi {
18453c60ba66SKatsushi Kobayashi 	int stat;
18463c60ba66SKatsushi Kobayashi 	stat = OREAD(sc, OHCI_IRCTL(dmach)) & 0x1f;
18473c60ba66SKatsushi Kobayashi 	switch(stat){
18483c60ba66SKatsushi Kobayashi 	case FWOHCIEV_ACKCOMPL:
18493c60ba66SKatsushi Kobayashi 		fw_rbuf_update(&sc->fc, dmach, 1);
18503c60ba66SKatsushi Kobayashi 		wakeup(sc->fc.ir[dmach]);
18513c60ba66SKatsushi Kobayashi 		fwohci_irx_enable(&sc->fc, dmach);
18523c60ba66SKatsushi Kobayashi 		break;
18533c60ba66SKatsushi Kobayashi 	default:
18543c60ba66SKatsushi Kobayashi 		break;
18553c60ba66SKatsushi Kobayashi 	}
18563c60ba66SKatsushi Kobayashi }
1857c572b810SHidetoshi Shimokawa 
1858c572b810SHidetoshi Shimokawa void
1859c572b810SHidetoshi Shimokawa dump_dma(struct fwohci_softc *sc, u_int32_t ch)
1860c572b810SHidetoshi Shimokawa {
18613c60ba66SKatsushi Kobayashi 	u_int32_t off, cntl, stat, cmd, match;
18623c60ba66SKatsushi Kobayashi 
18633c60ba66SKatsushi Kobayashi 	if(ch == 0){
18643c60ba66SKatsushi Kobayashi 		off = OHCI_ATQOFF;
18653c60ba66SKatsushi Kobayashi 	}else if(ch == 1){
18663c60ba66SKatsushi Kobayashi 		off = OHCI_ATSOFF;
18673c60ba66SKatsushi Kobayashi 	}else if(ch == 2){
18683c60ba66SKatsushi Kobayashi 		off = OHCI_ARQOFF;
18693c60ba66SKatsushi Kobayashi 	}else if(ch == 3){
18703c60ba66SKatsushi Kobayashi 		off = OHCI_ARSOFF;
18713c60ba66SKatsushi Kobayashi 	}else if(ch < IRX_CH){
18723c60ba66SKatsushi Kobayashi 		off = OHCI_ITCTL(ch - ITX_CH);
18733c60ba66SKatsushi Kobayashi 	}else{
18743c60ba66SKatsushi Kobayashi 		off = OHCI_IRCTL(ch - IRX_CH);
18753c60ba66SKatsushi Kobayashi 	}
18763c60ba66SKatsushi Kobayashi 	cntl = stat = OREAD(sc, off);
18773c60ba66SKatsushi Kobayashi 	cmd = OREAD(sc, off + 0xc);
18783c60ba66SKatsushi Kobayashi 	match = OREAD(sc, off + 0x10);
18793c60ba66SKatsushi Kobayashi 
18803c60ba66SKatsushi Kobayashi 	device_printf(sc->fc.dev, "dma ch %1x:dma regs 0x%08x 0x%08x 0x%08x 0x%08x \n",
18813c60ba66SKatsushi Kobayashi 		ch,
18823c60ba66SKatsushi Kobayashi 		cntl,
18833c60ba66SKatsushi Kobayashi 		stat,
18843c60ba66SKatsushi Kobayashi 		cmd,
18853c60ba66SKatsushi Kobayashi 		match);
18863c60ba66SKatsushi Kobayashi 	stat &= 0xffff ;
18873c60ba66SKatsushi Kobayashi 	if(stat & 0xff00){
18883c60ba66SKatsushi Kobayashi 		device_printf(sc->fc.dev, "dma %d ch:%s%s%s%s%s%s %s(%x)\n",
18893c60ba66SKatsushi Kobayashi 			ch,
18903c60ba66SKatsushi Kobayashi 			stat & OHCI_CNTL_DMA_RUN ? "RUN," : "",
18913c60ba66SKatsushi Kobayashi 			stat & OHCI_CNTL_DMA_WAKE ? "WAKE," : "",
18923c60ba66SKatsushi Kobayashi 			stat & OHCI_CNTL_DMA_DEAD ? "DEAD," : "",
18933c60ba66SKatsushi Kobayashi 			stat & OHCI_CNTL_DMA_ACTIVE ? "ACTIVE," : "",
18943c60ba66SKatsushi Kobayashi 			stat & OHCI_CNTL_DMA_BT ? "BRANCH," : "",
18953c60ba66SKatsushi Kobayashi 			stat & OHCI_CNTL_DMA_BAD ? "BADDMA," : "",
18963c60ba66SKatsushi Kobayashi 			fwohcicode[stat & 0x1f],
18973c60ba66SKatsushi Kobayashi 			stat & 0x1f
18983c60ba66SKatsushi Kobayashi 		);
18993c60ba66SKatsushi Kobayashi 	}else{
19003c60ba66SKatsushi Kobayashi 		device_printf(sc->fc.dev, "dma %d ch: Nostat\n", ch);
19013c60ba66SKatsushi Kobayashi 	}
19023c60ba66SKatsushi Kobayashi }
1903c572b810SHidetoshi Shimokawa 
1904c572b810SHidetoshi Shimokawa void
1905c572b810SHidetoshi Shimokawa dump_db(struct fwohci_softc *sc, u_int32_t ch)
1906c572b810SHidetoshi Shimokawa {
19073c60ba66SKatsushi Kobayashi 	struct fwohci_dbch *dbch;
19083c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *cp = NULL, *pp, *np;
19093c60ba66SKatsushi Kobayashi 	volatile struct fwohcidb *curr = NULL, *prev, *next = NULL;
19103c60ba66SKatsushi Kobayashi 	int idb, jdb;
19113c60ba66SKatsushi Kobayashi 	u_int32_t cmd, off;
19123c60ba66SKatsushi Kobayashi 	if(ch == 0){
19133c60ba66SKatsushi Kobayashi 		off = OHCI_ATQOFF;
19143c60ba66SKatsushi Kobayashi 		dbch = &sc->atrq;
19153c60ba66SKatsushi Kobayashi 	}else if(ch == 1){
19163c60ba66SKatsushi Kobayashi 		off = OHCI_ATSOFF;
19173c60ba66SKatsushi Kobayashi 		dbch = &sc->atrs;
19183c60ba66SKatsushi Kobayashi 	}else if(ch == 2){
19193c60ba66SKatsushi Kobayashi 		off = OHCI_ARQOFF;
19203c60ba66SKatsushi Kobayashi 		dbch = &sc->arrq;
19213c60ba66SKatsushi Kobayashi 	}else if(ch == 3){
19223c60ba66SKatsushi Kobayashi 		off = OHCI_ARSOFF;
19233c60ba66SKatsushi Kobayashi 		dbch = &sc->arrs;
19243c60ba66SKatsushi Kobayashi 	}else if(ch < IRX_CH){
19253c60ba66SKatsushi Kobayashi 		off = OHCI_ITCTL(ch - ITX_CH);
19263c60ba66SKatsushi Kobayashi 		dbch = &sc->it[ch - ITX_CH];
19273c60ba66SKatsushi Kobayashi 	}else {
19283c60ba66SKatsushi Kobayashi 		off = OHCI_IRCTL(ch - IRX_CH);
19293c60ba66SKatsushi Kobayashi 		dbch = &sc->ir[ch - IRX_CH];
19303c60ba66SKatsushi Kobayashi 	}
19313c60ba66SKatsushi Kobayashi 	cmd = OREAD(sc, off + 0xc);
19323c60ba66SKatsushi Kobayashi 
19333c60ba66SKatsushi Kobayashi 	if( dbch->ndb == 0 ){
19343c60ba66SKatsushi Kobayashi 		device_printf(sc->fc.dev, "No DB is attached ch=%d\n", ch);
19353c60ba66SKatsushi Kobayashi 		return;
19363c60ba66SKatsushi Kobayashi 	}
19373c60ba66SKatsushi Kobayashi 	pp = dbch->top;
19383c60ba66SKatsushi Kobayashi 	prev = pp->db;
19393c60ba66SKatsushi Kobayashi 	for(idb = 0 ; idb < dbch->ndb ; idb ++ ){
19403c60ba66SKatsushi Kobayashi 		if(pp == NULL){
19413c60ba66SKatsushi Kobayashi 			curr = NULL;
19423c60ba66SKatsushi Kobayashi 			goto outdb;
19433c60ba66SKatsushi Kobayashi 		}
19443c60ba66SKatsushi Kobayashi 		cp = STAILQ_NEXT(pp, link);
19453c60ba66SKatsushi Kobayashi 		if(cp == NULL){
19463c60ba66SKatsushi Kobayashi 			curr = NULL;
19473c60ba66SKatsushi Kobayashi 			goto outdb;
19483c60ba66SKatsushi Kobayashi 		}
19493c60ba66SKatsushi Kobayashi 		np = STAILQ_NEXT(cp, link);
19503c60ba66SKatsushi Kobayashi 		if(cp == NULL) break;
19513c60ba66SKatsushi Kobayashi 		for(jdb = 0 ; jdb < dbch->ndesc ; jdb ++ ){
19523c60ba66SKatsushi Kobayashi 			if((cmd  & 0xfffffff0)
19533c60ba66SKatsushi Kobayashi 				== vtophys(&(cp->db[jdb]))){
19543c60ba66SKatsushi Kobayashi 				curr = cp->db;
19553c60ba66SKatsushi Kobayashi 				if(np != NULL){
19563c60ba66SKatsushi Kobayashi 					next = np->db;
19573c60ba66SKatsushi Kobayashi 				}else{
19583c60ba66SKatsushi Kobayashi 					next = NULL;
19593c60ba66SKatsushi Kobayashi 				}
19603c60ba66SKatsushi Kobayashi 				goto outdb;
19613c60ba66SKatsushi Kobayashi 			}
19623c60ba66SKatsushi Kobayashi 		}
19633c60ba66SKatsushi Kobayashi 		pp = STAILQ_NEXT(pp, link);
19643c60ba66SKatsushi Kobayashi 		prev = pp->db;
19653c60ba66SKatsushi Kobayashi 	}
19663c60ba66SKatsushi Kobayashi outdb:
19673c60ba66SKatsushi Kobayashi 	if( curr != NULL){
19683c60ba66SKatsushi Kobayashi 		printf("Prev DB %d\n", ch);
19693c60ba66SKatsushi Kobayashi 		print_db(prev, ch, dbch->ndesc);
19703c60ba66SKatsushi Kobayashi 		printf("Current DB %d\n", ch);
19713c60ba66SKatsushi Kobayashi 		print_db(curr, ch, dbch->ndesc);
19723c60ba66SKatsushi Kobayashi 		printf("Next DB %d\n", ch);
19733c60ba66SKatsushi Kobayashi 		print_db(next, ch, dbch->ndesc);
19743c60ba66SKatsushi Kobayashi 	}else{
19753c60ba66SKatsushi Kobayashi 		printf("dbdump err ch = %d cmd = 0x%08x\n", ch, cmd);
19763c60ba66SKatsushi Kobayashi 	}
19773c60ba66SKatsushi Kobayashi 	return;
19783c60ba66SKatsushi Kobayashi }
1979c572b810SHidetoshi Shimokawa 
1980c572b810SHidetoshi Shimokawa void
1981c572b810SHidetoshi Shimokawa print_db(volatile struct fwohcidb *db, u_int32_t ch, u_int32_t max)
1982c572b810SHidetoshi Shimokawa {
19833c60ba66SKatsushi Kobayashi 	fwohcireg_t stat;
19843c60ba66SKatsushi Kobayashi 	int i, key;
19853c60ba66SKatsushi Kobayashi 
19863c60ba66SKatsushi Kobayashi 	if(db == NULL){
19873c60ba66SKatsushi Kobayashi 		printf("No Descriptor is found\n");
19883c60ba66SKatsushi Kobayashi 		return;
19893c60ba66SKatsushi Kobayashi 	}
19903c60ba66SKatsushi Kobayashi 
19913c60ba66SKatsushi Kobayashi 	printf("ch = %d\n%8s %s %s %s %s %4s %8s %8s %4s:%4s\n",
19923c60ba66SKatsushi Kobayashi 		ch,
19933c60ba66SKatsushi Kobayashi 		"Current",
19943c60ba66SKatsushi Kobayashi 		"OP  ",
19953c60ba66SKatsushi Kobayashi 		"KEY",
19963c60ba66SKatsushi Kobayashi 		"INT",
19973c60ba66SKatsushi Kobayashi 		"BR ",
19983c60ba66SKatsushi Kobayashi 		"len",
19993c60ba66SKatsushi Kobayashi 		"Addr",
20003c60ba66SKatsushi Kobayashi 		"Depend",
20013c60ba66SKatsushi Kobayashi 		"Stat",
20023c60ba66SKatsushi Kobayashi 		"Cnt");
20033c60ba66SKatsushi Kobayashi 	for( i = 0 ; i <= max ; i ++){
20043c60ba66SKatsushi Kobayashi 		key = db[i].db.desc.cmd & OHCI_KEY_MASK;
200570ce30b5SHidetoshi Shimokawa 		printf("%08tx %s %s %s %s %5d %08x %08x %04x:%04x",
20063c60ba66SKatsushi Kobayashi 				vtophys(&db[i]),
20073c60ba66SKatsushi Kobayashi 				dbcode[(db[i].db.desc.cmd >> 28) & 0xf],
20083c60ba66SKatsushi Kobayashi 				dbkey[(db[i].db.desc.cmd >> 24) & 0x7],
20093c60ba66SKatsushi Kobayashi 				dbcond[(db[i].db.desc.cmd >> 20) & 0x3],
20103c60ba66SKatsushi Kobayashi 				dbcond[(db[i].db.desc.cmd >> 18) & 0x3],
20113c60ba66SKatsushi Kobayashi 				db[i].db.desc.cmd & 0xffff,
20123c60ba66SKatsushi Kobayashi 				db[i].db.desc.addr,
20133c60ba66SKatsushi Kobayashi 				db[i].db.desc.depend,
20143c60ba66SKatsushi Kobayashi 				db[i].db.desc.status,
20153c60ba66SKatsushi Kobayashi 				db[i].db.desc.count);
20163c60ba66SKatsushi Kobayashi 		stat = db[i].db.desc.status;
20173c60ba66SKatsushi Kobayashi 		if(stat & 0xff00){
20183c60ba66SKatsushi Kobayashi 			printf(" %s%s%s%s%s%s %s(%x)\n",
20193c60ba66SKatsushi Kobayashi 				stat & OHCI_CNTL_DMA_RUN ? "RUN," : "",
20203c60ba66SKatsushi Kobayashi 				stat & OHCI_CNTL_DMA_WAKE ? "WAKE," : "",
20213c60ba66SKatsushi Kobayashi 				stat & OHCI_CNTL_DMA_DEAD ? "DEAD," : "",
20223c60ba66SKatsushi Kobayashi 				stat & OHCI_CNTL_DMA_ACTIVE ? "ACTIVE," : "",
20233c60ba66SKatsushi Kobayashi 				stat & OHCI_CNTL_DMA_BT ? "BRANCH," : "",
20243c60ba66SKatsushi Kobayashi 				stat & OHCI_CNTL_DMA_BAD ? "BADDMA," : "",
20253c60ba66SKatsushi Kobayashi 				fwohcicode[stat & 0x1f],
20263c60ba66SKatsushi Kobayashi 				stat & 0x1f
20273c60ba66SKatsushi Kobayashi 			);
20283c60ba66SKatsushi Kobayashi 		}else{
20293c60ba66SKatsushi Kobayashi 			printf(" Nostat\n");
20303c60ba66SKatsushi Kobayashi 		}
20313c60ba66SKatsushi Kobayashi 		if(key == OHCI_KEY_ST2 ){
20323c60ba66SKatsushi Kobayashi 			printf("0x%08x 0x%08x 0x%08x 0x%08x\n",
20333c60ba66SKatsushi Kobayashi 				db[i+1].db.immed[0],
20343c60ba66SKatsushi Kobayashi 				db[i+1].db.immed[1],
20353c60ba66SKatsushi Kobayashi 				db[i+1].db.immed[2],
20363c60ba66SKatsushi Kobayashi 				db[i+1].db.immed[3]);
20373c60ba66SKatsushi Kobayashi 		}
20383c60ba66SKatsushi Kobayashi 		if(key == OHCI_KEY_DEVICE){
20393c60ba66SKatsushi Kobayashi 			return;
20403c60ba66SKatsushi Kobayashi 		}
20413c60ba66SKatsushi Kobayashi 		if((db[i].db.desc.cmd & OHCI_BRANCH_MASK)
20423c60ba66SKatsushi Kobayashi 				== OHCI_BRANCH_ALWAYS){
20433c60ba66SKatsushi Kobayashi 			return;
20443c60ba66SKatsushi Kobayashi 		}
20453c60ba66SKatsushi Kobayashi 		if((db[i].db.desc.cmd & OHCI_CMD_MASK)
20463c60ba66SKatsushi Kobayashi 				== OHCI_OUTPUT_LAST){
20473c60ba66SKatsushi Kobayashi 			return;
20483c60ba66SKatsushi Kobayashi 		}
20493c60ba66SKatsushi Kobayashi 		if((db[i].db.desc.cmd & OHCI_CMD_MASK)
20503c60ba66SKatsushi Kobayashi 				== OHCI_INPUT_LAST){
20513c60ba66SKatsushi Kobayashi 			return;
20523c60ba66SKatsushi Kobayashi 		}
20533c60ba66SKatsushi Kobayashi 		if(key == OHCI_KEY_ST2 ){
20543c60ba66SKatsushi Kobayashi 			i++;
20553c60ba66SKatsushi Kobayashi 		}
20563c60ba66SKatsushi Kobayashi 	}
20573c60ba66SKatsushi Kobayashi 	return;
20583c60ba66SKatsushi Kobayashi }
2059c572b810SHidetoshi Shimokawa 
2060c572b810SHidetoshi Shimokawa void
2061c572b810SHidetoshi Shimokawa fwohci_ibr(struct firewire_comm *fc)
20623c60ba66SKatsushi Kobayashi {
20633c60ba66SKatsushi Kobayashi 	struct fwohci_softc *sc;
20643c60ba66SKatsushi Kobayashi 	u_int32_t fun;
20653c60ba66SKatsushi Kobayashi 
20663c60ba66SKatsushi Kobayashi 	sc = (struct fwohci_softc *)fc;
2067ac9f6692SHidetoshi Shimokawa 
2068ac9f6692SHidetoshi Shimokawa 	/*
2069ac9f6692SHidetoshi Shimokawa 	 * Set root hold-off bit so that non cyclemaster capable node
2070ac9f6692SHidetoshi Shimokawa 	 * shouldn't became the root node.
2071ac9f6692SHidetoshi Shimokawa 	 */
2072ac9f6692SHidetoshi Shimokawa 	fun = fwphy_rddata(sc, FW_PHY_RHB_REG);
2073ac9f6692SHidetoshi Shimokawa 	fun |= FW_PHY_RHB;
2074ac9f6692SHidetoshi Shimokawa 	fun = fwphy_wrdata(sc, FW_PHY_RHB_REG, fun);
20753c60ba66SKatsushi Kobayashi #if 1
20763c60ba66SKatsushi Kobayashi 	fun = fwphy_rddata(sc, FW_PHY_IBR_REG);
20773c60ba66SKatsushi Kobayashi 	fun |= FW_PHY_IBR;
20783c60ba66SKatsushi Kobayashi 	fun = fwphy_wrdata(sc, FW_PHY_IBR_REG, fun);
20793c60ba66SKatsushi Kobayashi #else
20803c60ba66SKatsushi Kobayashi 	fun = fwphy_rddata(sc, FW_PHY_ISBR_REG);
20813c60ba66SKatsushi Kobayashi 	fun |= FW_PHY_ISBR;
20823c60ba66SKatsushi Kobayashi 	fun = fwphy_wrdata(sc, FW_PHY_ISBR_REG, fun);
20833c60ba66SKatsushi Kobayashi #endif
20843c60ba66SKatsushi Kobayashi }
2085c572b810SHidetoshi Shimokawa 
2086c572b810SHidetoshi Shimokawa void
2087c572b810SHidetoshi Shimokawa fwohci_txbufdb(struct fwohci_softc *sc, int dmach, struct fw_bulkxfer *bulkxfer)
20883c60ba66SKatsushi Kobayashi {
20893c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr, *fdb_tr;
20903c60ba66SKatsushi Kobayashi 	struct fwohci_dbch *dbch;
20913c60ba66SKatsushi Kobayashi 	struct fw_pkt *fp;
20923c60ba66SKatsushi Kobayashi 	volatile struct fwohci_txpkthdr *ohcifp;
20933c60ba66SKatsushi Kobayashi 	unsigned short chtag;
20943c60ba66SKatsushi Kobayashi 	int idb;
20953c60ba66SKatsushi Kobayashi 
20963c60ba66SKatsushi Kobayashi 	dbch = &sc->it[dmach];
20973c60ba66SKatsushi Kobayashi 	chtag = sc->it[dmach].xferq.flag & 0xff;
20983c60ba66SKatsushi Kobayashi 
20993c60ba66SKatsushi Kobayashi 	db_tr = (struct fwohcidb_tr *)(bulkxfer->start);
21003c60ba66SKatsushi Kobayashi 	fdb_tr = (struct fwohcidb_tr *)(bulkxfer->end);
21013c60ba66SKatsushi Kobayashi /*
21023c60ba66SKatsushi Kobayashi device_printf(sc->fc.dev, "DB %08x %08x %08x\n", bulkxfer, vtophys(db_tr->db), vtophys(fdb_tr->db));
21033c60ba66SKatsushi Kobayashi */
21043c60ba66SKatsushi Kobayashi 	if(bulkxfer->flag != 0){
21053c60ba66SKatsushi Kobayashi 		return;
21063c60ba66SKatsushi Kobayashi 	}
21073c60ba66SKatsushi Kobayashi 	bulkxfer->flag = 1;
21083c60ba66SKatsushi Kobayashi 	for( idb = 0 ; idb < bulkxfer->npacket ; idb ++){
21093c60ba66SKatsushi Kobayashi 		db_tr->db[0].db.desc.cmd
21103c60ba66SKatsushi Kobayashi 			= OHCI_OUTPUT_MORE | OHCI_KEY_ST2 | 8;
21113c60ba66SKatsushi Kobayashi 		fp = (struct fw_pkt *)db_tr->buf;
21123c60ba66SKatsushi Kobayashi 		ohcifp = (volatile struct fwohci_txpkthdr *)
21133c60ba66SKatsushi Kobayashi 						db_tr->db[1].db.immed;
21143c60ba66SKatsushi Kobayashi 		ohcifp->mode.ld[0] = ntohl(fp->mode.ld[0]);
21153c60ba66SKatsushi Kobayashi 		ohcifp->mode.stream.len = ntohs(fp->mode.stream.len);
21163c60ba66SKatsushi Kobayashi 		ohcifp->mode.stream.chtag = chtag;
21173c60ba66SKatsushi Kobayashi 		ohcifp->mode.stream.tcode = 0xa;
21183c60ba66SKatsushi Kobayashi 		ohcifp->mode.stream.spd = 4;
21193c60ba66SKatsushi Kobayashi 		ohcifp->mode.ld[2] = ntohl(fp->mode.ld[1]);
21203c60ba66SKatsushi Kobayashi 		ohcifp->mode.ld[3] = ntohl(fp->mode.ld[2]);
21213c60ba66SKatsushi Kobayashi 
21223c60ba66SKatsushi Kobayashi 		db_tr->db[2].db.desc.cmd
21233c60ba66SKatsushi Kobayashi 			= OHCI_OUTPUT_LAST
21243c60ba66SKatsushi Kobayashi 			| OHCI_UPDATE
21253c60ba66SKatsushi Kobayashi 			| OHCI_BRANCH_ALWAYS
21263c60ba66SKatsushi Kobayashi 			| ((ntohs(fp->mode.stream.len) ) & 0xffff);
21273c60ba66SKatsushi Kobayashi 		db_tr->db[2].db.desc.status = 0;
21283c60ba66SKatsushi Kobayashi 		db_tr->db[2].db.desc.count = 0;
21293c60ba66SKatsushi Kobayashi 		if(dbch->xferq.flag & FWXFERQ_DV){
21303c60ba66SKatsushi Kobayashi 			db_tr->db[0].db.desc.depend
21313c60ba66SKatsushi Kobayashi 				= vtophys(STAILQ_NEXT(db_tr, link)->db) | dbch->ndesc;
21323c60ba66SKatsushi Kobayashi 			db_tr->db[dbch->ndesc - 1].db.desc.depend
21333c60ba66SKatsushi Kobayashi 				= vtophys(STAILQ_NEXT(db_tr, link)->db) | dbch->ndesc;
21343c60ba66SKatsushi Kobayashi 		}else{
21353c60ba66SKatsushi Kobayashi 			db_tr->db[0].db.desc.depend
21363c60ba66SKatsushi Kobayashi 				= vtophys(STAILQ_NEXT(db_tr, link)->db) | dbch->ndesc;
21373c60ba66SKatsushi Kobayashi 			db_tr->db[dbch->ndesc - 1].db.desc.depend
21383c60ba66SKatsushi Kobayashi 				= vtophys(STAILQ_NEXT(db_tr, link)->db) | dbch->ndesc;
21393c60ba66SKatsushi Kobayashi 		}
21403c60ba66SKatsushi Kobayashi 		bulkxfer->end = (caddr_t)db_tr;
21413c60ba66SKatsushi Kobayashi 		db_tr = STAILQ_NEXT(db_tr, link);
21423c60ba66SKatsushi Kobayashi 	}
21433c60ba66SKatsushi Kobayashi 	db_tr = (struct fwohcidb_tr *)bulkxfer->end;
21443c60ba66SKatsushi Kobayashi 	db_tr->db[0].db.desc.depend &= ~0xf;
21453c60ba66SKatsushi Kobayashi 	db_tr->db[dbch->ndesc - 1].db.desc.depend &= ~0xf;
21463c60ba66SKatsushi Kobayashi /**/
21473c60ba66SKatsushi Kobayashi 	db_tr->db[dbch->ndesc - 1].db.desc.cmd &= ~OHCI_BRANCH_ALWAYS;
21483c60ba66SKatsushi Kobayashi 	db_tr->db[dbch->ndesc - 1].db.desc.cmd |= OHCI_BRANCH_NEVER;
21493c60ba66SKatsushi Kobayashi /**/
21503c60ba66SKatsushi Kobayashi 	db_tr->db[dbch->ndesc - 1].db.desc.cmd |= OHCI_INTERRUPT_ALWAYS;
21513c60ba66SKatsushi Kobayashi 
21523c60ba66SKatsushi Kobayashi 	db_tr = (struct fwohcidb_tr *)bulkxfer->start;
21533c60ba66SKatsushi Kobayashi 	fdb_tr = (struct fwohcidb_tr *)bulkxfer->end;
21543c60ba66SKatsushi Kobayashi /*
21553c60ba66SKatsushi Kobayashi device_printf(sc->fc.dev, "DB %08x %3d %08x %08x\n", bulkxfer, bulkxfer->npacket, vtophys(db_tr->db), vtophys(fdb_tr->db));
21563c60ba66SKatsushi Kobayashi */
21573c60ba66SKatsushi Kobayashi 	return;
21583c60ba66SKatsushi Kobayashi }
2159c572b810SHidetoshi Shimokawa 
2160c572b810SHidetoshi Shimokawa static int
2161c572b810SHidetoshi Shimokawa fwohci_add_tx_buf(struct fwohcidb_tr *db_tr, unsigned short size,
2162c572b810SHidetoshi Shimokawa 	int mode, void *buf)
21633c60ba66SKatsushi Kobayashi {
21643c60ba66SKatsushi Kobayashi 	volatile struct fwohcidb *db = db_tr->db;
21653c60ba66SKatsushi Kobayashi 	int err = 0;
21663c60ba66SKatsushi Kobayashi 	if(buf == 0){
21673c60ba66SKatsushi Kobayashi 		err = EINVAL;
21683c60ba66SKatsushi Kobayashi 		return err;
21693c60ba66SKatsushi Kobayashi 	}
21703c60ba66SKatsushi Kobayashi 	db_tr->buf = buf;
21713c60ba66SKatsushi Kobayashi 	db_tr->dbcnt = 3;
21723c60ba66SKatsushi Kobayashi 	db_tr->dummy = NULL;
21733c60ba66SKatsushi Kobayashi 
21743c60ba66SKatsushi Kobayashi 	db[0].db.desc.cmd = OHCI_OUTPUT_MORE | OHCI_KEY_ST2 | 8;
21753c60ba66SKatsushi Kobayashi 
21763c60ba66SKatsushi Kobayashi 	db[2].db.desc.depend = 0;
21773c60ba66SKatsushi Kobayashi 	db[2].db.desc.addr = vtophys(buf) + sizeof(u_int32_t);
21783c60ba66SKatsushi Kobayashi 	db[2].db.desc.cmd = OHCI_OUTPUT_MORE;
21793c60ba66SKatsushi Kobayashi 
21803c60ba66SKatsushi Kobayashi 	db[0].db.desc.status = 0;
21813c60ba66SKatsushi Kobayashi 	db[0].db.desc.count = 0;
21823c60ba66SKatsushi Kobayashi 
21833c60ba66SKatsushi Kobayashi 	db[2].db.desc.status = 0;
21843c60ba66SKatsushi Kobayashi 	db[2].db.desc.count = 0;
21853c60ba66SKatsushi Kobayashi 	if( mode & FWXFERQ_STREAM ){
21863c60ba66SKatsushi Kobayashi 		db[2].db.desc.cmd |= OHCI_OUTPUT_LAST;
21873c60ba66SKatsushi Kobayashi 		if(mode & FWXFERQ_PACKET ){
21883c60ba66SKatsushi Kobayashi 			db[2].db.desc.cmd
21893c60ba66SKatsushi Kobayashi 					|= OHCI_INTERRUPT_ALWAYS;
21903c60ba66SKatsushi Kobayashi 		}
21913c60ba66SKatsushi Kobayashi 	}
21923c60ba66SKatsushi Kobayashi 	db[2].db.desc.cmd |= OHCI_BRANCH_ALWAYS;
21933c60ba66SKatsushi Kobayashi 	return 1;
21943c60ba66SKatsushi Kobayashi }
2195c572b810SHidetoshi Shimokawa 
2196c572b810SHidetoshi Shimokawa int
2197c572b810SHidetoshi Shimokawa fwohci_add_rx_buf(struct fwohcidb_tr *db_tr, unsigned short size, int mode,
2198c572b810SHidetoshi Shimokawa 	void *buf, void *dummy)
21993c60ba66SKatsushi Kobayashi {
22003c60ba66SKatsushi Kobayashi 	volatile struct fwohcidb *db = db_tr->db;
22013c60ba66SKatsushi Kobayashi 	int i;
22023c60ba66SKatsushi Kobayashi 	void *dbuf[2];
22033c60ba66SKatsushi Kobayashi 	int dsiz[2];
22043c60ba66SKatsushi Kobayashi 
22053c60ba66SKatsushi Kobayashi 	if(buf == 0){
22063c60ba66SKatsushi Kobayashi 		buf = malloc(size, M_DEVBUF, M_NOWAIT);
22073c60ba66SKatsushi Kobayashi 		if(buf == NULL) return 0;
22083c60ba66SKatsushi Kobayashi 		db_tr->buf = buf;
22093c60ba66SKatsushi Kobayashi 		db_tr->dbcnt = 1;
22103c60ba66SKatsushi Kobayashi 		db_tr->dummy = NULL;
22113c60ba66SKatsushi Kobayashi 		dsiz[0] = size;
22123c60ba66SKatsushi Kobayashi 		dbuf[0] = buf;
22133c60ba66SKatsushi Kobayashi 	}else if(dummy == NULL){
22143c60ba66SKatsushi Kobayashi 		db_tr->buf = buf;
22153c60ba66SKatsushi Kobayashi 		db_tr->dbcnt = 1;
22163c60ba66SKatsushi Kobayashi 		db_tr->dummy = NULL;
22173c60ba66SKatsushi Kobayashi 		dsiz[0] = size;
22183c60ba66SKatsushi Kobayashi 		dbuf[0] = buf;
22193c60ba66SKatsushi Kobayashi 	}else{
22203c60ba66SKatsushi Kobayashi 		db_tr->buf = buf;
22213c60ba66SKatsushi Kobayashi 		db_tr->dbcnt = 2;
22223c60ba66SKatsushi Kobayashi 		db_tr->dummy = dummy;
22233c60ba66SKatsushi Kobayashi 		dsiz[0] = sizeof(u_int32_t);
22243c60ba66SKatsushi Kobayashi 		dsiz[1] = size;
22253c60ba66SKatsushi Kobayashi 		dbuf[0] = dummy;
22263c60ba66SKatsushi Kobayashi 		dbuf[1] = buf;
22273c60ba66SKatsushi Kobayashi 	}
22283c60ba66SKatsushi Kobayashi 	for(i = 0 ; i < db_tr->dbcnt ; i++){
22293c60ba66SKatsushi Kobayashi 		db[i].db.desc.addr = vtophys(dbuf[i]) ;
22303c60ba66SKatsushi Kobayashi 		db[i].db.desc.cmd = OHCI_INPUT_MORE | dsiz[i];
22313c60ba66SKatsushi Kobayashi 		if( mode & FWXFERQ_STREAM ){
22323c60ba66SKatsushi Kobayashi 			db[i].db.desc.cmd |= OHCI_UPDATE;
22333c60ba66SKatsushi Kobayashi 		}
22343c60ba66SKatsushi Kobayashi 		db[i].db.desc.status = 0;
22353c60ba66SKatsushi Kobayashi 		db[i].db.desc.count = dsiz[i];
22363c60ba66SKatsushi Kobayashi 	}
22373c60ba66SKatsushi Kobayashi 	if( mode & FWXFERQ_STREAM ){
22383c60ba66SKatsushi Kobayashi 		db[db_tr->dbcnt - 1].db.desc.cmd |= OHCI_INPUT_LAST;
22393c60ba66SKatsushi Kobayashi 		if(mode & FWXFERQ_PACKET ){
22403c60ba66SKatsushi Kobayashi 			db[db_tr->dbcnt - 1].db.desc.cmd
22413c60ba66SKatsushi Kobayashi 					|= OHCI_INTERRUPT_ALWAYS;
22423c60ba66SKatsushi Kobayashi 		}
22433c60ba66SKatsushi Kobayashi 	}
22443c60ba66SKatsushi Kobayashi 	db[db_tr->dbcnt - 1].db.desc.cmd |= OHCI_BRANCH_ALWAYS;
22453c60ba66SKatsushi Kobayashi 	return 1;
22463c60ba66SKatsushi Kobayashi }
2247c572b810SHidetoshi Shimokawa 
2248c572b810SHidetoshi Shimokawa static void
2249c572b810SHidetoshi Shimokawa fwohci_ircv(struct fwohci_softc *sc, struct fwohci_dbch *dbch, int count)
22503c60ba66SKatsushi Kobayashi {
22513c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr = dbch->top, *odb_tr;
22523c60ba66SKatsushi Kobayashi 	struct firewire_comm *fc = (struct firewire_comm *)sc;
22533c60ba66SKatsushi Kobayashi 	int z = 1;
22543c60ba66SKatsushi Kobayashi 	struct fw_pkt *fp;
22553c60ba66SKatsushi Kobayashi 	u_int8_t *ld;
22563c60ba66SKatsushi Kobayashi 	u_int32_t off = NULL;
22573c60ba66SKatsushi Kobayashi 	u_int32_t stat;
22583c60ba66SKatsushi Kobayashi 	u_int32_t *qld;
22593c60ba66SKatsushi Kobayashi 	u_int32_t reg;
22603c60ba66SKatsushi Kobayashi 	u_int spd;
22613c60ba66SKatsushi Kobayashi 	u_int dmach;
22623c60ba66SKatsushi Kobayashi 	int len, i, plen;
22633c60ba66SKatsushi Kobayashi 	caddr_t buf;
22643c60ba66SKatsushi Kobayashi 
22653c60ba66SKatsushi Kobayashi 	for(dmach = 0 ; dmach < sc->fc.nisodma ; dmach++){
22663c60ba66SKatsushi Kobayashi 		if( &sc->ir[dmach] == dbch){
22673c60ba66SKatsushi Kobayashi 			off = OHCI_IROFF(dmach);
22683c60ba66SKatsushi Kobayashi 			break;
22693c60ba66SKatsushi Kobayashi 		}
22703c60ba66SKatsushi Kobayashi 	}
22713c60ba66SKatsushi Kobayashi 	if(off == NULL){
22723c60ba66SKatsushi Kobayashi 		return;
22733c60ba66SKatsushi Kobayashi 	}
22743c60ba66SKatsushi Kobayashi 	if(!(dbch->xferq.flag & FWXFERQ_RUNNING)){
22753c60ba66SKatsushi Kobayashi 		fwohci_irx_disable(&sc->fc, dmach);
22763c60ba66SKatsushi Kobayashi 		return;
22773c60ba66SKatsushi Kobayashi 	}
22783c60ba66SKatsushi Kobayashi 
22793c60ba66SKatsushi Kobayashi 	odb_tr = NULL;
22803c60ba66SKatsushi Kobayashi 	db_tr = dbch->top;
22813c60ba66SKatsushi Kobayashi 	i = 0;
22823c60ba66SKatsushi Kobayashi 	while ((reg = db_tr->db[0].db.desc.status) & 0x1f) {
2283783058faSHidetoshi Shimokawa 		if (count >= 0 && count-- == 0)
2284783058faSHidetoshi Shimokawa 			break;
22853c60ba66SKatsushi Kobayashi 		ld = (u_int8_t *)db_tr->buf;
22863c60ba66SKatsushi Kobayashi 		if (dbch->xferq.flag & FWXFERQ_PACKET) {
22873c60ba66SKatsushi Kobayashi 			/* skip timeStamp */
22883c60ba66SKatsushi Kobayashi 			ld += sizeof(struct fwohci_trailer);
22893c60ba66SKatsushi Kobayashi 		}
22903c60ba66SKatsushi Kobayashi 		qld = (u_int32_t *)ld;
22913c60ba66SKatsushi Kobayashi 		len = dbch->xferq.psize - (db_tr->db[0].db.desc.count);
22923c60ba66SKatsushi Kobayashi /*
22933c60ba66SKatsushi Kobayashi {
22943c60ba66SKatsushi Kobayashi device_printf(sc->fc.dev, "%04x %2x 0x%08x 0x%08x 0x%08x 0x%08x\n", len,
22953c60ba66SKatsushi Kobayashi 		db_tr->db[0].db.desc.status & 0x1f, qld[0],qld[1],qld[2],qld[3]);
22963c60ba66SKatsushi Kobayashi }
22973c60ba66SKatsushi Kobayashi */
22983c60ba66SKatsushi Kobayashi 		fp=(struct fw_pkt *)ld;
22993c60ba66SKatsushi Kobayashi 		qld[0] = htonl(qld[0]);
23003c60ba66SKatsushi Kobayashi 		plen = sizeof(struct fw_isohdr)
23013c60ba66SKatsushi Kobayashi 			+ ntohs(fp->mode.stream.len) + sizeof(u_int32_t);
23023c60ba66SKatsushi Kobayashi 		ld += plen;
23033c60ba66SKatsushi Kobayashi 		len -= plen;
23043c60ba66SKatsushi Kobayashi 		buf = db_tr->buf;
23053c60ba66SKatsushi Kobayashi 		db_tr->buf = NULL;
23063c60ba66SKatsushi Kobayashi 		stat = reg & 0x1f;
23073c60ba66SKatsushi Kobayashi 		spd =  reg & 0x3;
23083c60ba66SKatsushi Kobayashi 		switch(stat){
23093c60ba66SKatsushi Kobayashi 			case FWOHCIEV_ACKCOMPL:
23103c60ba66SKatsushi Kobayashi 			case FWOHCIEV_ACKPEND:
23113c60ba66SKatsushi Kobayashi 				fw_rcv(&sc->fc, buf, plen - sizeof(u_int32_t), dmach, sizeof(u_int32_t), spd);
23123c60ba66SKatsushi Kobayashi 				break;
23133c60ba66SKatsushi Kobayashi 			default:
23143c60ba66SKatsushi Kobayashi 				free(buf, M_DEVBUF);
23153c60ba66SKatsushi Kobayashi 				device_printf(sc->fc.dev, "Isochronous receive err %02x\n", stat);
23163c60ba66SKatsushi Kobayashi 				break;
23173c60ba66SKatsushi Kobayashi 		}
23183c60ba66SKatsushi Kobayashi 		i++;
23193c60ba66SKatsushi Kobayashi 		fwohci_add_rx_buf(db_tr, dbch->xferq.psize,
23203c60ba66SKatsushi Kobayashi 					dbch->xferq.flag, 0, NULL);
23213c60ba66SKatsushi Kobayashi 		db_tr->db[0].db.desc.depend &= ~0xf;
23223c60ba66SKatsushi Kobayashi 		if(dbch->pdb_tr != NULL){
23233c60ba66SKatsushi Kobayashi 			dbch->pdb_tr->db[0].db.desc.depend |= z;
23243c60ba66SKatsushi Kobayashi 		} else {
23253c60ba66SKatsushi Kobayashi 			/* XXX should be rewritten in better way */
23263c60ba66SKatsushi Kobayashi 			dbch->bottom->db[0].db.desc.depend |= z;
23273c60ba66SKatsushi Kobayashi 		}
23283c60ba66SKatsushi Kobayashi 		dbch->pdb_tr = db_tr;
23293c60ba66SKatsushi Kobayashi 		db_tr = STAILQ_NEXT(db_tr, link);
23303c60ba66SKatsushi Kobayashi 	}
23313c60ba66SKatsushi Kobayashi 	dbch->top = db_tr;
23323c60ba66SKatsushi Kobayashi 	reg = OREAD(sc, OHCI_DMACTL(off));
23333c60ba66SKatsushi Kobayashi 	if (reg & OHCI_CNTL_DMA_ACTIVE)
23343c60ba66SKatsushi Kobayashi 		return;
23353c60ba66SKatsushi Kobayashi 	device_printf(sc->fc.dev, "IR DMA %d stopped at %x status=%x (%d)\n",
23363c60ba66SKatsushi Kobayashi 			dmach, OREAD(sc, OHCI_DMACMD(off)), reg, i);
23373c60ba66SKatsushi Kobayashi 	dbch->top = db_tr;
23383c60ba66SKatsushi Kobayashi 	fwohci_irx_enable(fc, dmach);
23393c60ba66SKatsushi Kobayashi }
23403c60ba66SKatsushi Kobayashi 
23413c60ba66SKatsushi Kobayashi #define PLEN(x)	(((ntohs(x))+0x3) & ~0x3)
23423c60ba66SKatsushi Kobayashi static int
23433c60ba66SKatsushi Kobayashi fwohci_get_plen(struct fwohci_softc *sc, struct fw_pkt *fp, int hlen)
23443c60ba66SKatsushi Kobayashi {
23453c60ba66SKatsushi Kobayashi 	int i;
23463c60ba66SKatsushi Kobayashi 
23473c60ba66SKatsushi Kobayashi 	for( i = 4; i < hlen ; i+=4){
23483c60ba66SKatsushi Kobayashi 		fp->mode.ld[i/4] = htonl(fp->mode.ld[i/4]);
23493c60ba66SKatsushi Kobayashi 	}
23503c60ba66SKatsushi Kobayashi 
23513c60ba66SKatsushi Kobayashi 	switch(fp->mode.common.tcode){
23523c60ba66SKatsushi Kobayashi 	case FWTCODE_RREQQ:
23533c60ba66SKatsushi Kobayashi 		return sizeof(fp->mode.rreqq) + sizeof(u_int32_t);
23543c60ba66SKatsushi Kobayashi 	case FWTCODE_WRES:
23553c60ba66SKatsushi Kobayashi 		return sizeof(fp->mode.wres) + sizeof(u_int32_t);
23563c60ba66SKatsushi Kobayashi 	case FWTCODE_WREQQ:
23573c60ba66SKatsushi Kobayashi 		return sizeof(fp->mode.wreqq) + sizeof(u_int32_t);
23583c60ba66SKatsushi Kobayashi 	case FWTCODE_RREQB:
23593c60ba66SKatsushi Kobayashi 		return sizeof(fp->mode.rreqb) + sizeof(u_int32_t);
23603c60ba66SKatsushi Kobayashi 	case FWTCODE_RRESQ:
23613c60ba66SKatsushi Kobayashi 		return sizeof(fp->mode.rresq) + sizeof(u_int32_t);
23623c60ba66SKatsushi Kobayashi 	case FWTCODE_WREQB:
23633c60ba66SKatsushi Kobayashi 		return sizeof(struct fw_asyhdr) + PLEN(fp->mode.wreqb.len)
23643c60ba66SKatsushi Kobayashi 						+ sizeof(u_int32_t);
23653c60ba66SKatsushi Kobayashi 	case FWTCODE_LREQ:
23663c60ba66SKatsushi Kobayashi 		return sizeof(struct fw_asyhdr) + PLEN(fp->mode.lreq.len)
23673c60ba66SKatsushi Kobayashi 						+ sizeof(u_int32_t);
23683c60ba66SKatsushi Kobayashi 	case FWTCODE_RRESB:
23693c60ba66SKatsushi Kobayashi 		return sizeof(struct fw_asyhdr) + PLEN(fp->mode.rresb.len)
23703c60ba66SKatsushi Kobayashi 						+ sizeof(u_int32_t);
23713c60ba66SKatsushi Kobayashi 	case FWTCODE_LRES:
23723c60ba66SKatsushi Kobayashi 		return sizeof(struct fw_asyhdr) + PLEN(fp->mode.lres.len)
23733c60ba66SKatsushi Kobayashi 						+ sizeof(u_int32_t);
23743c60ba66SKatsushi Kobayashi 	case FWOHCITCODE_PHY:
23753c60ba66SKatsushi Kobayashi 		return 16;
23763c60ba66SKatsushi Kobayashi 	}
23773c60ba66SKatsushi Kobayashi 	device_printf(sc->fc.dev, "Unknown tcode %d\n", fp->mode.common.tcode);
23783c60ba66SKatsushi Kobayashi 	return 0;
23793c60ba66SKatsushi Kobayashi }
23803c60ba66SKatsushi Kobayashi 
2381c572b810SHidetoshi Shimokawa static void
2382c572b810SHidetoshi Shimokawa fwohci_arcv(struct fwohci_softc *sc, struct fwohci_dbch *dbch, int count)
23833c60ba66SKatsushi Kobayashi {
23843c60ba66SKatsushi Kobayashi 	struct fwohcidb_tr *db_tr;
23853c60ba66SKatsushi Kobayashi 	int z = 1;
23863c60ba66SKatsushi Kobayashi 	struct fw_pkt *fp;
23873c60ba66SKatsushi Kobayashi 	u_int8_t *ld;
23883c60ba66SKatsushi Kobayashi 	u_int32_t stat, off;
23893c60ba66SKatsushi Kobayashi 	u_int spd;
23903c60ba66SKatsushi Kobayashi 	int len, plen, hlen, pcnt, poff = 0, rlen;
23913c60ba66SKatsushi Kobayashi 	int s;
23923c60ba66SKatsushi Kobayashi 	caddr_t buf;
23933c60ba66SKatsushi Kobayashi 	int resCount;
23943c60ba66SKatsushi Kobayashi 
23953c60ba66SKatsushi Kobayashi 	if(&sc->arrq == dbch){
23963c60ba66SKatsushi Kobayashi 		off = OHCI_ARQOFF;
23973c60ba66SKatsushi Kobayashi 	}else if(&sc->arrs == dbch){
23983c60ba66SKatsushi Kobayashi 		off = OHCI_ARSOFF;
23993c60ba66SKatsushi Kobayashi 	}else{
24003c60ba66SKatsushi Kobayashi 		return;
24013c60ba66SKatsushi Kobayashi 	}
24023c60ba66SKatsushi Kobayashi 
24033c60ba66SKatsushi Kobayashi 	s = splfw();
24043c60ba66SKatsushi Kobayashi 	db_tr = dbch->top;
24053c60ba66SKatsushi Kobayashi 	pcnt = 0;
24063c60ba66SKatsushi Kobayashi 	/* XXX we cannot handle a packet which lies in more than two buf */
24073c60ba66SKatsushi Kobayashi 	while (db_tr->db[0].db.desc.status & OHCI_CNTL_DMA_ACTIVE) {
24083c60ba66SKatsushi Kobayashi 		ld = (u_int8_t *)db_tr->buf + dbch->buf_offset;
24093c60ba66SKatsushi Kobayashi 		resCount = db_tr->db[0].db.desc.count;
24103c60ba66SKatsushi Kobayashi 		len = dbch->xferq.psize - resCount
24113c60ba66SKatsushi Kobayashi 					- dbch->buf_offset;
24123c60ba66SKatsushi Kobayashi 		while (len > 0 ) {
2413783058faSHidetoshi Shimokawa 			if (count >= 0 && count-- == 0)
2414783058faSHidetoshi Shimokawa 				goto out;
24153c60ba66SKatsushi Kobayashi 			if(dbch->frag.buf != NULL){
24163c60ba66SKatsushi Kobayashi 				buf = dbch->frag.buf;
24173c60ba66SKatsushi Kobayashi 				if (dbch->frag.plen < 0) {
24183c60ba66SKatsushi Kobayashi 					/* incomplete header */
24193c60ba66SKatsushi Kobayashi 					int hlen;
24203c60ba66SKatsushi Kobayashi 
24213c60ba66SKatsushi Kobayashi 					hlen = - dbch->frag.plen;
24223c60ba66SKatsushi Kobayashi 					rlen = hlen - dbch->frag.len;
24233c60ba66SKatsushi Kobayashi 					bcopy(ld, dbch->frag.buf + dbch->frag.len, rlen);
24243c60ba66SKatsushi Kobayashi 					ld += rlen;
24253c60ba66SKatsushi Kobayashi 					len -= rlen;
24263c60ba66SKatsushi Kobayashi 					dbch->frag.len += rlen;
24273c60ba66SKatsushi Kobayashi #if 0
24283c60ba66SKatsushi Kobayashi 					printf("(1)frag.plen=%d frag.len=%d rlen=%d len=%d\n", dbch->frag.plen, dbch->frag.len, rlen, len);
24293c60ba66SKatsushi Kobayashi #endif
24303c60ba66SKatsushi Kobayashi 					fp=(struct fw_pkt *)dbch->frag.buf;
24313c60ba66SKatsushi Kobayashi 					dbch->frag.plen
24323c60ba66SKatsushi Kobayashi 						= fwohci_get_plen(sc, fp, hlen);
24333c60ba66SKatsushi Kobayashi 					if (dbch->frag.plen == 0)
24343c60ba66SKatsushi Kobayashi 						goto out;
24353c60ba66SKatsushi Kobayashi 				}
24363c60ba66SKatsushi Kobayashi 				rlen = dbch->frag.plen - dbch->frag.len;
24373c60ba66SKatsushi Kobayashi #if 0
24383c60ba66SKatsushi Kobayashi 				printf("(2)frag.plen=%d frag.len=%d rlen=%d len=%d\n", dbch->frag.plen, dbch->frag.len, rlen, len);
24393c60ba66SKatsushi Kobayashi #endif
24403c60ba66SKatsushi Kobayashi 				bcopy(ld, dbch->frag.buf + dbch->frag.len,
24413c60ba66SKatsushi Kobayashi 						rlen);
24423c60ba66SKatsushi Kobayashi 				ld += rlen;
24433c60ba66SKatsushi Kobayashi 				len -= rlen;
24443c60ba66SKatsushi Kobayashi 				plen = dbch->frag.plen;
24453c60ba66SKatsushi Kobayashi 				dbch->frag.buf = NULL;
24463c60ba66SKatsushi Kobayashi 				dbch->frag.plen = 0;
24473c60ba66SKatsushi Kobayashi 				dbch->frag.len = 0;
24483c60ba66SKatsushi Kobayashi 				poff = 0;
24493c60ba66SKatsushi Kobayashi 			}else{
24503c60ba66SKatsushi Kobayashi 				fp=(struct fw_pkt *)ld;
24513c60ba66SKatsushi Kobayashi 				fp->mode.ld[0] = htonl(fp->mode.ld[0]);
24523c60ba66SKatsushi Kobayashi 				switch(fp->mode.common.tcode){
24533c60ba66SKatsushi Kobayashi 				case FWTCODE_RREQQ:
24543c60ba66SKatsushi Kobayashi 				case FWTCODE_WRES:
24553c60ba66SKatsushi Kobayashi 				case FWTCODE_WREQQ:
24563c60ba66SKatsushi Kobayashi 				case FWTCODE_RRESQ:
24573c60ba66SKatsushi Kobayashi 				case FWOHCITCODE_PHY:
24583c60ba66SKatsushi Kobayashi 					hlen = 12;
24593c60ba66SKatsushi Kobayashi 					break;
24603c60ba66SKatsushi Kobayashi 				case FWTCODE_RREQB:
24613c60ba66SKatsushi Kobayashi 				case FWTCODE_WREQB:
24623c60ba66SKatsushi Kobayashi 				case FWTCODE_LREQ:
24633c60ba66SKatsushi Kobayashi 				case FWTCODE_RRESB:
24643c60ba66SKatsushi Kobayashi 				case FWTCODE_LRES:
24653c60ba66SKatsushi Kobayashi 					hlen = 16;
24663c60ba66SKatsushi Kobayashi 					break;
24673c60ba66SKatsushi Kobayashi 				default:
24683c60ba66SKatsushi Kobayashi 					device_printf(sc->fc.dev, "Unknown tcode %d\n", fp->mode.common.tcode);
24693c60ba66SKatsushi Kobayashi 					goto out;
24703c60ba66SKatsushi Kobayashi 				}
24713c60ba66SKatsushi Kobayashi 				if (len >= hlen) {
24723c60ba66SKatsushi Kobayashi 					plen = fwohci_get_plen(sc, fp, hlen);
24733c60ba66SKatsushi Kobayashi 					if (plen == 0)
24743c60ba66SKatsushi Kobayashi 						goto out;
24753c60ba66SKatsushi Kobayashi 					plen = (plen + 3) & ~3;
24763c60ba66SKatsushi Kobayashi 					len -= plen;
24773c60ba66SKatsushi Kobayashi 				} else {
24783c60ba66SKatsushi Kobayashi 					plen = -hlen;
24793c60ba66SKatsushi Kobayashi 					len -= hlen;
24803c60ba66SKatsushi Kobayashi 				}
24813c60ba66SKatsushi Kobayashi 				if(resCount > 0 || len > 0){
24823c60ba66SKatsushi Kobayashi 					buf = malloc( dbch->xferq.psize,
24833c60ba66SKatsushi Kobayashi 							M_DEVBUF, M_NOWAIT);
24843c60ba66SKatsushi Kobayashi 					if(buf == NULL){
24853c60ba66SKatsushi Kobayashi 						printf("cannot malloc!\n");
24863c60ba66SKatsushi Kobayashi 						free(db_tr->buf, M_DEVBUF);
24873c60ba66SKatsushi Kobayashi 						goto out;
24883c60ba66SKatsushi Kobayashi 					}
24893c60ba66SKatsushi Kobayashi 					bcopy(ld, buf, plen);
24903c60ba66SKatsushi Kobayashi 					poff = 0;
24913c60ba66SKatsushi Kobayashi 					dbch->frag.buf = NULL;
24923c60ba66SKatsushi Kobayashi 					dbch->frag.plen = 0;
24933c60ba66SKatsushi Kobayashi 					dbch->frag.len = 0;
24943c60ba66SKatsushi Kobayashi 				}else if(len < 0){
24953c60ba66SKatsushi Kobayashi 					dbch->frag.buf = db_tr->buf;
24963c60ba66SKatsushi Kobayashi 					if (plen < 0) {
24973c60ba66SKatsushi Kobayashi #if 0
24983c60ba66SKatsushi Kobayashi 						printf("plen < 0:"
24993c60ba66SKatsushi Kobayashi 						"hlen: %d  len: %d\n",
25003c60ba66SKatsushi Kobayashi 						hlen, len);
25013c60ba66SKatsushi Kobayashi #endif
25023c60ba66SKatsushi Kobayashi 						dbch->frag.len = hlen + len;
25033c60ba66SKatsushi Kobayashi 						dbch->frag.plen = -hlen;
25043c60ba66SKatsushi Kobayashi 					} else {
25053c60ba66SKatsushi Kobayashi 						dbch->frag.len = plen + len;
25063c60ba66SKatsushi Kobayashi 						dbch->frag.plen = plen;
25073c60ba66SKatsushi Kobayashi 					}
25083c60ba66SKatsushi Kobayashi 					bcopy(ld, db_tr->buf, dbch->frag.len);
25093c60ba66SKatsushi Kobayashi 					buf = NULL;
25103c60ba66SKatsushi Kobayashi 				}else{
25113c60ba66SKatsushi Kobayashi 					buf = db_tr->buf;
25123c60ba66SKatsushi Kobayashi 					poff = ld - (u_int8_t *)buf;
25133c60ba66SKatsushi Kobayashi 					dbch->frag.buf = NULL;
25143c60ba66SKatsushi Kobayashi 					dbch->frag.plen = 0;
25153c60ba66SKatsushi Kobayashi 					dbch->frag.len = 0;
25163c60ba66SKatsushi Kobayashi 				}
25173c60ba66SKatsushi Kobayashi 				ld += plen;
25183c60ba66SKatsushi Kobayashi 			}
25193c60ba66SKatsushi Kobayashi 			if( buf != NULL){
25203c60ba66SKatsushi Kobayashi /* DMA result-code will be written at the tail of packet */
25213c60ba66SKatsushi Kobayashi 				stat = ((struct fwohci_trailer *)(ld - sizeof(struct fwohci_trailer)))->stat;
25223c60ba66SKatsushi Kobayashi 				spd = (stat >> 5) & 0x3;
25233c60ba66SKatsushi Kobayashi 				stat &= 0x1f;
25243c60ba66SKatsushi Kobayashi 				switch(stat){
25253c60ba66SKatsushi Kobayashi 				case FWOHCIEV_ACKPEND:
25263c60ba66SKatsushi Kobayashi #if 0
25273c60ba66SKatsushi Kobayashi 					printf("fwohci_arcv: ack pending..\n");
25283c60ba66SKatsushi Kobayashi #endif
25293c60ba66SKatsushi Kobayashi 					/* fall through */
25303c60ba66SKatsushi Kobayashi 				case FWOHCIEV_ACKCOMPL:
25313c60ba66SKatsushi Kobayashi 					if( poff != 0 )
25323c60ba66SKatsushi Kobayashi 						bcopy(buf+poff, buf, plen - 4);
25333c60ba66SKatsushi Kobayashi 					fw_rcv(&sc->fc, buf, plen - sizeof(struct fwohci_trailer), 0, 0, spd);
25343c60ba66SKatsushi Kobayashi 					break;
25353c60ba66SKatsushi Kobayashi 				case FWOHCIEV_BUSRST:
25363c60ba66SKatsushi Kobayashi 					free(buf, M_DEVBUF);
25373c60ba66SKatsushi Kobayashi 					if (sc->fc.status != FWBUSRESET)
25383c60ba66SKatsushi Kobayashi 						printf("got BUSRST packet!?\n");
25393c60ba66SKatsushi Kobayashi 					break;
25403c60ba66SKatsushi Kobayashi 				default:
25413c60ba66SKatsushi Kobayashi 					device_printf(sc->fc.dev, "Async DMA Receive error err = %02x %s\n", stat, fwohcicode[stat]);
25423c60ba66SKatsushi Kobayashi #if 0 /* XXX */
25433c60ba66SKatsushi Kobayashi 					goto out;
25443c60ba66SKatsushi Kobayashi #endif
25453c60ba66SKatsushi Kobayashi 					break;
25463c60ba66SKatsushi Kobayashi 				}
25473c60ba66SKatsushi Kobayashi 			}
25483c60ba66SKatsushi Kobayashi 			pcnt ++;
25493c60ba66SKatsushi Kobayashi 		};
25503c60ba66SKatsushi Kobayashi out:
25513c60ba66SKatsushi Kobayashi 		if (resCount == 0) {
25523c60ba66SKatsushi Kobayashi 			/* done on this buffer */
25533c60ba66SKatsushi Kobayashi 			fwohci_add_rx_buf(db_tr, dbch->xferq.psize,
25543c60ba66SKatsushi Kobayashi 						dbch->xferq.flag, 0, NULL);
25553c60ba66SKatsushi Kobayashi 			dbch->bottom->db[0].db.desc.depend |= z;
25563c60ba66SKatsushi Kobayashi 			dbch->bottom = db_tr;
25573c60ba66SKatsushi Kobayashi 			db_tr = STAILQ_NEXT(db_tr, link);
25583c60ba66SKatsushi Kobayashi 			dbch->top = db_tr;
25593c60ba66SKatsushi Kobayashi 			dbch->buf_offset = 0;
25603c60ba66SKatsushi Kobayashi 		} else {
25613c60ba66SKatsushi Kobayashi 			dbch->buf_offset = dbch->xferq.psize - resCount;
25623c60ba66SKatsushi Kobayashi 			break;
25633c60ba66SKatsushi Kobayashi 		}
25643c60ba66SKatsushi Kobayashi 		/* XXX make sure DMA is not dead */
25653c60ba66SKatsushi Kobayashi 	}
25663c60ba66SKatsushi Kobayashi #if 0
25673c60ba66SKatsushi Kobayashi 	if (pcnt < 1)
25683c60ba66SKatsushi Kobayashi 		printf("fwohci_arcv: no packets\n");
25693c60ba66SKatsushi Kobayashi #endif
25703c60ba66SKatsushi Kobayashi 	splx(s);
25713c60ba66SKatsushi Kobayashi }
2572