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