← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/firewire/core-card.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/firewire/core-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/bug.h>
 
20
#include <linux/completion.h>
 
21
#include <linux/crc-itu-t.h>
 
22
#include <linux/device.h>
 
23
#include <linux/errno.h>
 
24
#include <linux/firewire.h>
 
25
#include <linux/firewire-constants.h>
 
26
#include <linux/jiffies.h>
 
27
#include <linux/kernel.h>
 
28
#include <linux/kref.h>
 
29
#include <linux/list.h>
 
30
#include <linux/module.h>
 
31
#include <linux/mutex.h>
 
32
#include <linux/spinlock.h>
 
33
#include <linux/workqueue.h>
 
34
 
 
35
#include <linux/atomic.h>
 
36
#include <asm/byteorder.h>
 
37
 
 
38
#include "core.h"
 
39
 
 
40
int fw_compute_block_crc(__be32 *block)
 
41
{
 
42
        int length;
 
43
        u16 crc;
 
44
 
 
45
        length = (be32_to_cpu(block[0]) >> 16) & 0xff;
 
46
        crc = crc_itu_t(0, (u8 *)&block[1], length * 4);
 
47
        *block |= cpu_to_be32(crc);
 
48
 
 
49
        return length;
 
50
}
 
51
 
 
52
static DEFINE_MUTEX(card_mutex);
 
53
static LIST_HEAD(card_list);
 
54
 
 
55
static LIST_HEAD(descriptor_list);
 
56
static int descriptor_count;
 
57
 
 
58
static __be32 tmp_config_rom[256];
 
59
/* ROM header, bus info block, root dir header, capabilities = 7 quadlets */
 
60
static size_t config_rom_length = 1 + 4 + 1 + 1;
 
61
 
 
62
#define BIB_CRC(v)              ((v) <<  0)
 
63
#define BIB_CRC_LENGTH(v)       ((v) << 16)
 
64
#define BIB_INFO_LENGTH(v)      ((v) << 24)
 
65
#define BIB_BUS_NAME            0x31333934 /* "1394" */
 
66
#define BIB_LINK_SPEED(v)       ((v) <<  0)
 
67
#define BIB_GENERATION(v)       ((v) <<  4)
 
68
#define BIB_MAX_ROM(v)          ((v) <<  8)
 
69
#define BIB_MAX_RECEIVE(v)      ((v) << 12)
 
70
#define BIB_CYC_CLK_ACC(v)      ((v) << 16)
 
71
#define BIB_PMC                 ((1) << 27)
 
72
#define BIB_BMC                 ((1) << 28)
 
73
#define BIB_ISC                 ((1) << 29)
 
74
#define BIB_CMC                 ((1) << 30)
 
75
#define BIB_IRMC                ((1) << 31)
 
76
#define NODE_CAPABILITIES       0x0c0083c0 /* per IEEE 1394 clause 8.3.2.6.5.2 */
 
77
 
 
78
/*
 
79
 * IEEE-1394 specifies a default SPLIT_TIMEOUT value of 800 cycles (100 ms),
 
80
 * but we have to make it longer because there are many devices whose firmware
 
81
 * is just too slow for that.
 
82
 */
 
83
#define DEFAULT_SPLIT_TIMEOUT   (2 * 8000)
 
84
 
 
85
#define CANON_OUI               0x000085
 
86
 
 
87
static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
 
88
{
 
89
        struct fw_descriptor *desc;
 
90
        int i, j, k, length;
 
91
 
 
92
        /*
 
93
         * Initialize contents of config rom buffer.  On the OHCI
 
94
         * controller, block reads to the config rom accesses the host
 
95
         * memory, but quadlet read access the hardware bus info block
 
96
         * registers.  That's just crack, but it means we should make
 
97
         * sure the contents of bus info block in host memory matches
 
98
         * the version stored in the OHCI registers.
 
99
         */
 
100
 
 
101
        config_rom[0] = cpu_to_be32(
 
102
                BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0));
 
103
        config_rom[1] = cpu_to_be32(BIB_BUS_NAME);
 
104
        config_rom[2] = cpu_to_be32(
 
105
                BIB_LINK_SPEED(card->link_speed) |
 
106
                BIB_GENERATION(card->config_rom_generation++ % 14 + 2) |
 
107
                BIB_MAX_ROM(2) |
 
108
                BIB_MAX_RECEIVE(card->max_receive) |
 
109
                BIB_BMC | BIB_ISC | BIB_CMC | BIB_IRMC);
 
110
        config_rom[3] = cpu_to_be32(card->guid >> 32);
 
111
        config_rom[4] = cpu_to_be32(card->guid);
 
112
 
 
113
        /* Generate root directory. */
 
114
        config_rom[6] = cpu_to_be32(NODE_CAPABILITIES);
 
115
        i = 7;
 
116
        j = 7 + descriptor_count;
 
117
 
 
118
        /* Generate root directory entries for descriptors. */
 
119
        list_for_each_entry (desc, &descriptor_list, link) {
 
120
                if (desc->immediate > 0)
 
121
                        config_rom[i++] = cpu_to_be32(desc->immediate);
 
122
                config_rom[i] = cpu_to_be32(desc->key | (j - i));
 
123
                i++;
 
124
                j += desc->length;
 
125
        }
 
126
 
 
127
        /* Update root directory length. */
 
128
        config_rom[5] = cpu_to_be32((i - 5 - 1) << 16);
 
129
 
 
130
        /* End of root directory, now copy in descriptors. */
 
131
        list_for_each_entry (desc, &descriptor_list, link) {
 
132
                for (k = 0; k < desc->length; k++)
 
133
                        config_rom[i + k] = cpu_to_be32(desc->data[k]);
 
134
                i += desc->length;
 
135
        }
 
136
 
 
137
        /* Calculate CRCs for all blocks in the config rom.  This
 
138
         * assumes that CRC length and info length are identical for
 
139
         * the bus info block, which is always the case for this
 
140
         * implementation. */
 
141
        for (i = 0; i < j; i += length + 1)
 
142
                length = fw_compute_block_crc(config_rom + i);
 
143
 
 
144
        WARN_ON(j != config_rom_length);
 
145
}
 
146
 
 
147
static void update_config_roms(void)
 
148
{
 
149
        struct fw_card *card;
 
150
 
 
151
        list_for_each_entry (card, &card_list, link) {
 
152
                generate_config_rom(card, tmp_config_rom);
 
153
                card->driver->set_config_rom(card, tmp_config_rom,
 
154
                                             config_rom_length);
 
155
        }
 
156
}
 
157
 
 
158
static size_t required_space(struct fw_descriptor *desc)
 
159
{
 
160
        /* descriptor + entry into root dir + optional immediate entry */
 
161
        return desc->length + 1 + (desc->immediate > 0 ? 1 : 0);
 
162
}
 
163
 
 
164
int fw_core_add_descriptor(struct fw_descriptor *desc)
 
165
{
 
166
        size_t i;
 
167
        int ret;
 
168
 
 
169
        /*
 
170
         * Check descriptor is valid; the length of all blocks in the
 
171
         * descriptor has to add up to exactly the length of the
 
172
         * block.
 
173
         */
 
174
        i = 0;
 
175
        while (i < desc->length)
 
176
                i += (desc->data[i] >> 16) + 1;
 
177
 
 
178
        if (i != desc->length)
 
179
                return -EINVAL;
 
180
 
 
181
        mutex_lock(&card_mutex);
 
182
 
 
183
        if (config_rom_length + required_space(desc) > 256) {
 
184
                ret = -EBUSY;
 
185
        } else {
 
186
                list_add_tail(&desc->link, &descriptor_list);
 
187
                config_rom_length += required_space(desc);
 
188
                descriptor_count++;
 
189
                if (desc->immediate > 0)
 
190
                        descriptor_count++;
 
191
                update_config_roms();
 
192
                ret = 0;
 
193
        }
 
194
 
 
195
        mutex_unlock(&card_mutex);
 
196
 
 
197
        return ret;
 
198
}
 
199
EXPORT_SYMBOL(fw_core_add_descriptor);
 
200
 
 
201
void fw_core_remove_descriptor(struct fw_descriptor *desc)
 
202
{
 
203
        mutex_lock(&card_mutex);
 
204
 
 
205
        list_del(&desc->link);
 
206
        config_rom_length -= required_space(desc);
 
207
        descriptor_count--;
 
208
        if (desc->immediate > 0)
 
209
                descriptor_count--;
 
210
        update_config_roms();
 
211
 
 
212
        mutex_unlock(&card_mutex);
 
213
}
 
214
EXPORT_SYMBOL(fw_core_remove_descriptor);
 
215
 
 
216
static int reset_bus(struct fw_card *card, bool short_reset)
 
217
{
 
218
        int reg = short_reset ? 5 : 1;
 
219
        int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET;
 
220
 
 
221
        return card->driver->update_phy_reg(card, reg, 0, bit);
 
222
}
 
223
 
 
224
void fw_schedule_bus_reset(struct fw_card *card, bool delayed, bool short_reset)
 
225
{
 
226
        /* We don't try hard to sort out requests of long vs. short resets. */
 
227
        card->br_short = short_reset;
 
228
 
 
229
        /* Use an arbitrary short delay to combine multiple reset requests. */
 
230
        fw_card_get(card);
 
231
        if (!queue_delayed_work(fw_workqueue, &card->br_work,
 
232
                                delayed ? DIV_ROUND_UP(HZ, 100) : 0))
 
233
                fw_card_put(card);
 
234
}
 
235
EXPORT_SYMBOL(fw_schedule_bus_reset);
 
236
 
 
237
static void br_work(struct work_struct *work)
 
238
{
 
239
        struct fw_card *card = container_of(work, struct fw_card, br_work.work);
 
240
 
 
241
        /* Delay for 2s after last reset per IEEE 1394 clause 8.2.1. */
 
242
        if (card->reset_jiffies != 0 &&
 
243
            time_before64(get_jiffies_64(), card->reset_jiffies + 2 * HZ)) {
 
244
                if (!queue_delayed_work(fw_workqueue, &card->br_work, 2 * HZ))
 
245
                        fw_card_put(card);
 
246
                return;
 
247
        }
 
248
 
 
249
        fw_send_phy_config(card, FW_PHY_CONFIG_NO_NODE_ID, card->generation,
 
250
                           FW_PHY_CONFIG_CURRENT_GAP_COUNT);
 
251
        reset_bus(card, card->br_short);
 
252
        fw_card_put(card);
 
253
}
 
254
 
 
255
static void allocate_broadcast_channel(struct fw_card *card, int generation)
 
256
{
 
257
        int channel, bandwidth = 0;
 
258
 
 
259
        if (!card->broadcast_channel_allocated) {
 
260
                fw_iso_resource_manage(card, generation, 1ULL << 31,
 
261
                                       &channel, &bandwidth, true);
 
262
                if (channel != 31) {
 
263
                        fw_notify("failed to allocate broadcast channel\n");
 
264
                        return;
 
265
                }
 
266
                card->broadcast_channel_allocated = true;
 
267
        }
 
268
 
 
269
        device_for_each_child(card->device, (void *)(long)generation,
 
270
                              fw_device_set_broadcast_channel);
 
271
}
 
272
 
 
273
static const char gap_count_table[] = {
 
274
        63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40
 
275
};
 
276
 
 
277
void fw_schedule_bm_work(struct fw_card *card, unsigned long delay)
 
278
{
 
279
        fw_card_get(card);
 
280
        if (!schedule_delayed_work(&card->bm_work, delay))
 
281
                fw_card_put(card);
 
282
}
 
283
 
 
284
static void bm_work(struct work_struct *work)
 
285
{
 
286
        struct fw_card *card = container_of(work, struct fw_card, bm_work.work);
 
287
        struct fw_device *root_device, *irm_device;
 
288
        struct fw_node *root_node;
 
289
        int root_id, new_root_id, irm_id, bm_id, local_id;
 
290
        int gap_count, generation, grace, rcode;
 
291
        bool do_reset = false;
 
292
        bool root_device_is_running;
 
293
        bool root_device_is_cmc;
 
294
        bool irm_is_1394_1995_only;
 
295
        bool keep_this_irm;
 
296
        __be32 transaction_data[2];
 
297
 
 
298
        spin_lock_irq(&card->lock);
 
299
 
 
300
        if (card->local_node == NULL) {
 
301
                spin_unlock_irq(&card->lock);
 
302
                goto out_put_card;
 
303
        }
 
304
 
 
305
        generation = card->generation;
 
306
 
 
307
        root_node = card->root_node;
 
308
        fw_node_get(root_node);
 
309
        root_device = root_node->data;
 
310
        root_device_is_running = root_device &&
 
311
                        atomic_read(&root_device->state) == FW_DEVICE_RUNNING;
 
312
        root_device_is_cmc = root_device && root_device->cmc;
 
313
 
 
314
        irm_device = card->irm_node->data;
 
315
        irm_is_1394_1995_only = irm_device && irm_device->config_rom &&
 
316
                        (irm_device->config_rom[2] & 0x000000f0) == 0;
 
317
 
 
318
        /* Canon MV5i works unreliably if it is not root node. */
 
319
        keep_this_irm = irm_device && irm_device->config_rom &&
 
320
                        irm_device->config_rom[3] >> 8 == CANON_OUI;
 
321
 
 
322
        root_id  = root_node->node_id;
 
323
        irm_id   = card->irm_node->node_id;
 
324
        local_id = card->local_node->node_id;
 
325
 
 
326
        grace = time_after64(get_jiffies_64(),
 
327
                             card->reset_jiffies + DIV_ROUND_UP(HZ, 8));
 
328
 
 
329
        if ((is_next_generation(generation, card->bm_generation) &&
 
330
             !card->bm_abdicate) ||
 
331
            (card->bm_generation != generation && grace)) {
 
332
                /*
 
333
                 * This first step is to figure out who is IRM and
 
334
                 * then try to become bus manager.  If the IRM is not
 
335
                 * well defined (e.g. does not have an active link
 
336
                 * layer or does not responds to our lock request, we
 
337
                 * will have to do a little vigilante bus management.
 
338
                 * In that case, we do a goto into the gap count logic
 
339
                 * so that when we do the reset, we still optimize the
 
340
                 * gap count.  That could well save a reset in the
 
341
                 * next generation.
 
342
                 */
 
343
 
 
344
                if (!card->irm_node->link_on) {
 
345
                        new_root_id = local_id;
 
346
                        fw_notify("%s, making local node (%02x) root.\n",
 
347
                                  "IRM has link off", new_root_id);
 
348
                        goto pick_me;
 
349
                }
 
350
 
 
351
                if (irm_is_1394_1995_only && !keep_this_irm) {
 
352
                        new_root_id = local_id;
 
353
                        fw_notify("%s, making local node (%02x) root.\n",
 
354
                                  "IRM is not 1394a compliant", new_root_id);
 
355
                        goto pick_me;
 
356
                }
 
357
 
 
358
                transaction_data[0] = cpu_to_be32(0x3f);
 
359
                transaction_data[1] = cpu_to_be32(local_id);
 
360
 
 
361
                spin_unlock_irq(&card->lock);
 
362
 
 
363
                rcode = fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP,
 
364
                                irm_id, generation, SCODE_100,
 
365
                                CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID,
 
366
                                transaction_data, 8);
 
367
 
 
368
                if (rcode == RCODE_GENERATION)
 
369
                        /* Another bus reset, BM work has been rescheduled. */
 
370
                        goto out;
 
371
 
 
372
                bm_id = be32_to_cpu(transaction_data[0]);
 
373
 
 
374
                spin_lock_irq(&card->lock);
 
375
                if (rcode == RCODE_COMPLETE && generation == card->generation)
 
376
                        card->bm_node_id =
 
377
                            bm_id == 0x3f ? local_id : 0xffc0 | bm_id;
 
378
                spin_unlock_irq(&card->lock);
 
379
 
 
380
                if (rcode == RCODE_COMPLETE && bm_id != 0x3f) {
 
381
                        /* Somebody else is BM.  Only act as IRM. */
 
382
                        if (local_id == irm_id)
 
383
                                allocate_broadcast_channel(card, generation);
 
384
 
 
385
                        goto out;
 
386
                }
 
387
 
 
388
                if (rcode == RCODE_SEND_ERROR) {
 
389
                        /*
 
390
                         * We have been unable to send the lock request due to
 
391
                         * some local problem.  Let's try again later and hope
 
392
                         * that the problem has gone away by then.
 
393
                         */
 
394
                        fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8));
 
395
                        goto out;
 
396
                }
 
397
 
 
398
                spin_lock_irq(&card->lock);
 
399
 
 
400
                if (rcode != RCODE_COMPLETE && !keep_this_irm) {
 
401
                        /*
 
402
                         * The lock request failed, maybe the IRM
 
403
                         * isn't really IRM capable after all. Let's
 
404
                         * do a bus reset and pick the local node as
 
405
                         * root, and thus, IRM.
 
406
                         */
 
407
                        new_root_id = local_id;
 
408
                        fw_notify("%s, making local node (%02x) root.\n",
 
409
                                  "BM lock failed", new_root_id);
 
410
                        goto pick_me;
 
411
                }
 
412
        } else if (card->bm_generation != generation) {
 
413
                /*
 
414
                 * We weren't BM in the last generation, and the last
 
415
                 * bus reset is less than 125ms ago.  Reschedule this job.
 
416
                 */
 
417
                spin_unlock_irq(&card->lock);
 
418
                fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8));
 
419
                goto out;
 
420
        }
 
421
 
 
422
        /*
 
423
         * We're bus manager for this generation, so next step is to
 
424
         * make sure we have an active cycle master and do gap count
 
425
         * optimization.
 
426
         */
 
427
        card->bm_generation = generation;
 
428
 
 
429
        if (root_device == NULL) {
 
430
                /*
 
431
                 * Either link_on is false, or we failed to read the
 
432
                 * config rom.  In either case, pick another root.
 
433
                 */
 
434
                new_root_id = local_id;
 
435
        } else if (!root_device_is_running) {
 
436
                /*
 
437
                 * If we haven't probed this device yet, bail out now
 
438
                 * and let's try again once that's done.
 
439
                 */
 
440
                spin_unlock_irq(&card->lock);
 
441
                goto out;
 
442
        } else if (root_device_is_cmc) {
 
443
                /*
 
444
                 * We will send out a force root packet for this
 
445
                 * node as part of the gap count optimization.
 
446
                 */
 
447
                new_root_id = root_id;
 
448
        } else {
 
449
                /*
 
450
                 * Current root has an active link layer and we
 
451
                 * successfully read the config rom, but it's not
 
452
                 * cycle master capable.
 
453
                 */
 
454
                new_root_id = local_id;
 
455
        }
 
456
 
 
457
 pick_me:
 
458
        /*
 
459
         * Pick a gap count from 1394a table E-1.  The table doesn't cover
 
460
         * the typically much larger 1394b beta repeater delays though.
 
461
         */
 
462
        if (!card->beta_repeaters_present &&
 
463
            root_node->max_hops < ARRAY_SIZE(gap_count_table))
 
464
                gap_count = gap_count_table[root_node->max_hops];
 
465
        else
 
466
                gap_count = 63;
 
467
 
 
468
        /*
 
469
         * Finally, figure out if we should do a reset or not.  If we have
 
470
         * done less than 5 resets with the same physical topology and we
 
471
         * have either a new root or a new gap count setting, let's do it.
 
472
         */
 
473
 
 
474
        if (card->bm_retries++ < 5 &&
 
475
            (card->gap_count != gap_count || new_root_id != root_id))
 
476
                do_reset = true;
 
477
 
 
478
        spin_unlock_irq(&card->lock);
 
479
 
 
480
        if (do_reset) {
 
481
                fw_notify("phy config: card %d, new root=%x, gap_count=%d\n",
 
482
                          card->index, new_root_id, gap_count);
 
483
                fw_send_phy_config(card, new_root_id, generation, gap_count);
 
484
                reset_bus(card, true);
 
485
                /* Will allocate broadcast channel after the reset. */
 
486
                goto out;
 
487
        }
 
488
 
 
489
        if (root_device_is_cmc) {
 
490
                /*
 
491
                 * Make sure that the cycle master sends cycle start packets.
 
492
                 */
 
493
                transaction_data[0] = cpu_to_be32(CSR_STATE_BIT_CMSTR);
 
494
                rcode = fw_run_transaction(card, TCODE_WRITE_QUADLET_REQUEST,
 
495
                                root_id, generation, SCODE_100,
 
496
                                CSR_REGISTER_BASE + CSR_STATE_SET,
 
497
                                transaction_data, 4);
 
498
                if (rcode == RCODE_GENERATION)
 
499
                        goto out;
 
500
        }
 
501
 
 
502
        if (local_id == irm_id)
 
503
                allocate_broadcast_channel(card, generation);
 
504
 
 
505
 out:
 
506
        fw_node_put(root_node);
 
507
 out_put_card:
 
508
        fw_card_put(card);
 
509
}
 
510
 
 
511
void fw_card_initialize(struct fw_card *card,
 
512
                        const struct fw_card_driver *driver,
 
513
                        struct device *device)
 
514
{
 
515
        static atomic_t index = ATOMIC_INIT(-1);
 
516
 
 
517
        card->index = atomic_inc_return(&index);
 
518
        card->driver = driver;
 
519
        card->device = device;
 
520
        card->current_tlabel = 0;
 
521
        card->tlabel_mask = 0;
 
522
        card->split_timeout_hi = DEFAULT_SPLIT_TIMEOUT / 8000;
 
523
        card->split_timeout_lo = (DEFAULT_SPLIT_TIMEOUT % 8000) << 19;
 
524
        card->split_timeout_cycles = DEFAULT_SPLIT_TIMEOUT;
 
525
        card->split_timeout_jiffies =
 
526
                        DIV_ROUND_UP(DEFAULT_SPLIT_TIMEOUT * HZ, 8000);
 
527
        card->color = 0;
 
528
        card->broadcast_channel = BROADCAST_CHANNEL_INITIAL;
 
529
 
 
530
        kref_init(&card->kref);
 
531
        init_completion(&card->done);
 
532
        INIT_LIST_HEAD(&card->transaction_list);
 
533
        INIT_LIST_HEAD(&card->phy_receiver_list);
 
534
        spin_lock_init(&card->lock);
 
535
 
 
536
        card->local_node = NULL;
 
537
 
 
538
        INIT_DELAYED_WORK(&card->br_work, br_work);
 
539
        INIT_DELAYED_WORK(&card->bm_work, bm_work);
 
540
}
 
541
EXPORT_SYMBOL(fw_card_initialize);
 
542
 
 
543
int fw_card_add(struct fw_card *card,
 
544
                u32 max_receive, u32 link_speed, u64 guid)
 
545
{
 
546
        int ret;
 
547
 
 
548
        card->max_receive = max_receive;
 
549
        card->link_speed = link_speed;
 
550
        card->guid = guid;
 
551
 
 
552
        mutex_lock(&card_mutex);
 
553
 
 
554
        generate_config_rom(card, tmp_config_rom);
 
555
        ret = card->driver->enable(card, tmp_config_rom, config_rom_length);
 
556
        if (ret == 0)
 
557
                list_add_tail(&card->link, &card_list);
 
558
 
 
559
        mutex_unlock(&card_mutex);
 
560
 
 
561
        return ret;
 
562
}
 
563
EXPORT_SYMBOL(fw_card_add);
 
564
 
 
565
/*
 
566
 * The next few functions implement a dummy driver that is used once a card
 
567
 * driver shuts down an fw_card.  This allows the driver to cleanly unload,
 
568
 * as all IO to the card will be handled (and failed) by the dummy driver
 
569
 * instead of calling into the module.  Only functions for iso context
 
570
 * shutdown still need to be provided by the card driver.
 
571
 *
 
572
 * .read/write_csr() should never be called anymore after the dummy driver
 
573
 * was bound since they are only used within request handler context.
 
574
 * .set_config_rom() is never called since the card is taken out of card_list
 
575
 * before switching to the dummy driver.
 
576
 */
 
577
 
 
578
static int dummy_read_phy_reg(struct fw_card *card, int address)
 
579
{
 
580
        return -ENODEV;
 
581
}
 
582
 
 
583
static int dummy_update_phy_reg(struct fw_card *card, int address,
 
584
                                int clear_bits, int set_bits)
 
585
{
 
586
        return -ENODEV;
 
587
}
 
588
 
 
589
static void dummy_send_request(struct fw_card *card, struct fw_packet *packet)
 
590
{
 
591
        packet->callback(packet, card, RCODE_CANCELLED);
 
592
}
 
593
 
 
594
static void dummy_send_response(struct fw_card *card, struct fw_packet *packet)
 
595
{
 
596
        packet->callback(packet, card, RCODE_CANCELLED);
 
597
}
 
598
 
 
599
static int dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet)
 
600
{
 
601
        return -ENOENT;
 
602
}
 
603
 
 
604
static int dummy_enable_phys_dma(struct fw_card *card,
 
605
                                 int node_id, int generation)
 
606
{
 
607
        return -ENODEV;
 
608
}
 
609
 
 
610
static struct fw_iso_context *dummy_allocate_iso_context(struct fw_card *card,
 
611
                                int type, int channel, size_t header_size)
 
612
{
 
613
        return ERR_PTR(-ENODEV);
 
614
}
 
615
 
 
616
static int dummy_start_iso(struct fw_iso_context *ctx,
 
617
                           s32 cycle, u32 sync, u32 tags)
 
618
{
 
619
        return -ENODEV;
 
620
}
 
621
 
 
622
static int dummy_set_iso_channels(struct fw_iso_context *ctx, u64 *channels)
 
623
{
 
624
        return -ENODEV;
 
625
}
 
626
 
 
627
static int dummy_queue_iso(struct fw_iso_context *ctx, struct fw_iso_packet *p,
 
628
                           struct fw_iso_buffer *buffer, unsigned long payload)
 
629
{
 
630
        return -ENODEV;
 
631
}
 
632
 
 
633
static void dummy_flush_queue_iso(struct fw_iso_context *ctx)
 
634
{
 
635
}
 
636
 
 
637
static const struct fw_card_driver dummy_driver_template = {
 
638
        .read_phy_reg           = dummy_read_phy_reg,
 
639
        .update_phy_reg         = dummy_update_phy_reg,
 
640
        .send_request           = dummy_send_request,
 
641
        .send_response          = dummy_send_response,
 
642
        .cancel_packet          = dummy_cancel_packet,
 
643
        .enable_phys_dma        = dummy_enable_phys_dma,
 
644
        .allocate_iso_context   = dummy_allocate_iso_context,
 
645
        .start_iso              = dummy_start_iso,
 
646
        .set_iso_channels       = dummy_set_iso_channels,
 
647
        .queue_iso              = dummy_queue_iso,
 
648
        .flush_queue_iso        = dummy_flush_queue_iso,
 
649
};
 
650
 
 
651
void fw_card_release(struct kref *kref)
 
652
{
 
653
        struct fw_card *card = container_of(kref, struct fw_card, kref);
 
654
 
 
655
        complete(&card->done);
 
656
}
 
657
 
 
658
void fw_core_remove_card(struct fw_card *card)
 
659
{
 
660
        struct fw_card_driver dummy_driver = dummy_driver_template;
 
661
 
 
662
        card->driver->update_phy_reg(card, 4,
 
663
                                     PHY_LINK_ACTIVE | PHY_CONTENDER, 0);
 
664
        fw_schedule_bus_reset(card, false, true);
 
665
 
 
666
        mutex_lock(&card_mutex);
 
667
        list_del_init(&card->link);
 
668
        mutex_unlock(&card_mutex);
 
669
 
 
670
        /* Switch off most of the card driver interface. */
 
671
        dummy_driver.free_iso_context   = card->driver->free_iso_context;
 
672
        dummy_driver.stop_iso           = card->driver->stop_iso;
 
673
        card->driver = &dummy_driver;
 
674
 
 
675
        fw_destroy_nodes(card);
 
676
 
 
677
        /* Wait for all users, especially device workqueue jobs, to finish. */
 
678
        fw_card_put(card);
 
679
        wait_for_completion(&card->done);
 
680
 
 
681
        WARN_ON(!list_empty(&card->transaction_list));
 
682
}
 
683
EXPORT_SYMBOL(fw_core_remove_card);