Merge git://git.kernel.org/pub/scm/linux/kernel/git/bart/ide-2.6
[linux-2.6] / drivers / firewire / fw-card.c
1 /*
2  * Copyright (C) 2005-2007  Kristian Hoegsberg <krh@bitplanet.net>
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/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"
28
29 int fw_compute_block_crc(u32 *block)
30 {
31         __be32 be32_block[256];
32         int i, length;
33
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);
38
39         return length;
40 }
41
42 static DEFINE_MUTEX(card_mutex);
43 static LIST_HEAD(card_list);
44
45 static LIST_HEAD(descriptor_list);
46 static int descriptor_count;
47
48 #define BIB_CRC(v)              ((v) <<  0)
49 #define BIB_CRC_LENGTH(v)       ((v) << 16)
50 #define BIB_INFO_LENGTH(v)      ((v) << 24)
51
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)
62
63 static u32 *
64 generate_config_rom(struct fw_card *card, size_t *config_rom_length)
65 {
66         struct fw_descriptor *desc;
67         static u32 config_rom[256];
68         int i, j, length;
69
70         /*
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.
77          */
78
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;
82
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;
91
92         /* Generate root directory. */
93         i = 5;
94         config_rom[i++] = 0;
95         config_rom[i++] = 0x0c0083c0; /* node capabilities */
96         j = i + descriptor_count;
97
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;
105         }
106
107         /* Update root directory length. */
108         config_rom[5] = (i - 5 - 1) << 16;
109
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;
114         }
115
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);
122
123         *config_rom_length = j;
124
125         return config_rom;
126 }
127
128 static void
129 update_config_roms(void)
130 {
131         struct fw_card *card;
132         u32 *config_rom;
133         size_t length;
134
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);
138         }
139 }
140
141 int
142 fw_core_add_descriptor(struct fw_descriptor *desc)
143 {
144         size_t i;
145
146         /*
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.
150          */
151         i = 0;
152         while (i < desc->length)
153                 i += (desc->data[i] >> 16) + 1;
154
155         if (i != desc->length)
156                 return -EINVAL;
157
158         mutex_lock(&card_mutex);
159
160         list_add_tail(&desc->link, &descriptor_list);
161         descriptor_count++;
162         if (desc->immediate > 0)
163                 descriptor_count++;
164         update_config_roms();
165
166         mutex_unlock(&card_mutex);
167
168         return 0;
169 }
170
171 void
172 fw_core_remove_descriptor(struct fw_descriptor *desc)
173 {
174         mutex_lock(&card_mutex);
175
176         list_del(&desc->link);
177         descriptor_count--;
178         if (desc->immediate > 0)
179                 descriptor_count--;
180         update_config_roms();
181
182         mutex_unlock(&card_mutex);
183 }
184
185 static const char gap_count_table[] = {
186         63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
187 };
188
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;
198 };
199
200 static void
201 complete_bm_lock(struct fw_card *card, int rcode,
202                  void *payload, size_t length, void *data)
203 {
204         struct bm_data *bmd = data;
205
206         if (rcode == RCODE_COMPLETE)
207                 bmd->old = be32_to_cpu(*(__be32 *) payload);
208         bmd->rcode = rcode;
209         complete(&bmd->done);
210 }
211
212 static void
213 fw_card_bm_work(struct work_struct *work)
214 {
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;
222
223         spin_lock_irqsave(&card->lock, flags);
224         local_node = card->local_node;
225         root_node  = card->root_node;
226
227         if (local_node == NULL) {
228                 spin_unlock_irqrestore(&card->lock, flags);
229                 return;
230         }
231         fw_node_get(local_node);
232         fw_node_get(root_node);
233
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));
240
241         if (card->bm_generation + 1 == generation ||
242             (card->bm_generation != generation && grace)) {
243                 /*
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.
253                  */
254
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;
261                 }
262
263                 bmd.lock.arg = cpu_to_be32(0x3f);
264                 bmd.lock.data = cpu_to_be32(local_node->node_id);
265
266                 spin_unlock_irqrestore(&card->lock, flags);
267
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);
275
276                 if (bmd.rcode == RCODE_GENERATION) {
277                         /*
278                          * Another bus reset happened. Just return,
279                          * the BM work has been rescheduled.
280                          */
281                         goto out;
282                 }
283
284                 if (bmd.rcode == RCODE_COMPLETE && bmd.old != 0x3f)
285                         /* Somebody else is BM, let them do the work. */
286                         goto out;
287
288                 spin_lock_irqsave(&card->lock, flags);
289                 if (bmd.rcode != RCODE_COMPLETE) {
290                         /*
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.
295                          */
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;
300                 }
301         } else if (card->bm_generation != generation) {
302                 /*
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.
306                  */
307                 spin_unlock_irqrestore(&card->lock, flags);
308                 schedule_delayed_work(&card->work, DIV_ROUND_UP(HZ, 10));
309                 goto out;
310         }
311
312         /*
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.
316          */
317         card->bm_generation = generation;
318
319         if (root_device == NULL) {
320                 /*
321                  * Either link_on is false, or we failed to read the
322                  * config rom.  In either case, pick another root.
323                  */
324                 new_root_id = local_node->node_id;
325         } else if (atomic_read(&root_device->state) != FW_DEVICE_RUNNING) {
326                 /*
327                  * If we haven't probed this device yet, bail out now
328                  * and let's try again once that's done.
329                  */
330                 spin_unlock_irqrestore(&card->lock, flags);
331                 goto out;
332         } else if (root_device->cmc) {
333                 /*
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.
338                  */
339                 new_root_id = root_id;
340         } else {
341                 /*
342                  * Current root has an active link layer and we
343                  * successfully read the config rom, but it's not
344                  * cycle master capable.
345                  */
346                 new_root_id = local_node->node_id;
347         }
348
349  pick_me:
350         /*
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.
353          */
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;
359
360         /*
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.
364          */
365
366         if (card->bm_retries++ < 5 &&
367             (card->gap_count != gap_count || new_root_id != root_id))
368                 do_reset = true;
369
370         spin_unlock_irqrestore(&card->lock, flags);
371
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);
377         }
378  out:
379         if (root_device)
380                 fw_device_put(root_device);
381         fw_node_put(root_node);
382         fw_node_put(local_node);
383 }
384
385 static void
386 flush_timer_callback(unsigned long data)
387 {
388         struct fw_card *card = (struct fw_card *)data;
389
390         fw_flush_transactions(card);
391 }
392
393 void
394 fw_card_initialize(struct fw_card *card, const struct fw_card_driver *driver,
395                    struct device *device)
396 {
397         static atomic_t index = ATOMIC_INIT(-1);
398
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;
406
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);
411
412         card->local_node = NULL;
413
414         INIT_DELAYED_WORK(&card->work, fw_card_bm_work);
415 }
416 EXPORT_SYMBOL(fw_card_initialize);
417
418 int
419 fw_card_add(struct fw_card *card,
420             u32 max_receive, u32 link_speed, u64 guid)
421 {
422         u32 *config_rom;
423         size_t length;
424
425         card->max_receive = max_receive;
426         card->link_speed = link_speed;
427         card->guid = guid;
428
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);
433
434         return card->driver->enable(card, config_rom, length);
435 }
436 EXPORT_SYMBOL(fw_card_add);
437
438
439 /*
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.
445  */
446
447 static int
448 dummy_enable(struct fw_card *card, u32 *config_rom, size_t length)
449 {
450         BUG();
451         return -1;
452 }
453
454 static int
455 dummy_update_phy_reg(struct fw_card *card, int address,
456                      int clear_bits, int set_bits)
457 {
458         return -ENODEV;
459 }
460
461 static int
462 dummy_set_config_rom(struct fw_card *card,
463                      u32 *config_rom, size_t length)
464 {
465         /*
466          * We take the card out of card_list before setting the dummy
467          * driver, so this should never get called.
468          */
469         BUG();
470         return -1;
471 }
472
473 static void
474 dummy_send_request(struct fw_card *card, struct fw_packet *packet)
475 {
476         packet->callback(packet, card, -ENODEV);
477 }
478
479 static void
480 dummy_send_response(struct fw_card *card, struct fw_packet *packet)
481 {
482         packet->callback(packet, card, -ENODEV);
483 }
484
485 static int
486 dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
487 {
488         return -ENOENT;
489 }
490
491 static int
492 dummy_enable_phys_dma(struct fw_card *card,
493                       int node_id, int generation)
494 {
495         return -ENODEV;
496 }
497
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,
507 };
508
509 void
510 fw_core_remove_card(struct fw_card *card)
511 {
512         card->driver->update_phy_reg(card, 4,
513                                      PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
514         fw_core_initiate_bus_reset(card, 1);
515
516         mutex_lock(&card_mutex);
517         list_del(&card->link);
518         mutex_unlock(&card_mutex);
519
520         /* Set up the dummy driver. */
521         card->driver = &dummy_driver;
522
523         fw_destroy_nodes(card);
524         /*
525          * Wait for all device workqueue jobs to finish.  Otherwise the
526          * firewire-core module could be unloaded before the jobs ran.
527          */
528         while (atomic_read(&card->device_count) > 0)
529                 msleep(100);
530
531         cancel_delayed_work_sync(&card->work);
532         fw_flush_transactions(card);
533         del_timer_sync(&card->flush_timer);
534 }
535 EXPORT_SYMBOL(fw_core_remove_card);
536
537 int
538 fw_core_initiate_bus_reset(struct fw_card *card, int short_reset)
539 {
540         int reg = short_reset ? 5 : 1;
541         int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
542
543         return card->driver->update_phy_reg(card, reg, 0, bit);
544 }
545 EXPORT_SYMBOL(fw_core_initiate_bus_reset);