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