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