work from JiSheng Zhang : fw_raw with firewire headers from FreeBSD current. Thanks!

clean up


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21775 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/firewire/firewire_module.h

@@ -0,0 +1,67 @@
+/* Kernel driver for firewire 
+ *
+ * Copyright (C) 2007 JiSheng Zhang <[email protected]>. All rights reserved 
+ * Distributed under the terms of the MIT license.
+ */
+#ifndef _FW_MODULE_H
+#define _FW_MODULE_H
+
+#include <KernelExport.h>
+#include <module.h>
+#include <bus_manager.h>
+
+#include "firewire.h"
+#include "firewirereg.h"
+
+
+#define	FIREWIRE_MODULE_NAME		"bus_managers/firewire/v1"
+#define MAX_CARDS 4
+struct fw_module_info{
+
+	bus_manager_info	binfo;
+
+	struct fw_device * (*fw_noderesolve_nodeid)(struct firewire_comm *fc, int dst);
+
+	struct fw_device * (*fw_noderesolve_eui64)(struct firewire_comm *fc, struct fw_eui64 *eui);
+
+	int (*fw_asyreq)(struct firewire_comm *fc, int sub, struct fw_xfer *xfer);
+
+	void (*fw_xferwake)(struct fw_xfer *xfer);
+	int (*fw_xferwait)(struct fw_xfer *xfer);
+
+	struct fw_bind * (*fw_bindlookup)(struct firewire_comm *fc, uint16_t dest_hi, uint32_t dest_lo);
+
+	int (*fw_bindadd)(struct firewire_comm *fc, struct fw_bind *fwb);
+	
+	int (*fw_bindremove)(struct firewire_comm *fc, struct fw_bind *fwb);
+	
+	int (*fw_xferlist_add)(struct fw_xferlist *q, 
+			int slen, int rlen, int n,
+			struct firewire_comm *fc, void *sc, void (*hand)(struct fw_xfer *));
+	
+	void (*fw_xferlist_remove)(struct fw_xferlist *q);
+	
+	struct fw_xfer * (*fw_xfer_alloc)();
+	
+	struct fw_xfer * (*fw_xfer_alloc_buf)(int send_len, int recv_len);
+	
+	void (*fw_xfer_done)(struct fw_xfer *xfer);
+	
+	void (*fw_xfer_unload)(struct fw_xfer* xfer);
+	
+	void (*fw_xfer_free_buf)( struct fw_xfer* xfer);
+	
+	void (*fw_xfer_free)( struct fw_xfer* xfer);
+	
+	void (*fw_asy_callback_free)(struct fw_xfer *xfer);
+	
+	int (*fw_open_isodma)(struct firewire_comm *fc, int tx);
+	
+	int (*get_handle)(int socket, struct firewire_softc *handle);
+	
+	struct fwdma_alloc_multi * (*fwdma_malloc_multiseg)(int alignment,
+			int esize, int n);
+	
+	void (*fwdma_free_multiseg)(struct fwdma_alloc_multi *);
+};
+#endif

headers/private/firewire/firewirereg.h

@@ -0,0 +1,391 @@
+/*-
+ * Copyright (c) 2003 Hidetoshi Shimokawa
+ * 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: src/sys/dev/firewire/firewirereg.h,v 1.49 2007/07/15 13:20:48 simokawa Exp $
+ *
+ */
+#ifndef _FIREWIREREG_H
+#define _FIREWIREREG_H
+#ifndef __HAIKU__
+#ifdef __DragonFly__
+typedef	d_thread_t fw_proc;
+#include <sys/select.h>
+#elif __FreeBSD_version >= 500000
+typedef	struct thread fw_proc;
+#include <sys/selinfo.h>
+#else
+typedef	struct proc fw_proc;
+#include <sys/select.h>
+#endif
+#endif/*__HAIKU__*/
+
+#include <sys/uio.h>
+
+#ifndef __HAIKU__
+#include <sys/mutex.h>
+#include <sys/taskqueue.h>
+#define	splfw splimp
+#else 
+#define splfw disable_interrupts
+#define splx restore_interrupts
+#endif
+
+STAILQ_HEAD(fw_xferlist, fw_xfer);
+
+struct fw_device{
+	uint16_t dst;
+	struct fw_eui64 eui;
+	uint8_t speed;
+	uint8_t maxrec;
+	uint8_t nport;
+	uint8_t power;
+#define CSRROMOFF 0x400
+#define CSRROMSIZE 0x400
+	int rommax;	/* offset from 0xffff f000 0000 */
+	uint32_t csrrom[CSRROMSIZE/4];
+	int rcnt;
+	struct firewire_comm *fc;
+	uint32_t status;
+#define FWDEVINIT	1
+#define FWDEVATTACHED	2
+#define FWDEVINVAL	3
+	STAILQ_ENTRY(fw_device) link;
+};
+
+struct firewire_softc {
+#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
+	struct cdev *dev;
+#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 {
+#ifndef __HAIKU__
+	device_t dev;
+#endif
+	struct firewire_comm *fc;
+	void (*post_busreset) (void *);
+	void (*post_explore) (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)
+	u_char valid_res;
+};
+
+#ifdef __HAIKU__
+struct crom_src_buf {
+	struct crom_src	src;
+	struct crom_chunk root;
+	struct crom_chunk vendor;
+	struct crom_chunk hw;
+};
+#endif //move from firewire.c to firewirereg.h
+
+struct firewire_comm{
+#ifndef __HAIKU__
+	device_t dev;
+	device_t bdev;
+#endif
+	uint16_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;
+#define FWPHYASYST (1 << 0)
+	uint32_t status;
+#define	FWBUSDETACH	(-2)
+#define	FWBUSNOTREADY	(-1)
+#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;
+	struct fw_xferq
+		*arq, *atq, *ars, *ats, *it[FW_MAX_DMACH],*ir[FW_MAX_DMACH];
+	struct fw_xferlist tlabels[0x40];
+	u_char last_tlabel[0x40];
+	STAILQ_HEAD(, fw_bind) binds;
+	STAILQ_HEAD(, fw_device) devices;
+	u_int  sid_cnt;
+#define CSRSIZE 0x4000
+	uint32_t csr_arc[CSRSIZE/4];
+#define CROMSIZE 0x400
+	uint32_t *config_rom;
+	struct crom_src_buf *crom_src_buf;
+	struct crom_src *crom_src;
+	struct crom_chunk *crom_root;
+	struct fw_topology_map *topology_map;
+	struct fw_speed_map *speed_map;
+#ifndef __HAIKU__
+	struct callout busprobe_callout;
+	struct callout bmr_callout;
+	struct callout timeout_callout;
+#else
+	//timer_id busprobe_callout;
+	//timer_id bmr_callout;
+	//timer_id timeout_callout;
+#endif
+	//struct task task_timeout;
+	uint32_t (*cyctimer) (struct  firewire_comm *);
+	void (*ibr) (struct firewire_comm *);
+	uint32_t (*set_bmr) (struct firewire_comm *, uint32_t);
+#ifndef __HAIKU__
+	int (*ioctl) (struct cdev *, u_long, caddr_t, int, fw_proc *);
+#else
+	int (*ioctl) (void *cookie, uint32 cmd, void *arg, size_t len);
+#endif
+	int (*irx_enable) (struct firewire_comm *, int);
+	int (*irx_disable) (struct firewire_comm *, int);
+	int (*itx_enable) (struct firewire_comm *, int);
+	int (*itx_disable) (struct firewire_comm *, int);
+	void (*timeout) (void *);
+	void (*poll) (struct firewire_comm *, int, int);
+	void (*set_intr) (struct firewire_comm *, int);
+	void (*irx_post) (struct firewire_comm *, uint32_t *);
+	void (*itx_post) (struct firewire_comm *, uint32_t *);
+	struct tcode_info *tcode;
+#ifndef __HAIKU__
+	bus_dma_tag_t dmat;
+	struct mtx mtx;
+	struct mtx wait_lock;
+#else
+	sem_id mtx;
+	sem_id wait_lock;
+#endif
+//	struct taskqueue *taskqueue;//to be completed
+#ifndef __HAIKU__
+	struct proc *probe_thread;
+#else
+	thread_id probe_thread;
+#endif
+};
+#define CSRARC(sc, offset) ((sc)->csr_arc[(offset)/4])
+
+#ifndef __HAIKU__
+#define FW_GMTX(fc)		(&(fc)->mtx)
+#define FW_GLOCK(fc)		mtx_lock(FW_GMTX(fc))
+#define FW_GUNLOCK(fc)		mtx_unlock(FW_GMTX(fc))
+#define FW_GLOCK_ASSERT(fc)	mtx_assert(FW_GMTX(fc), MA_OWNED)
+#endif
+#define FW_GMTX(fc)		((fc)->mtx)
+#define FW_GLOCK(fc)		acquire_sem_etc(FW_GMTX(fc), 1, B_CAN_INTERRUPT | B_TIMEOUT, 0)
+#define FW_GUNLOCK(fc)		release_sem(FW_GMTX(fc))
+#define FW_GLOCK_ASSERT(fc)
+
+struct fw_xferq {
+	int flag;
+#define FWXFERQ_CHTAGMASK 0xff
+#define FWXFERQ_RUNNING (1 << 8)
+#define FWXFERQ_STREAM (1 << 9)
+
+#define FWXFERQ_BULK (1 << 11)
+#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) (struct firewire_comm*);
+	int dmach;
+	struct fw_xferlist q;
+	u_int queued;
+	u_int maxq;
+	u_int psize;
+	struct fwdma_alloc_multi *buf;
+	u_int bnchunk;
+	u_int bnpacket;
+	struct fw_bulkxfer *bulkxfer;
+	STAILQ_HEAD(, fw_bulkxfer) stvalid;
+	STAILQ_HEAD(, fw_bulkxfer) stfree;
+	STAILQ_HEAD(, fw_bulkxfer) stdma;
+	struct fw_bulkxfer *stproc;
+//	struct selinfo rsel;
+	spinlock Spinlock;
+	sem_id Sem;
+	caddr_t sc;
+	void (*hand) (struct fw_xferq *);
+};
+
+struct fw_bulkxfer{
+	int poffset;
+//	struct mbuf *mbuf;//to be completed
+	STAILQ_ENTRY(fw_bulkxfer) link;
+	caddr_t start;
+	caddr_t end;
+	int resp;
+};
+
+struct fw_bind{
+	u_int64_t start;
+	u_int64_t end;
+	struct fw_xferlist xferlist;
+	STAILQ_ENTRY(fw_bind) fclist;
+	STAILQ_ENTRY(fw_bind) chlist;
+	void *sc;
+};
+
+struct fw_xfer{
+	caddr_t sc;
+	struct firewire_comm *fc;
+	struct fw_xferq *q;
+//	struct timeval tv;//to be completed
+	int8_t resp;
+#define FWXF_INIT	0x00
+#define FWXF_INQ	0x01
+#define FWXF_START	0x02
+#define FWXF_SENT	0x04
+#define FWXF_SENTERR	0x08
+#define FWXF_BUSY	0x10
+#define FWXF_RCVD	0x20
+
+#define FWXF_WAKE	0x80
+	uint8_t flag;
+	int8_t tl;
+	void (*hand) (struct fw_xfer *);
+	struct {
+		struct fw_pkt hdr;
+		uint32_t *payload;
+		uint16_t pay_len;
+		uint8_t spd;
+	} send, recv;
+//	struct mbuf *mbuf;//to be completed
+	STAILQ_ENTRY(fw_xfer) link;
+	STAILQ_ENTRY(fw_xfer) tlabel;
+	struct malloc_type *malloc;
+};
+
+struct fw_rcv_buf {
+	struct firewire_comm *fc;
+	struct fw_xfer *xfer;
+	struct iovec *vec;
+	u_int nvec;
+	uint8_t spd;
+};
+#ifndef __HAIKU__
+void fw_sidrcv (struct firewire_comm *, uint32_t *, u_int);
+void fw_rcv (struct fw_rcv_buf *);
+void fw_xfer_unload ( struct fw_xfer*);
+void fw_xfer_free_buf ( struct fw_xfer*);
+void fw_xfer_free ( struct fw_xfer*);
+struct fw_xfer *fw_xfer_alloc (struct malloc_type *);
+struct fw_xfer *fw_xfer_alloc_buf (struct malloc_type *, int, int);
+void fw_init (struct firewire_comm *);
+int fw_tbuf_update (struct firewire_comm *, int, int);
+int fw_rbuf_update (struct firewire_comm *, int, int);
+int fw_bindadd (struct firewire_comm *, struct fw_bind *);
+int fw_bindremove (struct firewire_comm *, struct fw_bind *);
+int fw_xferlist_add (struct fw_xferlist *, struct malloc_type *, int, int, int,
+    struct firewire_comm *, void *, void (*)(struct fw_xfer *));
+void fw_xferlist_remove (struct fw_xferlist *);
+int fw_asyreq (struct firewire_comm *, int, struct fw_xfer*);
+void fw_busreset (struct firewire_comm *, uint32_t);
+uint16_t fw_crc16 (uint32_t *, uint32_t);
+void fw_xfer_timeout (void *);
+void fw_xfer_done (struct fw_xfer *);
+void fw_xferwake (struct fw_xfer *);
+int fw_xferwait (struct fw_xfer *);
+void fw_asy_callback_free (struct fw_xfer *);
+struct fw_device *fw_noderesolve_nodeid (struct firewire_comm *, int);
+struct fw_device *fw_noderesolve_eui64 (struct firewire_comm *, struct fw_eui64 *);
+struct fw_bind *fw_bindlookup (struct firewire_comm *, uint16_t, uint32_t);
+void fw_drain_txq (struct firewire_comm *);
+int fwdev_makedev (struct firewire_softc *);
+int fwdev_destroydev (struct firewire_softc *);
+void fwdev_clone (void *, struct ucred *, char *, int, struct cdev **);
+int fw_open_isodma(struct firewire_comm *, int);
+#endif
+extern int firewire_debug;
+#ifndef __HAIKU__
+extern devclass_t firewire_devclass;
+#endif
+extern int firewire_phydma_enable;
+
+#ifndef __HAIKU__
+#ifdef __DragonFly__
+#define		FWPRI		PCATCH
+#else
+#define		FWPRI		((PZERO+8)|PCATCH)
+#endif
+
+#if defined(__DragonFly__) || __FreeBSD_version < 500000
+#define CALLOUT_INIT(x) callout_init(x)
+#else
+#define CALLOUT_INIT(x) callout_init(x, 1 /* mpsafe */)
+#endif
+
+#if defined(__DragonFly__) || __FreeBSD_version < 500000
+/* compatibility shim for 4.X */
+#define bio buf
+#define bio_bcount b_bcount
+#define bio_cmd b_flags
+#define bio_count b_count
+#define bio_data b_data
+#define bio_dev b_dev
+#define bio_error b_error
+#define bio_flags b_flags
+#define bio_offset b_offset
+#define bio_resid b_resid
+#define BIO_ERROR B_ERROR
+#define BIO_READ B_READ
+#define BIO_WRITE B_WRITE
+#define MIN(a,b) (((a)<(b))?(a):(b))
+#define MAX(a,b) (((a)>(b))?(a):(b))
+#endif
+
+MALLOC_DECLARE(M_FW);
+MALLOC_DECLARE(M_FWXFER);
+#endif /*__HAIKU__*/
+
+#endif

headers/private/firewire/fwdma.h

@@ -0,0 +1,130 @@
+/*-
+ * Copyright (C) 2003
+ * 	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 following acknowledgement:
+ *
+ *	This product includes software developed by Hidetoshi Shimokawa.
+ *
+ * 4. Neither the name of the author nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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: src/sys/dev/firewire/fwdma.h,v 1.3 2005/01/06 01:42:41 imp Exp $
+ */
+#ifndef _FWDMA_H
+#define _FWDMA_H
+
+#ifndef howmany
+#define howmany(x, y)   (((x)+((y)-1))/(y)) // x/y的上界
+#endif
+#define rounddown(x, y) (((x)/(y))*(y)) // 比x小，y的最大的倍数
+#define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))  /* to any y */ // 比x大，y的最小倍数
+#define roundup2(x, y)  (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */
+#define powerof2(x)     ((((x)-1)&(x))==0) // 是否是2的次方
+
+typedef uint32_t bus_addr_t;
+typedef uint32_t bus_size_t;
+
+struct fwdma_alloc {
+//	bus_dma_tag_t	dma_tag;
+//	bus_dmamap_t	dma_map;
+	area_id		BufArea;
+	void *		v_addr;
+	bus_addr_t	bus_addr;
+};
+
+struct fwdma_seg {
+//	bus_dmamap_t	dma_map;
+
+	void *		v_addr;
+	bus_addr_t	bus_addr;
+};
+
+struct fwdma_alloc_multi {
+	bus_size_t	ssize;
+	bus_size_t	esize;
+	int		nseg;
+//	bus_dma_tag_t	dma_tag;
+	area_id		BufArea;
+
+	struct fwdma_seg seg[0];
+};
+
+static __inline void *
+fwdma_v_addr(struct fwdma_alloc_multi *am, int index)
+{
+	bus_size_t ssize = am->ssize;
+	int offset = am->esize * index;
+
+	return ((caddr_t)am->seg[offset / ssize].v_addr + (offset % ssize));
+}
+
+static __inline bus_addr_t
+fwdma_bus_addr(struct fwdma_alloc_multi *am, int index)
+{
+	bus_size_t ssize = am->ssize;
+	int offset = am->esize * index;
+
+	return (am->seg[offset / ssize].bus_addr + (offset % ssize));
+}
+#ifndef __HAIKU__
+static __inline void
+fwdma_sync(struct fwdma_alloc *dma, bus_dmasync_op_t op)  
+{
+	bus_dmamap_sync(dma->dma_tag, dma->dma_map, op);
+}
+
+static __inline void
+fwdma_sync_multiseg(struct fwdma_alloc_multi *am,
+			int start, int end, bus_dmasync_op_t op)
+{
+	struct fwdma_seg *seg, *eseg;
+
+	seg = &am->seg[am->esize * start / am->ssize];
+	eseg = &am->seg[am->esize * end / am->ssize];
+	for (; seg <= eseg; seg ++)
+		bus_dmamap_sync(am->dma_tag, seg->dma_map, op);
+}
+
+static __inline void
+fwdma_sync_multiseg_all(struct fwdma_alloc_multi *am, bus_dmasync_op_t op)
+{
+	struct fwdma_seg *seg;
+	int i;
+
+	seg = &am->seg[0];
+	for (i = 0; i < am->nseg; i++, seg++)
+		bus_dmamap_sync(am->dma_tag, seg->dma_map, op);
+}
+
+void *fwdma_malloc(int, bus_size_t, struct fwdma_alloc *, int);
+void fwdma_free(struct fwdma_alloc *);
+void *fwdma_malloc_size(bus_dma_tag_t, bus_dmamap_t *, bus_size_t, bus_addr_t *, int);
+void fwdma_free_size(bus_dma_tag_t, bus_dmamap_t, void *, bus_size_t);
+struct fwdma_alloc_multi *fwdma_malloc_multiseg(struct firewire_comm *,
+	int, int, int, int);
+#endif /*__HAIKU__*/
+
+#endif /* _FWDMA_H*/

src/add-ons/kernel/drivers/bus/Jamfile

@@ -1,5 +1,6 @@
 SubDir HAIKU_TOP src add-ons kernel drivers bus ;
 
+SubInclude HAIKU_TOP src add-ons kernel drivers bus firewire ;
 SubInclude HAIKU_TOP src add-ons kernel drivers bus pcmcia ;
 SubInclude HAIKU_TOP src add-ons kernel drivers bus scsi ;
 SubInclude HAIKU_TOP src add-ons kernel drivers bus usb ;

src/add-ons/kernel/drivers/bus/firewire/Jamfile

@@ -0,0 +1,10 @@
+SubDir HAIKU_TOP src add-ons kernel drivers bus firewire ;
+
+UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ;
+UsePrivateHeaders firewire ;
+
+SubDirCcFlags [ FDefines _KERNEL=1 ] ;
+
+KernelAddon fw_raw :
+	fw_raw.c
+	;