Index: head/sys/dev/firewire/firewirereg.h =================================================================== --- head/sys/dev/firewire/firewirereg.h (revision 109987) +++ head/sys/dev/firewire/firewirereg.h (revision 109988) @@ -1,364 +1,362 @@ /* * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the acknowledgement as bellow: * * This product includes software developed by K. Kobayashi and H. Shimokawa * * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ * */ #if __FreeBSD_version >= 500000 typedef struct thread fw_proc; #include #else typedef struct proc fw_proc; #include #endif #define splfw splimp struct fw_device{ u_int16_t dst; struct fw_eui64 eui; #if 0 u_int32_t spec; u_int32_t ver; #endif u_int8_t speed; u_int8_t maxrec; u_int8_t nport; u_int8_t power; #define CSRROMOFF 0x400 #define CSRROMSIZE 0x400 int rommax; /* offset from 0xffff f000 0000 */ u_int32_t csrrom[CSRROMSIZE/4]; int rcnt; struct firewire_comm *fc; u_int32_t status; #define FWDEVINIT 1 #define FWDEVATTACHED 2 #define FWDEVINVAL 3 TAILQ_ENTRY(fw_device) link; #if 0 LIST_HEAD(, fw_xfer) txqueue; LIST_HEAD(, fw_xfer) rxqueue; #endif }; struct firewire_softc { #if __FreeBSD_version >= 500000 dev_t dev; #else dev_t dev[FWMAXNDMA+1]; #endif struct firewire_comm *fc; }; #define FW_MAX_DMACH 0x20 #define FW_MAX_DEVCH FW_MAX_DMACH #define FW_XFERTIMEOUT 1 struct firewire_dev_comm { device_t dev; struct firewire_comm *fc; void (*post_explore) __P((void *)); }; struct tcode_info { u_char hdr_len; /* IEEE1394 header length */ u_char flag; #define FWTI_REQ (1 << 0) #define FWTI_RES (1 << 1) #define FWTI_TLABEL (1 << 2) #define FWTI_BLOCK_STR (1 << 3) #define FWTI_BLOCK_ASY (1 << 4) }; struct firewire_comm{ device_t dev; device_t bdev; u_int16_t busid:10, nodeid:6; u_int mode; u_int nport; u_int speed; u_int maxrec; u_int irm; u_int max_node; u_int max_hop; u_int max_asyretry; #define FWPHYASYST (1 << 0) u_int retry_count; u_int32_t ongobus:10, ongonode:6, ongoaddr:16; struct fw_device *ongodev; struct fw_eui64 ongoeui; #define FWMAXCSRDIR 16 SLIST_HEAD(, csrdir) ongocsr; SLIST_HEAD(, csrdir) csrfree; u_int32_t status; #define FWBUSRESET 0 #define FWBUSINIT 1 #define FWBUSCYMELECT 2 #define FWBUSMGRELECT 3 #define FWBUSMGRDONE 4 #define FWBUSEXPLORE 5 #define FWBUSPHYCONF 6 #define FWBUSEXPDONE 7 #define FWBUSCOMPLETION 10 int nisodma; struct fw_eui64 eui; STAILQ_HEAD(fw_queue, fw_xfer); struct fw_xferq *arq, *atq, *ars, *ats, *it[FW_MAX_DMACH],*ir[FW_MAX_DMACH]; STAILQ_HEAD(, tlabel) tlabels[0x40]; STAILQ_HEAD(, fw_bind) binds; TAILQ_HEAD(, fw_device) devices; STAILQ_HEAD(, fw_xfer) pending; volatile u_int32_t *sid_buf; u_int sid_cnt; #define CSRSIZE 0x4000 u_int32_t csr_arc[CSRSIZE/4]; #define CROMSIZE 0x400 u_int32_t *config_rom; struct fw_topology_map *topology_map; struct fw_speed_map *speed_map; struct callout busprobe_callout; struct callout_handle bmrhandle; struct callout_handle timeouthandle; struct callout_handle retry_probe_handle; u_int32_t (*cyctimer) __P((struct firewire_comm *)); void (*ibr) __P((struct firewire_comm *)); u_int32_t (*set_bmr) __P((struct firewire_comm *, u_int32_t)); int (*ioctl) __P((dev_t, u_long, caddr_t, int, fw_proc *)); int (*irx_enable) __P((struct firewire_comm *, int)); int (*irx_disable) __P((struct firewire_comm *, int)); int (*itx_enable) __P((struct firewire_comm *, int)); int (*itx_disable) __P((struct firewire_comm *, int)); void (*timeout) __P((void *)); void (*poll) __P((struct firewire_comm *, int, int)); void (*set_intr) __P((struct firewire_comm *, int)); void (*irx_post) __P((struct firewire_comm *, u_int32_t *)); void (*itx_post) __P((struct firewire_comm *, u_int32_t *)); struct tcode_info *tcode; }; #define CSRARC(sc, offset) ((sc)->csr_arc[(offset)/4]) struct csrdir{ u_int32_t ongoaddr; u_int32_t off; SLIST_ENTRY(csrdir) link; }; struct fw_xferq { int flag; #define FWXFERQ_CHTAGMASK 0xff #define FWXFERQ_RUNNING (1 << 8) #define FWXFERQ_STREAM (1 << 9) #define FWXFERQ_PACKET (1 << 10) #define FWXFERQ_BULK (1 << 11) #if 0 /* BROKEN */ #define FWXFERQ_DV (1 << 12) #endif #define FWXFERQ_MODEMASK (7 << 10) #define FWXFERQ_EXTBUF (1 << 13) #define FWXFERQ_OPEN (1 << 14) #define FWXFERQ_HANDLER (1 << 16) #define FWXFERQ_WAKEUP (1 << 17) void (*start) __P((struct firewire_comm*)); void (*drain) __P((struct firewire_comm*, struct fw_xfer*)); struct fw_queue q; u_int queued; u_int maxq; u_int psize; u_int packets; - u_int error; STAILQ_HEAD(, fw_bind) binds; caddr_t buf; u_int bnchunk; u_int bnpacket; - u_int btpacket; struct fw_bulkxfer *bulkxfer; STAILQ_HEAD(, fw_bulkxfer) stvalid; STAILQ_HEAD(, fw_bulkxfer) stfree; STAILQ_HEAD(, fw_bulkxfer) stdma; struct fw_bulkxfer *stproc; #ifdef FWXFERQ_DV int dvdbc, dvdiff, dvsync, dvoffset; struct fw_dvbuf *dvbuf; STAILQ_HEAD(, fw_dvbuf) dvvalid; STAILQ_HEAD(, fw_dvbuf) dvfree; struct fw_dvbuf *dvdma; struct fw_dvbuf *dvproc; u_int dvptr; u_int dvpacket; #endif struct selinfo rsel; caddr_t sc; void (*hand) __P((struct fw_xferq *)); }; struct fw_bulkxfer{ caddr_t buf; STAILQ_ENTRY(fw_bulkxfer) link; caddr_t start; caddr_t end; u_int npacket; }; struct fw_dvbuf{ caddr_t buf; STAILQ_ENTRY(fw_dvbuf) link; }; struct tlabel{ struct fw_xfer *xfer; STAILQ_ENTRY(tlabel) link; }; struct fw_bind{ u_int32_t start_hi, start_lo, addrlen; struct fw_xfer* xfer; STAILQ_ENTRY(fw_bind) fclist; STAILQ_ENTRY(fw_bind) chlist; }; struct fw_xfer{ caddr_t sc; struct firewire_comm *fc; struct fw_xferq *q; struct callout_handle ch; time_t time; struct fw_tlabel *tlabel; u_int8_t spd; u_int8_t tcode; int resp; #define FWXF_INIT 0 #define FWXF_INQ 1 #define FWXF_START 2 #define FWXF_SENT 3 #define FWXF_SENTERR 4 #define FWXF_BUSY 8 #define FWXF_RCVD 10 int state; u_int8_t retry; u_int8_t tl; int sub; int32_t dst; u_int8_t act_type; #define FWACT_NULL 0 #define FWACT_XFER 2 #define FWACT_CH 3 void (*retry_req) __P((struct fw_xfer *)); union{ void (*hand) __P((struct fw_xfer *)); } act; union{ struct { struct fw_device *device; } req; struct { struct stch *channel; } stream; } mode; struct { u_int16_t len, off; caddr_t buf; } send, recv; struct mbuf *mbuf; STAILQ_ENTRY(fw_xfer) link; }; void fw_sidrcv __P((struct firewire_comm *, caddr_t, u_int, u_int)); void fw_rcv __P((struct firewire_comm *, caddr_t, u_int, u_int, u_int, u_int)); void fw_xfer_free __P(( struct fw_xfer*)); struct fw_xfer *fw_xfer_alloc __P((void)); void fw_init __P((struct firewire_comm *)); int fw_tbuf_update __P((struct firewire_comm *, int, int)); int fw_rbuf_update __P((struct firewire_comm *, int, int)); int fw_readreqq __P((struct firewire_comm *, u_int32_t, u_int32_t, u_int32_t *)); int fw_writereqb __P((struct firewire_comm *, u_int32_t, u_int32_t, u_int32_t, u_int32_t *)); int fw_readresb __P((struct firewire_comm *, u_int32_t, u_int32_t, u_int32_t, u_int32_t*)); int fw_writeres __P((struct firewire_comm *, u_int32_t, u_int32_t)); u_int32_t getcsrdata __P((struct fw_device *, u_int8_t)); void fw_asybusy __P((struct fw_xfer *)); int fw_bindadd __P((struct firewire_comm *, struct fw_bind *)); int fw_bindremove __P((struct firewire_comm *, struct fw_bind *)); int fw_asyreq __P((struct firewire_comm *, int, struct fw_xfer*)); void fw_busreset __P((struct firewire_comm *)); u_int16_t fw_crc16 __P((u_int32_t *, u_int32_t)); void fw_xfer_timeout __P((void *)); void fw_xfer_done __P((struct fw_xfer *)); void fw_asy_callback __P((struct fw_xfer *)); struct fw_device *fw_noderesolve __P((struct firewire_comm *, struct fw_eui64)); struct fw_bind *fw_bindlookup __P((struct firewire_comm *, u_int32_t, u_int32_t)); extern int firewire_debug; extern devclass_t firewire_devclass; #define DV_BROADCAST_ON (1<<30) #define IP_CHANNELS 0x0234 #define STATE_CLEAR 0x0000 #define STATE_SET 0x0004 #define NODE_IDS 0x0008 #define RESET_START 0x000c #define SPLIT_TIMEOUT_HI 0x0018 #define SPLIT_TIMEOUT_LO 0x001c #define CYCLE_TIME 0x0200 #define BUS_TIME 0x0210 #define BUS_MGR_ID 0x021c #define BANDWIDTH_AV 0x0220 #define CHANNELS_AV_HI 0x0224 #define CHANNELS_AV_LO 0x0228 #define CONF_ROM 0x0400 #define TOPO_MAP 0x1000 #define SPED_MAP 0x2000 #define oMPR 0x900 #define oPCR 0x904 #define iMPR 0x980 #define iPCR 0x984 #define FWPRI ((PZERO+8)|PCATCH) #ifdef __alpha__ #undef vtophys #define vtophys(va) alpha_XXX_dmamap((vm_offset_t)(va)) #endif /* __alpha__ */ Index: head/sys/dev/firewire/fwdev.c =================================================================== --- head/sys/dev/firewire/fwdev.c (revision 109987) +++ head/sys/dev/firewire/fwdev.c (revision 109988) @@ -1,928 +1,938 @@ /* * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the acknowledgement as bellow: * * This product includes software developed by K. Kobayashi and H. Shimokawa * * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define CDEV_MAJOR 127 #define FWNODE_INVAL 0xffff static d_open_t fw_open; static d_close_t fw_close; static d_ioctl_t fw_ioctl; static d_poll_t fw_poll; static d_read_t fw_read; /* for Isochronous packet */ static d_write_t fw_write; static d_mmap_t fw_mmap; struct cdevsw firewire_cdevsw = { fw_open, fw_close, fw_read, fw_write, fw_ioctl, fw_poll, fw_mmap, nostrategy, "fw", CDEV_MAJOR, nodump, nopsize, D_MEM }; static int fw_open (dev_t dev, int flags, int fmt, fw_proc *td) { struct firewire_softc *sc; int unit = DEV2UNIT(dev); int sub = DEV2DMACH(dev); int err = 0; if (DEV_FWMEM(dev)) return fwmem_open(dev, flags, fmt, td); sc = devclass_get_softc(firewire_devclass, unit); if(sc->fc->ir[sub]->flag & FWXFERQ_OPEN){ err = EBUSY; return err; } if(sc->fc->it[sub]->flag & FWXFERQ_OPEN){ err = EBUSY; return err; } if(sc->fc->ir[sub]->flag & FWXFERQ_MODEMASK){ err = EBUSY; return err; } /* Default is per packet mode */ sc->fc->ir[sub]->flag |= FWXFERQ_OPEN; sc->fc->it[sub]->flag |= FWXFERQ_OPEN; sc->fc->ir[sub]->flag |= FWXFERQ_PACKET; return err; } static int fw_close (dev_t dev, int flags, int fmt, fw_proc *td) { struct firewire_softc *sc; int unit = DEV2UNIT(dev); int sub = DEV2DMACH(dev); struct fw_xfer *xfer; struct fw_bind *fwb; int err = 0; if (DEV_FWMEM(dev)) return fwmem_close(dev, flags, fmt, td); sc = devclass_get_softc(firewire_devclass, unit); if(!(sc->fc->ir[sub]->flag & FWXFERQ_OPEN)){ err = EINVAL; return err; } sc->fc->ir[sub]->flag &= ~FWXFERQ_OPEN; if(!(sc->fc->it[sub]->flag & FWXFERQ_OPEN)){ err = EINVAL; return err; } sc->fc->it[sub]->flag &= ~FWXFERQ_OPEN; if(sc->fc->ir[sub]->flag & FWXFERQ_RUNNING){ sc->fc->irx_disable(sc->fc, sub); } if(sc->fc->it[sub]->flag & FWXFERQ_RUNNING){ sc->fc->it[sub]->flag &= ~FWXFERQ_RUNNING; sc->fc->itx_disable(sc->fc, sub); } #ifdef FWXFERQ_DV if(sc->fc->it[sub]->flag & FWXFERQ_DV){ struct fw_dvbuf *dvbuf; if((dvbuf = sc->fc->it[sub]->dvproc) != NULL){ free(dvbuf->buf, M_DEVBUF); sc->fc->it[sub]->dvproc = NULL; } if((dvbuf = sc->fc->it[sub]->dvdma) != NULL){ free(dvbuf->buf, M_DEVBUF); sc->fc->it[sub]->dvdma = NULL; } while((dvbuf = STAILQ_FIRST(&sc->fc->it[sub]->dvvalid)) != NULL){ STAILQ_REMOVE_HEAD(&sc->fc->it[sub]->dvvalid, link); free(dvbuf->buf, M_DEVBUF); } while((dvbuf = STAILQ_FIRST(&sc->fc->it[sub]->dvfree)) != NULL){ STAILQ_REMOVE_HEAD(&sc->fc->it[sub]->dvfree, link); free(dvbuf->buf, M_DEVBUF); } free(sc->fc->it[sub]->dvbuf, M_DEVBUF); sc->fc->it[sub]->dvbuf = NULL; } #endif if(sc->fc->ir[sub]->flag & FWXFERQ_EXTBUF){ free(sc->fc->ir[sub]->buf, M_DEVBUF); sc->fc->ir[sub]->buf = NULL; free(sc->fc->ir[sub]->bulkxfer, M_DEVBUF); sc->fc->ir[sub]->bulkxfer = NULL; sc->fc->ir[sub]->flag &= ~FWXFERQ_EXTBUF; sc->fc->ir[sub]->psize = PAGE_SIZE; sc->fc->ir[sub]->maxq = FWMAXQUEUE; } if(sc->fc->it[sub]->flag & FWXFERQ_EXTBUF){ free(sc->fc->it[sub]->buf, M_DEVBUF); sc->fc->it[sub]->buf = NULL; free(sc->fc->it[sub]->bulkxfer, M_DEVBUF); sc->fc->it[sub]->bulkxfer = NULL; #ifdef FWXFERQ_DV sc->fc->it[sub]->dvbuf = NULL; #endif sc->fc->it[sub]->flag &= ~FWXFERQ_EXTBUF; sc->fc->it[sub]->psize = 0; sc->fc->it[sub]->maxq = FWMAXQUEUE; } for(xfer = STAILQ_FIRST(&sc->fc->ir[sub]->q); xfer != NULL; xfer = STAILQ_FIRST(&sc->fc->ir[sub]->q)){ sc->fc->ir[sub]->queued--; STAILQ_REMOVE_HEAD(&sc->fc->ir[sub]->q, link); xfer->resp = 0; switch(xfer->act_type){ case FWACT_XFER: fw_xfer_done(xfer); break; default: break; } fw_xfer_free(xfer); } for(fwb = STAILQ_FIRST(&sc->fc->ir[sub]->binds); fwb != NULL; fwb = STAILQ_FIRST(&sc->fc->ir[sub]->binds)){ STAILQ_REMOVE(&sc->fc->binds, fwb, fw_bind, fclist); STAILQ_REMOVE_HEAD(&sc->fc->ir[sub]->binds, chlist); free(fwb, M_DEVBUF); } sc->fc->ir[sub]->flag &= ~FWXFERQ_MODEMASK; sc->fc->it[sub]->flag &= ~FWXFERQ_MODEMASK; return err; } /* * read request. */ static int fw_read (dev_t dev, struct uio *uio, int ioflag) { struct firewire_softc *sc; struct fw_xferq *ir; struct fw_xfer *xfer; int err = 0, s, slept = 0; int unit = DEV2UNIT(dev); int sub = DEV2DMACH(dev); struct fw_pkt *fp; if (DEV_FWMEM(dev)) return fwmem_read(dev, uio, ioflag); sc = devclass_get_softc(firewire_devclass, unit); ir = sc->fc->ir[sub]; - if(ir->flag & FWXFERQ_PACKET){ + if (ir->flag & FWXFERQ_PACKET) { ir->stproc = NULL; } readloop: xfer = STAILQ_FIRST(&ir->q); - if(!(ir->flag & FWXFERQ_PACKET) && ir->stproc == NULL){ + if ((ir->flag & FWXFERQ_PACKET) == 0 && ir->stproc == NULL) { + /* iso bulkxfer */ ir->stproc = STAILQ_FIRST(&ir->stvalid); - if(ir->stproc != NULL){ + if (ir->stproc != NULL) { s = splfw(); STAILQ_REMOVE_HEAD(&ir->stvalid, link); splx(s); ir->queued = 0; } } - - if(xfer == NULL && ir->stproc == NULL){ - if(slept == 0){ + if (xfer == NULL && ir->stproc == NULL) { + /* no data avaliable */ + if (slept == 0) { slept = 1; - if(!(ir->flag & FWXFERQ_RUNNING) - && (ir->flag & FWXFERQ_PACKET)){ + if ((ir->flag & FWXFERQ_RUNNING) == 0 + && (ir->flag & FWXFERQ_PACKET)) { err = sc->fc->irx_enable(sc->fc, sub); + if (err) + return err; } - if(err){ - return err; - } ir->flag |= FWXFERQ_WAKEUP; err = tsleep((caddr_t)ir, FWPRI, "fw_read", hz); - if(err){ - ir->flag &= ~FWXFERQ_WAKEUP; - return err; - } - goto readloop; - }else{ + ir->flag &= ~FWXFERQ_WAKEUP; + if (err == 0) + goto readloop; + } else if (slept == 1) err = EIO; - return err; - } - }else if(xfer != NULL){ + return err; + } else if(xfer != NULL) { + /* per packet mode */ s = splfw(); ir->queued --; STAILQ_REMOVE_HEAD(&ir->q, link); splx(s); fp = (struct fw_pkt *)(xfer->recv.buf + xfer->recv.off); if(sc->fc->irx_post != NULL) sc->fc->irx_post(sc->fc, fp->mode.ld); err = uiomove(xfer->recv.buf + xfer->recv.off, xfer->recv.len, uio); fw_xfer_free( xfer); - }else if(ir->stproc != NULL){ + } else if(ir->stproc != NULL) { + /* iso bulkxfer */ fp = (struct fw_pkt *)(ir->stproc->buf + ir->queued * ir->psize); if(sc->fc->irx_post != NULL) sc->fc->irx_post(sc->fc, fp->mode.ld); if(ntohs(fp->mode.stream.len) == 0){ err = EIO; return err; } - err = uiomove((caddr_t)fp, ntohs(fp->mode.stream.len) + sizeof(u_int32_t), uio); + err = uiomove((caddr_t)fp, + ntohs(fp->mode.stream.len) + sizeof(u_int32_t), uio); +#if 0 fp->mode.stream.len = 0; +#endif ir->queued ++; if(ir->queued >= ir->bnpacket){ s = splfw(); STAILQ_INSERT_TAIL(&ir->stfree, ir->stproc, link); splx(s); sc->fc->irx_enable(sc->fc, sub); ir->stproc = NULL; } + if (uio->uio_resid >= ir->psize) { + slept = -1; + goto readloop; + } } return err; } static int fw_write (dev_t dev, struct uio *uio, int ioflag) { int err = 0; struct firewire_softc *sc; int unit = DEV2UNIT(dev); int sub = DEV2DMACH(dev); int s, slept = 0; struct fw_pkt *fp; struct fw_xfer *xfer; struct fw_xferq *xferq; struct firewire_comm *fc; struct fw_xferq *it; if (DEV_FWMEM(dev)) return fwmem_write(dev, uio, ioflag); sc = devclass_get_softc(firewire_devclass, unit); fc = sc->fc; it = sc->fc->it[sub]; fp = (struct fw_pkt *)uio->uio_iov->iov_base; switch(fp->mode.common.tcode){ case FWTCODE_RREQQ: case FWTCODE_RREQB: case FWTCODE_LREQ: err = EINVAL; return err; case FWTCODE_WREQQ: case FWTCODE_WREQB: xferq = fc->atq; break; case FWTCODE_STREAM: if(it->flag & FWXFERQ_PACKET){ xferq = fc->atq; }else{ xferq = NULL; } break; case FWTCODE_WRES: case FWTCODE_RRESQ: case FWTCODE_RRESB: case FWTCODE_LRES: xferq = fc->ats; break; default: err = EINVAL; return err; } /* Discard unsent buffered stream packet, when sending Asyrequrst */ if(xferq != NULL && it->stproc != NULL){ s = splfw(); STAILQ_INSERT_TAIL(&it->stfree, it->stproc, link); splx(s); it->stproc = NULL; } #ifdef FWXFERQ_DV if(xferq == NULL && !(it->flag & FWXFERQ_DV)){ #else if (xferq == NULL) { #endif isoloop: if (it->stproc == NULL) { it->stproc = STAILQ_FIRST(&it->stfree); if (it->stproc != NULL) { s = splfw(); STAILQ_REMOVE_HEAD(&it->stfree, link); splx(s); it->queued = 0; } else if (slept == 0) { slept = 1; err = sc->fc->itx_enable(sc->fc, sub); - if(err){ + if (err) return err; - } - err = tsleep((caddr_t)it, FWPRI, "fw_write", hz); - if(err){ + err = tsleep((caddr_t)it, FWPRI, + "fw_write", hz); + if (err) return err; - } goto isoloop; - }else{ + } else { err = EIO; return err; } } - err = uiomove(it->stproc->buf + it->queued * it->psize, - uio->uio_resid, uio); + fp = (struct fw_pkt *) + (it->stproc->buf + it->queued * it->psize); + err = uiomove((caddr_t)fp, sizeof(struct fw_isohdr), uio); + err = uiomove((caddr_t)fp->mode.stream.payload, + ntohs(fp->mode.stream.len), uio); it->queued ++; - if(it->queued >= it->btpacket){ + if (it->queued >= it->bnpacket) { s = splfw(); STAILQ_INSERT_TAIL(&it->stvalid, it->stproc, link); splx(s); it->stproc = NULL; err = sc->fc->itx_enable(sc->fc, sub); } + if (uio->uio_resid >= sizeof(struct fw_isohdr)) { + slept = 0; + goto isoloop; + } return err; } #ifdef FWXFERQ_DV if(xferq == NULL && it->flag & FWXFERQ_DV){ dvloop: if(it->dvproc == NULL){ it->dvproc = STAILQ_FIRST(&it->dvfree); if(it->dvproc != NULL){ s = splfw(); STAILQ_REMOVE_HEAD(&it->dvfree, link); splx(s); it->dvptr = 0; }else if(slept == 0){ slept = 1; err = sc->fc->itx_enable(sc->fc, sub); if(err){ return err; } err = tsleep((caddr_t)it, FWPRI, "fw_write", hz); if(err){ return err; } goto dvloop; }else{ err = EIO; return err; } } #if 0 /* What's this for? (it->dvptr? overwritten by the following uiomove)*/ fp = (struct fw_pkt *)(it->dvproc->buf + it->queued * it->psize); fp->mode.stream.len = htons(uio->uio_resid - sizeof(u_int32_t)); #endif err = uiomove(it->dvproc->buf + it->dvptr, uio->uio_resid, uio); it->dvptr += it->psize; if(err){ return err; } if(it->dvptr >= it->psize * it->dvpacket){ s = splfw(); STAILQ_INSERT_TAIL(&it->dvvalid, it->dvproc, link); splx(s); it->dvproc = NULL; err = fw_tbuf_update(sc->fc, sub, 0); if(err){ return err; } err = sc->fc->itx_enable(sc->fc, sub); } return err; } #endif if(xferq != NULL){ xfer = fw_xfer_alloc(); if(xfer == NULL){ err = ENOMEM; return err; } xfer->send.buf = malloc(uio->uio_resid, M_DEVBUF, M_NOWAIT); if(xfer->send.buf == NULL){ fw_xfer_free( xfer); err = ENOBUFS; return err; } xfer->dst = ntohs(fp->mode.hdr.dst); #if 0 switch(fp->mode.common.tcode){ case FWTCODE_WREQQ: case FWTCODE_WREQB: if((tl = fw_get_tlabel(fc, xfer)) == -1 ){ fw_xfer_free( xfer); err = EAGAIN; return err; } fp->mode.hdr.tlrt = tl << 2; default: break; } xfer->tl = fp->mode.hdr.tlrt >> 2; xfer->tcode = fp->mode.common.tcode; xfer->fc = fc; xfer->q = xferq; xfer->act_type = FWACT_XFER; xfer->retry_req = fw_asybusy; #endif xfer->send.len = uio->uio_resid; xfer->send.off = 0; xfer->spd = 0;/* XXX: how to setup it */ xfer->act.hand = fw_asy_callback; err = uiomove(xfer->send.buf, uio->uio_resid, uio); if(err){ fw_xfer_free( xfer); return err; } #if 0 fw_asystart(xfer); #else fw_asyreq(fc, -1, xfer); #endif err = tsleep((caddr_t)xfer, FWPRI, "fw_write", hz); if(xfer->resp == EBUSY) return EBUSY; fw_xfer_free( xfer); return err; } return EINVAL; } /* * ioctl support. */ int fw_ioctl (dev_t dev, u_long cmd, caddr_t data, int flag, fw_proc *td) { struct firewire_softc *sc; int unit = DEV2UNIT(dev); int sub = DEV2DMACH(dev); int i, len, err = 0; struct fw_device *fwdev; struct fw_bind *fwb; struct fw_xferq *ir, *it; struct fw_xfer *xfer; struct fw_pkt *fp; struct fw_devinfo *devinfo; struct fw_devlstreq *fwdevlst = (struct fw_devlstreq *)data; struct fw_asyreq *asyreq = (struct fw_asyreq *)data; struct fw_isochreq *ichreq = (struct fw_isochreq *)data; struct fw_isobufreq *ibufreq = (struct fw_isobufreq *)data; struct fw_asybindreq *bindreq = (struct fw_asybindreq *)data; struct fw_crom_buf *crom_buf = (struct fw_crom_buf *)data; if (DEV_FWMEM(dev)) return fwmem_ioctl(dev, cmd, data, flag, td); sc = devclass_get_softc(firewire_devclass, unit); if (!data) return(EINVAL); switch (cmd) { case FW_STSTREAM: sc->fc->it[sub]->flag &= ~0xff; sc->fc->it[sub]->flag |= (0x3f & ichreq->ch); sc->fc->it[sub]->flag |= ((0x3 & ichreq->tag) << 6); err = 0; break; case FW_GTSTREAM: ichreq->ch = sc->fc->it[sub]->flag & 0x3f; ichreq->tag =(sc->fc->it[sub]->flag) >> 2 & 0x3; err = 0; break; case FW_SRSTREAM: sc->fc->ir[sub]->flag &= ~0xff; sc->fc->ir[sub]->flag |= (0x3f & ichreq->ch); sc->fc->ir[sub]->flag |= ((0x3 & ichreq->tag) << 6); err = sc->fc->irx_enable(sc->fc, sub); break; case FW_GRSTREAM: ichreq->ch = sc->fc->ir[sub]->flag & 0x3f; ichreq->tag =(sc->fc->ir[sub]->flag) >> 2 & 0x3; err = 0; break; #ifdef FWXFERQ_DV case FW_SSTDV: ibufreq = (struct fw_isobufreq *) malloc(sizeof(struct fw_isobufreq), M_DEVBUF, M_NOWAIT); if(ibufreq == NULL){ err = ENOMEM; break; } #if DV_PAL #define FWDVPACKET 300 #else #define FWDVPACKET 250 #endif #define FWDVPMAX 512 ibufreq->rx.nchunk = 8; ibufreq->rx.npacket = 50; ibufreq->rx.psize = FWDVPMAX; ibufreq->tx.nchunk = 5; ibufreq->tx.npacket = FWDVPACKET + 30; /* > 320 or 267 */ ibufreq->tx.psize = FWDVPMAX; err = fw_ioctl(dev, FW_SSTBUF, (caddr_t)ibufreq, flag, td); sc->fc->it[sub]->dvpacket = FWDVPACKET; free(ibufreq, M_DEVBUF); /* reserve a buffer space */ #define NDVCHUNK 8 sc->fc->it[sub]->dvproc = NULL; sc->fc->it[sub]->dvdma = NULL; sc->fc->it[sub]->flag |= FWXFERQ_DV; /* XXX check malloc failure */ sc->fc->it[sub]->dvbuf = (struct fw_dvbuf *)malloc(sizeof(struct fw_dvbuf) * NDVCHUNK, M_DEVBUF, M_NOWAIT); STAILQ_INIT(&sc->fc->it[sub]->dvvalid); STAILQ_INIT(&sc->fc->it[sub]->dvfree); for( i = 0 ; i < NDVCHUNK ; i++){ /* XXX check malloc failure */ sc->fc->it[sub]->dvbuf[i].buf = malloc(FWDVPMAX * sc->fc->it[sub]->dvpacket, M_DEVBUF, M_NOWAIT); STAILQ_INSERT_TAIL(&sc->fc->it[sub]->dvfree, &sc->fc->it[sub]->dvbuf[i], link); } break; #endif case FW_SSTBUF: ir = sc->fc->ir[sub]; it = sc->fc->it[sub]; if(ir->flag & FWXFERQ_RUNNING || it->flag & FWXFERQ_RUNNING){ return(EBUSY); } if((ir->flag & FWXFERQ_EXTBUF) || (it->flag & FWXFERQ_EXTBUF)){ return(EBUSY); } if((ibufreq->rx.nchunk * ibufreq->rx.psize * ibufreq->rx.npacket) + (ibufreq->tx.nchunk * ibufreq->tx.psize * ibufreq->tx.npacket) <= 0){ return(EINVAL); } if(ibufreq->rx.nchunk > FWSTMAXCHUNK || ibufreq->tx.nchunk > FWSTMAXCHUNK){ return(EINVAL); } ir->bulkxfer = (struct fw_bulkxfer *)malloc(sizeof(struct fw_bulkxfer) * ibufreq->rx.nchunk, M_DEVBUF, M_NOWAIT); if(ir->bulkxfer == NULL){ return(ENOMEM); } it->bulkxfer = (struct fw_bulkxfer *)malloc(sizeof(struct fw_bulkxfer) * ibufreq->tx.nchunk, M_DEVBUF, M_NOWAIT); if(it->bulkxfer == NULL){ return(ENOMEM); } ir->buf = malloc( ibufreq->rx.nchunk * ibufreq->rx.npacket /* XXX psize must be 2^n and less or equal to PAGE_SIZE */ * ((ibufreq->rx.psize + 3) &~3), M_DEVBUF, M_NOWAIT); if(ir->buf == NULL){ free(ir->bulkxfer, M_DEVBUF); free(it->bulkxfer, M_DEVBUF); ir->bulkxfer = NULL; it->bulkxfer = NULL; it->buf = NULL; return(ENOMEM); } it->buf = malloc( ibufreq->tx.nchunk * ibufreq->tx.npacket /* XXX psize must be 2^n and less or equal to PAGE_SIZE */ * ((ibufreq->tx.psize + 3) &~3), M_DEVBUF, M_NOWAIT); if(it->buf == NULL){ free(ir->bulkxfer, M_DEVBUF); free(it->bulkxfer, M_DEVBUF); free(ir->buf, M_DEVBUF); ir->bulkxfer = NULL; it->bulkxfer = NULL; it->buf = NULL; return(ENOMEM); } ir->bnchunk = ibufreq->rx.nchunk; ir->bnpacket = ibufreq->rx.npacket; - ir->btpacket = ibufreq->rx.npacket; ir->psize = (ibufreq->rx.psize + 3) & ~3; ir->queued = 0; it->bnchunk = ibufreq->tx.nchunk; it->bnpacket = ibufreq->tx.npacket; - it->btpacket = ibufreq->tx.npacket; it->psize = (ibufreq->tx.psize + 3) & ~3; it->queued = 0; #ifdef FWXFERQ_DV it->dvdbc = 0; it->dvdiff = 0; it->dvsync = 0; it->dvoffset = 0; #endif STAILQ_INIT(&ir->stvalid); STAILQ_INIT(&ir->stfree); STAILQ_INIT(&ir->stdma); ir->stproc = NULL; STAILQ_INIT(&it->stvalid); STAILQ_INIT(&it->stfree); STAILQ_INIT(&it->stdma); it->stproc = NULL; for(i = 0 ; i < sc->fc->ir[sub]->bnchunk; i++){ ir->bulkxfer[i].buf = ir->buf + i * sc->fc->ir[sub]->bnpacket * sc->fc->ir[sub]->psize; STAILQ_INSERT_TAIL(&ir->stfree, &ir->bulkxfer[i], link); ir->bulkxfer[i].npacket = ir->bnpacket; } for(i = 0 ; i < sc->fc->it[sub]->bnchunk; i++){ it->bulkxfer[i].buf = it->buf + i * sc->fc->it[sub]->bnpacket * sc->fc->it[sub]->psize; STAILQ_INSERT_TAIL(&it->stfree, &it->bulkxfer[i], link); it->bulkxfer[i].npacket = it->bnpacket; } ir->flag &= ~FWXFERQ_MODEMASK; ir->flag |= FWXFERQ_STREAM; ir->flag |= FWXFERQ_EXTBUF; it->flag &= ~FWXFERQ_MODEMASK; it->flag |= FWXFERQ_STREAM; it->flag |= FWXFERQ_EXTBUF; err = 0; break; case FW_GSTBUF: ibufreq->rx.nchunk = sc->fc->ir[sub]->bnchunk; ibufreq->rx.npacket = sc->fc->ir[sub]->bnpacket; ibufreq->rx.psize = sc->fc->ir[sub]->psize; ibufreq->tx.nchunk = sc->fc->it[sub]->bnchunk; ibufreq->tx.npacket = sc->fc->it[sub]->bnpacket; ibufreq->tx.psize = sc->fc->it[sub]->psize; break; case FW_ASYREQ: xfer = fw_xfer_alloc(); if(xfer == NULL){ err = ENOMEM; return err; } fp = &asyreq->pkt; switch (asyreq->req.type) { case FWASREQNODE: xfer->dst = ntohs(fp->mode.hdr.dst); break; case FWASREQEUI: fwdev = fw_noderesolve(sc->fc, asyreq->req.dst.eui); if (fwdev == NULL) { device_printf(sc->fc->bdev, "cannot find node\n"); err = EINVAL; goto error; } xfer->dst = fwdev->dst; fp->mode.hdr.dst = htons(FWLOCALBUS | xfer->dst); break; case FWASRESTL: /* XXX what's this? */ break; case FWASREQSTREAM: /* nothing to do */ break; } xfer->spd = asyreq->req.sped; xfer->send.len = asyreq->req.len; xfer->send.buf = malloc(xfer->send.len, M_DEVBUF, M_NOWAIT); if(xfer->send.buf == NULL){ return ENOMEM; } xfer->send.off = 0; bcopy(fp, xfer->send.buf, xfer->send.len); xfer->act.hand = fw_asy_callback; err = fw_asyreq(sc->fc, sub, xfer); if(err){ fw_xfer_free( xfer); return err; } err = tsleep((caddr_t)xfer, FWPRI, "asyreq", hz); if(err == 0){ if(asyreq->req.len >= xfer->recv.len){ asyreq->req.len = xfer->recv.len; }else{ err = EINVAL; } bcopy(xfer->recv.buf + xfer->recv.off, fp, asyreq->req.len); } error: fw_xfer_free( xfer); break; case FW_IBUSRST: sc->fc->ibr(sc->fc); break; case FW_CBINDADDR: fwb = fw_bindlookup(sc->fc, bindreq->start.hi, bindreq->start.lo); if(fwb == NULL){ err = EINVAL; break; } STAILQ_REMOVE(&sc->fc->binds, fwb, fw_bind, fclist); STAILQ_REMOVE(&sc->fc->ir[sub]->binds, fwb, fw_bind, chlist); free(fwb, M_DEVBUF); break; case FW_SBINDADDR: if(bindreq->len <= 0 ){ err = EINVAL; break; } if(bindreq->start.hi > 0xffff ){ err = EINVAL; break; } fwb = (struct fw_bind *)malloc(sizeof (struct fw_bind), M_DEVBUF, M_NOWAIT); if(fwb == NULL){ err = ENOMEM; break; } fwb->start_hi = bindreq->start.hi; fwb->start_lo = bindreq->start.lo; fwb->addrlen = bindreq->len; xfer = fw_xfer_alloc(); if(xfer == NULL){ err = ENOMEM; return err; } xfer->act_type = FWACT_CH; xfer->sub = sub; xfer->fc = sc->fc; fwb->xfer = xfer; err = fw_bindadd(sc->fc, fwb); break; case FW_GDEVLST: i = len = 1; /* myself */ devinfo = &fwdevlst->dev[0]; devinfo->dst = sc->fc->nodeid; devinfo->status = 0; /* XXX */ devinfo->eui.hi = sc->fc->eui.hi; devinfo->eui.lo = sc->fc->eui.lo; for (fwdev = TAILQ_FIRST(&sc->fc->devices); fwdev != NULL; fwdev = TAILQ_NEXT(fwdev, link)) { if(len < FW_MAX_DEVLST){ devinfo = &fwdevlst->dev[len++]; devinfo->dst = fwdev->dst; devinfo->status = (fwdev->status == FWDEVINVAL)?0:1; devinfo->eui.hi = fwdev->eui.hi; devinfo->eui.lo = fwdev->eui.lo; } i++; } fwdevlst->n = i; fwdevlst->info_len = len; break; case FW_GTPMAP: bcopy(sc->fc->topology_map, data, (sc->fc->topology_map->crc_len + 1) * 4); break; case FW_GCROM: for (fwdev = TAILQ_FIRST(&sc->fc->devices); fwdev != NULL; fwdev = TAILQ_NEXT(fwdev, link)) { if (fwdev->eui.hi == crom_buf->eui.hi && fwdev->eui.lo == crom_buf->eui.lo) break; } if (fwdev == NULL) { err = FWNODE_INVAL; break; } #if 0 if (fwdev->csrrom[0] >> 24 == 1) len = 4; else len = (1 + ((fwdev->csrrom[0] >> 16) & 0xff)) * 4; #else if (fwdev->rommax < CSRROMOFF) len = 0; else len = fwdev->rommax - CSRROMOFF + 4; #endif if (crom_buf->len < len) len = crom_buf->len; else crom_buf->len = len; err = copyout(&fwdev->csrrom[0], crom_buf->ptr, len); break; default: sc->fc->ioctl (dev, cmd, data, flag, td); break; } return err; } int fw_poll(dev_t dev, int events, fw_proc *td) { int revents; int tmp; int unit = DEV2UNIT(dev); int sub = DEV2DMACH(dev); struct firewire_softc *sc; if (DEV_FWMEM(dev)) return fwmem_poll(dev, events, td); sc = devclass_get_softc(firewire_devclass, unit); revents = 0; tmp = POLLIN | POLLRDNORM; if (events & tmp) { if (STAILQ_FIRST(&sc->fc->ir[sub]->q) != NULL) revents |= tmp; else selrecord(td, &sc->fc->ir[sub]->rsel); } tmp = POLLOUT | POLLWRNORM; if (events & tmp) { /* XXX should be fixed */ revents |= tmp; } return revents; } static int fw_mmap (dev_t dev, vm_offset_t offset, int nproto) { struct firewire_softc *fc; int unit = DEV2UNIT(dev); if (DEV_FWMEM(dev)) return fwmem_mmap(dev, offset, nproto); fc = devclass_get_softc(firewire_devclass, unit); return EINVAL; }