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