]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/firewire/fw-card.c
firewire: remove unused macro
[mirror_ubuntu-zesty-kernel.git] / drivers / firewire / fw-card.c
CommitLineData
c781c06d
KH
1/*
2 * Copyright (C) 2005-2007 Kristian Hoegsberg <krh@bitplanet.net>
3038e353
KH
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>
6a5033be 22#include <linux/mutex.h>
e175569c 23#include <linux/crc-itu-t.h>
3038e353
KH
24#include "fw-transaction.h"
25#include "fw-topology.h"
19a15b93 26#include "fw-device.h"
3038e353 27
e175569c 28int fw_compute_block_crc(u32 *block)
3038e353 29{
e175569c
KH
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);
3038e353 37
e175569c 38 return length;
3038e353
KH
39}
40
6a5033be 41static DEFINE_MUTEX(card_mutex);
3038e353
KH
42static LIST_HEAD(card_list);
43
44static LIST_HEAD(descriptor_list);
45static int descriptor_count;
46
a77754a7
KH
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)
3038e353
KH
61
62static u32 *
a98e2719 63generate_config_rom(struct fw_card *card, size_t *config_rom_length)
3038e353
KH
64{
65 struct fw_descriptor *desc;
66 static u32 config_rom[256];
67 int i, j, length;
68
c781c06d
KH
69 /*
70 * Initialize contents of config rom buffer. On the OHCI
5e20c282
SR
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
c781c06d
KH
75 * the version stored in the OHCI registers.
76 */
3038e353 77
2d826cc5 78 memset(config_rom, 0, sizeof(config_rom));
a77754a7 79 config_rom[0] = BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0);
3038e353
KH
80 config_rom[1] = 0x31333934;
81
82 config_rom[2] =
a77754a7
KH
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;
3038e353
KH
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 */
3038e353
KH
95 j = i + descriptor_count;
96
97 /* Generate root directory entries for descriptors. */
98 list_for_each_entry (desc, &descriptor_list, link) {
937f6879
KH
99 if (desc->immediate > 0)
100 config_rom[i++] = desc->immediate;
3038e353
KH
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. */
e175569c
KH
119 for (i = 0; i < j; i += length + 1)
120 length = fw_compute_block_crc(config_rom + i);
3038e353
KH
121
122 *config_rom_length = j;
123
124 return config_rom;
125}
126
127static void
a98e2719 128update_config_roms(void)
3038e353
KH
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
a98e2719 141fw_core_add_descriptor(struct fw_descriptor *desc)
3038e353
KH
142{
143 size_t i;
144
c781c06d
KH
145 /*
146 * Check descriptor is valid; the length of all blocks in the
3038e353 147 * descriptor has to add up to exactly the length of the
c781c06d
KH
148 * block.
149 */
3038e353
KH
150 i = 0;
151 while (i < desc->length)
152 i += (desc->data[i] >> 16) + 1;
153
154 if (i != desc->length)
66dea3e5 155 return -EINVAL;
3038e353 156
6a5033be 157 mutex_lock(&card_mutex);
3038e353 158
a98e2719 159 list_add_tail(&desc->link, &descriptor_list);
3038e353 160 descriptor_count++;
937f6879
KH
161 if (desc->immediate > 0)
162 descriptor_count++;
3038e353
KH
163 update_config_roms();
164
6a5033be 165 mutex_unlock(&card_mutex);
3038e353
KH
166
167 return 0;
168}
169EXPORT_SYMBOL(fw_core_add_descriptor);
170
171void
a98e2719 172fw_core_remove_descriptor(struct fw_descriptor *desc)
3038e353 173{
6a5033be 174 mutex_lock(&card_mutex);
3038e353
KH
175
176 list_del(&desc->link);
177 descriptor_count--;
937f6879
KH
178 if (desc->immediate > 0)
179 descriptor_count--;
3038e353
KH
180 update_config_roms();
181
6a5033be 182 mutex_unlock(&card_mutex);
3038e353
KH
183}
184EXPORT_SYMBOL(fw_core_remove_descriptor);
185
83db801c
KH
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
931c4834
KH
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
19a15b93 201static void
931c4834
KH
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)
19a15b93 215{
83db801c 216 struct fw_card *card = container_of(work, struct fw_card, work.work);
19a15b93 217 struct fw_device *root;
931c4834 218 struct bm_data bmd;
19a15b93 219 unsigned long flags;
931c4834
KH
220 int root_id, new_root_id, irm_id, gap_count, generation, grace;
221 int do_reset = 0;
19a15b93
KH
222
223 spin_lock_irqsave(&card->lock, flags);
224
225 generation = card->generation;
226 root = card->root_node->data;
83db801c 227 root_id = card->root_node->node_id;
931c4834
KH
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)) {
c781c06d
KH
232 /*
233 * This first step is to figure out who is IRM and
931c4834
KH
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
c781c06d
KH
241 * next generation.
242 */
931c4834
KH
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,
2d826cc5 261 &bmd.lock, sizeof(bmd.lock),
931c4834
KH
262 complete_bm_lock, &bmd);
263 wait_for_completion(&bmd.done);
264
265 if (bmd.rcode == RCODE_GENERATION) {
c781c06d
KH
266 /*
267 * Another bus reset happened. Just return,
268 * the BM work has been rescheduled.
269 */
931c4834
KH
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) {
c781c06d
KH
279 /*
280 * The lock request failed, maybe the IRM
931c4834
KH
281 * isn't really IRM capable after all. Let's
282 * do a bus reset and pick the local node as
c781c06d
KH
283 * root, and thus, IRM.
284 */
931c4834
KH
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) {
c781c06d
KH
291 /*
292 * OK, we weren't BM in the last generation, and it's
931c4834 293 * less than 100ms since last bus reset. Reschedule
c781c06d
KH
294 * this task 100ms from now.
295 */
931c4834
KH
296 spin_unlock_irqrestore(&card->lock, flags);
297 schedule_delayed_work(&card->work, DIV_ROUND_UP(HZ, 10));
298 return;
299 }
300
c781c06d
KH
301 /*
302 * We're bus manager for this generation, so next step is to
931c4834 303 * make sure we have an active cycle master and do gap count
c781c06d
KH
304 * optimization.
305 */
931c4834 306 card->bm_generation = generation;
19a15b93 307
83db801c 308 if (root == NULL) {
c781c06d
KH
309 /*
310 * Either link_on is false, or we failed to read the
311 * config rom. In either case, pick another root.
312 */
931c4834 313 new_root_id = card->local_node->node_id;
641f8791 314 } else if (atomic_read(&root->state) != FW_DEVICE_RUNNING) {
c781c06d
KH
315 /*
316 * If we haven't probed this device yet, bail out now
317 * and let's try again once that's done.
318 */
931c4834
KH
319 spin_unlock_irqrestore(&card->lock, flags);
320 return;
a77754a7 321 } else if (root->config_rom[2] & BIB_CMC) {
c781c06d
KH
322 /*
323 * FIXME: I suppose we should set the cmstr bit in the
19a15b93
KH
324 * STATE_CLEAR register of this node, as described in
325 * 1394-1995, 8.4.2.6. Also, send out a force root
c781c06d
KH
326 * packet for this node.
327 */
931c4834 328 new_root_id = root_id;
83db801c 329 } else {
c781c06d
KH
330 /*
331 * Current root has an active link layer and we
19a15b93 332 * successfully read the config rom, but it's not
c781c06d
KH
333 * cycle master capable.
334 */
931c4834 335 new_root_id = card->local_node->node_id;
83db801c
KH
336 }
337
931c4834 338 pick_me:
83db801c
KH
339 /* Now figure out what gap count to set. */
340 if (card->topology_type == FW_TOPOLOGY_A &&
341 card->root_node->max_hops < ARRAY_SIZE(gap_count_table))
342 gap_count = gap_count_table[card->root_node->max_hops];
343 else
344 gap_count = 63;
345
c781c06d
KH
346 /*
347 * Finally, figure out if we should do a reset or not. If we've
83db801c 348 * done less that 5 resets with the same physical topology and we
c781c06d
KH
349 * have either a new root or a new gap count setting, let's do it.
350 */
19a15b93 351
931c4834
KH
352 if (card->bm_retries++ < 5 &&
353 (card->gap_count != gap_count || new_root_id != root_id))
83db801c 354 do_reset = 1;
19a15b93
KH
355
356 spin_unlock_irqrestore(&card->lock, flags);
357
83db801c
KH
358 if (do_reset) {
359 fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
931c4834
KH
360 card->index, new_root_id, gap_count);
361 fw_send_phy_config(card, new_root_id, generation, gap_count);
19a15b93
KH
362 fw_core_initiate_bus_reset(card, 1);
363 }
364}
365
3038e353
KH
366static void
367flush_timer_callback(unsigned long data)
368{
369 struct fw_card *card = (struct fw_card *)data;
370
371 fw_flush_transactions(card);
372}
373
374void
21ebcd12 375fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
3038e353
KH
376 struct device *device)
377{
bbf19db3 378 static atomic_t index = ATOMIC_INIT(-1);
3038e353 379
49e1179b 380 kref_init(&card->kref);
bbf19db3 381 card->index = atomic_inc_return(&index);
5e20c282 382 card->driver = driver;
3038e353 383 card->device = device;
5e20c282
SR
384 card->current_tlabel = 0;
385 card->tlabel_mask = 0;
3038e353
KH
386 card->color = 0;
387
5e20c282 388 INIT_LIST_HEAD(&card->transaction_list);
3038e353
KH
389 spin_lock_init(&card->lock);
390 setup_timer(&card->flush_timer,
391 flush_timer_callback, (unsigned long)card);
392
393 card->local_node = NULL;
394
931c4834 395 INIT_DELAYED_WORK(&card->work, fw_card_bm_work);
3038e353
KH
396}
397EXPORT_SYMBOL(fw_card_initialize);
398
399int
400fw_card_add(struct fw_card *card,
401 u32 max_receive, u32 link_speed, u64 guid)
402{
3038e353
KH
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
c781c06d
KH
410 /*
411 * The subsystem grabs a reference when the card is added and
412 * drops it when the driver calls fw_core_remove_card.
413 */
3038e353
KH
414 fw_card_get(card);
415
6a5033be 416 mutex_lock(&card_mutex);
a98e2719 417 config_rom = generate_config_rom(card, &length);
3038e353 418 list_add_tail(&card->link, &card_list);
6a5033be 419 mutex_unlock(&card_mutex);
3038e353
KH
420
421 return card->driver->enable(card, config_rom, length);
422}
423EXPORT_SYMBOL(fw_card_add);
424
425
c781c06d
KH
426/*
427 * The next few functions implements a dummy driver that use once a
3038e353
KH
428 * card driver shuts down an fw_card. This allows the driver to
429 * cleanly unload, as all IO to the card will be handled by the dummy
430 * driver instead of calling into the (possibly) unloaded module. The
c781c06d
KH
431 * dummy driver just fails all IO.
432 */
3038e353
KH
433
434static int
435dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
436{
437 BUG();
438 return -1;
439}
440
441static int
442dummy_update_phy_reg(struct fw_card *card, int address,
443 int clear_bits, int set_bits)
444{
445 return -ENODEV;
446}
447
448static int
449dummy_set_config_rom(struct fw_card *card,
450 u32 *config_rom, size_t length)
451{
c781c06d
KH
452 /*
453 * We take the card out of card_list before setting the dummy
454 * driver, so this should never get called.
455 */
3038e353
KH
456 BUG();
457 return -1;
458}
459
460static void
461dummy_send_request(struct fw_card *card, struct fw_packet *packet)
462{
5e20c282 463 packet->callback(packet, card, -ENODEV);
3038e353
KH
464}
465
466static void
467dummy_send_response(struct fw_card *card, struct fw_packet *packet)
468{
5e20c282 469 packet->callback(packet, card, -ENODEV);
3038e353
KH
470}
471
730c32f5
KH
472static int
473dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
474{
475 return -ENOENT;
476}
477
3038e353
KH
478static int
479dummy_enable_phys_dma(struct fw_card *card,
480 int node_id, int generation)
481{
482 return -ENODEV;
483}
484
485static struct fw_card_driver dummy_driver = {
5e20c282 486 .name = "dummy",
3038e353
KH
487 .enable = dummy_enable,
488 .update_phy_reg = dummy_update_phy_reg,
489 .set_config_rom = dummy_set_config_rom,
5e20c282 490 .send_request = dummy_send_request,
730c32f5 491 .cancel_packet = dummy_cancel_packet,
5e20c282 492 .send_response = dummy_send_response,
5af4e5ea 493 .enable_phys_dma = dummy_enable_phys_dma,
3038e353
KH
494};
495
496void
497fw_core_remove_card(struct fw_card *card)
498{
ecab4133
MB
499 card->driver->update_phy_reg(card, 4,
500 PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
3038e353
KH
501 fw_core_initiate_bus_reset(card, 1);
502
6a5033be 503 mutex_lock(&card_mutex);
3038e353 504 list_del(&card->link);
6a5033be 505 mutex_unlock(&card_mutex);
3038e353
KH
506
507 /* Set up the dummy driver. */
508 card->driver = &dummy_driver;
509
510 fw_flush_transactions(card);
511
512 fw_destroy_nodes(card);
513
49e1179b 514 fw_card_put(card);
3038e353
KH
515}
516EXPORT_SYMBOL(fw_core_remove_card);
517
518struct fw_card *
519fw_card_get(struct fw_card *card)
520{
49e1179b 521 kref_get(&card->kref);
3038e353
KH
522
523 return card;
524}
525EXPORT_SYMBOL(fw_card_get);
526
49e1179b
KH
527static void
528release_card(struct kref *kref)
529{
530 struct fw_card *card = container_of(kref, struct fw_card, kref);
531
532 kfree(card);
533}
534
c781c06d
KH
535/*
536 * An assumption for fw_card_put() is that the card driver allocates
3038e353 537 * the fw_card struct with kalloc and that it has been shut down
c781c06d
KH
538 * before the last ref is dropped.
539 */
3038e353
KH
540void
541fw_card_put(struct fw_card *card)
542{
49e1179b 543 kref_put(&card->kref, release_card);
3038e353
KH
544}
545EXPORT_SYMBOL(fw_card_put);
546
547int
548fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
549{
ecab4133 550 int reg = short_reset ? 5 : 1;
ecab4133
MB
551 int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
552
553 return card->driver->update_phy_reg(card, reg, 0, bit);
3038e353
KH
554}
555EXPORT_SYMBOL(fw_core_initiate_bus_reset);