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 BANDWIDTH_AVAILABLE_INITIAL     4915
  86 #define BROADCAST_CHANNEL_INITIAL       (1 << 31 | 31)
  87 #define BROADCAST_CHANNEL_VALID         (1 << 30)
  88
  89 #define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
  90 #define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
  91
  92 static inline void 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 fw_memcpy_to_be32(void *_dst, void *_src, size_t size)
 103 {
 104         fw_memcpy_from_be32(_dst, _src, size);
 105 }
 106
 107 struct fw_card;
 108 struct fw_packet;
 109 struct fw_node;
 110 struct fw_request;
 111
 112 struct fw_descriptor {
 113         struct list_head link;
 114         size_t length;
 115         u32 immediate;
 116         u32 key;
 117         const u32 *data;
 118 };
 119
 120 int fw_core_add_descriptor(struct fw_descriptor *desc);
 121 void fw_core_remove_descriptor(struct fw_descriptor *desc);
 122
 123 typedef void (*fw_packet_callback_t)(struct fw_packet *packet,
 124                                      struct fw_card *card, int status);
 125
 126 typedef void (*fw_transaction_callback_t)(struct fw_card *card, int rcode,
 127                                           void *data, 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 struct fw_packet {
 143         int speed;
 144         int generation;
 145         u32 header[4];
 146         size_t header_length;
 147         void *payload;
 148         size_t payload_length;
 149         dma_addr_t payload_bus;
 150         u32 timestamp;
 151
 152         /*
 153          * This callback is called when the packet transmission has
 154          * completed; for successful transmission, the status code is
 155          * the ack received from the destination, otherwise it's a
 156          * negative errno: ENOMEM, ESTALE, ETIMEDOUT, ENODEV, EIO.
 157          * The callback can be called from tasklet context and thus
 158          * must never block.
 159          */
 160         fw_packet_callback_t callback;
 161         int ack;
 162         struct list_head link;
 163         void *driver_data;
 164 };
 165
 166 struct fw_transaction {
 167         int node_id; /* The generation is implied; it is always the current. */
 168         int tlabel;
 169         int timestamp;
 170         struct list_head link;
 171
 172         struct fw_packet packet;
 173
 174         /*
 175          * The data passed to the callback is valid only during the
 176          * callback.
 177          */
 178         fw_transaction_callback_t callback;
 179         void *callback_data;
 180 };
 181
 182 struct fw_address_handler {
 183         u64 offset;
 184         size_t length;
 185         fw_address_callback_t address_callback;
 186         void *callback_data;
 187         struct list_head link;
 188 };
 189
 190 struct fw_address_region {
 191         u64 start;
 192         u64 end;
 193 };
 194
 195 extern const struct fw_address_region fw_high_memory_region;
 196
 197 int fw_core_add_address_handler(struct fw_address_handler *handler,
 198                                 const struct fw_address_region *region);
 199 void fw_core_remove_address_handler(struct fw_address_handler *handler);
 200 void fw_fill_response(struct fw_packet *response, u32 *request_header,
 201                       int rcode, void *payload, size_t length);
 202 void fw_send_response(struct fw_card *card,
 203                       struct fw_request *request, int rcode);
 204
 205 extern struct bus_type fw_bus_type;
 206
 207 struct fw_card {
 208         const struct fw_card_driver *driver;
 209         struct device *device;
 210         struct kref kref;
 211         struct completion done;
 212
 213         int node_id;
 214         int generation;
 215         int current_tlabel, tlabel_mask;
 216         struct list_head transaction_list;
 217         struct timer_list flush_timer;
 218         unsigned long reset_jiffies;
 219
 220         unsigned long long guid;
 221         unsigned max_receive;
 222         int link_speed;
 223         int config_rom_generation;
 224
 225         spinlock_t lock; /* Take this lock when handling the lists in
 226                           * this struct. */
 227         struct fw_node *local_node;
 228         struct fw_node *root_node;
 229         struct fw_node *irm_node;
 230         u8 color; /* must be u8 to match the definition in struct fw_node */
 231         int gap_count;
 232         bool beta_repeaters_present;
 233         /*
 234          * Set if the local device is the IRM and the broadcast channel
 235          * was allocated.
 236          */
 237         bool is_irm;
 238
 239         int index;
 240
 241         struct list_head link;
 242
 243         /* Work struct for BM duties. */
 244         struct delayed_work work;
 245         int bm_retries;
 246         int bm_generation;
 247
 248         u32 broadcast_channel;
 249         u32 topology_map[(CSR_TOPOLOGY_MAP_END - CSR_TOPOLOGY_MAP) / 4];
 250 };
 251
 252 static inline struct fw_card *fw_card_get(struct fw_card *card)
 253 {
 254         kref_get(&card->kref);
 255
 256         return card;
 257 }
 258
 259 void fw_card_release(struct kref *kref);
 260
 261 static inline void fw_card_put(struct fw_card *card)
 262 {
 263         kref_put(&card->kref, fw_card_release);
 264 }
 265
 266 extern void fw_schedule_bm_work(struct fw_card *card, unsigned long delay);
 267
 268 /*
 269  * Check whether new_generation is the immediate successor of old_generation.
 270  * Take counter roll-over at 255 (as per to OHCI) into account.
 271  */
 272 static inline bool is_next_generation(int new_generation, int old_generation)
 273 {
 274         return (new_generation & 0xff) == ((old_generation + 1) & 0xff);
 275 }
 276
 277 /*
 278  * The iso packet format allows for an immediate header/payload part
 279  * stored in 'header' immediately after the packet info plus an
 280  * indirect payload part that is pointer to by the 'payload' field.
 281  * Applications can use one or the other or both to implement simple
 282  * low-bandwidth streaming (e.g. audio) or more advanced
 283  * scatter-gather streaming (e.g. assembling video frame automatically).
 284  */
 285
 286 struct fw_iso_packet {
 287         u16 payload_length;     /* Length of indirect payload. */
 288         u32 interrupt : 1;      /* Generate interrupt on this packet */
 289         u32 skip : 1;           /* Set to not send packet at all. */
 290         u32 tag : 2;
 291         u32 sy : 4;
 292         u32 header_length : 8;  /* Length of immediate header. */
 293         u32 header[0];
 294 };
 295
 296 #define FW_ISO_CONTEXT_TRANSMIT 0
 297 #define FW_ISO_CONTEXT_RECEIVE  1
 298
 299 #define FW_ISO_CONTEXT_MATCH_TAG0        1
 300 #define FW_ISO_CONTEXT_MATCH_TAG1        2
 301 #define FW_ISO_CONTEXT_MATCH_TAG2        4
 302 #define FW_ISO_CONTEXT_MATCH_TAG3        8
 303 #define FW_ISO_CONTEXT_MATCH_ALL_TAGS   15
 304
 305 struct fw_iso_context;
 306
 307 typedef void (*fw_iso_callback_t)(struct fw_iso_context *context,
 308                                   u32 cycle, size_t header_length,
 309                                   void *header, void *data);
 310
 311 /*
 312  * An iso buffer is just a set of pages mapped for DMA in the
 313  * specified direction.  Since the pages are to be used for DMA, they
 314  * are not mapped into the kernel virtual address space.  We store the
 315  * DMA address in the page private. The helper function
 316  * fw_iso_buffer_map() will map the pages into a given vma.
 317  */
 318
 319 struct fw_iso_buffer {
 320         enum dma_data_direction direction;
 321         struct page **pages;
 322         int page_count;
 323 };
 324
 325 struct fw_iso_context {
 326         struct fw_card *card;
 327         int type;
 328         int channel;
 329         int speed;
 330         size_t header_size;
 331         fw_iso_callback_t callback;
 332         void *callback_data;
 333 };
 334
 335 int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
 336                        int page_count, enum dma_data_direction direction);
 337 int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma);
 338 void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer, struct fw_card *card);
 339
 340 struct fw_iso_context *fw_iso_context_create(struct fw_card *card,
 341                 int type, int channel, int speed, size_t header_size,
 342                 fw_iso_callback_t callback, void *callback_data);
 343 int fw_iso_context_queue(struct fw_iso_context *ctx,
 344                          struct fw_iso_packet *packet,
 345                          struct fw_iso_buffer *buffer,
 346                          unsigned long payload);
 347 int fw_iso_context_start(struct fw_iso_context *ctx,
 348                          int cycle, int sync, int tags);
 349 int fw_iso_context_stop(struct fw_iso_context *ctx);
 350 void fw_iso_context_destroy(struct fw_iso_context *ctx);
 351
 352 void fw_iso_resource_manage(struct fw_card *card, int generation,
 353                 u64 channels_mask, int *channel, int *bandwidth, bool allocate);
 354
 355 struct fw_card_driver {
 356         /*
 357          * Enable the given card with the given initial config rom.
 358          * This function is expected to activate the card, and either
 359          * enable the PHY or set the link_on bit and initiate a bus
 360          * reset.
 361          */
 362         int (*enable)(struct fw_card *card, u32 *config_rom, size_t length);
 363
 364         int (*update_phy_reg)(struct fw_card *card, int address,
 365                               int clear_bits, int set_bits);
 366
 367         /*
 368          * Update the config rom for an enabled card.  This function
 369          * should change the config rom that is presented on the bus
 370          * an initiate a bus reset.
 371          */
 372         int (*set_config_rom)(struct fw_card *card,
 373                               u32 *config_rom, size_t length);
 374
 375         void (*send_request)(struct fw_card *card, struct fw_packet *packet);
 376         void (*send_response)(struct fw_card *card, struct fw_packet *packet);
 377         /* Calling cancel is valid once a packet has been submitted. */
 378         int (*cancel_packet)(struct fw_card *card, struct fw_packet *packet);
 379
 380         /*
 381          * Allow the specified node ID to do direct DMA out and in of
 382          * host memory.  The card will disable this for all node when
 383          * a bus reset happens, so driver need to reenable this after
 384          * bus reset.  Returns 0 on success, -ENODEV if the card
 385          * doesn't support this, -ESTALE if the generation doesn't
 386          * match.
 387          */
 388         int (*enable_phys_dma)(struct fw_card *card,
 389                                int node_id, int generation);
 390
 391         u64 (*get_bus_time)(struct fw_card *card);
 392
 393         struct fw_iso_context *
 394         (*allocate_iso_context)(struct fw_card *card,
 395                                 int type, int channel, size_t header_size);
 396         void (*free_iso_context)(struct fw_iso_context *ctx);
 397
 398         int (*start_iso)(struct fw_iso_context *ctx,
 399                          s32 cycle, u32 sync, u32 tags);
 400
 401         int (*queue_iso)(struct fw_iso_context *ctx,
 402                          struct fw_iso_packet *packet,
 403                          struct fw_iso_buffer *buffer,
 404                          unsigned long payload);
 405
 406         int (*stop_iso)(struct fw_iso_context *ctx);
 407 };
 408
 409 int fw_core_initiate_bus_reset(struct fw_card *card, int short_reset);
 410
 411 void fw_send_request(struct fw_card *card, struct fw_transaction *t,
 412                 int tcode, int destination_id, int generation, int speed,
 413                 unsigned long long offset, void *payload, size_t length,
 414                 fw_transaction_callback_t callback, void *callback_data);
 415 void fw_send_stream_packet(struct fw_card *card, struct fw_packet *p,
 416                 int generation, int speed, int channel, int sy, int tag,
 417                 void *payload, size_t length, fw_packet_callback_t callback);
 418
 419 int fw_cancel_transaction(struct fw_card *card,
 420                           struct fw_transaction *transaction);
 421 void fw_flush_transactions(struct fw_card *card);
 422 int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
 423                        int generation, int speed, unsigned long long offset,
 424                        void *payload, size_t length);
 425 void fw_send_phy_config(struct fw_card *card,
 426                         int node_id, int generation, int gap_count);
 427
 428 /*
 429  * Called by the topology code to inform the device code of node
 430  * activity; found, lost, or updated nodes.
 431  */
 432 void fw_node_event(struct fw_card *card, struct fw_node *node, int event);
 433
 434 /* API used by card level drivers */
 435
 436 void fw_card_initialize(struct fw_card *card,
 437                 const struct fw_card_driver *driver, struct device *device);
 438 int fw_card_add(struct fw_card *card,
 439                 u32 max_receive, u32 link_speed, u64 guid);
 440 void fw_core_remove_card(struct fw_card *card);
 441 void fw_core_handle_bus_reset(struct fw_card *card, int node_id,
 442                 int generation, int self_id_count, u32 *self_ids);
 443 void fw_core_handle_request(struct fw_card *card, struct fw_packet *request);
 444 void fw_core_handle_response(struct fw_card *card, struct fw_packet *packet);
 445
 446 extern int fw_irm_set_broadcast_channel_register(struct device *dev,
 447                                                  void *data);
 448
 449 #endif /* __fw_transaction_h */