ieee1394_core.h

1394在linux下单独的驱动程序代码

#ifndef _IEEE1394_CORE_H
#define _IEEE1394_CORE_H

#include <linux/slab.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/proc_fs.h>
#include <asm/semaphore.h>
#include "hosts.h"


struct hpsb_packet {
/* This struct is basically read-only for hosts with the exception of
	* the data buffer contents and xnext - see below. */
	struct list_head list;
	
	/* This can be used for host driver internal linking. */
	struct list_head driver_list;
	
	nodeid_t node_id;
	
	/* Async and Iso types should be clear, raw means send-as-is, do not
	* CRC!  Byte swapping shall still be done in this case. */
	enum { hpsb_async, hpsb_iso, hpsb_raw } __attribute__((packed)) type;
	
	/* Okay, this is core internal and a no care for hosts.
	* queued   = queued for sending
	* pending  = sent, waiting for response
	* complete = processing completed, successful or not
	* incoming = incoming packet
	*/
	enum { 
		hpsb_unused, hpsb_queued, hpsb_pending, hpsb_complete, hpsb_incoming 
	} __attribute__((packed)) state;
	
	/* These are core internal. */
	signed char tlabel;
	char ack_code;
	char tcode;
	
	unsigned expect_response:1;
	unsigned no_waiter:1;
	
	/* Data big endianness flag - may vary from request to request.  The
	* header is always in machine byte order.
	* Not really used currently.  */
	unsigned data_be:1;
	
	/* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */
	unsigned speed_code:2;
	
	/*
	* *header and *data are guaranteed to be 32-bit DMAable and may be
	* overwritten to allow in-place byte swapping.  Neither of these is
	* CRCed (the sizes also don't include CRC), but contain space for at
	* least one additional quadlet to allow in-place CRCing.  The memory is
	* also guaranteed to be DMA mappable.
	*/
	quadlet_t *header;
	quadlet_t *data;
	size_t header_size;
	size_t data_size;
	
	
	struct hpsb_host *host;
	unsigned int generation;
	
	/* Very core internal, don't care. */
	struct semaphore state_change;
	
	/* Function (and possible data to pass to it) to call when this
	* packet is completed.  */
	void (*complete_routine)(void *);
	void *complete_data;
	
	/* Store jiffies for implementing bus timeouts. */
	unsigned long sendtime;
	
	quadlet_t embedded_header[5];
};

/* Set a task for when a packet completes */
void hpsb_set_packet_complete_task(struct hpsb_packet *packet,
								   void (*routine)(void *), void *data);

static inline struct hpsb_packet *driver_packet(struct list_head *l)
{
	return list_entry(l, struct hpsb_packet, driver_list);
}

void abort_timedouts(unsigned long __opaque);
void abort_requests(struct hpsb_host *host);

struct hpsb_packet *alloc_hpsb_packet(size_t data_size);
void free_hpsb_packet(struct hpsb_packet *packet);


/*
* Generation counter for the complete 1394 subsystem.  Generation gets
* incremented on every change in the subsystem (e.g. bus reset).
*
* Use the functions, not the variable.
*/
#include <asm/atomic.h>

static inline unsigned int get_hpsb_generation(struct hpsb_host *host)
{
	return atomic_read(&host->generation);
}

/*
* Send a PHY configuration packet.
*/
int hpsb_send_phy_config(struct hpsb_host *host, int rootid, int gapcnt);

/*
* Queue packet for transmitting, return 0 for failure.
*/
int hpsb_send_packet(struct hpsb_packet *packet);

/* Initiate bus reset on the given host.  Returns 1 if bus reset already in
* progress, 0 otherwise. */
int hpsb_reset_bus(struct hpsb_host *host, int type);

/*
* The following functions are exported for host driver module usage.  All of
* them are safe to use in interrupt contexts, although some are quite
* complicated so you may want to run them in bottom halves instead of calling
* them directly.
*/

/* Notify a bus reset to the core.  Returns 1 if bus reset already in progress,
* 0 otherwise. */
int hpsb_bus_reset(struct hpsb_host *host);

/*
* Hand over received selfid packet to the core.  Complement check (second
* quadlet is complement of first) is expected to be done and succesful.
*/
void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid);

/* 
* Notify completion of SelfID stage to the core and report new physical ID
* and whether host is root now.
*/
void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot);

/*
* Notify core of sending a packet.  Ackcode is the ack code returned for async
* transmits or ACKX_SEND_ERROR if the transmission failed completely; ACKX_NONE
* for other cases (internal errors that don't justify a panic).  Safe to call
* from within a transmit packet routine.
*/
void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
                      int ackcode);

/*
* Hand over received packet to the core.  The contents of data are expected to
* be the full packet but with the CRCs left out (data block follows header
* immediately), with the header (i.e. the first four quadlets) in machine byte
* order and the data block in big endian.  *data can be safely overwritten
* after this call.
*
* If the packet is a write request, write_acked is to be set to true if it was
* ack_complete'd already, false otherwise.  This arg is ignored for any other
* packet type.
*/
void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
                          int write_acked);


/*
* CHARACTER DEVICE DISPATCHING
*
* All ieee1394 character device drivers share the same major number
* (major 171).  The 256 minor numbers are allocated to the various
* task-specific interfaces (raw1394, video1394, dv1394, etc) in
* blocks of 16.
*
* The core ieee1394.o modules handles the initial open() for all
* character devices on major 171; it then dispatches to the
* appropriate task-specific driver.
*
* Minor device number block allocations:
*
* Block 0  (  0- 15)  raw1394
* Block 1  ( 16- 31)  video1394
* Block 2  ( 32- 47)  dv1394
*
* Blocks 3-14 free for future allocation
*
* Block 15 (240-255)  reserved for drivers under development, etc.
*/

#define IEEE1394_MAJOR               171

#define IEEE1394_MINOR_BLOCK_RAW1394       0
#define IEEE1394_MINOR_BLOCK_VIDEO1394     1
#define IEEE1394_MINOR_BLOCK_DV1394        2
#define IEEE1394_MINOR_BLOCK_AMDTP         3
#define IEEE1394_MINOR_BLOCK_EXPERIMENTAL 15

/* return the index (within a minor number block) of a file */
static inline unsigned char ieee1394_file_to_instance(struct file *file)
{
	unsigned char minor = MINOR(file->f_dentry->d_inode->i_rdev);
	
	/* return lower 4 bits */
	return minor & 0xF;
}

/* 
* Task-specific drivers should call ieee1394_register_chardev() to
* request a block of 16 minor numbers.
*
* Returns 0 if the request was successful, -EBUSY if the block was
* already taken.
*/

int  ieee1394_register_chardev(int blocknum,           /* 0-15 */
							   struct module *module,  /* THIS_MODULE */
							   struct file_operations *file_ops);

/* release a block of minor numbers */
void ieee1394_unregister_chardev(int blocknum);

/* the devfs handle for /dev/ieee1394; NULL if devfs is not in use */
extern devfs_handle_t ieee1394_devfs_handle;

/* the proc_fs entry for /proc/ieee1394 */
extern struct proc_dir_entry *ieee1394_procfs_entry;

#endif /* _IEEE1394_CORE_H */