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