1/* 2 * Copyright (C) 2005-2007 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#include <linux/module.h> 20#include <linux/errno.h> 21#include <linux/device.h> 22#include <linux/mutex.h> 23#include <linux/crc-itu-t.h> 24#include "fw-transaction.h" 25#include "fw-topology.h" 26#include "fw-device.h" 27 28int fw_compute_block_crc(u32 *block) 29{ 30 __be32 be32_block[256]; 31 int i, length; 32 33 length = (*block >> 16) & 0xff; 34 for (i = 0; i < length; i++) 35 be32_block[i] = cpu_to_be32(block[i + 1]); 36 *block |= crc_itu_t(0, (u8 *) be32_block, length * 4); 37 38 return length; 39} 40 41static DEFINE_MUTEX(card_mutex); 42static LIST_HEAD(card_list); 43 44static LIST_HEAD(descriptor_list); 45static int descriptor_count; 46 47#define BIB_CRC(v) ((v) << 0) 48#define BIB_CRC_LENGTH(v) ((v) << 16) 49#define BIB_INFO_LENGTH(v) ((v) << 24) 50 51#define BIB_LINK_SPEED(v) ((v) << 0) 52#define BIB_GENERATION(v) ((v) << 4) 53#define BIB_MAX_ROM(v) ((v) << 8) 54#define BIB_MAX_RECEIVE(v) ((v) << 12) 55#define BIB_CYC_CLK_ACC(v) ((v) << 16) 56#define BIB_PMC ((1) << 27) 57#define BIB_BMC ((1) << 28) 58#define BIB_ISC ((1) << 29) 59#define BIB_CMC ((1) << 30) 60#define BIB_IMC ((1) << 31) 61 62static u32 * 63generate_config_rom(struct fw_card *card, size_t *config_rom_length) 64{ 65 struct fw_descriptor *desc; 66 static u32 config_rom[256]; 67 int i, j, length; 68 69 /* 70 * Initialize contents of config rom buffer. On the OHCI 71 * controller, block reads to the config rom accesses the host 72 * memory, but quadlet read access the hardware bus info block 73 * registers. That's just crack, but it means we should make 74 * sure the contents of bus info block in host memory mathces 75 * the version stored in the OHCI registers. 76 */ 77 78 memset(config_rom, 0, sizeof(config_rom)); 79 config_rom[0] = BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0); 80 config_rom[1] = 0x31333934; 81 82 config_rom[2] = 83 BIB_LINK_SPEED(card->link_speed) | 84 BIB_GENERATION(card->config_rom_generation++ % 14 + 2) | 85 BIB_MAX_ROM(2) | 86 BIB_MAX_RECEIVE(card->max_receive) | 87 BIB_BMC | BIB_ISC | BIB_CMC | BIB_IMC; 88 config_rom[3] = card->guid >> 32; 89 config_rom[4] = card->guid; 90 91 /* Generate root directory. */ 92 i = 5; 93 config_rom[i++] = 0; 94 config_rom[i++] = 0x0c0083c0; /* node capabilities */ 95 j = i + descriptor_count; 96 97 /* Generate root directory entries for descriptors. */ 98 list_for_each_entry (desc, &descriptor_list, link) { 99 if (desc->immediate > 0) 100 config_rom[i++] = desc->immediate; 101 config_rom[i] = desc->key | (j - i); 102 i++; 103 j += desc->length; 104 } 105 106 /* Update root directory length. */ 107 config_rom[5] = (i - 5 - 1) << 16; 108 109 /* End of root directory, now copy in descriptors. */ 110 list_for_each_entry (desc, &descriptor_list, link) { 111 memcpy(&config_rom[i], desc->data, desc->length * 4); 112 i += desc->length; 113 } 114 115 /* Calculate CRCs for all blocks in the config rom. This 116 * assumes that CRC length and info length are identical for 117 * the bus info block, which is always the case for this 118 * implementation. */ 119 for (i = 0; i < j; i += length + 1) 120 length = fw_compute_block_crc(config_rom + i); 121 122 *config_rom_length = j; 123 124 return config_rom; 125} 126 127static void 128update_config_roms(void) 129{ 130 struct fw_card *card; 131 u32 *config_rom; 132 size_t length; 133 134 list_for_each_entry (card, &card_list, link) { 135 config_rom = generate_config_rom(card, &length); 136 card->driver->set_config_rom(card, config_rom, length); 137 } 138} 139 140int 141fw_core_add_descriptor(struct fw_descriptor *desc) 142{ 143 size_t i; 144 145 /* 146 * Check descriptor is valid; the length of all blocks in the 147 * descriptor has to add up to exactly the length of the 148 * block. 149 */ 150 i = 0; 151 while (i < desc->length) 152 i += (desc->data[i] >> 16) + 1; 153 154 if (i != desc->length) 155 return -EINVAL; 156 157 mutex_lock(&card_mutex); 158 159 list_add_tail(&desc->link, &descriptor_list); 160 descriptor_count++; 161 if (desc->immediate > 0) 162 descriptor_count++; 163 update_config_roms(); 164 165 mutex_unlock(&card_mutex); 166 167 return 0; 168} 169EXPORT_SYMBOL(fw_core_add_descriptor); 170 171void 172fw_core_remove_descriptor(struct fw_descriptor *desc) 173{ 174 mutex_lock(&card_mutex); 175 176 list_del(&desc->link); 177 descriptor_count--; 178 if (desc->immediate > 0) 179 descriptor_count--; 180 update_config_roms(); 181 182 mutex_unlock(&card_mutex); 183} 184EXPORT_SYMBOL(fw_core_remove_descriptor); 185 186static const char gap_count_table[] = { 187 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40 188}; 189 190struct bm_data { 191 struct fw_transaction t; 192 struct { 193 __be32 arg; 194 __be32 data; 195 } lock; 196 u32 old; 197 int rcode; 198 struct completion done; 199}; 200 201static void 202complete_bm_lock(struct fw_card *card, int rcode, 203 void *payload, size_t length, void *data) 204{ 205 struct bm_data *bmd = data; 206 207 if (rcode == RCODE_COMPLETE) 208 bmd->old = be32_to_cpu(*(__be32 *) payload); 209 bmd->rcode = rcode; 210 complete(&bmd->done); 211} 212 213static void 214fw_card_bm_work(struct work_struct *work) 215{ 216 struct fw_card *card = container_of(work, struct fw_card, work.work); 217 struct fw_device *root; 218 struct bm_data bmd; 219 unsigned long flags; 220 int root_id, new_root_id, irm_id, gap_count, generation, grace; 221 int do_reset = 0; 222 223 spin_lock_irqsave(&card->lock, flags); 224 225 generation = card->generation; 226 root = card->root_node->data; 227 root_id = card->root_node->node_id; 228 grace = time_after(jiffies, card->reset_jiffies + DIV_ROUND_UP(HZ, 10)); 229 230 if (card->bm_generation + 1 == generation || 231 (card->bm_generation != generation && grace)) { 232 /* 233 * This first step is to figure out who is IRM and 234 * then try to become bus manager. If the IRM is not 235 * well defined (e.g. does not have an active link 236 * layer or does not responds to our lock request, we 237 * will have to do a little vigilante bus management. 238 * In that case, we do a goto into the gap count logic 239 * so that when we do the reset, we still optimize the 240 * gap count. That could well save a reset in the 241 * next generation. 242 */ 243 244 irm_id = card->irm_node->node_id; 245 if (!card->irm_node->link_on) { 246 new_root_id = card->local_node->node_id; 247 fw_notify("IRM has link off, making local node (%02x) root.\n", 248 new_root_id); 249 goto pick_me; 250 } 251 252 bmd.lock.arg = cpu_to_be32(0x3f); 253 bmd.lock.data = cpu_to_be32(card->local_node->node_id); 254 255 spin_unlock_irqrestore(&card->lock, flags); 256 257 init_completion(&bmd.done); 258 fw_send_request(card, &bmd.t, TCODE_LOCK_COMPARE_SWAP, 259 irm_id, generation, 260 SCODE_100, CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID, 261 &bmd.lock, sizeof(bmd.lock), 262 complete_bm_lock, &bmd); 263 wait_for_completion(&bmd.done); 264 265 if (bmd.rcode == RCODE_GENERATION) { 266 /* 267 * Another bus reset happened. Just return, 268 * the BM work has been rescheduled. 269 */ 270 return; 271 } 272 273 if (bmd.rcode == RCODE_COMPLETE && bmd.old != 0x3f) 274 /* Somebody else is BM, let them do the work. */ 275 return; 276 277 spin_lock_irqsave(&card->lock, flags); 278 if (bmd.rcode != RCODE_COMPLETE) { 279 /* 280 * The lock request failed, maybe the IRM 281 * isn't really IRM capable after all. Let's 282 * do a bus reset and pick the local node as 283 * root, and thus, IRM. 284 */ 285 new_root_id = card->local_node->node_id; 286 fw_notify("BM lock failed, making local node (%02x) root.\n", 287 new_root_id); 288 goto pick_me; 289 } 290 } else if (card->bm_generation != generation) { 291 /* 292 * OK, we weren't BM in the last generation, and it's 293 * less than 100ms since last bus reset. Reschedule 294 * this task 100ms from now. 295 */ 296 spin_unlock_irqrestore(&card->lock, flags); 297 schedule_delayed_work(&card->work, DIV_ROUND_UP(HZ, 10)); 298 return; 299 } 300 301 /* 302 * We're bus manager for this generation, so next step is to 303 * make sure we have an active cycle master and do gap count 304 * optimization. 305 */ 306 card->bm_generation = generation; 307 308 if (root == NULL) { 309 /* 310 * Either link_on is false, or we failed to read the 311 * config rom. In either case, pick another root. 312 */ 313 new_root_id = card->local_node->node_id; 314 } else if (atomic_read(&root->state) != FW_DEVICE_RUNNING) { 315 /* 316 * If we haven't probed this device yet, bail out now 317 * and let's try again once that's done. 318 */ 319 spin_unlock_irqrestore(&card->lock, flags); 320 return; 321 } else if (root->config_rom[2] & BIB_CMC) { 322 new_root_id = root_id; 323 } else { 324 /* 325 * Current root has an active link layer and we 326 * successfully read the config rom, but it's not 327 * cycle master capable. 328 */ 329 new_root_id = card->local_node->node_id; 330 } 331 332 pick_me: 333 /* Now figure out what gap count to set. */ 334 if (card->topology_type == FW_TOPOLOGY_A && 335 card->root_node->max_hops < ARRAY_SIZE(gap_count_table)) 336 gap_count = gap_count_table[card->root_node->max_hops]; 337 else 338 gap_count = 63; 339 340 /* 341 * Finally, figure out if we should do a reset or not. If we've 342 * done less that 5 resets with the same physical topology and we 343 * have either a new root or a new gap count setting, let's do it. 344 */ 345 346 if (card->bm_retries++ < 5 && 347 (card->gap_count != gap_count || new_root_id != root_id)) 348 do_reset = 1; 349 350 spin_unlock_irqrestore(&card->lock, flags); 351 352 if (do_reset) { 353 fw_notify("phy config: card %d, new root=%x, gap_count=%d\n", 354 card->index, new_root_id, gap_count); 355 fw_send_phy_config(card, new_root_id, generation, gap_count); 356 fw_core_initiate_bus_reset(card, 1); 357 } 358} 359 360static void 361flush_timer_callback(unsigned long data) 362{ 363 struct fw_card *card = (struct fw_card *)data; 364 365 fw_flush_transactions(card); 366} 367 368void 369fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver, 370 struct device *device) 371{ 372 static atomic_t index = ATOMIC_INIT(-1); 373 374 kref_init(&card->kref); 375 card->index = atomic_inc_return(&index); 376 card->driver = driver; 377 card->device = device; 378 card->current_tlabel = 0; 379 card->tlabel_mask = 0; 380 card->color = 0; 381 382 INIT_LIST_HEAD(&card->transaction_list); 383 spin_lock_init(&card->lock); 384 setup_timer(&card->flush_timer, 385 flush_timer_callback, (unsigned long)card); 386 387 card->local_node = NULL; 388 389 INIT_DELAYED_WORK(&card->work, fw_card_bm_work); 390} 391EXPORT_SYMBOL(fw_card_initialize); 392 393int 394fw_card_add(struct fw_card *card, 395 u32 max_receive, u32 link_speed, u64 guid) 396{ 397 u32 *config_rom; 398 size_t length; 399 400 card->max_receive = max_receive; 401 card->link_speed = link_speed; 402 card->guid = guid; 403 404 /* 405 * The subsystem grabs a reference when the card is added and 406 * drops it when the driver calls fw_core_remove_card. 407 */ 408 fw_card_get(card); 409 410 mutex_lock(&card_mutex); 411 config_rom = generate_config_rom(card, &length); 412 list_add_tail(&card->link, &card_list); 413 mutex_unlock(&card_mutex); 414 415 return card->driver->enable(card, config_rom, length); 416} 417EXPORT_SYMBOL(fw_card_add); 418 419 420/* 421 * The next few functions implements a dummy driver that use once a 422 * card driver shuts down an fw_card. This allows the driver to 423 * cleanly unload, as all IO to the card will be handled by the dummy 424 * driver instead of calling into the (possibly) unloaded module. The 425 * dummy driver just fails all IO. 426 */ 427 428static int 429dummy_enable(struct fw_card *card, u32 *config_rom, size_t length) 430{ 431 BUG(); 432 return -1; 433} 434 435static int 436dummy_update_phy_reg(struct fw_card *card, int address, 437 int clear_bits, int set_bits) 438{ 439 return -ENODEV; 440} 441 442static int 443dummy_set_config_rom(struct fw_card *card, 444 u32 *config_rom, size_t length) 445{ 446 /* 447 * We take the card out of card_list before setting the dummy 448 * driver, so this should never get called. 449 */ 450 BUG(); 451 return -1; 452} 453 454static void 455dummy_send_request(struct fw_card *card, struct fw_packet *packet) 456{ 457 packet->callback(packet, card, -ENODEV); 458} 459 460static void 461dummy_send_response(struct fw_card *card, struct fw_packet *packet) 462{ 463 packet->callback(packet, card, -ENODEV); 464} 465 466static int 467dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet) 468{ 469 return -ENOENT; 470} 471 472static int 473dummy_enable_phys_dma(struct fw_card *card, 474 int node_id, int generation) 475{ 476 return -ENODEV; 477} 478 479static struct fw_card_driver dummy_driver = { 480 .name = "dummy", 481 .enable = dummy_enable, 482 .update_phy_reg = dummy_update_phy_reg, 483 .set_config_rom = dummy_set_config_rom, 484 .send_request = dummy_send_request, 485 .cancel_packet = dummy_cancel_packet, 486 .send_response = dummy_send_response, 487 .enable_phys_dma = dummy_enable_phys_dma, 488}; 489 490void 491fw_core_remove_card(struct fw_card *card) 492{ 493 card->driver->update_phy_reg(card, 4, 494 PHY_LINK_ACTIVE | PHY_CONTENDER, 0); 495 fw_core_initiate_bus_reset(card, 1); 496 497 mutex_lock(&card_mutex); 498 list_del(&card->link); 499 mutex_unlock(&card_mutex); 500 501 /* Set up the dummy driver. */ 502 card->driver = &dummy_driver; 503 504 fw_flush_transactions(card); 505 506 fw_destroy_nodes(card); 507 508 fw_card_put(card); 509} 510EXPORT_SYMBOL(fw_core_remove_card); 511 512struct fw_card * 513fw_card_get(struct fw_card *card) 514{ 515 kref_get(&card->kref); 516 517 return card; 518} 519EXPORT_SYMBOL(fw_card_get); 520 521static void 522release_card(struct kref *kref) 523{ 524 struct fw_card *card = container_of(kref, struct fw_card, kref); 525 526 kfree(card); 527} 528 529/* 530 * An assumption for fw_card_put() is that the card driver allocates 531 * the fw_card struct with kalloc and that it has been shut down 532 * before the last ref is dropped. 533 */ 534void 535fw_card_put(struct fw_card *card) 536{ 537 kref_put(&card->kref, release_card); 538} 539EXPORT_SYMBOL(fw_card_put); 540 541int 542fw_core_initiate_bus_reset(struct fw_card *card, int short_reset) 543{ 544 int reg = short_reset ? 5 : 1; 545 int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET; 546 547 return card->driver->update_phy_reg(card, reg, 0, bit); 548} 549EXPORT_SYMBOL(fw_core_initiate_bus_reset); 550