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