7f5dc43ec131e658bf41e0d7fc033631d261d967
[linux-2.6.git] / 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);