]>
Commit | Line | Data |
---|---|---|
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 | ||
459f7923 SR |
19 | #include <linux/completion.h> |
20 | #include <linux/crc-itu-t.h> | |
855c603d | 21 | #include <linux/delay.h> |
3038e353 | 22 | #include <linux/device.h> |
459f7923 SR |
23 | #include <linux/errno.h> |
24 | #include <linux/kref.h> | |
25 | #include <linux/module.h> | |
6a5033be | 26 | #include <linux/mutex.h> |
459f7923 | 27 | |
3038e353 KH |
28 | #include "fw-transaction.h" |
29 | #include "fw-topology.h" | |
19a15b93 | 30 | #include "fw-device.h" |
3038e353 | 31 | |
e175569c | 32 | int fw_compute_block_crc(u32 *block) |
3038e353 | 33 | { |
e175569c KH |
34 | __be32 be32_block[256]; |
35 | int i, length; | |
36 | ||
37 | length = (*block >> 16) & 0xff; | |
38 | for (i = 0; i < length; i++) | |
39 | be32_block[i] = cpu_to_be32(block[i + 1]); | |
40 | *block |= crc_itu_t(0, (u8 *) be32_block, length * 4); | |
3038e353 | 41 | |
e175569c | 42 | return length; |
3038e353 KH |
43 | } |
44 | ||
6a5033be | 45 | static DEFINE_MUTEX(card_mutex); |
3038e353 KH |
46 | static LIST_HEAD(card_list); |
47 | ||
48 | static LIST_HEAD(descriptor_list); | |
49 | static int descriptor_count; | |
50 | ||
a77754a7 KH |
51 | #define BIB_CRC(v) ((v) << 0) |
52 | #define BIB_CRC_LENGTH(v) ((v) << 16) | |
53 | #define BIB_INFO_LENGTH(v) ((v) << 24) | |
54 | ||
55 | #define BIB_LINK_SPEED(v) ((v) << 0) | |
56 | #define BIB_GENERATION(v) ((v) << 4) | |
57 | #define BIB_MAX_ROM(v) ((v) << 8) | |
58 | #define BIB_MAX_RECEIVE(v) ((v) << 12) | |
59 | #define BIB_CYC_CLK_ACC(v) ((v) << 16) | |
60 | #define BIB_PMC ((1) << 27) | |
61 | #define BIB_BMC ((1) << 28) | |
62 | #define BIB_ISC ((1) << 29) | |
63 | #define BIB_CMC ((1) << 30) | |
64 | #define BIB_IMC ((1) << 31) | |
3038e353 | 65 | |
53dca511 | 66 | static u32 *generate_config_rom(struct fw_card *card, size_t *config_rom_length) |
3038e353 KH |
67 | { |
68 | struct fw_descriptor *desc; | |
69 | static u32 config_rom[256]; | |
70 | int i, j, length; | |
71 | ||
c781c06d KH |
72 | /* |
73 | * Initialize contents of config rom buffer. On the OHCI | |
5e20c282 SR |
74 | * controller, block reads to the config rom accesses the host |
75 | * memory, but quadlet read access the hardware bus info block | |
76 | * registers. That's just crack, but it means we should make | |
2cc489c2 | 77 | * sure the contents of bus info block in host memory matches |
c781c06d KH |
78 | * the version stored in the OHCI registers. |
79 | */ | |
3038e353 | 80 | |
2d826cc5 | 81 | memset(config_rom, 0, sizeof(config_rom)); |
a77754a7 | 82 | config_rom[0] = BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0); |
3038e353 KH |
83 | config_rom[1] = 0x31333934; |
84 | ||
85 | config_rom[2] = | |
a77754a7 KH |
86 | BIB_LINK_SPEED(card->link_speed) | |
87 | BIB_GENERATION(card->config_rom_generation++ % 14 + 2) | | |
88 | BIB_MAX_ROM(2) | | |
89 | BIB_MAX_RECEIVE(card->max_receive) | | |
90 | BIB_BMC | BIB_ISC | BIB_CMC | BIB_IMC; | |
3038e353 KH |
91 | config_rom[3] = card->guid >> 32; |
92 | config_rom[4] = card->guid; | |
93 | ||
94 | /* Generate root directory. */ | |
95 | i = 5; | |
96 | config_rom[i++] = 0; | |
97 | config_rom[i++] = 0x0c0083c0; /* node capabilities */ | |
3038e353 KH |
98 | j = i + descriptor_count; |
99 | ||
100 | /* Generate root directory entries for descriptors. */ | |
101 | list_for_each_entry (desc, &descriptor_list, link) { | |
937f6879 KH |
102 | if (desc->immediate > 0) |
103 | config_rom[i++] = desc->immediate; | |
3038e353 KH |
104 | config_rom[i] = desc->key | (j - i); |
105 | i++; | |
106 | j += desc->length; | |
107 | } | |
108 | ||
109 | /* Update root directory length. */ | |
110 | config_rom[5] = (i - 5 - 1) << 16; | |
111 | ||
112 | /* End of root directory, now copy in descriptors. */ | |
113 | list_for_each_entry (desc, &descriptor_list, link) { | |
114 | memcpy(&config_rom[i], desc->data, desc->length * 4); | |
115 | i += desc->length; | |
116 | } | |
117 | ||
118 | /* Calculate CRCs for all blocks in the config rom. This | |
119 | * assumes that CRC length and info length are identical for | |
120 | * the bus info block, which is always the case for this | |
121 | * implementation. */ | |
e175569c KH |
122 | for (i = 0; i < j; i += length + 1) |
123 | length = fw_compute_block_crc(config_rom + i); | |
3038e353 KH |
124 | |
125 | *config_rom_length = j; | |
126 | ||
127 | return config_rom; | |
128 | } | |
129 | ||
53dca511 | 130 | static void update_config_roms(void) |
3038e353 KH |
131 | { |
132 | struct fw_card *card; | |
133 | u32 *config_rom; | |
134 | size_t length; | |
135 | ||
136 | list_for_each_entry (card, &card_list, link) { | |
137 | config_rom = generate_config_rom(card, &length); | |
138 | card->driver->set_config_rom(card, config_rom, length); | |
139 | } | |
140 | } | |
141 | ||
53dca511 | 142 | int fw_core_add_descriptor(struct fw_descriptor *desc) |
3038e353 KH |
143 | { |
144 | size_t i; | |
145 | ||
c781c06d KH |
146 | /* |
147 | * Check descriptor is valid; the length of all blocks in the | |
3038e353 | 148 | * descriptor has to add up to exactly the length of the |
c781c06d KH |
149 | * block. |
150 | */ | |
3038e353 KH |
151 | i = 0; |
152 | while (i < desc->length) | |
153 | i += (desc->data[i] >> 16) + 1; | |
154 | ||
155 | if (i != desc->length) | |
66dea3e5 | 156 | return -EINVAL; |
3038e353 | 157 | |
6a5033be | 158 | mutex_lock(&card_mutex); |
3038e353 | 159 | |
a98e2719 | 160 | list_add_tail(&desc->link, &descriptor_list); |
3038e353 | 161 | descriptor_count++; |
937f6879 KH |
162 | if (desc->immediate > 0) |
163 | descriptor_count++; | |
3038e353 KH |
164 | update_config_roms(); |
165 | ||
6a5033be | 166 | mutex_unlock(&card_mutex); |
3038e353 KH |
167 | |
168 | return 0; | |
169 | } | |
3038e353 | 170 | |
53dca511 | 171 | void fw_core_remove_descriptor(struct fw_descriptor *desc) |
3038e353 | 172 | { |
6a5033be | 173 | mutex_lock(&card_mutex); |
3038e353 KH |
174 | |
175 | list_del(&desc->link); | |
176 | descriptor_count--; | |
937f6879 KH |
177 | if (desc->immediate > 0) |
178 | descriptor_count--; | |
3038e353 KH |
179 | update_config_roms(); |
180 | ||
6a5033be | 181 | mutex_unlock(&card_mutex); |
3038e353 | 182 | } |
3038e353 | 183 | |
6104ee92 JF |
184 | /* ------------------------------------------------------------------ */ |
185 | /* Code to handle 1394a broadcast channel */ | |
186 | ||
187 | #define THIRTY_TWO_CHANNELS (0xFFFFFFFFU) | |
188 | #define IRM_RETRIES 2 | |
189 | ||
190 | /* | |
191 | * The abi is set by device_for_each_child(), even though we have no use | |
192 | * for data, nor do we have a meaningful return value. | |
193 | */ | |
194 | int fw_irm_set_broadcast_channel_register(struct device *dev, void *data) | |
195 | { | |
196 | struct fw_device *d; | |
197 | int rcode; | |
198 | int node_id; | |
199 | int max_speed; | |
200 | int retries; | |
201 | int generation; | |
202 | __be32 regval; | |
203 | struct fw_card *card; | |
204 | ||
205 | d = fw_device(dev); | |
206 | /* FIXME: do we need locking here? */ | |
207 | generation = d->generation; | |
208 | smp_rmb(); /* Ensure generation is at least as old as node_id */ | |
209 | node_id = d->node_id; | |
210 | max_speed = d->max_speed; | |
211 | retries = IRM_RETRIES; | |
212 | card = d->card; | |
213 | tryagain_r: | |
214 | rcode = fw_run_transaction(card, TCODE_READ_QUADLET_REQUEST, | |
215 | node_id, generation, max_speed, | |
216 | CSR_REGISTER_BASE + CSR_BROADCAST_CHANNEL, | |
217 | ®val, 4); | |
218 | switch (rcode) { | |
219 | case RCODE_BUSY: | |
220 | if (retries--) | |
221 | goto tryagain_r; | |
222 | fw_notify("node %x read broadcast channel busy\n", | |
223 | node_id); | |
224 | return 0; | |
225 | ||
226 | default: | |
227 | fw_notify("node %x read broadcast channel failed %x\n", | |
228 | node_id, rcode); | |
229 | return 0; | |
230 | ||
231 | case RCODE_COMPLETE: | |
232 | /* | |
233 | * Paranoid reporting of nonstandard broadcast channel | |
234 | * contents goes here | |
235 | */ | |
236 | if (regval != cpu_to_be32(BROADCAST_CHANNEL_INITIAL)) | |
237 | return 0; | |
238 | break; | |
239 | } | |
240 | retries = IRM_RETRIES; | |
241 | regval = cpu_to_be32(BROADCAST_CHANNEL_INITIAL | | |
242 | BROADCAST_CHANNEL_VALID); | |
243 | tryagain_w: | |
244 | rcode = fw_run_transaction(card, | |
245 | TCODE_WRITE_QUADLET_REQUEST, node_id, | |
246 | generation, max_speed, | |
247 | CSR_REGISTER_BASE + CSR_BROADCAST_CHANNEL, | |
248 | ®val, 4); | |
249 | switch (rcode) { | |
250 | case RCODE_BUSY: | |
251 | if (retries--) | |
252 | goto tryagain_w; | |
253 | fw_notify("node %x write broadcast channel busy\n", | |
254 | node_id); | |
255 | return 0; | |
256 | ||
257 | default: | |
258 | fw_notify("node %x write broadcast channel failed %x\n", | |
259 | node_id, rcode); | |
260 | return 0; | |
261 | ||
262 | case RCODE_COMPLETE: | |
263 | return 0; | |
264 | } | |
265 | return 0; | |
266 | } | |
267 | ||
268 | static void | |
269 | irm_allocate_broadcast(struct fw_device *irm_dev, struct device *locald) | |
270 | { | |
271 | u32 generation; | |
272 | u32 node_id; | |
273 | u32 max_speed; | |
274 | u32 retries; | |
275 | __be32 old_data; | |
276 | __be32 lock_data[2]; | |
277 | int rcode; | |
278 | ||
279 | /* | |
280 | * The device we are updating is the IRM, so we must do | |
281 | * some extra work. | |
282 | */ | |
283 | retries = IRM_RETRIES; | |
284 | generation = irm_dev->generation; | |
285 | /* FIXME: do we need locking here? */ | |
286 | smp_rmb(); | |
287 | node_id = irm_dev->node_id; | |
288 | max_speed = irm_dev->max_speed; | |
289 | ||
290 | lock_data[0] = cpu_to_be32(THIRTY_TWO_CHANNELS); | |
291 | lock_data[1] = cpu_to_be32(THIRTY_TWO_CHANNELS & ~1); | |
292 | tryagain: | |
293 | old_data = lock_data[0]; | |
294 | rcode = fw_run_transaction(irm_dev->card, TCODE_LOCK_COMPARE_SWAP, | |
295 | node_id, generation, max_speed, | |
296 | CSR_REGISTER_BASE+CSR_CHANNELS_AVAILABLE_HI, | |
297 | &lock_data[0], 8); | |
298 | switch (rcode) { | |
299 | case RCODE_BUSY: | |
300 | if (retries--) | |
301 | goto tryagain; | |
302 | /* fallthrough */ | |
303 | default: | |
304 | fw_error("node %x: allocate broadcast channel failed (%x)\n", | |
305 | node_id, rcode); | |
306 | return; | |
307 | ||
308 | case RCODE_COMPLETE: | |
309 | if (lock_data[0] == old_data) | |
310 | break; | |
311 | if (retries--) { | |
312 | lock_data[1] = cpu_to_be32(be32_to_cpu(lock_data[0])&~1); | |
313 | goto tryagain; | |
314 | } | |
315 | fw_error("node %x: allocate broadcast channel failed: too many" | |
316 | " retries\n", node_id); | |
317 | return; | |
318 | } | |
319 | irm_dev->card->is_irm = true; | |
320 | device_for_each_child(locald, NULL, fw_irm_set_broadcast_channel_register); | |
321 | } | |
322 | /* ------------------------------------------------------------------ */ | |
323 | ||
324 | ||
83db801c KH |
325 | static const char gap_count_table[] = { |
326 | 63, 5, 7, 8, 10, 13, 16, 18, 21, 24, 26, 29, 32, 35, 37, 40 | |
327 | }; | |
328 | ||
53dca511 | 329 | void fw_schedule_bm_work(struct fw_card *card, unsigned long delay) |
0fa1986f JF |
330 | { |
331 | int scheduled; | |
332 | ||
333 | fw_card_get(card); | |
334 | scheduled = schedule_delayed_work(&card->work, delay); | |
335 | if (!scheduled) | |
336 | fw_card_put(card); | |
337 | } | |
338 | ||
53dca511 | 339 | static void fw_card_bm_work(struct work_struct *work) |
19a15b93 | 340 | { |
83db801c | 341 | struct fw_card *card = container_of(work, struct fw_card, work.work); |
6104ee92 JF |
342 | struct fw_device *root_device, *irm_device, *local_device; |
343 | struct fw_node *root_node, *local_node, *irm_node; | |
19a15b93 | 344 | unsigned long flags; |
1e119fa9 | 345 | int root_id, new_root_id, irm_id, gap_count, generation, grace, rcode; |
25b1c3d8 | 346 | bool do_reset = false; |
62305823 SR |
347 | bool root_device_is_running; |
348 | bool root_device_is_cmc; | |
1e119fa9 | 349 | __be32 lock_data[2]; |
19a15b93 KH |
350 | |
351 | spin_lock_irqsave(&card->lock, flags); | |
6104ee92 | 352 | card->is_irm = false; |
15803478 SR |
353 | local_node = card->local_node; |
354 | root_node = card->root_node; | |
6104ee92 | 355 | irm_node = card->irm_node; |
15803478 SR |
356 | |
357 | if (local_node == NULL) { | |
358 | spin_unlock_irqrestore(&card->lock, flags); | |
0fa1986f | 359 | goto out_put_card; |
15803478 SR |
360 | } |
361 | fw_node_get(local_node); | |
362 | fw_node_get(root_node); | |
6104ee92 | 363 | fw_node_get(irm_node); |
19a15b93 KH |
364 | |
365 | generation = card->generation; | |
15803478 | 366 | root_device = root_node->data; |
62305823 SR |
367 | root_device_is_running = root_device && |
368 | atomic_read(&root_device->state) == FW_DEVICE_RUNNING; | |
369 | root_device_is_cmc = root_device && root_device->cmc; | |
15803478 | 370 | root_id = root_node->node_id; |
6104ee92 JF |
371 | irm_device = irm_node->data; |
372 | local_device = local_node->data; | |
e1dc7cab SR |
373 | |
374 | grace = time_after(jiffies, card->reset_jiffies + DIV_ROUND_UP(HZ, 8)); | |
375 | ||
8cd0bbbd | 376 | if (is_next_generation(generation, card->bm_generation) || |
931c4834 | 377 | (card->bm_generation != generation && grace)) { |
c781c06d KH |
378 | /* |
379 | * This first step is to figure out who is IRM and | |
931c4834 KH |
380 | * then try to become bus manager. If the IRM is not |
381 | * well defined (e.g. does not have an active link | |
382 | * layer or does not responds to our lock request, we | |
383 | * will have to do a little vigilante bus management. | |
384 | * In that case, we do a goto into the gap count logic | |
385 | * so that when we do the reset, we still optimize the | |
386 | * gap count. That could well save a reset in the | |
c781c06d KH |
387 | * next generation. |
388 | */ | |
931c4834 | 389 | |
6104ee92 JF |
390 | irm_id = irm_node->node_id; |
391 | if (!irm_node->link_on) { | |
15803478 | 392 | new_root_id = local_node->node_id; |
931c4834 KH |
393 | fw_notify("IRM has link off, making local node (%02x) root.\n", |
394 | new_root_id); | |
395 | goto pick_me; | |
396 | } | |
397 | ||
1e119fa9 JF |
398 | lock_data[0] = cpu_to_be32(0x3f); |
399 | lock_data[1] = cpu_to_be32(local_node->node_id); | |
931c4834 KH |
400 | |
401 | spin_unlock_irqrestore(&card->lock, flags); | |
402 | ||
1e119fa9 JF |
403 | rcode = fw_run_transaction(card, TCODE_LOCK_COMPARE_SWAP, |
404 | irm_id, generation, SCODE_100, | |
405 | CSR_REGISTER_BASE + CSR_BUS_MANAGER_ID, | |
406 | lock_data, sizeof(lock_data)); | |
931c4834 | 407 | |
1e119fa9 JF |
408 | if (rcode == RCODE_GENERATION) |
409 | /* Another bus reset, BM work has been rescheduled. */ | |
15803478 | 410 | goto out; |
931c4834 | 411 | |
1e119fa9 | 412 | if (rcode == RCODE_COMPLETE && |
6104ee92 | 413 | lock_data[0] != cpu_to_be32(0x3f)) { |
931c4834 | 414 | /* Somebody else is BM, let them do the work. */ |
6104ee92 JF |
415 | if (irm_id == local_node->node_id) { |
416 | /* But we are IRM, so do irm-y things */ | |
417 | irm_allocate_broadcast(irm_device, | |
418 | card->device); | |
419 | } | |
15803478 | 420 | goto out; |
6104ee92 | 421 | } |
931c4834 KH |
422 | |
423 | spin_lock_irqsave(&card->lock, flags); | |
1e119fa9 JF |
424 | |
425 | if (rcode != RCODE_COMPLETE) { | |
c781c06d KH |
426 | /* |
427 | * The lock request failed, maybe the IRM | |
931c4834 KH |
428 | * isn't really IRM capable after all. Let's |
429 | * do a bus reset and pick the local node as | |
c781c06d KH |
430 | * root, and thus, IRM. |
431 | */ | |
15803478 | 432 | new_root_id = local_node->node_id; |
931c4834 KH |
433 | fw_notify("BM lock failed, making local node (%02x) root.\n", |
434 | new_root_id); | |
435 | goto pick_me; | |
436 | } | |
437 | } else if (card->bm_generation != generation) { | |
c781c06d | 438 | /* |
e1dc7cab SR |
439 | * We weren't BM in the last generation, and the last |
440 | * bus reset is less than 125ms ago. Reschedule this job. | |
c781c06d | 441 | */ |
931c4834 | 442 | spin_unlock_irqrestore(&card->lock, flags); |
e1dc7cab | 443 | fw_schedule_bm_work(card, DIV_ROUND_UP(HZ, 8)); |
15803478 | 444 | goto out; |
931c4834 KH |
445 | } |
446 | ||
c781c06d KH |
447 | /* |
448 | * We're bus manager for this generation, so next step is to | |
931c4834 | 449 | * make sure we have an active cycle master and do gap count |
c781c06d KH |
450 | * optimization. |
451 | */ | |
931c4834 | 452 | card->bm_generation = generation; |
19a15b93 | 453 | |
15803478 | 454 | if (root_device == NULL) { |
c781c06d KH |
455 | /* |
456 | * Either link_on is false, or we failed to read the | |
457 | * config rom. In either case, pick another root. | |
458 | */ | |
15803478 | 459 | new_root_id = local_node->node_id; |
62305823 | 460 | } else if (!root_device_is_running) { |
c781c06d KH |
461 | /* |
462 | * If we haven't probed this device yet, bail out now | |
463 | * and let's try again once that's done. | |
464 | */ | |
931c4834 | 465 | spin_unlock_irqrestore(&card->lock, flags); |
15803478 | 466 | goto out; |
62305823 | 467 | } else if (root_device_is_cmc) { |
c781c06d KH |
468 | /* |
469 | * FIXME: I suppose we should set the cmstr bit in the | |
19a15b93 KH |
470 | * STATE_CLEAR register of this node, as described in |
471 | * 1394-1995, 8.4.2.6. Also, send out a force root | |
c781c06d KH |
472 | * packet for this node. |
473 | */ | |
931c4834 | 474 | new_root_id = root_id; |
83db801c | 475 | } else { |
c781c06d KH |
476 | /* |
477 | * Current root has an active link layer and we | |
19a15b93 | 478 | * successfully read the config rom, but it's not |
c781c06d KH |
479 | * cycle master capable. |
480 | */ | |
15803478 | 481 | new_root_id = local_node->node_id; |
83db801c KH |
482 | } |
483 | ||
931c4834 | 484 | pick_me: |
24d40125 SR |
485 | /* |
486 | * Pick a gap count from 1394a table E-1. The table doesn't cover | |
487 | * the typically much larger 1394b beta repeater delays though. | |
488 | */ | |
489 | if (!card->beta_repeaters_present && | |
15803478 SR |
490 | root_node->max_hops < ARRAY_SIZE(gap_count_table)) |
491 | gap_count = gap_count_table[root_node->max_hops]; | |
83db801c KH |
492 | else |
493 | gap_count = 63; | |
494 | ||
c781c06d | 495 | /* |
25b1c3d8 SR |
496 | * Finally, figure out if we should do a reset or not. If we have |
497 | * done less than 5 resets with the same physical topology and we | |
c781c06d KH |
498 | * have either a new root or a new gap count setting, let's do it. |
499 | */ | |
19a15b93 | 500 | |
931c4834 KH |
501 | if (card->bm_retries++ < 5 && |
502 | (card->gap_count != gap_count || new_root_id != root_id)) | |
25b1c3d8 | 503 | do_reset = true; |
19a15b93 KH |
504 | |
505 | spin_unlock_irqrestore(&card->lock, flags); | |
506 | ||
83db801c KH |
507 | if (do_reset) { |
508 | fw_notify("phy config: card %d, new root=%x, gap_count=%d\n", | |
931c4834 KH |
509 | card->index, new_root_id, gap_count); |
510 | fw_send_phy_config(card, new_root_id, generation, gap_count); | |
19a15b93 | 511 | fw_core_initiate_bus_reset(card, 1); |
6104ee92 JF |
512 | } else if (irm_node->node_id == local_node->node_id) { |
513 | /* | |
514 | * We are IRM, so do irm-y things. | |
515 | * There's no reason to do this if we're doing a reset. . . | |
516 | * We'll be back. | |
517 | */ | |
518 | irm_allocate_broadcast(irm_device, card->device); | |
19a15b93 | 519 | } |
6104ee92 | 520 | |
15803478 | 521 | out: |
15803478 SR |
522 | fw_node_put(root_node); |
523 | fw_node_put(local_node); | |
6104ee92 | 524 | fw_node_put(irm_node); |
0fa1986f JF |
525 | out_put_card: |
526 | fw_card_put(card); | |
19a15b93 KH |
527 | } |
528 | ||
53dca511 | 529 | static void flush_timer_callback(unsigned long data) |
3038e353 KH |
530 | { |
531 | struct fw_card *card = (struct fw_card *)data; | |
532 | ||
533 | fw_flush_transactions(card); | |
534 | } | |
535 | ||
53dca511 SR |
536 | void fw_card_initialize(struct fw_card *card, |
537 | const struct fw_card_driver *driver, | |
538 | struct device *device) | |
3038e353 | 539 | { |
bbf19db3 | 540 | static atomic_t index = ATOMIC_INIT(-1); |
3038e353 | 541 | |
bbf19db3 | 542 | card->index = atomic_inc_return(&index); |
5e20c282 | 543 | card->driver = driver; |
3038e353 | 544 | card->device = device; |
5e20c282 SR |
545 | card->current_tlabel = 0; |
546 | card->tlabel_mask = 0; | |
3038e353 | 547 | card->color = 0; |
e534fe16 | 548 | card->broadcast_channel = BROADCAST_CHANNEL_INITIAL; |
3038e353 | 549 | |
459f7923 SR |
550 | kref_init(&card->kref); |
551 | init_completion(&card->done); | |
5e20c282 | 552 | INIT_LIST_HEAD(&card->transaction_list); |
3038e353 KH |
553 | spin_lock_init(&card->lock); |
554 | setup_timer(&card->flush_timer, | |
555 | flush_timer_callback, (unsigned long)card); | |
556 | ||
557 | card->local_node = NULL; | |
558 | ||
931c4834 | 559 | INIT_DELAYED_WORK(&card->work, fw_card_bm_work); |
3038e353 KH |
560 | } |
561 | EXPORT_SYMBOL(fw_card_initialize); | |
562 | ||
53dca511 SR |
563 | int fw_card_add(struct fw_card *card, |
564 | u32 max_receive, u32 link_speed, u64 guid) | |
3038e353 | 565 | { |
3038e353 KH |
566 | u32 *config_rom; |
567 | size_t length; | |
e1eff7a3 | 568 | int ret; |
3038e353 KH |
569 | |
570 | card->max_receive = max_receive; | |
571 | card->link_speed = link_speed; | |
572 | card->guid = guid; | |
573 | ||
6a5033be | 574 | mutex_lock(&card_mutex); |
a98e2719 | 575 | config_rom = generate_config_rom(card, &length); |
3038e353 | 576 | list_add_tail(&card->link, &card_list); |
6a5033be | 577 | mutex_unlock(&card_mutex); |
3038e353 | 578 | |
e1eff7a3 SR |
579 | ret = card->driver->enable(card, config_rom, length); |
580 | if (ret < 0) { | |
b7479feb PV |
581 | mutex_lock(&card_mutex); |
582 | list_del(&card->link); | |
583 | mutex_unlock(&card_mutex); | |
584 | } | |
e1eff7a3 SR |
585 | |
586 | return ret; | |
3038e353 KH |
587 | } |
588 | EXPORT_SYMBOL(fw_card_add); | |
589 | ||
590 | ||
c781c06d KH |
591 | /* |
592 | * The next few functions implements a dummy driver that use once a | |
3038e353 KH |
593 | * card driver shuts down an fw_card. This allows the driver to |
594 | * cleanly unload, as all IO to the card will be handled by the dummy | |
595 | * driver instead of calling into the (possibly) unloaded module. The | |
c781c06d KH |
596 | * dummy driver just fails all IO. |
597 | */ | |
3038e353 | 598 | |
53dca511 | 599 | static int dummy_enable(struct fw_card *card, u32 *config_rom, size_t length) |
3038e353 KH |
600 | { |
601 | BUG(); | |
602 | return -1; | |
603 | } | |
604 | ||
53dca511 SR |
605 | static int dummy_update_phy_reg(struct fw_card *card, int address, |
606 | int clear_bits, int set_bits) | |
3038e353 KH |
607 | { |
608 | return -ENODEV; | |
609 | } | |
610 | ||
53dca511 SR |
611 | static int dummy_set_config_rom(struct fw_card *card, |
612 | u32 *config_rom, size_t length) | |
3038e353 | 613 | { |
c781c06d KH |
614 | /* |
615 | * We take the card out of card_list before setting the dummy | |
616 | * driver, so this should never get called. | |
617 | */ | |
3038e353 KH |
618 | BUG(); |
619 | return -1; | |
620 | } | |
621 | ||
53dca511 | 622 | static void dummy_send_request(struct fw_card *card, struct fw_packet *packet) |
3038e353 | 623 | { |
5e20c282 | 624 | packet->callback(packet, card, -ENODEV); |
3038e353 KH |
625 | } |
626 | ||
53dca511 | 627 | static void dummy_send_response(struct fw_card *card, struct fw_packet *packet) |
3038e353 | 628 | { |
5e20c282 | 629 | packet->callback(packet, card, -ENODEV); |
3038e353 KH |
630 | } |
631 | ||
53dca511 | 632 | static int dummy_cancel_packet(struct fw_card *card, struct fw_packet *packet) |
730c32f5 KH |
633 | { |
634 | return -ENOENT; | |
635 | } | |
636 | ||
53dca511 SR |
637 | static int dummy_enable_phys_dma(struct fw_card *card, |
638 | int node_id, int generation) | |
3038e353 KH |
639 | { |
640 | return -ENODEV; | |
641 | } | |
642 | ||
643 | static struct fw_card_driver dummy_driver = { | |
3038e353 KH |
644 | .enable = dummy_enable, |
645 | .update_phy_reg = dummy_update_phy_reg, | |
646 | .set_config_rom = dummy_set_config_rom, | |
5e20c282 | 647 | .send_request = dummy_send_request, |
730c32f5 | 648 | .cancel_packet = dummy_cancel_packet, |
5e20c282 | 649 | .send_response = dummy_send_response, |
5af4e5ea | 650 | .enable_phys_dma = dummy_enable_phys_dma, |
3038e353 KH |
651 | }; |
652 | ||
53dca511 | 653 | void fw_card_release(struct kref *kref) |
459f7923 SR |
654 | { |
655 | struct fw_card *card = container_of(kref, struct fw_card, kref); | |
656 | ||
657 | complete(&card->done); | |
658 | } | |
659 | ||
53dca511 | 660 | void fw_core_remove_card(struct fw_card *card) |
3038e353 | 661 | { |
ecab4133 MB |
662 | card->driver->update_phy_reg(card, 4, |
663 | PHY_LINK_ACTIVE | PHY_CONTENDER, 0); | |
3038e353 KH |
664 | fw_core_initiate_bus_reset(card, 1); |
665 | ||
6a5033be | 666 | mutex_lock(&card_mutex); |
e747a5c0 | 667 | list_del_init(&card->link); |
6a5033be | 668 | mutex_unlock(&card_mutex); |
3038e353 KH |
669 | |
670 | /* Set up the dummy driver. */ | |
671 | card->driver = &dummy_driver; | |
672 | ||
3038e353 | 673 | fw_destroy_nodes(card); |
459f7923 SR |
674 | |
675 | /* Wait for all users, especially device workqueue jobs, to finish. */ | |
676 | fw_card_put(card); | |
677 | wait_for_completion(&card->done); | |
8a2d9ed3 | 678 | |
1e8afea1 | 679 | WARN_ON(!list_empty(&card->transaction_list)); |
8a2d9ed3 | 680 | del_timer_sync(&card->flush_timer); |
3038e353 KH |
681 | } |
682 | EXPORT_SYMBOL(fw_core_remove_card); | |
683 | ||
53dca511 | 684 | int fw_core_initiate_bus_reset(struct fw_card *card, int short_reset) |
3038e353 | 685 | { |
ecab4133 | 686 | int reg = short_reset ? 5 : 1; |
ecab4133 MB |
687 | int bit = short_reset ? PHY_BUS_SHORT_RESET : PHY_BUS_RESET; |
688 | ||
689 | return card->driver->update_phy_reg(card, reg, 0, bit); | |
3038e353 KH |
690 | } |
691 | EXPORT_SYMBOL(fw_core_initiate_bus_reset); |