2 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
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.
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.
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.
19 #include <linux/bug.h>
20 #include <linux/completion.h>
21 #include <linux/crc-itu-t.h>
22 #include <linux/device.h>
23 #include <linux/errno.h>
24 #include <linux/firewire.h>
25 #include <linux/firewire-constants.h>
26 #include <linux/jiffies.h>
27 #include <linux/kernel.h>
28 #include <linux/kref.h>
29 #include <linux/list.h>
30 #include <linux/module.h>
31 #include <linux/mutex.h>
32 #include <linux/spinlock.h>
33 #include <linux/workqueue.h>
35 #include <linux/atomic.h>
36 #include <asm/byteorder.h>
40 #define define_fw_printk_level(func, kern_level) \
41 void func(const struct fw_card *card, const char *fmt, ...) \
43 struct va_format vaf; \
46 va_start(args, fmt); \
49 printk(kern_level KBUILD_MODNAME " %s: %pV", \
50 dev_name(card->device), &vaf); \
53 define_fw_printk_level(fw_err, KERN_ERR);
54 define_fw_printk_level(fw_notice, KERN_NOTICE);
56 int fw_compute_block_crc(__be32 *block)
61 length = (be32_to_cpu(block[0]) >> 16) & 0xff;
62 crc = crc_itu_t(0, (u8 *)&block[1], length * 4);
63 *block |= cpu_to_be32(crc);
68 static DEFINE_MUTEX(card_mutex);
69 static LIST_HEAD(card_list);
71 static LIST_HEAD(descriptor_list);
72 static int descriptor_count;
74 static __be32 tmp_config_rom[256];
75 /* ROM header, bus info block, root dir header, capabilities = 7 quadlets */
76 static size_t config_rom_length = 1 + 4 + 1 + 1;
78 #define BIB_CRC(v) ((v) << 0)
79 #define BIB_CRC_LENGTH(v) ((v) << 16)
80 #define BIB_INFO_LENGTH(v) ((v) << 24)
81 #define BIB_BUS_NAME 0x31333934 /* "1394" */
82 #define BIB_LINK_SPEED(v) ((v) << 0)
83 #define BIB_GENERATION(v) ((v) << 4)
84 #define BIB_MAX_ROM(v) ((v) << 8)
85 #define BIB_MAX_RECEIVE(v) ((v) << 12)
86 #define BIB_CYC_CLK_ACC(v) ((v) << 16)
87 #define BIB_PMC ((1) << 27)
88 #define BIB_BMC ((1) << 28)
89 #define BIB_ISC ((1) << 29)
90 #define BIB_CMC ((1) << 30)
91 #define BIB_IRMC ((1) << 31)
92 #define NODE_CAPABILITIES 0x0c0083c0 /* per IEEE 1394 clause 8.3.2.6.5.2 */
95 * IEEE-1394 specifies a default SPLIT_TIMEOUT value of 800 cycles (100 ms),
96 * but we have to make it longer because there are many devices whose firmware
97 * is just too slow for that.
99 #define DEFAULT_SPLIT_TIMEOUT (2 * 8000)
101 #define CANON_OUI 0x000085
103 static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
105 struct fw_descriptor *desc;
109 * Initialize contents of config rom buffer. On the OHCI
110 * controller, block reads to the config rom accesses the host
111 * memory, but quadlet read access the hardware bus info block
112 * registers. That's just crack, but it means we should make
113 * sure the contents of bus info block in host memory matches
114 * the version stored in the OHCI registers.
117 config_rom[0] = cpu_to_be32(
118 BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0));
119 config_rom[1] = cpu_to_be32(BIB_BUS_NAME);
120 config_rom[2] = cpu_to_be32(
121 BIB_LINK_SPEED(card->link_speed) |
122 BIB_GENERATION(card->config_rom_generation++ % 14 + 2) |
124 BIB_MAX_RECEIVE(card->max_receive) |
125 BIB_BMC | BIB_ISC | BIB_CMC | BIB_IRMC);
126 config_rom[3] = cpu_to_be32(card->guid >> 32);
127 config_rom[4] = cpu_to_be32(card->guid);
129 /* Generate root directory. */
130 config_rom[6] = cpu_to_be32(NODE_CAPABILITIES);
132 j = 7 + descriptor_count;
134 /* Generate root directory entries for descriptors. */
135 list_for_each_entry (desc, &descriptor_list, link) {
136 if (desc->immediate > 0)
137 config_rom[i++] = cpu_to_be32(desc->immediate);
138 config_rom[i] = cpu_to_be32(desc->key | (j - i));
143 /* Update root directory length. */
144 config_rom[5] = cpu_to_be32((i - 5 - 1) << 16);
146 /* End of root directory, now copy in descriptors. */
147 list_for_each_entry (desc, &descriptor_list, link) {
148 for (k = 0; k < desc->length; k++)
149 config_rom[i + k] = cpu_to_be32(desc->data[k]);
153 /* Calculate CRCs for all blocks in the config rom. This
154 * assumes that CRC length and info length are identical for
155 * the bus info block, which is always the case for this
157 for (i = 0; i < j; i += length + 1)
158 length = fw_compute_block_crc(config_rom + i);
160 WARN_ON(j != config_rom_length);
163 static void update_config_roms(void)
165 struct fw_card *card;
167 list_for_each_entry (card, &card_list, link) {
168 generate_config_rom(card, tmp_config_rom);
169 card->driver->set_config_rom(card, tmp_config_rom,
174 static size_t required_space(struct fw_descriptor *desc)
176 /* descriptor + entry into root dir + optional immediate entry */
177 return desc->length + 1 + (desc->immediate > 0 ? 1 : 0);
180 int fw_core_add_descriptor(struct fw_descriptor *desc)
186 * Check descriptor is valid; the length of all blocks in the
187 * descriptor has to add up to exactly the length of the
191 while (i < desc->length)
192 i += (desc->data[i] >> 16) + 1;
194 if (i != desc->length)
197 mutex_lock(&card_mutex);
199 if (config_rom_length + required_space(desc) > 256) {
202 list_add_tail(&desc->link, &descriptor_list);
203 config_rom_length += required_space(desc);
205 if (desc->immediate > 0)
207 update_config_roms();
211 mutex_unlock(&card_mutex);
215 EXPORT_SYMBOL(fw_core_add_descriptor);
217 void fw_core_remove_descriptor(struct fw_descriptor *desc)
219 mutex_lock(&card_mutex);
221 list_del(&desc->link);
222 config_rom_length -= required_space(desc);
224 if (desc->immediate > 0)
226 update_config_roms();
228 mutex_unlock(&card_mutex);
230 EXPORT_SYMBOL(fw_core_remove_descriptor);
232 static int reset_bus(struct fw_card *card, bool short_reset)
234 int reg = short_reset ? 5 : 1;
235 int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
237 return card->driver->update_phy_reg(card, reg, 0, bit);
240 void fw_schedule_bus_reset(struct fw_card *card, bool delayed, bool short_reset)
242 /* We don't try hard to sort out requests of long vs. short resets. */
243 card->br_short = short_reset;
245 /* Use an arbitrary short delay to combine multiple reset requests. */
247 if (!queue_delayed_work(fw_workqueue, &card->br_work,
248 delayed ? DIV_ROUND_UP(HZ, 100) : 0))
251 EXPORT_SYMBOL(fw_schedule_bus_reset);
253 static void br_work(struct work_struct *work)
255 struct fw_card *card = container_of(work, struct fw_card, br_work.work);
257 /* Delay for 2s after last reset per IEEE 1394 clause 8.2.1. */
258 if (card->reset_jiffies != 0 &&
259 time_before64(get_jiffies_64(), card->reset_jiffies + 2 * HZ)) {
260 if (!queue_delayed_work(fw_workqueue, &card->br_work, 2 * HZ))
265 fw_send_phy_config(card, FW_PHY_CONFIG_NO_NODE_ID, card->generation,
266 FW_PHY_CONFIG_CURRENT_GAP_COUNT);
267 reset_bus(card, card->br_short);
271 static void allocate_broadcast_channel(struct fw_card *card, int generation)
273 int channel, bandwidth = 0;
275 if (!card->broadcast_channel_allocated) {
276 fw_iso_resource_manage(card, generation, 1ULL << 31,
277 &channel, &bandwidth, true);
279 fw_notice(card, "failed to allocate broadcast channel\n");
282 card->broadcast_channel_allocated = true;
285 device_for_each_child(card->device, (void *)(long)generation,
286 fw_device_set_broadcast_channel);
289 static const char gap_count_table[] = {
290 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
293 void fw_schedule_bm_work(struct fw_card *card, unsigned long delay)
296 if (!schedule_delayed_work(&card->bm_work, delay))
300 static void bm_work(struct work_struct *work)
302 struct fw_card *card = container_of(work, struct fw_card, bm_work.work);
303 struct fw_device *root_device, *irm_device;
304 struct fw_node *root_node;
305 int root_id, new_root_id, irm_id, bm_id, local_id;
306 int gap_count, generation, grace, rcode;
307 bool do_reset = false;
308 bool root_device_is_running;
309 bool root_device_is_cmc;
310 bool irm_is_1394_1995_only;
312 __be32 transaction_data[2];
314 spin_lock_irq(&card->lock);
316 if (card->local_node == NULL) {
317 spin_unlock_irq(&card->lock);
321 generation = card->generation;
323 root_node = card->root_node;
324 fw_node_get(root_node);
325 root_device = root_node->data;
326 root_device_is_running = root_device &&
327 atomic_read(&root_device->state) == FW_DEVICE_RUNNING;
328 root_device_is_cmc = root_device && root_device->cmc;
330 irm_device = card->irm_node->data;
331 irm_is_1394_1995_only = irm_device && irm_device->config_rom &&
332 (irm_device->config_rom[2] & 0x000000f0) == 0;
334 /* Canon MV5i works unreliably if it is not root node. */
335 keep_this_irm = irm_device && irm_device->config_rom &&
336 irm_device->config_rom[3] >> 8 == CANON_OUI;
338 root_id = root_node->node_id;
339 irm_id = card->irm_node->node_id;
340 local_id = card->local_node->node_id;
342 grace = time_after64(get_jiffies_64(),
343 card->reset_jiffies + DIV_ROUND_UP(HZ, 8));
345 if ((is_next_generation(generation, card->bm_generation) &&
346 !card->bm_abdicate) ||
347 (card->bm_generation != generation && grace)) {
349 * This first step is to figure out who is IRM and
350 * then try to become bus manager. If the IRM is not
351 * well defined (e.g. does not have an active link
352 * layer or does not responds to our lock request, we
353 * will have to do a little vigilante bus management.
354 * In that case, we do a goto into the gap count logic
355 * so that when we do the reset, we still optimize the
356 * gap count. That could well save a reset in the
360 if (!card->irm_node->link_on) {
361 new_root_id = local_id;
362 fw_notice(card, "%s, making local node (%02x) root\n",
363 "IRM has link off", new_root_id);
367 if (irm_is_1394_1995_only && !keep_this_irm) {
368 new_root_id = local_id;
369 fw_notice(card, "%s, making local node (%02x) root\n",
370 "IRM is not 1394a compliant", new_root_id);
374 transaction_data[0] = cpu_to_be32(0x3f);
375 transaction_data[1] = cpu_to_be32(local_id);
377 spin_unlock_irq(&card->lock);
379 rcode = fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP,
380 irm_id, generation, SCODE_100,
381 CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID,
382 transaction_data, 8);
384 if (rcode == RCODE_GENERATION)
385 /* Another bus reset, BM work has been rescheduled. */
388 bm_id = be32_to_cpu(transaction_data[0]);
390 spin_lock_irq(&card->lock);
391 if (rcode == RCODE_COMPLETE && generation == card->generation)
393 bm_id == 0x3f ? local_id : 0xffc0 | bm_id;
394 spin_unlock_irq(&card->lock);
396 if (rcode == RCODE_COMPLETE && bm_id != 0x3f) {
397 /* Somebody else is BM. Only act as IRM. */
398 if (local_id == irm_id)
399 allocate_broadcast_channel(card, generation);
404 if (rcode == RCODE_SEND_ERROR) {
406 * We have been unable to send the lock request due to
407 * some local problem. Let's try again later and hope
408 * that the problem has gone away by then.
410 fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8));
414 spin_lock_irq(&card->lock);
416 if (rcode != RCODE_COMPLETE && !keep_this_irm) {
418 * The lock request failed, maybe the IRM
419 * isn't really IRM capable after all. Let's
420 * do a bus reset and pick the local node as
421 * root, and thus, IRM.
423 new_root_id = local_id;
424 fw_notice(card, "BM lock failed (%s), making local node (%02x) root\n",
425 fw_rcode_string(rcode), new_root_id);
428 } else if (card->bm_generation != generation) {
430 * We weren't BM in the last generation, and the last
431 * bus reset is less than 125ms ago. Reschedule this job.
433 spin_unlock_irq(&card->lock);
434 fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8));
439 * We're bus manager for this generation, so next step is to
440 * make sure we have an active cycle master and do gap count
443 card->bm_generation = generation;
445 if (card->gap_count == 0) {
447 * If self IDs have inconsistent gap counts, do a
448 * bus reset ASAP. The config rom read might never
449 * complete, so don't wait for it. However, still
450 * send a PHY configuration packet prior to the
451 * bus reset. The PHY configuration packet might
452 * fail, but 1394-2008 8.4.5.2 explicitly permits
453 * it in this case, so it should be safe to try.
455 new_root_id = local_id;
457 * We must always send a bus reset if the gap count
458 * is inconsistent, so bypass the 5-reset limit.
460 card->bm_retries = 0;
461 } else if (root_device == NULL) {
463 * Either link_on is false, or we failed to read the
464 * config rom. In either case, pick another root.
466 new_root_id = local_id;
467 } else if (!root_device_is_running) {
469 * If we haven't probed this device yet, bail out now
470 * and let's try again once that's done.
472 spin_unlock_irq(&card->lock);
474 } else if (root_device_is_cmc) {
476 * We will send out a force root packet for this
477 * node as part of the gap count optimization.
479 new_root_id = root_id;
482 * Current root has an active link layer and we
483 * successfully read the config rom, but it's not
484 * cycle master capable.
486 new_root_id = local_id;
491 * Pick a gap count from 1394a table E-1. The table doesn't cover
492 * the typically much larger 1394b beta repeater delays though.
494 if (!card->beta_repeaters_present &&
495 root_node->max_hops < ARRAY_SIZE(gap_count_table))
496 gap_count = gap_count_table[root_node->max_hops];
501 * Finally, figure out if we should do a reset or not. If we have
502 * done less than 5 resets with the same physical topology and we
503 * have either a new root or a new gap count setting, let's do it.
506 if (card->bm_retries++ < 5 &&
507 (card->gap_count != gap_count || new_root_id != root_id))
510 spin_unlock_irq(&card->lock);
513 fw_notice(card, "phy config: new root=%x, gap_count=%d\n",
514 new_root_id, gap_count);
515 fw_send_phy_config(card, new_root_id, generation, gap_count);
517 * Where possible, use a short bus reset to minimize
518 * disruption to isochronous transfers. But in the event
519 * of a gap count inconsistency, use a long bus reset.
521 * As noted in 1394a 8.4.6.2, nodes on a mixed 1394/1394a bus
522 * may set different gap counts after a bus reset. On a mixed
523 * 1394/1394a bus, a short bus reset can get doubled. Some
524 * nodes may treat the double reset as one bus reset and others
525 * may treat it as two, causing a gap count inconsistency
526 * again. Using a long bus reset prevents this.
528 reset_bus(card, card->gap_count != 0);
529 /* Will allocate broadcast channel after the reset. */
533 if (root_device_is_cmc) {
535 * Make sure that the cycle master sends cycle start packets.
537 transaction_data[0] = cpu_to_be32(CSR_STATE_BIT_CMSTR);
538 rcode = fw_run_transaction(card, TCODE_WRITE_QUADLET_REQUEST,
539 root_id, generation, SCODE_100,
540 CSR_REGISTER_BASE + CSR_STATE_SET,
541 transaction_data, 4);
542 if (rcode == RCODE_GENERATION)
546 if (local_id == irm_id)
547 allocate_broadcast_channel(card, generation);
550 fw_node_put(root_node);
555 void fw_card_initialize(struct fw_card *card,
556 const struct fw_card_driver *driver,
557 struct device *device)
559 static atomic_t index = ATOMIC_INIT(-1);
561 card->index = atomic_inc_return(&index);
562 card->driver = driver;
563 card->device = device;
564 card->current_tlabel = 0;
565 card->tlabel_mask = 0;
566 card->split_timeout_hi = DEFAULT_SPLIT_TIMEOUT / 8000;
567 card->split_timeout_lo = (DEFAULT_SPLIT_TIMEOUT % 8000) << 19;
568 card->split_timeout_cycles = DEFAULT_SPLIT_TIMEOUT;
569 card->split_timeout_jiffies =
570 DIV_ROUND_UP(DEFAULT_SPLIT_TIMEOUT * HZ, 8000);
572 card->broadcast_channel = BROADCAST_CHANNEL_INITIAL;
574 kref_init(&card->kref);
575 init_completion(&card->done);
576 INIT_LIST_HEAD(&card->transaction_list);
577 INIT_LIST_HEAD(&card->phy_receiver_list);
578 spin_lock_init(&card->lock);
580 card->local_node = NULL;
582 INIT_DELAYED_WORK(&card->br_work, br_work);
583 INIT_DELAYED_WORK(&card->bm_work, bm_work);
585 EXPORT_SYMBOL(fw_card_initialize);
587 int fw_card_add(struct fw_card *card,
588 u32 max_receive, u32 link_speed, u64 guid)
592 card->max_receive = max_receive;
593 card->link_speed = link_speed;
596 mutex_lock(&card_mutex);
598 generate_config_rom(card, tmp_config_rom);
599 ret = card->driver->enable(card, tmp_config_rom, config_rom_length);
601 list_add_tail(&card->link, &card_list);
603 mutex_unlock(&card_mutex);
607 EXPORT_SYMBOL(fw_card_add);
610 * The next few functions implement a dummy driver that is used once a card
611 * driver shuts down an fw_card. This allows the driver to cleanly unload,
612 * as all IO to the card will be handled (and failed) by the dummy driver
613 * instead of calling into the module. Only functions for iso context
614 * shutdown still need to be provided by the card driver.
616 * .read/write_csr() should never be called anymore after the dummy driver
617 * was bound since they are only used within request handler context.
618 * .set_config_rom() is never called since the card is taken out of card_list
619 * before switching to the dummy driver.
622 static int dummy_read_phy_reg(struct fw_card *card, int address)
627 static int dummy_update_phy_reg(struct fw_card *card, int address,
628 int clear_bits, int set_bits)
633 static void dummy_send_request(struct fw_card *card, struct fw_packet *packet)
635 packet->callback(packet, card, RCODE_CANCELLED);
638 static void dummy_send_response(struct fw_card *card, struct fw_packet *packet)
640 packet->callback(packet, card, RCODE_CANCELLED);
643 static int dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
648 static int dummy_enable_phys_dma(struct fw_card *card,
649 int node_id, int generation)
654 static struct fw_iso_context *dummy_allocate_iso_context(struct fw_card *card,
655 int type, int channel, size_t header_size)
657 return ERR_PTR(-ENODEV);
660 static int dummy_start_iso(struct fw_iso_context *ctx,
661 s32 cycle, u32 sync, u32 tags)
666 static int dummy_set_iso_channels(struct fw_iso_context *ctx, u64 *channels)
671 static int dummy_queue_iso(struct fw_iso_context *ctx, struct fw_iso_packet *p,
672 struct fw_iso_buffer *buffer, unsigned long payload)
677 static void dummy_flush_queue_iso(struct fw_iso_context *ctx)
681 static int dummy_flush_iso_completions(struct fw_iso_context *ctx)
686 static const struct fw_card_driver dummy_driver_template = {
687 .read_phy_reg = dummy_read_phy_reg,
688 .update_phy_reg = dummy_update_phy_reg,
689 .send_request = dummy_send_request,
690 .send_response = dummy_send_response,
691 .cancel_packet = dummy_cancel_packet,
692 .enable_phys_dma = dummy_enable_phys_dma,
693 .allocate_iso_context = dummy_allocate_iso_context,
694 .start_iso = dummy_start_iso,
695 .set_iso_channels = dummy_set_iso_channels,
696 .queue_iso = dummy_queue_iso,
697 .flush_queue_iso = dummy_flush_queue_iso,
698 .flush_iso_completions = dummy_flush_iso_completions,
701 void fw_card_release(struct kref *kref)
703 struct fw_card *card = container_of(kref, struct fw_card, kref);
705 complete(&card->done);
707 EXPORT_SYMBOL_GPL(fw_card_release);
709 void fw_core_remove_card(struct fw_card *card)
711 struct fw_card_driver dummy_driver = dummy_driver_template;
714 card->driver->update_phy_reg(card, 4,
715 PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
716 fw_schedule_bus_reset(card, false, true);
718 mutex_lock(&card_mutex);
719 list_del_init(&card->link);
720 mutex_unlock(&card_mutex);
722 /* Switch off most of the card driver interface. */
723 dummy_driver.free_iso_context = card->driver->free_iso_context;
724 dummy_driver.stop_iso = card->driver->stop_iso;
725 card->driver = &dummy_driver;
727 spin_lock_irqsave(&card->lock, flags);
728 fw_destroy_nodes(card);
729 spin_unlock_irqrestore(&card->lock, flags);
731 /* Wait for all users, especially device workqueue jobs, to finish. */
733 wait_for_completion(&card->done);
735 WARN_ON(!list_empty(&card->transaction_list));
737 EXPORT_SYMBOL(fw_core_remove_card);