blob: b1deb5214bd4c95a90734f539e2a20df73ac4e4e [file] [log] [blame]
Kristian Høgsberg3038e352006-12-19 19:58:27 -05001/* -*- 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"
Kristian Høgsberg19a15b92006-12-19 19:58:31 -050027#include "fw-device.h"
Kristian Høgsberg3038e352006-12-19 19:58:27 -050028
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. */
33static u16
34crc16_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
52static LIST_HEAD(card_list);
53
54static LIST_HEAD(descriptor_list);
55static 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
72static u32 *
73generate_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
Stefan Richter5e20c282007-01-21 20:44:09 +010079 /* 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. */
Kristian Høgsberg3038e352006-12-19 19:58:27 -050085
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) |
Kristian Høgsberg931c4832007-01-26 00:38:45 -050095 bib_bmc | bib_isc | bib_cmc | bib_imc;
Kristian Høgsberg3038e352006-12-19 19:58:27 -050096 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 */
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500103 j = i + descriptor_count;
104
105 /* Generate root directory entries for descriptors. */
106 list_for_each_entry (desc, &descriptor_list, link) {
Kristian Høgsberg937f6872007-03-07 12:12:36 -0500107 if (desc->immediate > 0)
108 config_rom[i++] = desc->immediate;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500109 config_rom[i] = desc->key | (j - i);
110 i++;
111 j += desc->length;
112 }
113
114 /* Update root directory length. */
115 config_rom[5] = (i - 5 - 1) << 16;
116
117 /* End of root directory, now copy in descriptors. */
118 list_for_each_entry (desc, &descriptor_list, link) {
119 memcpy(&config_rom[i], desc->data, desc->length * 4);
120 i += desc->length;
121 }
122
123 /* Calculate CRCs for all blocks in the config rom. This
124 * assumes that CRC length and info length are identical for
125 * the bus info block, which is always the case for this
126 * implementation. */
127 for (i = 0; i < j; i += length + 1) {
128 length = (config_rom[i] >> 16) & 0xff;
129 config_rom[i] |= crc16_itu_t(&config_rom[i + 1], length);
130 }
131
132 *config_rom_length = j;
133
134 return config_rom;
135}
136
137static void
138update_config_roms (void)
139{
140 struct fw_card *card;
141 u32 *config_rom;
142 size_t length;
143
144 list_for_each_entry (card, &card_list, link) {
145 config_rom = generate_config_rom(card, &length);
146 card->driver->set_config_rom(card, config_rom, length);
147 }
148}
149
150int
151fw_core_add_descriptor (struct fw_descriptor *desc)
152{
153 size_t i;
154
155 /* Check descriptor is valid; the length of all blocks in the
156 * descriptor has to add up to exactly the length of the
157 * block. */
158 i = 0;
159 while (i < desc->length)
160 i += (desc->data[i] >> 16) + 1;
161
162 if (i != desc->length)
163 return -1;
164
165 down_write(&fw_bus_type.subsys.rwsem);
166
167 list_add_tail (&desc->link, &descriptor_list);
168 descriptor_count++;
Kristian Høgsberg937f6872007-03-07 12:12:36 -0500169 if (desc->immediate > 0)
170 descriptor_count++;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500171 update_config_roms();
172
173 up_write(&fw_bus_type.subsys.rwsem);
174
175 return 0;
176}
177EXPORT_SYMBOL(fw_core_add_descriptor);
178
179void
180fw_core_remove_descriptor (struct fw_descriptor *desc)
181{
182 down_write(&fw_bus_type.subsys.rwsem);
183
184 list_del(&desc->link);
185 descriptor_count--;
Kristian Høgsberg937f6872007-03-07 12:12:36 -0500186 if (desc->immediate > 0)
187 descriptor_count--;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500188 update_config_roms();
189
190 up_write(&fw_bus_type.subsys.rwsem);
191}
192EXPORT_SYMBOL(fw_core_remove_descriptor);
193
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500194static const char gap_count_table[] = {
195 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
196};
197
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500198struct bm_data {
199 struct fw_transaction t;
200 struct {
201 __be32 arg;
202 __be32 data;
203 } lock;
204 u32 old;
205 int rcode;
206 struct completion done;
207};
208
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500209static void
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500210complete_bm_lock(struct fw_card *card, int rcode,
211 void *payload, size_t length, void *data)
212{
213 struct bm_data *bmd = data;
214
215 if (rcode == RCODE_COMPLETE)
216 bmd->old = be32_to_cpu(*(__be32 *) payload);
217 bmd->rcode = rcode;
218 complete(&bmd->done);
219}
220
221static void
222fw_card_bm_work(struct work_struct *work)
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500223{
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500224 struct fw_card *card = container_of(work, struct fw_card, work.work);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500225 struct fw_device *root;
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500226 struct bm_data bmd;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500227 unsigned long flags;
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500228 int root_id, new_root_id, irm_id, gap_count, generation, grace;
229 int do_reset = 0;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500230
231 spin_lock_irqsave(&card->lock, flags);
232
233 generation = card->generation;
234 root = card->root_node->data;
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500235 root_id = card->root_node->node_id;
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500236 grace = time_after(jiffies, card->reset_jiffies + DIV_ROUND_UP(HZ, 10));
237
238 if (card->bm_generation + 1 == generation ||
239 (card->bm_generation != generation && grace)) {
240 /* This first step is to figure out who is IRM and
241 * then try to become bus manager. If the IRM is not
242 * well defined (e.g. does not have an active link
243 * layer or does not responds to our lock request, we
244 * will have to do a little vigilante bus management.
245 * In that case, we do a goto into the gap count logic
246 * so that when we do the reset, we still optimize the
247 * gap count. That could well save a reset in the
248 * next generation. */
249
250 irm_id = card->irm_node->node_id;
251 if (!card->irm_node->link_on) {
252 new_root_id = card->local_node->node_id;
253 fw_notify("IRM has link off, making local node (%02x) root.\n",
254 new_root_id);
255 goto pick_me;
256 }
257
258 bmd.lock.arg = cpu_to_be32(0x3f);
259 bmd.lock.data = cpu_to_be32(card->local_node->node_id);
260
261 spin_unlock_irqrestore(&card->lock, flags);
262
263 init_completion(&bmd.done);
264 fw_send_request(card, &bmd.t, TCODE_LOCK_COMPARE_SWAP,
265 irm_id, generation,
266 SCODE_100, CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID,
267 &bmd.lock, sizeof bmd.lock,
268 complete_bm_lock, &bmd);
269 wait_for_completion(&bmd.done);
270
271 if (bmd.rcode == RCODE_GENERATION) {
272 /* Another bus reset happened. Just return,
273 * the BM work has been rescheduled. */
274 return;
275 }
276
277 if (bmd.rcode == RCODE_COMPLETE && bmd.old != 0x3f)
278 /* Somebody else is BM, let them do the work. */
279 return;
280
281 spin_lock_irqsave(&card->lock, flags);
282 if (bmd.rcode != RCODE_COMPLETE) {
283 /* The lock request failed, maybe the IRM
284 * isn't really IRM capable after all. Let's
285 * do a bus reset and pick the local node as
286 * root, and thus, IRM. */
287 new_root_id = card->local_node->node_id;
288 fw_notify("BM lock failed, making local node (%02x) root.\n",
289 new_root_id);
290 goto pick_me;
291 }
292 } else if (card->bm_generation != generation) {
293 /* OK, we weren't BM in the last generation, and it's
294 * less than 100ms since last bus reset. Reschedule
295 * this task 100ms from now. */
296 spin_unlock_irqrestore(&card->lock, flags);
297 schedule_delayed_work(&card->work, DIV_ROUND_UP(HZ, 10));
298 return;
299 }
300
301 /* We're bus manager for this generation, so next step is to
302 * make sure we have an active cycle master and do gap count
303 * optimization. */
304 card->bm_generation = generation;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500305
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500306 if (root == NULL) {
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500307 /* Either link_on is false, or we failed to read the
308 * config rom. In either case, pick another root. */
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500309 new_root_id = card->local_node->node_id;
Stefan Richter641f8792007-01-27 10:34:55 +0100310 } else if (atomic_read(&root->state) != FW_DEVICE_RUNNING) {
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500311 /* If we haven't probed this device yet, bail out now
312 * and let's try again once that's done. */
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500313 spin_unlock_irqrestore(&card->lock, flags);
314 return;
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500315 } else if (root->config_rom[2] & bib_cmc) {
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500316 /* FIXME: I suppose we should set the cmstr bit in the
317 * STATE_CLEAR register of this node, as described in
318 * 1394-1995, 8.4.2.6. Also, send out a force root
319 * packet for this node. */
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500320 new_root_id = root_id;
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500321 } else {
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500322 /* Current root has an active link layer and we
323 * successfully read the config rom, but it's not
324 * cycle master capable. */
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500325 new_root_id = card->local_node->node_id;
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500326 }
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500327
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500328 pick_me:
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500329 /* Now figure out what gap count to set. */
330 if (card->topology_type == FW_TOPOLOGY_A &&
331 card->root_node->max_hops < ARRAY_SIZE(gap_count_table))
332 gap_count = gap_count_table[card->root_node->max_hops];
333 else
334 gap_count = 63;
335
336 /* Finally, figure out if we should do a reset or not. If we've
337 * done less that 5 resets with the same physical topology and we
338 * have either a new root or a new gap count setting, let's do it. */
339
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500340 if (card->bm_retries++ < 5 &&
341 (card->gap_count != gap_count || new_root_id != root_id))
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500342 do_reset = 1;
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500343
344 spin_unlock_irqrestore(&card->lock, flags);
345
Kristian Høgsberg83db8012007-01-26 00:37:50 -0500346 if (do_reset) {
347 fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500348 card->index, new_root_id, gap_count);
349 fw_send_phy_config(card, new_root_id, generation, gap_count);
Kristian Høgsberg19a15b92006-12-19 19:58:31 -0500350 fw_core_initiate_bus_reset(card, 1);
351 }
352}
353
354static void
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500355flush_timer_callback(unsigned long data)
356{
357 struct fw_card *card = (struct fw_card *)data;
358
359 fw_flush_transactions(card);
360}
361
362void
Stefan Richter21ebcd12007-01-14 15:29:07 +0100363fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500364 struct device *device)
365{
Kristian Høgsbergbbf19db2007-02-06 14:49:38 -0500366 static atomic_t index = ATOMIC_INIT(-1);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500367
Kristian Høgsberg49e11792007-03-07 12:12:37 -0500368 kref_init(&card->kref);
Kristian Høgsbergbbf19db2007-02-06 14:49:38 -0500369 card->index = atomic_inc_return(&index);
Stefan Richter5e20c282007-01-21 20:44:09 +0100370 card->driver = driver;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500371 card->device = device;
Stefan Richter5e20c282007-01-21 20:44:09 +0100372 card->current_tlabel = 0;
373 card->tlabel_mask = 0;
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500374 card->color = 0;
375
Stefan Richter5e20c282007-01-21 20:44:09 +0100376 INIT_LIST_HEAD(&card->transaction_list);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500377 spin_lock_init(&card->lock);
378 setup_timer(&card->flush_timer,
379 flush_timer_callback, (unsigned long)card);
380
381 card->local_node = NULL;
382
Kristian Høgsberg931c4832007-01-26 00:38:45 -0500383 INIT_DELAYED_WORK(&card->work, fw_card_bm_work);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500384}
385EXPORT_SYMBOL(fw_card_initialize);
386
387int
388fw_card_add(struct fw_card *card,
389 u32 max_receive, u32 link_speed, u64 guid)
390{
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500391 u32 *config_rom;
392 size_t length;
393
394 card->max_receive = max_receive;
395 card->link_speed = link_speed;
396 card->guid = guid;
397
398 /* FIXME: add #define's for phy registers. */
399 /* Activate link_on bit and contender bit in our self ID packets.*/
400 if (card->driver->update_phy_reg(card, 4, 0, 0x80 | 0x40) < 0)
401 return -EIO;
402
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500403 /* The subsystem grabs a reference when the card is added and
404 * drops it when the driver calls fw_core_remove_card. */
405 fw_card_get(card);
406
407 down_write(&fw_bus_type.subsys.rwsem);
408 config_rom = generate_config_rom (card, &length);
409 list_add_tail(&card->link, &card_list);
410 up_write(&fw_bus_type.subsys.rwsem);
411
412 return card->driver->enable(card, config_rom, length);
413}
414EXPORT_SYMBOL(fw_card_add);
415
416
417/* The next few functions implements a dummy driver that use once a
418 * card driver shuts down an fw_card. This allows the driver to
419 * cleanly unload, as all IO to the card will be handled by the dummy
420 * driver instead of calling into the (possibly) unloaded module. The
421 * dummy driver just fails all IO. */
422
423static int
424dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
425{
426 BUG();
427 return -1;
428}
429
430static int
431dummy_update_phy_reg(struct fw_card *card, int address,
432 int clear_bits, int set_bits)
433{
434 return -ENODEV;
435}
436
437static int
438dummy_set_config_rom(struct fw_card *card,
439 u32 *config_rom, size_t length)
440{
441 /* We take the card out of card_list before setting the dummy
442 * driver, so this should never get called. */
443 BUG();
444 return -1;
445}
446
447static void
448dummy_send_request(struct fw_card *card, struct fw_packet *packet)
449{
Stefan Richter5e20c282007-01-21 20:44:09 +0100450 packet->callback(packet, card, -ENODEV);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500451}
452
453static void
454dummy_send_response(struct fw_card *card, struct fw_packet *packet)
455{
Stefan Richter5e20c282007-01-21 20:44:09 +0100456 packet->callback(packet, card, -ENODEV);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500457}
458
459static int
Kristian Høgsberg730c32f2007-02-06 14:49:32 -0500460dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
461{
462 return -ENOENT;
463}
464
465static int
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500466dummy_enable_phys_dma(struct fw_card *card,
467 int node_id, int generation)
468{
469 return -ENODEV;
470}
471
472static struct fw_card_driver dummy_driver = {
Stefan Richter5e20c282007-01-21 20:44:09 +0100473 .name = "dummy",
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500474 .enable = dummy_enable,
475 .update_phy_reg = dummy_update_phy_reg,
476 .set_config_rom = dummy_set_config_rom,
Stefan Richter5e20c282007-01-21 20:44:09 +0100477 .send_request = dummy_send_request,
Kristian Høgsberg730c32f2007-02-06 14:49:32 -0500478 .cancel_packet = dummy_cancel_packet,
Stefan Richter5e20c282007-01-21 20:44:09 +0100479 .send_response = dummy_send_response,
Stefan Richter5af4e5e2007-01-21 20:45:32 +0100480 .enable_phys_dma = dummy_enable_phys_dma,
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500481};
482
483void
484fw_core_remove_card(struct fw_card *card)
485{
486 card->driver->update_phy_reg(card, 4, 0x80 | 0x40, 0);
487 fw_core_initiate_bus_reset(card, 1);
488
489 down_write(&fw_bus_type.subsys.rwsem);
490 list_del(&card->link);
491 up_write(&fw_bus_type.subsys.rwsem);
492
493 /* Set up the dummy driver. */
494 card->driver = &dummy_driver;
495
496 fw_flush_transactions(card);
497
498 fw_destroy_nodes(card);
499
Kristian Høgsberg49e11792007-03-07 12:12:37 -0500500 fw_card_put(card);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500501}
502EXPORT_SYMBOL(fw_core_remove_card);
503
504struct fw_card *
505fw_card_get(struct fw_card *card)
506{
Kristian Høgsberg49e11792007-03-07 12:12:37 -0500507 kref_get(&card->kref);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500508
509 return card;
510}
511EXPORT_SYMBOL(fw_card_get);
512
Kristian Høgsberg49e11792007-03-07 12:12:37 -0500513static void
514release_card(struct kref *kref)
515{
516 struct fw_card *card = container_of(kref, struct fw_card, kref);
517
518 kfree(card);
519}
520
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500521/* An assumption for fw_card_put() is that the card driver allocates
522 * the fw_card struct with kalloc and that it has been shut down
523 * before the last ref is dropped. */
524void
525fw_card_put(struct fw_card *card)
526{
Kristian Høgsberg49e11792007-03-07 12:12:37 -0500527 kref_put(&card->kref, release_card);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500528}
529EXPORT_SYMBOL(fw_card_put);
530
531int
532fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
533{
Stefan Richter5e20c282007-01-21 20:44:09 +0100534 return card->driver->update_phy_reg(card, short_reset ? 5 : 1, 0, 0x40);
Kristian Høgsberg3038e352006-12-19 19:58:27 -0500535}
536EXPORT_SYMBOL(fw_core_initiate_bus_reset);