ia64/kvm: compilation fix. export account_system_vtime.
[pv_ops_mirror.git] / drivers / firewire / fw-card.c
blob5b4c0d9f517346ec79a1426a4d7982ebe07986c8
1 /*
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/module.h>
20 #include <linux/errno.h>
21 #include <linux/delay.h>
22 #include <linux/device.h>
23 #include <linux/mutex.h>
24 #include <linux/crc-itu-t.h>
25 #include "fw-transaction.h"
26 #include "fw-topology.h"
27 #include "fw-device.h"
29 int fw_compute_block_crc(u32 *block)
31 __be32 be32_block[256];
32 int i, length;
34 length = (*block >> 16) & 0xff;
35 for (i = 0; i < length; i++)
36 be32_block[i] = cpu_to_be32(block[i + 1]);
37 *block |= crc_itu_t(0, (u8 *) be32_block, length * 4);
39 return length;
42 static DEFINE_MUTEX(card_mutex);
43 static LIST_HEAD(card_list);
45 static LIST_HEAD(descriptor_list);
46 static int descriptor_count;
48 #define BIB_CRC(v) ((v) << 0)
49 #define BIB_CRC_LENGTH(v) ((v) << 16)
50 #define BIB_INFO_LENGTH(v) ((v) << 24)
52 #define BIB_LINK_SPEED(v) ((v) << 0)
53 #define BIB_GENERATION(v) ((v) << 4)
54 #define BIB_MAX_ROM(v) ((v) << 8)
55 #define BIB_MAX_RECEIVE(v) ((v) << 12)
56 #define BIB_CYC_CLK_ACC(v) ((v) << 16)
57 #define BIB_PMC ((1) << 27)
58 #define BIB_BMC ((1) << 28)
59 #define BIB_ISC ((1) << 29)
60 #define BIB_CMC ((1) << 30)
61 #define BIB_IMC ((1) << 31)
63 static u32 *
64 generate_config_rom(struct fw_card *card, size_t *config_rom_length)
66 struct fw_descriptor *desc;
67 static u32 config_rom[256];
68 int i, j, length;
71 * Initialize contents of config rom buffer. On the OHCI
72 * controller, block reads to the config rom accesses the host
73 * memory, but quadlet read access the hardware bus info block
74 * registers. That's just crack, but it means we should make
75 * sure the contents of bus info block in host memory mathces
76 * the version stored in the OHCI registers.
79 memset(config_rom, 0, sizeof(config_rom));
80 config_rom[0] = BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0);
81 config_rom[1] = 0x31333934;
83 config_rom[2] =
84 BIB_LINK_SPEED(card->link_speed) |
85 BIB_GENERATION(card->config_rom_generation++ % 14 + 2) |
86 BIB_MAX_ROM(2) |
87 BIB_MAX_RECEIVE(card->max_receive) |
88 BIB_BMC | BIB_ISC | BIB_CMC | BIB_IMC;
89 config_rom[3] = card->guid >> 32;
90 config_rom[4] = card->guid;
92 /* Generate root directory. */
93 i = 5;
94 config_rom[i++] = 0;
95 config_rom[i++] = 0x0c0083c0; /* node capabilities */
96 j = i + descriptor_count;
98 /* Generate root directory entries for descriptors. */
99 list_for_each_entry (desc, &descriptor_list, link) {
100 if (desc->immediate > 0)
101 config_rom[i++] = desc->immediate;
102 config_rom[i] = desc->key | (j - i);
103 i++;
104 j += desc->length;
107 /* Update root directory length. */
108 config_rom[5] = (i - 5 - 1) << 16;
110 /* End of root directory, now copy in descriptors. */
111 list_for_each_entry (desc, &descriptor_list, link) {
112 memcpy(&config_rom[i], desc->data, desc->length * 4);
113 i += desc->length;
116 /* Calculate CRCs for all blocks in the config rom. This
117 * assumes that CRC length and info length are identical for
118 * the bus info block, which is always the case for this
119 * implementation. */
120 for (i = 0; i < j; i += length + 1)
121 length = fw_compute_block_crc(config_rom + i);
123 *config_rom_length = j;
125 return config_rom;
128 static void
129 update_config_roms(void)
131 struct fw_card *card;
132 u32 *config_rom;
133 size_t length;
135 list_for_each_entry (card, &card_list, link) {
136 config_rom = generate_config_rom(card, &length);
137 card->driver->set_config_rom(card, config_rom, length);
142 fw_core_add_descriptor(struct fw_descriptor *desc)
144 size_t i;
147 * Check descriptor is valid; the length of all blocks in the
148 * descriptor has to add up to exactly the length of the
149 * block.
151 i = 0;
152 while (i < desc->length)
153 i += (desc->data[i] >> 16) + 1;
155 if (i != desc->length)
156 return -EINVAL;
158 mutex_lock(&card_mutex);
160 list_add_tail(&desc->link, &descriptor_list);
161 descriptor_count++;
162 if (desc->immediate > 0)
163 descriptor_count++;
164 update_config_roms();
166 mutex_unlock(&card_mutex);
168 return 0;
171 void
172 fw_core_remove_descriptor(struct fw_descriptor *desc)
174 mutex_lock(&card_mutex);
176 list_del(&desc->link);
177 descriptor_count--;
178 if (desc->immediate > 0)
179 descriptor_count--;
180 update_config_roms();
182 mutex_unlock(&card_mutex);
185 static const char gap_count_table[] = {
186 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
189 struct bm_data {
190 struct fw_transaction t;
191 struct {
192 __be32 arg;
193 __be32 data;
194 } lock;
195 u32 old;
196 int rcode;
197 struct completion done;
200 static void
201 complete_bm_lock(struct fw_card *card, int rcode,
202 void *payload, size_t length, void *data)
204 struct bm_data *bmd = data;
206 if (rcode == RCODE_COMPLETE)
207 bmd->old = be32_to_cpu(*(__be32 *) payload);
208 bmd->rcode = rcode;
209 complete(&bmd->done);
212 static void
213 fw_card_bm_work(struct work_struct *work)
215 struct fw_card *card = container_of(work, struct fw_card, work.work);
216 struct fw_device *root_device;
217 struct fw_node *root_node, *local_node;
218 struct bm_data bmd;
219 unsigned long flags;
220 int root_id, new_root_id, irm_id, gap_count, generation, grace;
221 bool do_reset = false;
223 spin_lock_irqsave(&card->lock, flags);
224 local_node = card->local_node;
225 root_node = card->root_node;
227 if (local_node == NULL) {
228 spin_unlock_irqrestore(&card->lock, flags);
229 return;
231 fw_node_get(local_node);
232 fw_node_get(root_node);
234 generation = card->generation;
235 root_device = root_node->data;
236 if (root_device)
237 fw_device_get(root_device);
238 root_id = root_node->node_id;
239 grace = time_after(jiffies, card->reset_jiffies + DIV_ROUND_UP(HZ, 10));
241 if (card->bm_generation + 1 == generation ||
242 (card->bm_generation != generation && grace)) {
244 * This first step is to figure out who is IRM and
245 * then try to become bus manager. If the IRM is not
246 * well defined (e.g. does not have an active link
247 * layer or does not responds to our lock request, we
248 * will have to do a little vigilante bus management.
249 * In that case, we do a goto into the gap count logic
250 * so that when we do the reset, we still optimize the
251 * gap count. That could well save a reset in the
252 * next generation.
255 irm_id = card->irm_node->node_id;
256 if (!card->irm_node->link_on) {
257 new_root_id = local_node->node_id;
258 fw_notify("IRM has link off, making local node (%02x) root.\n",
259 new_root_id);
260 goto pick_me;
263 bmd.lock.arg = cpu_to_be32(0x3f);
264 bmd.lock.data = cpu_to_be32(local_node->node_id);
266 spin_unlock_irqrestore(&card->lock, flags);
268 init_completion(&bmd.done);
269 fw_send_request(card, &bmd.t, TCODE_LOCK_COMPARE_SWAP,
270 irm_id, generation,
271 SCODE_100, CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID,
272 &bmd.lock, sizeof(bmd.lock),
273 complete_bm_lock, &bmd);
274 wait_for_completion(&bmd.done);
276 if (bmd.rcode == RCODE_GENERATION) {
278 * Another bus reset happened. Just return,
279 * the BM work has been rescheduled.
281 goto out;
284 if (bmd.rcode == RCODE_COMPLETE && bmd.old != 0x3f)
285 /* Somebody else is BM, let them do the work. */
286 goto out;
288 spin_lock_irqsave(&card->lock, flags);
289 if (bmd.rcode != RCODE_COMPLETE) {
291 * The lock request failed, maybe the IRM
292 * isn't really IRM capable after all. Let's
293 * do a bus reset and pick the local node as
294 * root, and thus, IRM.
296 new_root_id = local_node->node_id;
297 fw_notify("BM lock failed, making local node (%02x) root.\n",
298 new_root_id);
299 goto pick_me;
301 } else if (card->bm_generation != generation) {
303 * OK, we weren't BM in the last generation, and it's
304 * less than 100ms since last bus reset. Reschedule
305 * this task 100ms from now.
307 spin_unlock_irqrestore(&card->lock, flags);
308 schedule_delayed_work(&card->work, DIV_ROUND_UP(HZ, 10));
309 goto out;
313 * We're bus manager for this generation, so next step is to
314 * make sure we have an active cycle master and do gap count
315 * optimization.
317 card->bm_generation = generation;
319 if (root_device == NULL) {
321 * Either link_on is false, or we failed to read the
322 * config rom. In either case, pick another root.
324 new_root_id = local_node->node_id;
325 } else if (atomic_read(&root_device->state) != FW_DEVICE_RUNNING) {
327 * If we haven't probed this device yet, bail out now
328 * and let's try again once that's done.
330 spin_unlock_irqrestore(&card->lock, flags);
331 goto out;
332 } else if (root_device->cmc) {
334 * FIXME: I suppose we should set the cmstr bit in the
335 * STATE_CLEAR register of this node, as described in
336 * 1394-1995, 8.4.2.6. Also, send out a force root
337 * packet for this node.
339 new_root_id = root_id;
340 } else {
342 * Current root has an active link layer and we
343 * successfully read the config rom, but it's not
344 * cycle master capable.
346 new_root_id = local_node->node_id;
349 pick_me:
351 * Pick a gap count from 1394a table E-1. The table doesn't cover
352 * the typically much larger 1394b beta repeater delays though.
354 if (!card->beta_repeaters_present &&
355 root_node->max_hops < ARRAY_SIZE(gap_count_table))
356 gap_count = gap_count_table[root_node->max_hops];
357 else
358 gap_count = 63;
361 * Finally, figure out if we should do a reset or not. If we have
362 * done less than 5 resets with the same physical topology and we
363 * have either a new root or a new gap count setting, let's do it.
366 if (card->bm_retries++ < 5 &&
367 (card->gap_count != gap_count || new_root_id != root_id))
368 do_reset = true;
370 spin_unlock_irqrestore(&card->lock, flags);
372 if (do_reset) {
373 fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
374 card->index, new_root_id, gap_count);
375 fw_send_phy_config(card, new_root_id, generation, gap_count);
376 fw_core_initiate_bus_reset(card, 1);
378 out:
379 if (root_device)
380 fw_device_put(root_device);
381 fw_node_put(root_node);
382 fw_node_put(local_node);
385 static void
386 flush_timer_callback(unsigned long data)
388 struct fw_card *card = (struct fw_card *)data;
390 fw_flush_transactions(card);
393 void
394 fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
395 struct device *device)
397 static atomic_t index = ATOMIC_INIT(-1);
399 atomic_set(&card->device_count, 0);
400 card->index = atomic_inc_return(&index);
401 card->driver = driver;
402 card->device = device;
403 card->current_tlabel = 0;
404 card->tlabel_mask = 0;
405 card->color = 0;
407 INIT_LIST_HEAD(&card->transaction_list);
408 spin_lock_init(&card->lock);
409 setup_timer(&card->flush_timer,
410 flush_timer_callback, (unsigned long)card);
412 card->local_node = NULL;
414 INIT_DELAYED_WORK(&card->work, fw_card_bm_work);
416 EXPORT_SYMBOL(fw_card_initialize);
419 fw_card_add(struct fw_card *card,
420 u32 max_receive, u32 link_speed, u64 guid)
422 u32 *config_rom;
423 size_t length;
425 card->max_receive = max_receive;
426 card->link_speed = link_speed;
427 card->guid = guid;
429 mutex_lock(&card_mutex);
430 config_rom = generate_config_rom(card, &length);
431 list_add_tail(&card->link, &card_list);
432 mutex_unlock(&card_mutex);
434 return card->driver->enable(card, config_rom, length);
436 EXPORT_SYMBOL(fw_card_add);
440 * The next few functions implements a dummy driver that use once a
441 * card driver shuts down an fw_card. This allows the driver to
442 * cleanly unload, as all IO to the card will be handled by the dummy
443 * driver instead of calling into the (possibly) unloaded module. The
444 * dummy driver just fails all IO.
447 static int
448 dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
450 BUG();
451 return -1;
454 static int
455 dummy_update_phy_reg(struct fw_card *card, int address,
456 int clear_bits, int set_bits)
458 return -ENODEV;
461 static int
462 dummy_set_config_rom(struct fw_card *card,
463 u32 *config_rom, size_t length)
466 * We take the card out of card_list before setting the dummy
467 * driver, so this should never get called.
469 BUG();
470 return -1;
473 static void
474 dummy_send_request(struct fw_card *card, struct fw_packet *packet)
476 packet->callback(packet, card, -ENODEV);
479 static void
480 dummy_send_response(struct fw_card *card, struct fw_packet *packet)
482 packet->callback(packet, card, -ENODEV);
485 static int
486 dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
488 return -ENOENT;
491 static int
492 dummy_enable_phys_dma(struct fw_card *card,
493 int node_id, int generation)
495 return -ENODEV;
498 static struct fw_card_driver dummy_driver = {
499 .name = "dummy",
500 .enable = dummy_enable,
501 .update_phy_reg = dummy_update_phy_reg,
502 .set_config_rom = dummy_set_config_rom,
503 .send_request = dummy_send_request,
504 .cancel_packet = dummy_cancel_packet,
505 .send_response = dummy_send_response,
506 .enable_phys_dma = dummy_enable_phys_dma,
509 void
510 fw_core_remove_card(struct fw_card *card)
512 card->driver->update_phy_reg(card, 4,
513 PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
514 fw_core_initiate_bus_reset(card, 1);
516 mutex_lock(&card_mutex);
517 list_del(&card->link);
518 mutex_unlock(&card_mutex);
520 /* Set up the dummy driver. */
521 card->driver = &dummy_driver;
523 fw_destroy_nodes(card);
525 * Wait for all device workqueue jobs to finish. Otherwise the
526 * firewire-core module could be unloaded before the jobs ran.
528 while (atomic_read(&card->device_count) > 0)
529 msleep(100);
531 cancel_delayed_work_sync(&card->work);
532 fw_flush_transactions(card);
533 del_timer_sync(&card->flush_timer);
535 EXPORT_SYMBOL(fw_core_remove_card);
538 fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
540 int reg = short_reset ? 5 : 1;
541 int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
543 return card->driver->update_phy_reg(card, reg, 0, bit);
545 EXPORT_SYMBOL(fw_core_initiate_bus_reset);