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_BLOCK_PACKET(tcode)    (((tcode) &  1) != 0)
  44 #define TCODE_IS_REQUEST(tcode)         (((tcode) &  2) == 0)
  45 #define TCODE_IS_RESPONSE(tcode)        (((tcode) &  2) != 0)
  46 #define TCODE_HAS_REQUEST_DATA(tcode)   (((tcode) & 12) != 4)
  47 #define TCODE_HAS_RESPONSE_DATA(tcode)  (((tcode) & 12) != 0)
  48
  49 /* Juju specific tcodes */
  50 #define TCODE_DEALLOCATE                0x10
  51 #define TCODE_LOCK_MASK_SWAP            0x11
  52 #define TCODE_LOCK_COMPARE_SWAP         0x12
  53 #define TCODE_LOCK_FETCH_ADD            0x13
  54 #define TCODE_LOCK_LITTLE_ADD           0x14
  55 #define TCODE_LOCK_BOUNDED_ADD          0x15
  56 #define TCODE_LOCK_WRAP_ADD             0x16
  57 #define TCODE_LOCK_VENDOR_SPECIFIC      0x17
  58
  59 #define SCODE_100                       0x0
  60 #define SCODE_200                       0x1
  61 #define SCODE_400                       0x2
  62 #define SCODE_BETA                      0x3
  63
  64 #define EXTCODE_MASK_SWAP       0x1
  65 #define EXTCODE_COMPARE_SWAP    0x2
  66 #define EXTCODE_FETCH_ADD       0x3
  67 #define EXTCODE_LITTLE_ADD      0x4
  68 #define EXTCODE_BOUNDED_ADD     0x5
  69 #define EXTCODE_WRAP_ADD        0x6
  70
  71 #define ACK_COMPLETE            0x1
  72 #define ACK_PENDING             0x2
  73 #define ACK_BUSY_X              0x4
  74 #define ACK_BUSY_A              0x5
  75 #define ACK_BUSY_B              0x6
  76 #define ACK_DATA_ERROR          0xd
  77 #define ACK_TYPE_ERROR          0xe
  78
  79 #define RCODE_COMPLETE          0x0
  80 #define RCODE_CONFLICT_ERROR    0x4
  81 #define RCODE_DATA_ERROR        0x5
  82 #define RCODE_TYPE_ERROR        0x6
  83 #define RCODE_ADDRESS_ERROR     0x7
  84
  85 /* Juju specific rcodes */
  86 #define RCODE_SEND_ERROR        0x10
  87 #define RCODE_CANCELLED         0x11
  88 #define RCODE_BUSY              0x12
  89
  90 #define RETRY_1 0x00
  91 #define RETRY_X 0x01
  92 #define RETRY_A 0x02
  93 #define RETRY_B 0x03
  94
  95 #define LOCAL_BUS 0xffc0
  96
  97 #define SELFID_PORT_CHILD       0x3
  98 #define SELFID_PORT_PARENT      0x2
  99 #define SELFID_PORT_NCONN       0x1
 100 #define SELFID_PORT_NONE        0x0
 101
 102 #define PHY_PACKET_CONFIG       0x0
 103 #define PHY_PACKET_LINK_ON      0x1
 104 #define PHY_PACKET_SELF_ID      0x2
 105
 106 #define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
 107 #define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
 108 #define fw_debug(s, args...) printk(KERN_DEBUG KBUILD_MODNAME ": " s, ## args)
 109
 110 static inline void
 111 fw_memcpy_from_be32(void *_dst, void *_src, size_t size)
 112 {
 113         u32 *dst = _dst;
 114         u32 *src = _src;
 115         int i;
 116
 117         for (i = 0; i < size / 4; i++)
 118                 dst[i] = cpu_to_be32(src[i]);
 119 }
 120
 121 static inline void
 122 fw_memcpy_to_be32(void *_dst, void *_src, size_t size)
 123 {
 124         fw_memcpy_from_be32(_dst, _src, size);
 125 }
 126
 127 struct fw_card;
 128 struct fw_packet;
 129 struct fw_node;
 130 struct fw_request;
 131
 132 struct fw_descriptor {
 133         struct list_head link;
 134         size_t length;
 135         u32 key;
 136         const u32 *data;
 137 };
 138
 139 int fw_core_add_descriptor (struct fw_descriptor *desc);
 140 void fw_core_remove_descriptor (struct fw_descriptor *desc);
 141
 142 typedef void (*fw_packet_callback_t) (struct fw_packet *packet,
 143                                       struct fw_card *card, int status);
 144
 145 typedef void (*fw_transaction_callback_t)(struct fw_card *card, int rcode,
 146                                           void *data,
 147                                           size_t length,
 148                                           void *callback_data);
 149
 150 typedef void (*fw_address_callback_t)(struct fw_card *card,
 151                                       struct fw_request *request,
 152                                       int tcode, int destination, int source,
 153                                       int generation, int speed,
 154                                       unsigned long long offset,
 155                                       void *data, size_t length,
 156                                       void *callback_data);
 157
 158 typedef void (*fw_bus_reset_callback_t)(struct fw_card *handle,
 159                                         int node_id, int generation,
 160                                         u32 *self_ids,
 161                                         int self_id_count,
 162                                         void *callback_data);
 163
 164 struct fw_packet {
 165         int speed;
 166         int generation;
 167         u32 header[4];
 168         size_t header_length;
 169         void *payload;
 170         size_t payload_length;
 171         u32 timestamp;
 172
 173         dma_addr_t payload_bus;
 174
 175         /* This callback is called when the packet transmission has
 176          * completed; for successful transmission, the status code is
 177          * the ack received from the destination, otherwise it's a
 178          * negative errno: ENOMEM, ESTALE, ETIMEDOUT, ENODEV, EIO.
 179          * The callback can be called from tasklet context and thus
 180          * must never block.
 181          */
 182         fw_packet_callback_t callback;
 183         int status;
 184         struct list_head link;
 185 };
 186
 187 struct fw_transaction {
 188         int node_id; /* The generation is implied; it is always the current. */
 189         int tlabel;
 190         int timestamp;
 191         struct list_head link;
 192
 193         struct fw_packet packet;
 194
 195         /* The data passed to the callback is valid only during the
 196          * callback.  */
 197         fw_transaction_callback_t callback;
 198         void *callback_data;
 199 };
 200
 201 static inline struct fw_packet *
 202 fw_packet(struct list_head *l)
 203 {
 204         return list_entry (l, struct fw_packet, link);
 205 }
 206
 207 struct fw_address_handler {
 208         u64 offset;
 209         size_t length;
 210         fw_address_callback_t address_callback;
 211         void *callback_data;
 212         struct list_head link;
 213 };
 214
 215
 216 struct fw_address_region {
 217         u64 start;
 218         u64 end;
 219 };
 220
 221 extern const struct fw_address_region fw_low_memory_region;
 222 extern const struct fw_address_region fw_high_memory_region;
 223 extern const struct fw_address_region fw_private_region;
 224 extern const struct fw_address_region fw_csr_region;
 225 extern const struct fw_address_region fw_unit_space_region;
 226
 227 int fw_core_add_address_handler(struct fw_address_handler *handler,
 228                                 const struct fw_address_region *region);
 229 void fw_core_remove_address_handler(struct fw_address_handler *handler);
 230 void fw_send_response(struct fw_card *card,
 231                       struct fw_request *request, int rcode);
 232
 233 extern struct bus_type fw_bus_type;
 234
 235 struct fw_card {
 236         const struct fw_card_driver *driver;
 237         struct device *device;
 238
 239         int node_id;
 240         int generation;
 241         /* This is the generation used for timestamping incoming requests. */
 242         int request_generation;
 243         int current_tlabel, tlabel_mask;
 244         struct list_head transaction_list;
 245         struct timer_list flush_timer;
 246
 247         unsigned long long guid;
 248         int max_receive;
 249         int link_speed;
 250         int config_rom_generation;
 251
 252         /* We need to store up to 4 self ID for a maximum of 63 devices. */
 253         int self_id_count;
 254         u32 self_ids[252];
 255
 256         spinlock_t lock; /* Take this lock when handling the lists in
 257                           * this struct. */
 258         struct fw_node *local_node;
 259         struct fw_node *root_node;
 260         struct fw_node *irm_node;
 261         int color;
 262
 263         int index;
 264
 265         struct device card_device;
 266
 267         struct list_head link;
 268
 269         /* Work struct for IRM duties. */
 270         struct delayed_work work;
 271         int irm_retries;
 272 };
 273
 274 struct fw_card *fw_card_get(struct fw_card *card);
 275 void fw_card_put(struct fw_card *card);
 276
 277 /* The iso packet format allows for an immediate header/payload part
 278  * stored in 'header' immediately after the packet info plus an
 279  * indirect payload part that is pointer to by the 'payload' field.
 280  * Applications can use one or the other or both to implement simple
 281  * low-bandwidth streaming (e.g. audio) or more advanced
 282  * scatter-gather streaming (e.g. assembling video frame automatically). */
 283
 284 struct fw_iso_packet {
 285         u16 payload_length;     /* Length of indirect payload. */
 286         u32 interrupt : 1;      /* Generate interrupt on this packet */
 287         u32 skip : 1;           /* Set to not send packet at all. */
 288         u32 tag : 2;
 289         u32 sy : 4;
 290         u32 header_length : 8;  /* Length of immediate header. */
 291         u32 header[0];
 292 };
 293
 294 #define FW_ISO_CONTEXT_TRANSMIT 0
 295 #define FW_ISO_CONTEXT_RECEIVE  1
 296
 297 struct fw_iso_context;
 298
 299 typedef void (*fw_iso_callback_t) (struct fw_iso_context *context,
 300                                    int status, u32 cycle, void *data);
 301
 302 struct fw_iso_context {
 303         struct fw_card *card;
 304         int type;
 305         int channel;
 306         int speed;
 307         fw_iso_callback_t callback;
 308         void *callback_data;
 309
 310         void *buffer;
 311         size_t buffer_size;
 312         dma_addr_t *pages;
 313         int page_count;
 314 };
 315
 316 struct fw_iso_context *
 317 fw_iso_context_create(struct fw_card *card, int type,
 318                       size_t buffer_size,
 319                       fw_iso_callback_t callback,
 320                       void *callback_data);
 321
 322 void
 323 fw_iso_context_destroy(struct fw_iso_context *ctx);
 324
 325 void
 326 fw_iso_context_start(struct fw_iso_context *ctx,
 327                      int channel, int speed, int cycle);
 328
 329 int
 330 fw_iso_context_queue(struct fw_iso_context *ctx,
 331                      struct fw_iso_packet *packet, void *payload);
 332
 333 int
 334 fw_iso_context_send(struct fw_iso_context *ctx,
 335                     int channel, int speed, int cycle);
 336
 337 struct fw_card_driver {
 338         const char *name;
 339
 340         /* Enable the given card with the given initial config rom.
 341          * This function is expected to activate the card, and either
 342          * enable the PHY or set the link_on bit and initiate a bus
 343          * reset. */
 344         int (*enable) (struct fw_card *card, u32 *config_rom, size_t length);
 345
 346         int (*update_phy_reg) (struct fw_card *card, int address,
 347                                int clear_bits, int set_bits);
 348
 349         /* Update the config rom for an enabled card.  This function
 350          * should change the config rom that is presented on the bus
 351          * an initiate a bus reset. */
 352         int (*set_config_rom) (struct fw_card *card,
 353                                u32 *config_rom, size_t length);
 354
 355         void (*send_request) (struct fw_card *card, struct fw_packet *packet);
 356         void (*send_response) (struct fw_card *card, struct fw_packet *packet);
 357
 358         /* Allow the specified node ID to do direct DMA out and in of
 359          * host memory.  The card will disable this for all node when
 360          * a bus reset happens, so driver need to reenable this after
 361          * bus reset.  Returns 0 on success, -ENODEV if the card
 362          * doesn't support this, -ESTALE if the generation doesn't
 363          * match. */
 364         int (*enable_phys_dma) (struct fw_card *card,
 365                                 int node_id, int generation);
 366
 367         struct fw_iso_context *
 368         (*allocate_iso_context)(struct fw_card *card, int type);
 369         void (*free_iso_context)(struct fw_iso_context *ctx);
 370
 371         int (*send_iso)(struct fw_iso_context *ctx, s32 cycle);
 372
 373         int (*queue_iso)(struct fw_iso_context *ctx,
 374                          struct fw_iso_packet *packet, void *payload);
 375 };
 376
 377 int
 378 fw_core_initiate_bus_reset(struct fw_card *card, int short_reset);
 379
 380 void
 381 fw_send_request(struct fw_card *card, struct fw_transaction *t,
 382                 int tcode, int node_id, int generation, int speed,
 383                 unsigned long long offset,
 384                 void *data, size_t length,
 385                 fw_transaction_callback_t callback, void *callback_data);
 386
 387 void fw_flush_transactions(struct fw_card *card);
 388
 389 void
 390 fw_send_force_root(struct fw_card *card, int node_id, int generation);
 391
 392 /* Called by the topology code to inform the device code of node
 393  * activity; found, lost, or updated nodes */
 394 void
 395 fw_node_event(struct fw_card *card, struct fw_node *node, int event);
 396
 397 /* API used by card level drivers */
 398
 399 /* Do we need phy speed here also?  If we add more args, maybe we
 400    should go back to struct fw_card_info. */
 401 void
 402 fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
 403                    struct device *device);
 404 int
 405 fw_card_add(struct fw_card *card,
 406             u32 max_receive, u32 link_speed, u64 guid);
 407
 408 void
 409 fw_core_remove_card(struct fw_card *card);
 410
 411 void
 412 fw_core_handle_bus_reset(struct fw_card *card,
 413                          int node_id, int generation,
 414                          int self_id_count, u32 *self_ids);
 415 void
 416 fw_core_handle_request(struct fw_card *card,
 417                        int speed, int ack, int timestamp,
 418                        int generation,
 419                        u32 length, u32 *payload);
 420 void
 421 fw_core_handle_response(struct fw_card *card,
 422                         int speed, int ack, int timestamp,
 423                         u32 length, u32 *payload);
 424
 425
 426 #endif /* __fw_transaction_h */