drivers/ieee1394/dv1394-private.h - android_kernel_htc_msm8960 - Gitiles

 /*
  * dv1394-private.h - DV input/output over IEEE 1394 on OHCI chips
  *   Copyright (C)2001 Daniel Maas <dmaas@dcine.com>
  *     receive by Dan Dennedy <dan@dennedy.org>
  *
  * based on:
  *   video1394.h - driver for OHCI 1394 boards
  *   Copyright (C)1999,2000 Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>
  *                          Peter Schlaile <udbz@rz.uni-karlsruhe.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */

 #ifndef _DV_1394_PRIVATE_H
 #define _DV_1394_PRIVATE_H

 #include "ieee1394.h"
 #include "ohci1394.h"
 #include "dma.h"

 /* data structures private to the dv1394 driver */
 /* none of this is exposed to user-space */


 /*
    the 8-byte CIP (Common Isochronous Packet) header that precedes
    each packet of DV data.

    See the IEC 61883 standard.
 */

 struct CIP_header { unsigned char b[8]; };

 static inline void fill_cip_header(struct CIP_header *cip,
 				   unsigned char source_node_id,
 				   unsigned long counter,
 				   enum pal_or_ntsc format,
 				   unsigned long timestamp)
 {
 	cip->b[0] = source_node_id;
 	cip->b[1] = 0x78; /* packet size in quadlets (480/4) - even for empty packets! */
 	cip->b[2] = 0x00;
 	cip->b[3] = counter;

 	cip->b[4] = 0x80; /* const */

 	switch(format) {
 	case DV1394_PAL:
 		cip->b[5] = 0x80;
 		break;
 	case DV1394_NTSC:
 		cip->b[5] = 0x00;
 		break;
 	}

 	cip->b[6] = timestamp >> 8;
 	cip->b[7] = timestamp & 0xFF;
 }


 /*
    DMA commands used to program the OHCI's DMA engine

    See the Texas Instruments OHCI 1394 chipset documentation.
 */

 struct output_more_immediate { u32 q[8]; };
 struct output_more { u32 q[4]; };
 struct output_last { u32 q[4]; };
 struct input_more { u32 q[4]; };
 struct input_last { u32 q[4]; };

 /* outputs */

 static inline void fill_output_more_immediate(struct output_more_immediate *omi,
 					      unsigned char tag,
 					      unsigned char channel,
 					      unsigned char sync_tag,
 					      unsigned int  payload_size)
 {
 	omi->q[0] = cpu_to_le32(0x02000000 | 8); /* OUTPUT_MORE_IMMEDIATE; 8 is the size of the IT header */
 	omi->q[1] = 0;
 	omi->q[2] = 0;
 	omi->q[3] = 0;

 	/* IT packet header */
 	omi->q[4] = cpu_to_le32(  (0x0 << 16)  /* IEEE1394_SPEED_100 */
 				  | (tag << 14)
 				  | (channel << 8)
 				  | (TCODE_ISO_DATA << 4)
 				  | (sync_tag) );

 	/* reserved field; mimic behavior of my Sony DSR-40 */
 	omi->q[5] = cpu_to_le32((payload_size << 16) | (0x7F << 8) | 0xA0);

 	omi->q[6] = 0;
 	omi->q[7] = 0;
 }

 static inline void fill_output_more(struct output_more *om,
 				    unsigned int data_size,
 				    unsigned long data_phys_addr)
 {
 	om->q[0] = cpu_to_le32(data_size);
 	om->q[1] = cpu_to_le32(data_phys_addr);
 	om->q[2] = 0;
 	om->q[3] = 0;
 }

 static inline void fill_output_last(struct output_last *ol,
 				    int want_timestamp,
 				    int want_interrupt,
 				    unsigned int data_size,
 				    unsigned long data_phys_addr)
 {
 	u32 temp = 0;
 	temp |= 1 << 28; /* OUTPUT_LAST */

 	if (want_timestamp) /* controller will update timestamp at DMA time */
 		temp |= 1 << 27;

 	if (want_interrupt)
 		temp |= 3 << 20;

 	temp |= 3 << 18; /* must take branch */
 	temp |= data_size;

 	ol->q[0] = cpu_to_le32(temp);
 	ol->q[1] = cpu_to_le32(data_phys_addr);
 	ol->q[2] = 0;
 	ol->q[3] = 0;
 }

 /* inputs */

 static inline void fill_input_more(struct input_more *im,
 				   int want_interrupt,
 				   unsigned int data_size,
 				   unsigned long data_phys_addr)
 {
 	u32 temp =  2 << 28; /* INPUT_MORE */
 	temp |= 8 << 24; /* s = 1, update xferStatus and resCount */
 	if (want_interrupt)
 		temp |= 0 << 20; /* interrupts, i=0 in packet-per-buffer mode */
 	temp |= 0x0 << 16; /* disable branch to address for packet-per-buffer mode */
 	                       /* disable wait on sync field, not used in DV :-( */
        	temp |= data_size;

 	im->q[0] = cpu_to_le32(temp);
 	im->q[1] = cpu_to_le32(data_phys_addr);
 	im->q[2] = 0; /* branchAddress and Z not use in packet-per-buffer mode */
 	im->q[3] = 0; /* xferStatus & resCount, resCount must be initialize to data_size */
 }

 static inline void fill_input_last(struct input_last *il,
 				    int want_interrupt,
 				    unsigned int data_size,
 				    unsigned long data_phys_addr)
 {
 	u32 temp =  3 << 28; /* INPUT_LAST */
 	temp |= 8 << 24; /* s = 1, update xferStatus and resCount */
 	if (want_interrupt)
 		temp |= 3 << 20; /* enable interrupts */
 	temp |= 0xC << 16; /* enable branch to address */
 	                       /* disable wait on sync field, not used in DV :-( */
 	temp |= data_size;

 	il->q[0] = cpu_to_le32(temp);
 	il->q[1] = cpu_to_le32(data_phys_addr);
 	il->q[2] = cpu_to_le32(1); /* branchAddress (filled in later) and Z = 1 descriptor in next block */
 	il->q[3] = cpu_to_le32(data_size); /* xferStatus & resCount, resCount must be initialize to data_size */
 }


 /*
    A "DMA descriptor block" consists of several contiguous DMA commands.
    struct DMA_descriptor_block encapsulates all of the commands necessary
    to send one packet of DV data.

    There are three different types of these blocks:

         1) command to send an empty packet (CIP header only, no DV data):

 	    OUTPUT_MORE-Immediate <-- contains the iso header in-line
 	    OUTPUT_LAST           <-- points to the CIP header

 	2) command to send a full packet when the DV data payload does NOT
 	   cross a page boundary:

 	    OUTPUT_MORE-Immediate <-- contains the iso header in-line
 	    OUTPUT_MORE           <-- points to the CIP header
 	    OUTPUT_LAST           <-- points to entire DV data payload

 	3) command to send a full packet when the DV payload DOES cross
 	   a page boundary:

 	    OUTPUT_MORE-Immediate <-- contains the iso header in-line
 	    OUTPUT_MORE           <-- points to the CIP header
 	    OUTPUT_MORE           <-- points to first part of DV data payload
 	    OUTPUT_LAST           <-- points to second part of DV data payload

    This struct describes all three block types using unions.

    !!! It is vital that an even number of these descriptor blocks fit on one
    page of memory, since a block cannot cross a page boundary !!!

  */

 struct DMA_descriptor_block {

 	union {
 		struct {
 			/*  iso header, common to all output block types */
 			struct output_more_immediate omi;

 			union {
 				/* empty packet */
 				struct {
 					struct output_last ol;  /* CIP header */
 				} empty;

 				/* full packet */
 				struct {
 					struct output_more om;  /* CIP header */

 					union {
 				               /* payload does not cross page boundary */
 						struct {
 							struct output_last ol;  /* data payload */
 						} nocross;

 				               /* payload crosses page boundary */
 						struct {
 							struct output_more om;  /* data payload */
 							struct output_last ol;  /* data payload */
 						} cross;
 					} u;

 				} full;
 			} u;
 		} out;

 		struct {
 			struct input_last il;
 		} in;

 	} u;

 	/* ensure that PAGE_SIZE % sizeof(struct DMA_descriptor_block) == 0
 	   by padding out to 128 bytes */
 	u32 __pad__[12];
 };


 /* struct frame contains all data associated with one frame in the
    ringbuffer these are allocated when the DMA context is initialized
    do_dv1394_init().  They are re-used after the card finishes
    transmitting the frame. */

 struct video_card; /* forward declaration */

 struct frame {

 	/* points to the struct video_card that owns this frame */
 	struct video_card *video;

 	/* index of this frame in video_card->frames[] */
 	unsigned int frame_num;

 	/* FRAME_CLEAR - DMA program not set up, waiting for data
 	   FRAME_READY - DMA program written, ready to transmit

 	   Changes to these should be locked against the interrupt
 	*/
 	enum {
 		FRAME_CLEAR = 0,
 		FRAME_READY
 	} state;

 	/* whether this frame has been DMA'ed already; used only from
 	   the IRQ handler to determine whether the frame can be reset */
 	int done;


 	/* kernel virtual pointer to the start of this frame's data in
 	   the user ringbuffer. Use only for CPU access; to get the DMA
 	   bus address you must go through the video->user_dma mapping */
 	unsigned long data;

 	/* Max # of packets per frame */
 #define MAX_PACKETS 500


 	/* a PAGE_SIZE memory pool for allocating CIP headers
 	   !header_pool must be aligned to PAGE_SIZE! */
 	struct CIP_header *header_pool;
 	dma_addr_t         header_pool_dma;


 	/* a physically contiguous memory pool for allocating DMA
 	   descriptor blocks; usually around 64KB in size
 	   !descriptor_pool must be aligned to PAGE_SIZE! */
 	struct DMA_descriptor_block *descriptor_pool;
 	dma_addr_t                   descriptor_pool_dma;
 	unsigned long                descriptor_pool_size;


 	/* # of packets allocated for this frame */
 	unsigned int n_packets;


 	/* below are several pointers (kernel virtual addresses, not
 	   DMA bus addresses) to parts of the DMA program.  These are
 	   set each time the DMA program is written in
 	   frame_prepare(). They are used later on, e.g. from the
 	   interrupt handler, to check the status of the frame */

 	/* points to status/timestamp field of first DMA packet */
 	/* (we'll check it later to monitor timestamp accuracy) */
 	u32 *frame_begin_timestamp;

 	/* the timestamp we assigned to the first packet in the frame */
 	u32 assigned_timestamp;

 	/* pointer to the first packet's CIP header (where the timestamp goes) */
 	struct CIP_header *cip_syt1;

 	/* pointer to the second packet's CIP header
 	   (only set if the first packet was empty) */
 	struct CIP_header *cip_syt2;

 	/* in order to figure out what caused an interrupt,
 	   store pointers to the status fields of the two packets
 	   that can cause interrupts. We'll check these from the
 	   interrupt handler.
 	*/
 	u32 *mid_frame_timestamp;
 	u32 *frame_end_timestamp;

 	/* branch address field of final packet. This is effectively
 	   the "tail" in the chain of DMA descriptor blocks.
 	   We will fill it with the address of the first DMA descriptor
 	   block in the subsequent frame, once it is ready.
 	*/
 	u32 *frame_end_branch;

 	/* the number of descriptors in the first descriptor block
 	   of the frame. Needed to start DMA */
 	int first_n_descriptors;
 };


 struct packet {
 	u16	timestamp;
 	u16	invalid;
 	u16	iso_header;
 	u16	data_length;
 	u32	cip_h1;
 	u32	cip_h2;
 	unsigned char data[480];
 	unsigned char padding[16]; /* force struct size =512 for page alignment */
 };


 /* allocate/free a frame */
 static struct frame* frame_new(unsigned int frame_num, struct video_card *video);
 static void frame_delete(struct frame *f);

 /* reset f so that it can be used again */
 static void frame_reset(struct frame *f);

 /* struct video_card contains all data associated with one instance
    of the dv1394 driver
 */
 enum modes {
 	MODE_RECEIVE,
 	MODE_TRANSMIT
 };

 struct video_card {

 	/* ohci card to which this instance corresponds */
 	struct ti_ohci *ohci;

 	/* OHCI card id; the link between the VFS inode and a specific video_card
 	   (essentially the device minor number) */
 	int id;

 	/* entry in dv1394_cards */
 	struct list_head list;

 	/* OHCI card IT DMA context number, -1 if not in use */
 	int ohci_it_ctx;
 	struct ohci1394_iso_tasklet it_tasklet;

 	/* register offsets for current IT DMA context, 0 if not in use */
 	u32 ohci_IsoXmitContextControlSet;
 	u32 ohci_IsoXmitContextControlClear;
 	u32 ohci_IsoXmitCommandPtr;

 	/* OHCI card IR DMA context number, -1 if not in use */
 	struct ohci1394_iso_tasklet ir_tasklet;
 	int ohci_ir_ctx;

 	/* register offsets for current IR DMA context, 0 if not in use */
 	u32 ohci_IsoRcvContextControlSet;
 	u32 ohci_IsoRcvContextControlClear;
 	u32 ohci_IsoRcvCommandPtr;
 	u32 ohci_IsoRcvContextMatch;


 	/* CONCURRENCY CONTROL */

 	/* there are THREE levels of locking associated with video_card. */

 	/*
 	   1) the 'open' flag - this prevents more than one process from
 	   opening the device. (the driver currently assumes only one opener).
 	   This is a regular int, but use test_and_set_bit() (on bit zero)
 	   for atomicity.
 	 */
 	unsigned long open;

 	/*
 	   2) the spinlock - this provides mutual exclusion between the interrupt
 	   handler and process-context operations. Generally you must take the
 	   spinlock under the following conditions:
 	     1) DMA (and hence the interrupt handler) may be running
 	     AND
 	     2) you need to operate on the video_card, especially active_frame

 	     It is OK to play with video_card without taking the spinlock if
 	     you are certain that DMA is not running. Even if DMA is running,
 	     it is OK to *read* active_frame with the lock, then drop it
 	     immediately. This is safe because the interrupt handler will never
 	     advance active_frame onto a frame that is not READY (and the spinlock
 	     must be held while marking a frame READY).

 	     spinlock is also used to protect ohci_it_ctx and ohci_ir_ctx,
 	     which can be accessed from both process and interrupt context
 	 */
 	spinlock_t spinlock;

 	/* flag to prevent spurious interrupts (which OHCI seems to
 	   generate a lot :) from accessing the struct */
 	int dma_running;

 	/*
 	  3) the sleeping mutex 'mtx' - this is used from process context only,
 	  to serialize various operations on the video_card. Even though only one
 	  open() is allowed, we still need to prevent multiple threads of execution
 	  from entering calls like read, write, ioctl, etc.

 	  I honestly can't think of a good reason to use dv1394 from several threads
 	  at once, but we need to serialize anyway to prevent oopses =).

 	  NOTE: if you need both spinlock and mtx, take mtx first to avoid deadlock!
 	 */
 	struct mutex mtx;

 	/* people waiting for buffer space, please form a line here... */
 	wait_queue_head_t waitq;

 	/* support asynchronous I/O signals (SIGIO) */
 	struct fasync_struct *fasync;

 	/* the large, non-contiguous (rvmalloc()) ringbuffer for DV
            data, exposed to user-space via mmap() */
 	unsigned long      dv_buf_size;
 	struct dma_region  dv_buf;

 	/* next byte in the ringbuffer that a write() call will fill */
 	size_t write_off;

 	struct frame *frames[DV1394_MAX_FRAMES];

 	/* n_frames also serves as an indicator that this struct video_card is
 	   initialized and ready to run DMA buffers */

 	int n_frames;

 	/* this is the frame that is currently "owned" by the OHCI DMA controller
 	   (set to -1 iff DMA is not running)

 	   ! must lock against the interrupt handler when accessing it !

 	   RULES:

 	       Only the interrupt handler may change active_frame if DMA
 	          is running; if not, process may change it

 	       If the next frame is READY, the interrupt handler will advance
 	       active_frame when the current frame is finished.

 	       If the next frame is CLEAR, the interrupt handler will re-transmit
 	       the current frame, and the dropped_frames counter will be  incremented.

 	       The interrupt handler will NEVER advance active_frame to a
 	       frame that is not READY.
 	*/
 	int active_frame;
 	int first_run;

 	/* the same locking rules apply to these three fields also: */

 	/* altered ONLY from process context. Must check first_clear_frame->state;
 	   if it's READY, that means the ringbuffer is full with READY frames;
 	   if it's CLEAR, that means one or more ringbuffer frames are CLEAR */
 	unsigned int first_clear_frame;

 	/* altered both by process and interrupt */
 	unsigned int n_clear_frames;

 	/* only altered by the interrupt */
 	unsigned int dropped_frames;


 	/* the CIP accumulator and continuity counter are properties
 	   of the DMA stream as a whole (not a single frame), so they
 	   are stored here in the video_card */

 	unsigned long cip_accum;
 	unsigned long cip_n, cip_d;
 	unsigned int syt_offset;
 	unsigned int continuity_counter;

 	enum pal_or_ntsc pal_or_ntsc;

 	/* redundant, but simplifies the code somewhat */
 	unsigned int frame_size; /* in bytes */

 	/* the isochronous channel to use, -1 if video card is inactive */
 	int channel;


 	/* physically contiguous packet ringbuffer for receive */
 	struct dma_region packet_buf;
 	unsigned long  packet_buf_size;

 	unsigned int current_packet;
 	int first_frame; 	/* received first start frame marker? */
 	enum modes mode;
 };

 /*
    if the video_card is not initialized, then the ONLY fields that are valid are:
    ohci
    open
    n_frames
 */

 static inline int video_card_initialized(struct video_card *v)
 {
 	return v->n_frames > 0;
 }

 static int do_dv1394_init(struct video_card *video, struct dv1394_init *init);
 static int do_dv1394_init_default(struct video_card *video);
 static void do_dv1394_shutdown(struct video_card *video, int free_user_buf);


 /* NTSC empty packet rate accurate to within 0.01%,
    calibrated against a Sony DSR-40 DVCAM deck */

 #define CIP_N_NTSC   68000000
 #define CIP_D_NTSC 1068000000

 #define CIP_N_PAL  1
 #define CIP_D_PAL 16

 #endif /* _DV_1394_PRIVATE_H */
	/*
	* dv1394-private.h - DV input/output over IEEE 1394 on OHCI chips
	* Copyright (C)2001 Daniel Maas <dmaas@dcine.com>
	* receive by Dan Dennedy <dan@dennedy.org>
	*
	* based on:
	* video1394.h - driver for OHCI 1394 boards
	* Copyright (C)1999,2000 Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>
	* Peter Schlaile <udbz@rz.uni-karlsruhe.de>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software Foundation,
	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	*/

	#ifndef _DV_1394_PRIVATE_H
	#define _DV_1394_PRIVATE_H

	#include "ieee1394.h"
	#include "ohci1394.h"
	#include "dma.h"

	/* data structures private to the dv1394 driver */
	/* none of this is exposed to user-space */


	/*
	the 8-byte CIP (Common Isochronous Packet) header that precedes
	each packet of DV data.

	See the IEC 61883 standard.
	*/

	struct CIP_header { unsigned char b[8]; };

	static inline void fill_cip_header(struct CIP_header *cip,
	unsigned char source_node_id,
	unsigned long counter,
	enum pal_or_ntsc format,
	unsigned long timestamp)
	{
	cip->b[0] = source_node_id;
	cip->b[1] = 0x78; /* packet size in quadlets (480/4) - even for empty packets! */
	cip->b[2] = 0x00;
	cip->b[3] = counter;

	cip->b[4] = 0x80; /* const */

	switch(format) {
	case DV1394_PAL:
	cip->b[5] = 0x80;
	break;
	case DV1394_NTSC:
	cip->b[5] = 0x00;
	break;
	}

	cip->b[6] = timestamp >> 8;
	cip->b[7] = timestamp & 0xFF;
	}



	/*
	DMA commands used to program the OHCI's DMA engine

	See the Texas Instruments OHCI 1394 chipset documentation.
	*/

	struct output_more_immediate { u32 q[8]; };
	struct output_more { u32 q[4]; };
	struct output_last { u32 q[4]; };
	struct input_more { u32 q[4]; };
	struct input_last { u32 q[4]; };

	/* outputs */

	static inline void fill_output_more_immediate(struct output_more_immediate *omi,
	unsigned char tag,
	unsigned char channel,
	unsigned char sync_tag,
	unsigned int payload_size)
	{
	omi->q[0] = cpu_to_le32(0x02000000 \| 8); /* OUTPUT_MORE_IMMEDIATE; 8 is the size of the IT header */
	omi->q[1] = 0;
	omi->q[2] = 0;
	omi->q[3] = 0;

	/* IT packet header */
	omi->q[4] = cpu_to_le32( (0x0 << 16) /* IEEE1394_SPEED_100 */
	\| (tag << 14)
	\| (channel << 8)
	\| (TCODE_ISO_DATA << 4)
	\| (sync_tag) );

	/* reserved field; mimic behavior of my Sony DSR-40 */
	omi->q[5] = cpu_to_le32((payload_size << 16) \| (0x7F << 8) \| 0xA0);

	omi->q[6] = 0;
	omi->q[7] = 0;
	}

	static inline void fill_output_more(struct output_more *om,
	unsigned int data_size,
	unsigned long data_phys_addr)
	{
	om->q[0] = cpu_to_le32(data_size);
	om->q[1] = cpu_to_le32(data_phys_addr);
	om->q[2] = 0;
	om->q[3] = 0;
	}

	static inline void fill_output_last(struct output_last *ol,
	int want_timestamp,
	int want_interrupt,
	unsigned int data_size,
	unsigned long data_phys_addr)
	{
	u32 temp = 0;
	temp \|= 1 << 28; /* OUTPUT_LAST */

	if (want_timestamp) /* controller will update timestamp at DMA time */
	temp \|= 1 << 27;

	if (want_interrupt)
	temp \|= 3 << 20;

	temp \|= 3 << 18; /* must take branch */
	temp \|= data_size;

	ol->q[0] = cpu_to_le32(temp);
	ol->q[1] = cpu_to_le32(data_phys_addr);
	ol->q[2] = 0;
	ol->q[3] = 0;
	}

	/* inputs */

	static inline void fill_input_more(struct input_more *im,
	int want_interrupt,
	unsigned int data_size,
	unsigned long data_phys_addr)
	{
	u32 temp = 2 << 28; /* INPUT_MORE */
	temp \|= 8 << 24; /* s = 1, update xferStatus and resCount */
	if (want_interrupt)
	temp \|= 0 << 20; /* interrupts, i=0 in packet-per-buffer mode */
	temp \|= 0x0 << 16; /* disable branch to address for packet-per-buffer mode */
	/* disable wait on sync field, not used in DV :-( */
	temp \|= data_size;

	im->q[0] = cpu_to_le32(temp);
	im->q[1] = cpu_to_le32(data_phys_addr);
	im->q[2] = 0; /* branchAddress and Z not use in packet-per-buffer mode */
	im->q[3] = 0; /* xferStatus & resCount, resCount must be initialize to data_size */
	}

	static inline void fill_input_last(struct input_last *il,
	int want_interrupt,
	unsigned int data_size,
	unsigned long data_phys_addr)
	{
	u32 temp = 3 << 28; /* INPUT_LAST */
	temp \|= 8 << 24; /* s = 1, update xferStatus and resCount */
	if (want_interrupt)
	temp \|= 3 << 20; /* enable interrupts */
	temp \|= 0xC << 16; /* enable branch to address */
	/* disable wait on sync field, not used in DV :-( */
	temp \|= data_size;

	il->q[0] = cpu_to_le32(temp);
	il->q[1] = cpu_to_le32(data_phys_addr);
	il->q[2] = cpu_to_le32(1); /* branchAddress (filled in later) and Z = 1 descriptor in next block */
	il->q[3] = cpu_to_le32(data_size); /* xferStatus & resCount, resCount must be initialize to data_size */
	}



	/*
	A "DMA descriptor block" consists of several contiguous DMA commands.
	struct DMA_descriptor_block encapsulates all of the commands necessary
	to send one packet of DV data.

	There are three different types of these blocks:

	1) command to send an empty packet (CIP header only, no DV data):

	OUTPUT_MORE-Immediate <-- contains the iso header in-line
	OUTPUT_LAST <-- points to the CIP header

	2) command to send a full packet when the DV data payload does NOT
	cross a page boundary:

	OUTPUT_MORE-Immediate <-- contains the iso header in-line
	OUTPUT_MORE <-- points to the CIP header
	OUTPUT_LAST <-- points to entire DV data payload

	3) command to send a full packet when the DV payload DOES cross
	a page boundary:

	OUTPUT_MORE-Immediate <-- contains the iso header in-line
	OUTPUT_MORE <-- points to the CIP header
	OUTPUT_MORE <-- points to first part of DV data payload
	OUTPUT_LAST <-- points to second part of DV data payload

	This struct describes all three block types using unions.

	!!! It is vital that an even number of these descriptor blocks fit on one
	page of memory, since a block cannot cross a page boundary !!!

	*/

	struct DMA_descriptor_block {

	union {
	struct {
	/* iso header, common to all output block types */
	struct output_more_immediate omi;

	union {
	/* empty packet */
	struct {
	struct output_last ol; /* CIP header */
	} empty;

	/* full packet */
	struct {
	struct output_more om; /* CIP header */

	union {
	/* payload does not cross page boundary */
	struct {
	struct output_last ol; /* data payload */
	} nocross;

	/* payload crosses page boundary */
	struct {
	struct output_more om; /* data payload */
	struct output_last ol; /* data payload */
	} cross;
	} u;

	} full;
	} u;
	} out;

	struct {
	struct input_last il;
	} in;

	} u;

	/* ensure that PAGE_SIZE % sizeof(struct DMA_descriptor_block) == 0
	by padding out to 128 bytes */
	u32 __pad__[12];
	};


	/* struct frame contains all data associated with one frame in the
	ringbuffer these are allocated when the DMA context is initialized
	do_dv1394_init(). They are re-used after the card finishes
	transmitting the frame. */

	struct video_card; /* forward declaration */

	struct frame {

	/* points to the struct video_card that owns this frame */
	struct video_card *video;

	/* index of this frame in video_card->frames[] */
	unsigned int frame_num;

	/* FRAME_CLEAR - DMA program not set up, waiting for data
	FRAME_READY - DMA program written, ready to transmit

	Changes to these should be locked against the interrupt
	*/
	enum {
	FRAME_CLEAR = 0,
	FRAME_READY
	} state;

	/* whether this frame has been DMA'ed already; used only from
	the IRQ handler to determine whether the frame can be reset */
	int done;


	/* kernel virtual pointer to the start of this frame's data in
	the user ringbuffer. Use only for CPU access; to get the DMA
	bus address you must go through the video->user_dma mapping */
	unsigned long data;

	/* Max # of packets per frame */
	#define MAX_PACKETS 500


	/* a PAGE_SIZE memory pool for allocating CIP headers
	!header_pool must be aligned to PAGE_SIZE! */
	struct CIP_header *header_pool;
	dma_addr_t header_pool_dma;


	/* a physically contiguous memory pool for allocating DMA
	descriptor blocks; usually around 64KB in size
	!descriptor_pool must be aligned to PAGE_SIZE! */
	struct DMA_descriptor_block *descriptor_pool;
	dma_addr_t descriptor_pool_dma;
	unsigned long descriptor_pool_size;


	/* # of packets allocated for this frame */
	unsigned int n_packets;


	/* below are several pointers (kernel virtual addresses, not
	DMA bus addresses) to parts of the DMA program. These are
	set each time the DMA program is written in
	frame_prepare(). They are used later on, e.g. from the
	interrupt handler, to check the status of the frame */

	/* points to status/timestamp field of first DMA packet */
	/* (we'll check it later to monitor timestamp accuracy) */
	u32 *frame_begin_timestamp;

	/* the timestamp we assigned to the first packet in the frame */
	u32 assigned_timestamp;

	/* pointer to the first packet's CIP header (where the timestamp goes) */
	struct CIP_header *cip_syt1;

	/* pointer to the second packet's CIP header
	(only set if the first packet was empty) */
	struct CIP_header *cip_syt2;

	/* in order to figure out what caused an interrupt,
	store pointers to the status fields of the two packets
	that can cause interrupts. We'll check these from the
	interrupt handler.
	*/
	u32 *mid_frame_timestamp;
	u32 *frame_end_timestamp;

	/* branch address field of final packet. This is effectively
	the "tail" in the chain of DMA descriptor blocks.
	We will fill it with the address of the first DMA descriptor
	block in the subsequent frame, once it is ready.
	*/
	u32 *frame_end_branch;

	/* the number of descriptors in the first descriptor block
	of the frame. Needed to start DMA */
	int first_n_descriptors;
	};


	struct packet {
	u16 timestamp;
	u16 invalid;
	u16 iso_header;
	u16 data_length;
	u32 cip_h1;
	u32 cip_h2;
	unsigned char data[480];
	unsigned char padding[16]; /* force struct size =512 for page alignment */
	};


	/* allocate/free a frame */
	static struct frame* frame_new(unsigned int frame_num, struct video_card *video);
	static void frame_delete(struct frame *f);

	/* reset f so that it can be used again */
	static void frame_reset(struct frame *f);

	/* struct video_card contains all data associated with one instance
	of the dv1394 driver
	*/
	enum modes {
	MODE_RECEIVE,
	MODE_TRANSMIT
	};

	struct video_card {

	/* ohci card to which this instance corresponds */
	struct ti_ohci *ohci;

	/* OHCI card id; the link between the VFS inode and a specific video_card
	(essentially the device minor number) */
	int id;

	/* entry in dv1394_cards */
	struct list_head list;

	/* OHCI card IT DMA context number, -1 if not in use */
	int ohci_it_ctx;
	struct ohci1394_iso_tasklet it_tasklet;

	/* register offsets for current IT DMA context, 0 if not in use */
	u32 ohci_IsoXmitContextControlSet;
	u32 ohci_IsoXmitContextControlClear;
	u32 ohci_IsoXmitCommandPtr;

	/* OHCI card IR DMA context number, -1 if not in use */
	struct ohci1394_iso_tasklet ir_tasklet;
	int ohci_ir_ctx;

	/* register offsets for current IR DMA context, 0 if not in use */
	u32 ohci_IsoRcvContextControlSet;
	u32 ohci_IsoRcvContextControlClear;
	u32 ohci_IsoRcvCommandPtr;
	u32 ohci_IsoRcvContextMatch;


	/* CONCURRENCY CONTROL */

	/* there are THREE levels of locking associated with video_card. */

	/*
	1) the 'open' flag - this prevents more than one process from
	opening the device. (the driver currently assumes only one opener).
	This is a regular int, but use test_and_set_bit() (on bit zero)
	for atomicity.
	*/
	unsigned long open;

	/*
	2) the spinlock - this provides mutual exclusion between the interrupt
	handler and process-context operations. Generally you must take the
	spinlock under the following conditions:
	1) DMA (and hence the interrupt handler) may be running
	AND
	2) you need to operate on the video_card, especially active_frame

	It is OK to play with video_card without taking the spinlock if
	you are certain that DMA is not running. Even if DMA is running,
	it is OK to read active_frame with the lock, then drop it
	immediately. This is safe because the interrupt handler will never
	advance active_frame onto a frame that is not READY (and the spinlock
	must be held while marking a frame READY).

	spinlock is also used to protect ohci_it_ctx and ohci_ir_ctx,
	which can be accessed from both process and interrupt context
	*/
	spinlock_t spinlock;

	/* flag to prevent spurious interrupts (which OHCI seems to
	generate a lot :) from accessing the struct */
	int dma_running;

	/*
	3) the sleeping mutex 'mtx' - this is used from process context only,
	to serialize various operations on the video_card. Even though only one
	open() is allowed, we still need to prevent multiple threads of execution
	from entering calls like read, write, ioctl, etc.

	I honestly can't think of a good reason to use dv1394 from several threads
	at once, but we need to serialize anyway to prevent oopses =).

	NOTE: if you need both spinlock and mtx, take mtx first to avoid deadlock!
	*/
	struct mutex mtx;

	/* people waiting for buffer space, please form a line here... */
	wait_queue_head_t waitq;

	/* support asynchronous I/O signals (SIGIO) */
	struct fasync_struct *fasync;

	/* the large, non-contiguous (rvmalloc()) ringbuffer for DV
	data, exposed to user-space via mmap() */
	unsigned long dv_buf_size;
	struct dma_region dv_buf;

	/* next byte in the ringbuffer that a write() call will fill */
	size_t write_off;

	struct frame *frames[DV1394_MAX_FRAMES];

	/* n_frames also serves as an indicator that this struct video_card is
	initialized and ready to run DMA buffers */

	int n_frames;

	/* this is the frame that is currently "owned" by the OHCI DMA controller
	(set to -1 iff DMA is not running)

	! must lock against the interrupt handler when accessing it !

	RULES:

	Only the interrupt handler may change active_frame if DMA
	is running; if not, process may change it

	If the next frame is READY, the interrupt handler will advance
	active_frame when the current frame is finished.

	If the next frame is CLEAR, the interrupt handler will re-transmit
	the current frame, and the dropped_frames counter will be incremented.

	The interrupt handler will NEVER advance active_frame to a
	frame that is not READY.
	*/
	int active_frame;
	int first_run;

	/* the same locking rules apply to these three fields also: */

	/* altered ONLY from process context. Must check first_clear_frame->state;
	if it's READY, that means the ringbuffer is full with READY frames;
	if it's CLEAR, that means one or more ringbuffer frames are CLEAR */
	unsigned int first_clear_frame;

	/* altered both by process and interrupt */
	unsigned int n_clear_frames;

	/* only altered by the interrupt */
	unsigned int dropped_frames;



	/* the CIP accumulator and continuity counter are properties
	of the DMA stream as a whole (not a single frame), so they
	are stored here in the video_card */

	unsigned long cip_accum;
	unsigned long cip_n, cip_d;
	unsigned int syt_offset;
	unsigned int continuity_counter;

	enum pal_or_ntsc pal_or_ntsc;

	/* redundant, but simplifies the code somewhat */
	unsigned int frame_size; /* in bytes */

	/* the isochronous channel to use, -1 if video card is inactive */
	int channel;


	/* physically contiguous packet ringbuffer for receive */
	struct dma_region packet_buf;
	unsigned long packet_buf_size;

	unsigned int current_packet;
	int first_frame; /* received first start frame marker? */
	enum modes mode;
	};

	/*
	if the video_card is not initialized, then the ONLY fields that are valid are:
	ohci
	open
	n_frames
	*/

	static inline int video_card_initialized(struct video_card *v)
	{
	return v->n_frames > 0;
	}

	static int do_dv1394_init(struct video_card video, struct dv1394_init init);
	static int do_dv1394_init_default(struct video_card *video);
	static void do_dv1394_shutdown(struct video_card *video, int free_user_buf);


	/* NTSC empty packet rate accurate to within 0.01%,
	calibrated against a Sony DSR-40 DVCAM deck */

	#define CIP_N_NTSC 68000000
	#define CIP_D_NTSC 1068000000

	#define CIP_N_PAL 1
	#define CIP_D_PAL 16

	#endif /* _DV_1394_PRIVATE_H */