]> www.pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/firewire/fw-transaction.h
firewire: remove unused struct members
[linux-2.6-omap-h63xx.git] / drivers / firewire / fw-transaction.h
1 /*
2  * Copyright (C) 2003-2006 Kristian Hoegsberg <krh@bitplanet.net>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  */
18
19 #ifndef __fw_transaction_h
20 #define __fw_transaction_h
21
22 #include <linux/device.h>
23 #include <linux/timer.h>
24 #include <linux/interrupt.h>
25 #include <linux/list.h>
26 #include <linux/fs.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/firewire-constants.h>
29 #include <asm/atomic.h>
30
31 #define TCODE_IS_READ_REQUEST(tcode)    (((tcode) & ~1) == 4)
32 #define TCODE_IS_BLOCK_PACKET(tcode)    (((tcode) &  1) != 0)
33 #define TCODE_IS_REQUEST(tcode)         (((tcode) &  2) == 0)
34 #define TCODE_IS_RESPONSE(tcode)        (((tcode) &  2) != 0)
35 #define TCODE_HAS_REQUEST_DATA(tcode)   (((tcode) & 12) != 4)
36 #define TCODE_HAS_RESPONSE_DATA(tcode)  (((tcode) & 12) != 0)
37
38 #define LOCAL_BUS 0xffc0
39
40 #define SELFID_PORT_CHILD       0x3
41 #define SELFID_PORT_PARENT      0x2
42 #define SELFID_PORT_NCONN       0x1
43 #define SELFID_PORT_NONE        0x0
44
45 #define PHY_PACKET_CONFIG       0x0
46 #define PHY_PACKET_LINK_ON      0x1
47 #define PHY_PACKET_SELF_ID      0x2
48
49 /* Bit fields _within_ the PHY registers. */
50 #define PHY_LINK_ACTIVE         0x80
51 #define PHY_CONTENDER           0x40
52 #define PHY_BUS_RESET           0x40
53 #define PHY_BUS_SHORT_RESET     0x40
54
55 #define CSR_REGISTER_BASE               0xfffff0000000ULL
56
57 /* register offsets relative to CSR_REGISTER_BASE */
58 #define CSR_STATE_CLEAR                 0x0
59 #define CSR_STATE_SET                   0x4
60 #define CSR_NODE_IDS                    0x8
61 #define CSR_RESET_START                 0xc
62 #define CSR_SPLIT_TIMEOUT_HI            0x18
63 #define CSR_SPLIT_TIMEOUT_LO            0x1c
64 #define CSR_CYCLE_TIME                  0x200
65 #define CSR_BUS_TIME                    0x204
66 #define CSR_BUSY_TIMEOUT                0x210
67 #define CSR_BUS_MANAGER_ID              0x21c
68 #define CSR_BANDWIDTH_AVAILABLE         0x220
69 #define CSR_CHANNELS_AVAILABLE          0x224
70 #define CSR_CHANNELS_AVAILABLE_HI       0x224
71 #define CSR_CHANNELS_AVAILABLE_LO       0x228
72 #define CSR_BROADCAST_CHANNEL           0x234
73 #define CSR_CONFIG_ROM                  0x400
74 #define CSR_CONFIG_ROM_END              0x800
75 #define CSR_FCP_COMMAND                 0xB00
76 #define CSR_FCP_RESPONSE                0xD00
77 #define CSR_FCP_END                     0xF00
78 #define CSR_TOPOLOGY_MAP                0x1000
79 #define CSR_TOPOLOGY_MAP_END            0x1400
80 #define CSR_SPEED_MAP                   0x2000
81 #define CSR_SPEED_MAP_END               0x3000
82
83 #define BROADCAST_CHANNEL_INITIAL       (1 << 31 | 31)
84 #define BROADCAST_CHANNEL_VALID         (1 << 30)
85
86 #define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
87 #define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
88
89 static inline void
90 fw_memcpy_from_be32(void *_dst, void *_src, size_t size)
91 {
92         u32    *dst = _dst;
93         __be32 *src = _src;
94         int i;
95
96         for (i = 0; i < size / 4; i++)
97                 dst[i] = be32_to_cpu(src[i]);
98 }
99
100 static inline void
101 fw_memcpy_to_be32(void *_dst, void *_src, size_t size)
102 {
103         fw_memcpy_from_be32(_dst, _src, size);
104 }
105
106 struct fw_card;
107 struct fw_packet;
108 struct fw_node;
109 struct fw_request;
110
111 struct fw_descriptor {
112         struct list_head link;
113         size_t length;
114         u32 immediate;
115         u32 key;
116         const u32 *data;
117 };
118
119 int fw_core_add_descriptor(struct fw_descriptor *desc);
120 void fw_core_remove_descriptor(struct fw_descriptor *desc);
121
122 typedef void (*fw_packet_callback_t)(struct fw_packet *packet,
123                                      struct fw_card *card, int status);
124
125 typedef void (*fw_transaction_callback_t)(struct fw_card *card, int rcode,
126                                           void *data,
127                                           size_t length,
128                                           void *callback_data);
129
130 /*
131  * Important note:  The callback must guarantee that either fw_send_response()
132  * or kfree() is called on the @request.
133  */
134 typedef void (*fw_address_callback_t)(struct fw_card *card,
135                                       struct fw_request *request,
136                                       int tcode, int destination, int source,
137                                       int generation, int speed,
138                                       unsigned long long offset,
139                                       void *data, size_t length,
140                                       void *callback_data);
141
142 typedef void (*fw_bus_reset_callback_t)(struct fw_card *handle,
143                                         int node_id, int generation,
144                                         u32 *self_ids,
145                                         int self_id_count,
146                                         void *callback_data);
147
148 struct fw_packet {
149         int speed;
150         int generation;
151         u32 header[4];
152         size_t header_length;
153         void *payload;
154         size_t payload_length;
155         u32 timestamp;
156
157         /*
158          * This callback is called when the packet transmission has
159          * completed; for successful transmission, the status code is
160          * the ack received from the destination, otherwise it's a
161          * negative errno: ENOMEM, ESTALE, ETIMEDOUT, ENODEV, EIO.
162          * The callback can be called from tasklet context and thus
163          * must never block.
164          */
165         fw_packet_callback_t callback;
166         int ack;
167         struct list_head link;
168         void *driver_data;
169 };
170
171 struct fw_transaction {
172         int node_id; /* The generation is implied; it is always the current. */
173         int tlabel;
174         int timestamp;
175         struct list_head link;
176
177         struct fw_packet packet;
178
179         /*
180          * The data passed to the callback is valid only during the
181          * callback.
182          */
183         fw_transaction_callback_t callback;
184         void *callback_data;
185 };
186
187 static inline struct fw_packet *
188 fw_packet(struct list_head *l)
189 {
190         return list_entry(l, struct fw_packet, link);
191 }
192
193 struct fw_address_handler {
194         u64 offset;
195         size_t length;
196         fw_address_callback_t address_callback;
197         void *callback_data;
198         struct list_head link;
199 };
200
201
202 struct fw_address_region {
203         u64 start;
204         u64 end;
205 };
206
207 extern const struct fw_address_region fw_high_memory_region;
208
209 int fw_core_add_address_handler(struct fw_address_handler *handler,
210                                 const struct fw_address_region *region);
211 void fw_core_remove_address_handler(struct fw_address_handler *handler);
212 void fw_fill_response(struct fw_packet *response, u32 *request_header,
213                       int rcode, void *payload, size_t length);
214 void fw_send_response(struct fw_card *card,
215                       struct fw_request *request, int rcode);
216
217 extern struct bus_type fw_bus_type;
218
219 struct fw_card {
220         const struct fw_card_driver *driver;
221         struct device *device;
222         atomic_t device_count;
223
224         int node_id;
225         int generation;
226         int current_tlabel, tlabel_mask;
227         struct list_head transaction_list;
228         struct timer_list flush_timer;
229         unsigned long reset_jiffies;
230
231         unsigned long long guid;
232         unsigned max_receive;
233         int link_speed;
234         int config_rom_generation;
235
236         /*
237          * We need to store up to 4 self ID for a maximum of 63
238          * devices plus 3 words for the topology map header.
239          */
240         int self_id_count;
241         u32 topology_map[252 + 3];
242         u32 broadcast_channel;
243
244         spinlock_t lock; /* Take this lock when handling the lists in
245                           * this struct. */
246         struct fw_node *local_node;
247         struct fw_node *root_node;
248         struct fw_node *irm_node;
249         int color;
250         int gap_count;
251         bool beta_repeaters_present;
252
253         int index;
254
255         struct list_head link;
256
257         /* Work struct for BM duties. */
258         struct delayed_work work;
259         int bm_retries;
260         int bm_generation;
261 };
262
263 /*
264  * The iso packet format allows for an immediate header/payload part
265  * stored in 'header' immediately after the packet info plus an
266  * indirect payload part that is pointer to by the 'payload' field.
267  * Applications can use one or the other or both to implement simple
268  * low-bandwidth streaming (e.g. audio) or more advanced
269  * scatter-gather streaming (e.g. assembling video frame automatically).
270  */
271
272 struct fw_iso_packet {
273         u16 payload_length;     /* Length of indirect payload. */
274         u32 interrupt : 1;      /* Generate interrupt on this packet */
275         u32 skip : 1;           /* Set to not send packet at all. */
276         u32 tag : 2;
277         u32 sy : 4;
278         u32 header_length : 8;  /* Length of immediate header. */
279         u32 header[0];
280 };
281
282 #define FW_ISO_CONTEXT_TRANSMIT 0
283 #define FW_ISO_CONTEXT_RECEIVE  1
284
285 #define FW_ISO_CONTEXT_MATCH_TAG0        1
286 #define FW_ISO_CONTEXT_MATCH_TAG1        2
287 #define FW_ISO_CONTEXT_MATCH_TAG2        4
288 #define FW_ISO_CONTEXT_MATCH_TAG3        8
289 #define FW_ISO_CONTEXT_MATCH_ALL_TAGS   15
290
291 struct fw_iso_context;
292
293 typedef void (*fw_iso_callback_t)(struct fw_iso_context *context,
294                                   u32 cycle,
295                                   size_t header_length,
296                                   void *header,
297                                   void *data);
298
299 /*
300  * An iso buffer is just a set of pages mapped for DMA in the
301  * specified direction.  Since the pages are to be used for DMA, they
302  * are not mapped into the kernel virtual address space.  We store the
303  * DMA address in the page private. The helper function
304  * fw_iso_buffer_map() will map the pages into a given vma.
305  */
306
307 struct fw_iso_buffer {
308         enum dma_data_direction direction;
309         struct page **pages;
310         int page_count;
311 };
312
313 struct fw_iso_context {
314         struct fw_card *card;
315         int type;
316         int channel;
317         int speed;
318         size_t header_size;
319         fw_iso_callback_t callback;
320         void *callback_data;
321 };
322
323 int
324 fw_iso_buffer_init(struct fw_iso_buffer *buffer,
325                    struct fw_card *card,
326                    int page_count,
327                    enum dma_data_direction direction);
328 int
329 fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma);
330 void
331 fw_iso_buffer_destroy(struct fw_iso_buffer *buffer, struct fw_card *card);
332
333 struct fw_iso_context *
334 fw_iso_context_create(struct fw_card *card, int type,
335                       int channel, int speed, size_t header_size,
336                       fw_iso_callback_t callback, void *callback_data);
337
338 void
339 fw_iso_context_destroy(struct fw_iso_context *ctx);
340
341 int
342 fw_iso_context_queue(struct fw_iso_context *ctx,
343                      struct fw_iso_packet *packet,
344                      struct fw_iso_buffer *buffer,
345                      unsigned long payload);
346
347 int
348 fw_iso_context_start(struct fw_iso_context *ctx,
349                      int cycle, int sync, int tags);
350
351 int
352 fw_iso_context_stop(struct fw_iso_context *ctx);
353
354 struct fw_card_driver {
355         /*
356          * Enable the given card with the given initial config rom.
357          * This function is expected to activate the card, and either
358          * enable the PHY or set the link_on bit and initiate a bus
359          * reset.
360          */
361         int (*enable)(struct fw_card *card, u32 *config_rom, size_t length);
362
363         int (*update_phy_reg)(struct fw_card *card, int address,
364                               int clear_bits, int set_bits);
365
366         /*
367          * Update the config rom for an enabled card.  This function
368          * should change the config rom that is presented on the bus
369          * an initiate a bus reset.
370          */
371         int (*set_config_rom)(struct fw_card *card,
372                               u32 *config_rom, size_t length);
373
374         void (*send_request)(struct fw_card *card, struct fw_packet *packet);
375         void (*send_response)(struct fw_card *card, struct fw_packet *packet);
376         /* Calling cancel is valid once a packet has been submitted. */
377         int (*cancel_packet)(struct fw_card *card, struct fw_packet *packet);
378
379         /*
380          * Allow the specified node ID to do direct DMA out and in of
381          * host memory.  The card will disable this for all node when
382          * a bus reset happens, so driver need to reenable this after
383          * bus reset.  Returns 0 on success, -ENODEV if the card
384          * doesn't support this, -ESTALE if the generation doesn't
385          * match.
386          */
387         int (*enable_phys_dma)(struct fw_card *card,
388                                int node_id, int generation);
389
390         u64 (*get_bus_time)(struct fw_card *card);
391
392         struct fw_iso_context *
393         (*allocate_iso_context)(struct fw_card *card,
394                                 int type, size_t header_size);
395         void (*free_iso_context)(struct fw_iso_context *ctx);
396
397         int (*start_iso)(struct fw_iso_context *ctx,
398                          s32 cycle, u32 sync, u32 tags);
399
400         int (*queue_iso)(struct fw_iso_context *ctx,
401                          struct fw_iso_packet *packet,
402                          struct fw_iso_buffer *buffer,
403                          unsigned long payload);
404
405         int (*stop_iso)(struct fw_iso_context *ctx);
406 };
407
408 int
409 fw_core_initiate_bus_reset(struct fw_card *card, int short_reset);
410
411 void
412 fw_send_request(struct fw_card *card, struct fw_transaction *t,
413                 int tcode, int node_id, int generation, int speed,
414                 unsigned long long offset,
415                 void *data, size_t length,
416                 fw_transaction_callback_t callback, void *callback_data);
417
418 int fw_cancel_transaction(struct fw_card *card,
419                           struct fw_transaction *transaction);
420
421 void fw_flush_transactions(struct fw_card *card);
422
423 void fw_send_phy_config(struct fw_card *card,
424                         int node_id, int generation, int gap_count);
425
426 /*
427  * Called by the topology code to inform the device code of node
428  * activity; found, lost, or updated nodes.
429  */
430 void
431 fw_node_event(struct fw_card *card, struct fw_node *node, int event);
432
433 /* API used by card level drivers */
434
435 void
436 fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
437                    struct device *device);
438 int
439 fw_card_add(struct fw_card *card,
440             u32 max_receive, u32 link_speed, u64 guid);
441
442 void
443 fw_core_remove_card(struct fw_card *card);
444
445 void
446 fw_core_handle_bus_reset(struct fw_card *card,
447                          int node_id, int generation,
448                          int self_id_count, u32 *self_ids);
449 void
450 fw_core_handle_request(struct fw_card *card, struct fw_packet *request);
451
452 void
453 fw_core_handle_response(struct fw_card *card, struct fw_packet *packet);
454
455 #endif /* __fw_transaction_h */