v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / ieee1394 / ieee1394_core.h
1
2 #ifndef _IEEE1394_CORE_H
3 #define _IEEE1394_CORE_H
4
5 #include <linux/tqueue.h>
6 #include <linux/slab.h>
7 #include <asm/semaphore.h>
8 #include "hosts.h"
9
10
11 struct hpsb_packet {
12         /* This struct is basically read-only for hosts with the exception of
13          * the data buffer contents and xnext - see below. */
14         struct list_head list;
15
16         /* This can be used for host driver internal linking. */
17         struct hpsb_packet *xnext;
18
19         nodeid_t node_id;
20
21         /* Async and Iso types should be clear, raw means send-as-is, do not
22          * CRC!  Byte swapping shall still be done in this case. */
23         enum { async, iso, raw } __attribute__((packed)) type;
24
25         /* Okay, this is core internal and a no care for hosts.
26          * queued   = queued for sending
27          * pending  = sent, waiting for response
28          * complete = processing completed, successful or not
29          * incoming = incoming packet
30          */
31         enum { 
32                 unused, queued, pending, complete, incoming 
33         } __attribute__((packed)) state;
34
35         /* These are core internal. */
36         char tlabel;
37         char ack_code;
38         char tcode;
39
40         unsigned expect_response:1;
41         unsigned no_waiter:1;
42
43         /* Data big endianness flag - may vary from request to request.  The
44          * header is always in machine byte order.
45          * Not really used currently.  */
46         unsigned data_be:1;
47
48         /* Speed to transmit with: 0 = 100Mbps, 1 = 200Mbps, 2 = 400Mbps */
49         unsigned speed_code:2;
50
51         /*
52          * *header and *data are guaranteed to be 32-bit DMAable and may be
53          * overwritten to allow in-place byte swapping.  Neither of these is
54          * CRCed (the sizes also don't include CRC), but contain space for at
55          * least one additional quadlet to allow in-place CRCing.  The memory is
56          * also guaranteed to be DMA mappable.
57          */
58         quadlet_t *header;
59         quadlet_t *data;
60         size_t header_size;
61         size_t data_size;
62
63
64         struct hpsb_host *host;
65         unsigned int generation;
66
67         /* Very core internal, don't care. */
68         struct semaphore state_change;
69
70         task_queue complete_tq;
71
72         /* Store jiffies for implementing bus timeouts. */
73         unsigned long sendtime;
74
75         quadlet_t embedded_header[5];
76 };
77
78
79 void abort_timedouts(struct hpsb_host *host);
80 void abort_requests(struct hpsb_host *host);
81
82 struct hpsb_packet *alloc_hpsb_packet(size_t data_size);
83 void free_hpsb_packet(struct hpsb_packet *packet);
84
85
86 /*
87  * Generation counter for the complete 1394 subsystem.  Generation gets
88  * incremented on every change in the subsystem (e.g. bus reset).
89  *
90  * Use the functions, not the variable.
91  */
92 #include <asm/atomic.h>
93
94 static inline unsigned int get_hpsb_generation(struct hpsb_host *host)
95 {
96         return atomic_read(&host->generation);
97 }
98
99
100 /*
101  * Queue packet for transmitting, return 0 for failure.
102  */
103 int hpsb_send_packet(struct hpsb_packet *packet);
104
105 /* Initiate bus reset on the given host.  Returns 1 if bus reset already in
106  * progress, 0 otherwise. */
107 int hpsb_reset_bus(struct hpsb_host *host, int type);
108
109 /*
110  * The following functions are exported for host driver module usage.  All of
111  * them are safe to use in interrupt contexts, although some are quite
112  * complicated so you may want to run them in bottom halves instead of calling
113  * them directly.
114  */
115
116 /* Notify a bus reset to the core.  Returns 1 if bus reset already in progress,
117  * 0 otherwise. */
118 int hpsb_bus_reset(struct hpsb_host *host);
119
120 /*
121  * Hand over received selfid packet to the core.  Complement check (second
122  * quadlet is complement of first) is expected to be done and succesful.
123  */
124 void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid);
125
126 /* 
127  * Notify completion of SelfID stage to the core and report new physical ID
128  * and whether host is root now.
129  */
130 void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot);
131
132 /*
133  * Notify core of sending a packet.  Ackcode is the ack code returned for async
134  * transmits or ACKX_SEND_ERROR if the transmission failed completely; ACKX_NONE
135  * for other cases (internal errors that don't justify a panic).  Safe to call
136  * from within a transmit packet routine.
137  */
138 void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet,
139                       int ackcode);
140
141 /*
142  * Hand over received packet to the core.  The contents of data are expected to
143  * be the full packet but with the CRCs left out (data block follows header
144  * immediately), with the header (i.e. the first four quadlets) in machine byte
145  * order and the data block in big endian.  *data can be safely overwritten
146  * after this call.
147  *
148  * If the packet is a write request, write_acked is to be set to true if it was
149  * ack_complete'd already, false otherwise.  This arg is ignored for any other
150  * packet type.
151  */
152 void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
153                           int write_acked);
154
155 #endif /* _IEEE1394_CORE_H */