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