SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/firewire/fw-card.c

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