xref: /openbmc/linux/drivers/rapidio/rio-scan.c (revision 800e26b8)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * RapidIO enumeration and discovery support
4  *
5  * Copyright 2005 MontaVista Software, Inc.
6  * Matt Porter <mporter@kernel.crashing.org>
7  *
8  * Copyright 2009 Integrated Device Technology, Inc.
9  * Alex Bounine <alexandre.bounine@idt.com>
10  * - Added Port-Write/Error Management initialization and handling
11  *
12  * Copyright 2009 Sysgo AG
13  * Thomas Moll <thomas.moll@sysgo.com>
14  * - Added Input- Output- enable functionality, to allow full communication
15  */
16 
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 
20 #include <linux/delay.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/init.h>
23 #include <linux/rio.h>
24 #include <linux/rio_drv.h>
25 #include <linux/rio_ids.h>
26 #include <linux/rio_regs.h>
27 #include <linux/module.h>
28 #include <linux/spinlock.h>
29 #include <linux/timer.h>
30 #include <linux/sched.h>
31 #include <linux/jiffies.h>
32 #include <linux/slab.h>
33 
34 #include "rio.h"
35 
36 static void rio_init_em(struct rio_dev *rdev);
37 
38 struct rio_id_table {
39 	u16 start;	/* logical minimal id */
40 	u32 max;	/* max number of IDs in table */
41 	spinlock_t lock;
42 	unsigned long table[];
43 };
44 
45 static int next_destid = 0;
46 static int next_comptag = 1;
47 
48 /**
49  * rio_destid_alloc - Allocate next available destID for given network
50  * @net: RIO network
51  *
52  * Returns next available device destination ID for the specified RIO network.
53  * Marks allocated ID as one in use.
54  * Returns RIO_INVALID_DESTID if new destID is not available.
55  */
56 static u16 rio_destid_alloc(struct rio_net *net)
57 {
58 	int destid;
59 	struct rio_id_table *idtab = (struct rio_id_table *)net->enum_data;
60 
61 	spin_lock(&idtab->lock);
62 	destid = find_first_zero_bit(idtab->table, idtab->max);
63 
64 	if (destid < idtab->max) {
65 		set_bit(destid, idtab->table);
66 		destid += idtab->start;
67 	} else
68 		destid = RIO_INVALID_DESTID;
69 
70 	spin_unlock(&idtab->lock);
71 	return (u16)destid;
72 }
73 
74 /**
75  * rio_destid_reserve - Reserve the specified destID
76  * @net: RIO network
77  * @destid: destID to reserve
78  *
79  * Tries to reserve the specified destID.
80  * Returns 0 if successful.
81  */
82 static int rio_destid_reserve(struct rio_net *net, u16 destid)
83 {
84 	int oldbit;
85 	struct rio_id_table *idtab = (struct rio_id_table *)net->enum_data;
86 
87 	destid -= idtab->start;
88 	spin_lock(&idtab->lock);
89 	oldbit = test_and_set_bit(destid, idtab->table);
90 	spin_unlock(&idtab->lock);
91 	return oldbit;
92 }
93 
94 /**
95  * rio_destid_free - free a previously allocated destID
96  * @net: RIO network
97  * @destid: destID to free
98  *
99  * Makes the specified destID available for use.
100  */
101 static void rio_destid_free(struct rio_net *net, u16 destid)
102 {
103 	struct rio_id_table *idtab = (struct rio_id_table *)net->enum_data;
104 
105 	destid -= idtab->start;
106 	spin_lock(&idtab->lock);
107 	clear_bit(destid, idtab->table);
108 	spin_unlock(&idtab->lock);
109 }
110 
111 /**
112  * rio_destid_first - return first destID in use
113  * @net: RIO network
114  */
115 static u16 rio_destid_first(struct rio_net *net)
116 {
117 	int destid;
118 	struct rio_id_table *idtab = (struct rio_id_table *)net->enum_data;
119 
120 	spin_lock(&idtab->lock);
121 	destid = find_first_bit(idtab->table, idtab->max);
122 	if (destid >= idtab->max)
123 		destid = RIO_INVALID_DESTID;
124 	else
125 		destid += idtab->start;
126 	spin_unlock(&idtab->lock);
127 	return (u16)destid;
128 }
129 
130 /**
131  * rio_destid_next - return next destID in use
132  * @net: RIO network
133  * @from: destination ID from which search shall continue
134  */
135 static u16 rio_destid_next(struct rio_net *net, u16 from)
136 {
137 	int destid;
138 	struct rio_id_table *idtab = (struct rio_id_table *)net->enum_data;
139 
140 	spin_lock(&idtab->lock);
141 	destid = find_next_bit(idtab->table, idtab->max, from);
142 	if (destid >= idtab->max)
143 		destid = RIO_INVALID_DESTID;
144 	else
145 		destid += idtab->start;
146 	spin_unlock(&idtab->lock);
147 	return (u16)destid;
148 }
149 
150 /**
151  * rio_get_device_id - Get the base/extended device id for a device
152  * @port: RIO master port
153  * @destid: Destination ID of device
154  * @hopcount: Hopcount to device
155  *
156  * Reads the base/extended device id from a device. Returns the
157  * 8/16-bit device ID.
158  */
159 static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount)
160 {
161 	u32 result;
162 
163 	rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result);
164 
165 	return RIO_GET_DID(port->sys_size, result);
166 }
167 
168 /**
169  * rio_set_device_id - Set the base/extended device id for a device
170  * @port: RIO master port
171  * @destid: Destination ID of device
172  * @hopcount: Hopcount to device
173  * @did: Device ID value to be written
174  *
175  * Writes the base/extended device id from a device.
176  */
177 static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did)
178 {
179 	rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR,
180 				  RIO_SET_DID(port->sys_size, did));
181 }
182 
183 /**
184  * rio_clear_locks- Release all host locks and signal enumeration complete
185  * @net: RIO network to run on
186  *
187  * Marks the component tag CSR on each device with the enumeration
188  * complete flag. When complete, it then release the host locks on
189  * each device. Returns 0 on success or %-EINVAL on failure.
190  */
191 static int rio_clear_locks(struct rio_net *net)
192 {
193 	struct rio_mport *port = net->hport;
194 	struct rio_dev *rdev;
195 	u32 result;
196 	int ret = 0;
197 
198 	/* Release host device id locks */
199 	rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
200 				  port->host_deviceid);
201 	rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
202 	if ((result & 0xffff) != 0xffff) {
203 		printk(KERN_INFO
204 		       "RIO: badness when releasing host lock on master port, result %8.8x\n",
205 		       result);
206 		ret = -EINVAL;
207 	}
208 	list_for_each_entry(rdev, &net->devices, net_list) {
209 		rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR,
210 				    port->host_deviceid);
211 		rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result);
212 		if ((result & 0xffff) != 0xffff) {
213 			printk(KERN_INFO
214 			       "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n",
215 			       rdev->vid, rdev->did);
216 			ret = -EINVAL;
217 		}
218 
219 		/* Mark device as discovered and enable master */
220 		rio_read_config_32(rdev,
221 				   rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
222 				   &result);
223 		result |= RIO_PORT_GEN_DISCOVERED | RIO_PORT_GEN_MASTER;
224 		rio_write_config_32(rdev,
225 				    rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
226 				    result);
227 	}
228 
229 	return ret;
230 }
231 
232 /**
233  * rio_enum_host- Set host lock and initialize host destination ID
234  * @port: Master port to issue transaction
235  *
236  * Sets the local host master port lock and destination ID register
237  * with the host device ID value. The host device ID value is provided
238  * by the platform. Returns %0 on success or %-1 on failure.
239  */
240 static int rio_enum_host(struct rio_mport *port)
241 {
242 	u32 result;
243 
244 	/* Set master port host device id lock */
245 	rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
246 				  port->host_deviceid);
247 
248 	rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
249 	if ((result & 0xffff) != port->host_deviceid)
250 		return -1;
251 
252 	/* Set master port destid and init destid ctr */
253 	rio_local_set_device_id(port, port->host_deviceid);
254 	return 0;
255 }
256 
257 /**
258  * rio_device_has_destid- Test if a device contains a destination ID register
259  * @port: Master port to issue transaction
260  * @src_ops: RIO device source operations
261  * @dst_ops: RIO device destination operations
262  *
263  * Checks the provided @src_ops and @dst_ops for the necessary transaction
264  * capabilities that indicate whether or not a device will implement a
265  * destination ID register. Returns 1 if true or 0 if false.
266  */
267 static int rio_device_has_destid(struct rio_mport *port, int src_ops,
268 				 int dst_ops)
269 {
270 	u32 mask = RIO_OPS_READ | RIO_OPS_WRITE | RIO_OPS_ATOMIC_TST_SWP | RIO_OPS_ATOMIC_INC | RIO_OPS_ATOMIC_DEC | RIO_OPS_ATOMIC_SET | RIO_OPS_ATOMIC_CLR;
271 
272 	return !!((src_ops | dst_ops) & mask);
273 }
274 
275 /**
276  * rio_release_dev- Frees a RIO device struct
277  * @dev: LDM device associated with a RIO device struct
278  *
279  * Gets the RIO device struct associated a RIO device struct.
280  * The RIO device struct is freed.
281  */
282 static void rio_release_dev(struct device *dev)
283 {
284 	struct rio_dev *rdev;
285 
286 	rdev = to_rio_dev(dev);
287 	kfree(rdev);
288 }
289 
290 /**
291  * rio_is_switch- Tests if a RIO device has switch capabilities
292  * @rdev: RIO device
293  *
294  * Gets the RIO device Processing Element Features register
295  * contents and tests for switch capabilities. Returns 1 if
296  * the device is a switch or 0 if it is not a switch.
297  * The RIO device struct is freed.
298  */
299 static int rio_is_switch(struct rio_dev *rdev)
300 {
301 	if (rdev->pef & RIO_PEF_SWITCH)
302 		return 1;
303 	return 0;
304 }
305 
306 /**
307  * rio_setup_device- Allocates and sets up a RIO device
308  * @net: RIO network
309  * @port: Master port to send transactions
310  * @destid: Current destination ID
311  * @hopcount: Current hopcount
312  * @do_enum: Enumeration/Discovery mode flag
313  *
314  * Allocates a RIO device and configures fields based on configuration
315  * space contents. If device has a destination ID register, a destination
316  * ID is either assigned in enumeration mode or read from configuration
317  * space in discovery mode.  If the device has switch capabilities, then
318  * a switch is allocated and configured appropriately. Returns a pointer
319  * to a RIO device on success or NULL on failure.
320  *
321  */
322 static struct rio_dev *rio_setup_device(struct rio_net *net,
323 					struct rio_mport *port, u16 destid,
324 					u8 hopcount, int do_enum)
325 {
326 	int ret = 0;
327 	struct rio_dev *rdev;
328 	struct rio_switch *rswitch = NULL;
329 	int result, rdid;
330 	size_t size;
331 	u32 swpinfo = 0;
332 
333 	size = sizeof(struct rio_dev);
334 	if (rio_mport_read_config_32(port, destid, hopcount,
335 				     RIO_PEF_CAR, &result))
336 		return NULL;
337 
338 	if (result & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) {
339 		rio_mport_read_config_32(port, destid, hopcount,
340 					 RIO_SWP_INFO_CAR, &swpinfo);
341 		if (result & RIO_PEF_SWITCH) {
342 			size += (RIO_GET_TOTAL_PORTS(swpinfo) *
343 				sizeof(rswitch->nextdev[0])) + sizeof(*rswitch);
344 		}
345 	}
346 
347 	rdev = kzalloc(size, GFP_KERNEL);
348 	if (!rdev)
349 		return NULL;
350 
351 	rdev->net = net;
352 	rdev->pef = result;
353 	rdev->swpinfo = swpinfo;
354 	rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR,
355 				 &result);
356 	rdev->did = result >> 16;
357 	rdev->vid = result & 0xffff;
358 	rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR,
359 				 &rdev->device_rev);
360 	rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR,
361 				 &result);
362 	rdev->asm_did = result >> 16;
363 	rdev->asm_vid = result & 0xffff;
364 	rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR,
365 				 &result);
366 	rdev->asm_rev = result >> 16;
367 	if (rdev->pef & RIO_PEF_EXT_FEATURES) {
368 		rdev->efptr = result & 0xffff;
369 		rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid,
370 						hopcount, &rdev->phys_rmap);
371 		pr_debug("RIO: %s Register Map %d device\n",
372 			 __func__, rdev->phys_rmap);
373 
374 		rdev->em_efptr = rio_mport_get_feature(port, 0, destid,
375 						hopcount, RIO_EFB_ERR_MGMNT);
376 		if (!rdev->em_efptr)
377 			rdev->em_efptr = rio_mport_get_feature(port, 0, destid,
378 						hopcount, RIO_EFB_ERR_MGMNT_HS);
379 	}
380 
381 	rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
382 				 &rdev->src_ops);
383 	rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR,
384 				 &rdev->dst_ops);
385 
386 	if (do_enum) {
387 		/* Assign component tag to device */
388 		if (next_comptag >= 0x10000) {
389 			pr_err("RIO: Component Tag Counter Overflow\n");
390 			goto cleanup;
391 		}
392 		rio_mport_write_config_32(port, destid, hopcount,
393 					  RIO_COMPONENT_TAG_CSR, next_comptag);
394 		rdev->comp_tag = next_comptag++;
395 		rdev->do_enum = true;
396 	}  else {
397 		rio_mport_read_config_32(port, destid, hopcount,
398 					 RIO_COMPONENT_TAG_CSR,
399 					 &rdev->comp_tag);
400 	}
401 
402 	if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) {
403 		if (do_enum) {
404 			rio_set_device_id(port, destid, hopcount, next_destid);
405 			rdev->destid = next_destid;
406 			next_destid = rio_destid_alloc(net);
407 		} else
408 			rdev->destid = rio_get_device_id(port, destid, hopcount);
409 
410 		rdev->hopcount = 0xff;
411 	} else {
412 		/* Switch device has an associated destID which
413 		 * will be adjusted later
414 		 */
415 		rdev->destid = destid;
416 		rdev->hopcount = hopcount;
417 	}
418 
419 	/* If a PE has both switch and other functions, show it as a switch */
420 	if (rio_is_switch(rdev)) {
421 		rswitch = rdev->rswitch;
422 		rswitch->port_ok = 0;
423 		spin_lock_init(&rswitch->lock);
424 		rswitch->route_table =
425 			kzalloc(RIO_MAX_ROUTE_ENTRIES(port->sys_size),
426 				GFP_KERNEL);
427 		if (!rswitch->route_table)
428 			goto cleanup;
429 		/* Initialize switch route table */
430 		for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size);
431 				rdid++)
432 			rswitch->route_table[rdid] = RIO_INVALID_ROUTE;
433 		dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id,
434 			     rdev->comp_tag & RIO_CTAG_UDEVID);
435 
436 		if (do_enum)
437 			rio_route_clr_table(rdev, RIO_GLOBAL_TABLE, 0);
438 	} else {
439 		if (do_enum)
440 			/*Enable Input Output Port (transmitter receiver)*/
441 			rio_enable_rx_tx_port(port, 0, destid, hopcount, 0);
442 
443 		dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id,
444 			     rdev->comp_tag & RIO_CTAG_UDEVID);
445 	}
446 
447 	rdev->dev.parent = &net->dev;
448 	rio_attach_device(rdev);
449 	rdev->dev.release = rio_release_dev;
450 	rdev->dma_mask = DMA_BIT_MASK(32);
451 	rdev->dev.dma_mask = &rdev->dma_mask;
452 	rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
453 
454 	if (rdev->dst_ops & RIO_DST_OPS_DOORBELL)
455 		rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
456 				   0, 0xffff);
457 
458 	ret = rio_add_device(rdev);
459 	if (ret)
460 		goto cleanup;
461 
462 	rio_dev_get(rdev);
463 
464 	return rdev;
465 
466 cleanup:
467 	if (rswitch)
468 		kfree(rswitch->route_table);
469 
470 	kfree(rdev);
471 	return NULL;
472 }
473 
474 /**
475  * rio_sport_is_active- Tests if a switch port has an active connection.
476  * @rdev: RapidIO device object
477  * @sp: Switch port number
478  *
479  * Reads the port error status CSR for a particular switch port to
480  * determine if the port has an active link.  Returns
481  * %RIO_PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is
482  * inactive.
483  */
484 static int
485 rio_sport_is_active(struct rio_dev *rdev, int sp)
486 {
487 	u32 result = 0;
488 
489 	rio_read_config_32(rdev, RIO_DEV_PORT_N_ERR_STS_CSR(rdev, sp),
490 			   &result);
491 
492 	return result & RIO_PORT_N_ERR_STS_PORT_OK;
493 }
494 
495 /**
496  * rio_get_host_deviceid_lock- Reads the Host Device ID Lock CSR on a device
497  * @port: Master port to send transaction
498  * @hopcount: Number of hops to the device
499  *
500  * Used during enumeration to read the Host Device ID Lock CSR on a
501  * RIO device. Returns the value of the lock register.
502  */
503 static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)
504 {
505 	u32 result;
506 
507 	rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), hopcount,
508 				 RIO_HOST_DID_LOCK_CSR, &result);
509 
510 	return (u16) (result & 0xffff);
511 }
512 
513 /**
514  * rio_enum_peer- Recursively enumerate a RIO network through a master port
515  * @net: RIO network being enumerated
516  * @port: Master port to send transactions
517  * @hopcount: Number of hops into the network
518  * @prev: Previous RIO device connected to the enumerated one
519  * @prev_port: Port on previous RIO device
520  *
521  * Recursively enumerates a RIO network.  Transactions are sent via the
522  * master port passed in @port.
523  */
524 static int rio_enum_peer(struct rio_net *net, struct rio_mport *port,
525 			 u8 hopcount, struct rio_dev *prev, int prev_port)
526 {
527 	struct rio_dev *rdev;
528 	u32 regval;
529 	int tmp;
530 
531 	if (rio_mport_chk_dev_access(port,
532 			RIO_ANY_DESTID(port->sys_size), hopcount)) {
533 		pr_debug("RIO: device access check failed\n");
534 		return -1;
535 	}
536 
537 	if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) {
538 		pr_debug("RIO: PE already discovered by this host\n");
539 		/*
540 		 * Already discovered by this host. Add it as another
541 		 * link to the existing device.
542 		 */
543 		rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size),
544 				hopcount, RIO_COMPONENT_TAG_CSR, &regval);
545 
546 		if (regval) {
547 			rdev = rio_get_comptag((regval & 0xffff), NULL);
548 
549 			if (rdev && prev && rio_is_switch(prev)) {
550 				pr_debug("RIO: redundant path to %s\n",
551 					 rio_name(rdev));
552 				prev->rswitch->nextdev[prev_port] = rdev;
553 			}
554 		}
555 
556 		return 0;
557 	}
558 
559 	/* Attempt to acquire device lock */
560 	rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
561 				  hopcount,
562 				  RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
563 	while ((tmp = rio_get_host_deviceid_lock(port, hopcount))
564 	       < port->host_deviceid) {
565 		/* Delay a bit */
566 		mdelay(1);
567 		/* Attempt to acquire device lock again */
568 		rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
569 					  hopcount,
570 					  RIO_HOST_DID_LOCK_CSR,
571 					  port->host_deviceid);
572 	}
573 
574 	if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) {
575 		pr_debug(
576 		    "RIO: PE locked by a higher priority host...retreating\n");
577 		return -1;
578 	}
579 
580 	/* Setup new RIO device */
581 	rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size),
582 					hopcount, 1);
583 	if (rdev) {
584 		rdev->prev = prev;
585 		if (prev && rio_is_switch(prev))
586 			prev->rswitch->nextdev[prev_port] = rdev;
587 	} else
588 		return -1;
589 
590 	if (rio_is_switch(rdev)) {
591 		int sw_destid;
592 		int cur_destid;
593 		int sw_inport;
594 		u16 destid;
595 		int port_num;
596 
597 		sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo);
598 		rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
599 				    port->host_deviceid, sw_inport, 0);
600 		rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
601 
602 		destid = rio_destid_first(net);
603 		while (destid != RIO_INVALID_DESTID && destid < next_destid) {
604 			if (destid != port->host_deviceid) {
605 				rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
606 						    destid, sw_inport, 0);
607 				rdev->rswitch->route_table[destid] = sw_inport;
608 			}
609 			destid = rio_destid_next(net, destid + 1);
610 		}
611 		pr_debug(
612 		    "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
613 		    rio_name(rdev), rdev->vid, rdev->did,
614 		    RIO_GET_TOTAL_PORTS(rdev->swpinfo));
615 		sw_destid = next_destid;
616 		for (port_num = 0;
617 		     port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
618 		     port_num++) {
619 			if (sw_inport == port_num) {
620 				rio_enable_rx_tx_port(port, 0,
621 					      RIO_ANY_DESTID(port->sys_size),
622 					      hopcount, port_num);
623 				rdev->rswitch->port_ok |= (1 << port_num);
624 				continue;
625 			}
626 
627 			cur_destid = next_destid;
628 
629 			if (rio_sport_is_active(rdev, port_num)) {
630 				pr_debug(
631 				    "RIO: scanning device on port %d\n",
632 				    port_num);
633 				rio_enable_rx_tx_port(port, 0,
634 					      RIO_ANY_DESTID(port->sys_size),
635 					      hopcount, port_num);
636 				rdev->rswitch->port_ok |= (1 << port_num);
637 				rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
638 						RIO_ANY_DESTID(port->sys_size),
639 						port_num, 0);
640 
641 				if (rio_enum_peer(net, port, hopcount + 1,
642 						  rdev, port_num) < 0)
643 					return -1;
644 
645 				/* Update routing tables */
646 				destid = rio_destid_next(net, cur_destid + 1);
647 				if (destid != RIO_INVALID_DESTID) {
648 					for (destid = cur_destid;
649 					     destid < next_destid;) {
650 						if (destid != port->host_deviceid) {
651 							rio_route_add_entry(rdev,
652 								    RIO_GLOBAL_TABLE,
653 								    destid,
654 								    port_num,
655 								    0);
656 							rdev->rswitch->
657 								route_table[destid] =
658 								port_num;
659 						}
660 						destid = rio_destid_next(net,
661 								destid + 1);
662 					}
663 				}
664 			} else {
665 				/* If switch supports Error Management,
666 				 * set PORT_LOCKOUT bit for unused port
667 				 */
668 				if (rdev->em_efptr)
669 					rio_set_port_lockout(rdev, port_num, 1);
670 
671 				rdev->rswitch->port_ok &= ~(1 << port_num);
672 			}
673 		}
674 
675 		/* Direct Port-write messages to the enumeratiing host */
676 		if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) &&
677 		    (rdev->em_efptr)) {
678 			rio_write_config_32(rdev,
679 					rdev->em_efptr + RIO_EM_PW_TGT_DEVID,
680 					(port->host_deviceid << 16) |
681 					(port->sys_size << 15));
682 		}
683 
684 		rio_init_em(rdev);
685 
686 		/* Check for empty switch */
687 		if (next_destid == sw_destid)
688 			next_destid = rio_destid_alloc(net);
689 
690 		rdev->destid = sw_destid;
691 	} else
692 		pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
693 		    rio_name(rdev), rdev->vid, rdev->did);
694 
695 	return 0;
696 }
697 
698 /**
699  * rio_enum_complete- Tests if enumeration of a network is complete
700  * @port: Master port to send transaction
701  *
702  * Tests the PGCCSR discovered bit for non-zero value (enumeration
703  * complete flag). Return %1 if enumeration is complete or %0 if
704  * enumeration is incomplete.
705  */
706 static int rio_enum_complete(struct rio_mport *port)
707 {
708 	u32 regval;
709 
710 	rio_local_read_config_32(port, port->phys_efptr + RIO_PORT_GEN_CTL_CSR,
711 				 &regval);
712 	return (regval & RIO_PORT_GEN_DISCOVERED) ? 1 : 0;
713 }
714 
715 /**
716  * rio_disc_peer- Recursively discovers a RIO network through a master port
717  * @net: RIO network being discovered
718  * @port: Master port to send transactions
719  * @destid: Current destination ID in network
720  * @hopcount: Number of hops into the network
721  * @prev: previous rio_dev
722  * @prev_port: previous port number
723  *
724  * Recursively discovers a RIO network.  Transactions are sent via the
725  * master port passed in @port.
726  */
727 static int
728 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
729 	      u8 hopcount, struct rio_dev *prev, int prev_port)
730 {
731 	u8 port_num, route_port;
732 	struct rio_dev *rdev;
733 	u16 ndestid;
734 
735 	/* Setup new RIO device */
736 	if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) {
737 		rdev->prev = prev;
738 		if (prev && rio_is_switch(prev))
739 			prev->rswitch->nextdev[prev_port] = rdev;
740 	} else
741 		return -1;
742 
743 	if (rio_is_switch(rdev)) {
744 		/* Associated destid is how we accessed this switch */
745 		rdev->destid = destid;
746 
747 		pr_debug(
748 		    "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
749 		    rio_name(rdev), rdev->vid, rdev->did,
750 		    RIO_GET_TOTAL_PORTS(rdev->swpinfo));
751 		for (port_num = 0;
752 		     port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
753 		     port_num++) {
754 			if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num)
755 				continue;
756 
757 			if (rio_sport_is_active(rdev, port_num)) {
758 				pr_debug(
759 				    "RIO: scanning device on port %d\n",
760 				    port_num);
761 
762 				rio_lock_device(port, destid, hopcount, 1000);
763 
764 				for (ndestid = 0;
765 				     ndestid < RIO_ANY_DESTID(port->sys_size);
766 				     ndestid++) {
767 					rio_route_get_entry(rdev,
768 							    RIO_GLOBAL_TABLE,
769 							    ndestid,
770 							    &route_port, 0);
771 					if (route_port == port_num)
772 						break;
773 				}
774 
775 				if (ndestid == RIO_ANY_DESTID(port->sys_size))
776 					continue;
777 				rio_unlock_device(port, destid, hopcount);
778 				if (rio_disc_peer(net, port, ndestid,
779 					hopcount + 1, rdev, port_num) < 0)
780 					return -1;
781 			}
782 		}
783 	} else
784 		pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
785 		    rio_name(rdev), rdev->vid, rdev->did);
786 
787 	return 0;
788 }
789 
790 /**
791  * rio_mport_is_active- Tests if master port link is active
792  * @port: Master port to test
793  *
794  * Reads the port error status CSR for the master port to
795  * determine if the port has an active link.  Returns
796  * %RIO_PORT_N_ERR_STS_PORT_OK if the  master port is active
797  * or %0 if it is inactive.
798  */
799 static int rio_mport_is_active(struct rio_mport *port)
800 {
801 	u32 result = 0;
802 
803 	rio_local_read_config_32(port,
804 		port->phys_efptr +
805 			RIO_PORT_N_ERR_STS_CSR(port->index, port->phys_rmap),
806 		&result);
807 	return result & RIO_PORT_N_ERR_STS_PORT_OK;
808 }
809 
810 static void rio_scan_release_net(struct rio_net *net)
811 {
812 	pr_debug("RIO-SCAN: %s: net_%d\n", __func__, net->id);
813 	kfree(net->enum_data);
814 }
815 
816 static void rio_scan_release_dev(struct device *dev)
817 {
818 	struct rio_net *net;
819 
820 	net = to_rio_net(dev);
821 	pr_debug("RIO-SCAN: %s: net_%d\n", __func__, net->id);
822 	kfree(net);
823 }
824 
825 /*
826  * rio_scan_alloc_net - Allocate and configure a new RIO network
827  * @mport: Master port associated with the RIO network
828  * @do_enum: Enumeration/Discovery mode flag
829  * @start: logical minimal start id for new net
830  *
831  * Allocates a new RIO network structure and initializes enumerator-specific
832  * part of it (if required).
833  * Returns a RIO network pointer on success or %NULL on failure.
834  */
835 static struct rio_net *rio_scan_alloc_net(struct rio_mport *mport,
836 					  int do_enum, u16 start)
837 {
838 	struct rio_net *net;
839 
840 	net = rio_alloc_net(mport);
841 
842 	if (net && do_enum) {
843 		struct rio_id_table *idtab;
844 		size_t size;
845 
846 		size = sizeof(struct rio_id_table) +
847 				BITS_TO_LONGS(
848 					RIO_MAX_ROUTE_ENTRIES(mport->sys_size)
849 					) * sizeof(long);
850 
851 		idtab = kzalloc(size, GFP_KERNEL);
852 
853 		if (idtab == NULL) {
854 			pr_err("RIO: failed to allocate destID table\n");
855 			rio_free_net(net);
856 			net = NULL;
857 		} else {
858 			net->enum_data = idtab;
859 			net->release = rio_scan_release_net;
860 			idtab->start = start;
861 			idtab->max = RIO_MAX_ROUTE_ENTRIES(mport->sys_size);
862 			spin_lock_init(&idtab->lock);
863 		}
864 	}
865 
866 	if (net) {
867 		net->id = mport->id;
868 		net->hport = mport;
869 		dev_set_name(&net->dev, "rnet_%d", net->id);
870 		net->dev.parent = &mport->dev;
871 		net->dev.release = rio_scan_release_dev;
872 		rio_add_net(net);
873 	}
874 
875 	return net;
876 }
877 
878 /**
879  * rio_update_route_tables- Updates route tables in switches
880  * @net: RIO network to run update on
881  *
882  * For each enumerated device, ensure that each switch in a system
883  * has correct routing entries. Add routes for devices that where
884  * unknown during the first enumeration pass through the switch.
885  */
886 static void rio_update_route_tables(struct rio_net *net)
887 {
888 	struct rio_dev *rdev, *swrdev;
889 	struct rio_switch *rswitch;
890 	u8 sport;
891 	u16 destid;
892 
893 	list_for_each_entry(rdev, &net->devices, net_list) {
894 
895 		destid = rdev->destid;
896 
897 		list_for_each_entry(rswitch, &net->switches, node) {
898 
899 			if (rio_is_switch(rdev)	&& (rdev->rswitch == rswitch))
900 				continue;
901 
902 			if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) {
903 				swrdev = sw_to_rio_dev(rswitch);
904 
905 				/* Skip if destid ends in empty switch*/
906 				if (swrdev->destid == destid)
907 					continue;
908 
909 				sport = RIO_GET_PORT_NUM(swrdev->swpinfo);
910 
911 				rio_route_add_entry(swrdev, RIO_GLOBAL_TABLE,
912 						    destid, sport, 0);
913 				rswitch->route_table[destid] = sport;
914 			}
915 		}
916 	}
917 }
918 
919 /**
920  * rio_init_em - Initializes RIO Error Management (for switches)
921  * @rdev: RIO device
922  *
923  * For each enumerated switch, call device-specific error management
924  * initialization routine (if supplied by the switch driver).
925  */
926 static void rio_init_em(struct rio_dev *rdev)
927 {
928 	if (rio_is_switch(rdev) && (rdev->em_efptr) &&
929 	    rdev->rswitch->ops && rdev->rswitch->ops->em_init) {
930 		rdev->rswitch->ops->em_init(rdev);
931 	}
932 }
933 
934 /**
935  * rio_enum_mport- Start enumeration through a master port
936  * @mport: Master port to send transactions
937  * @flags: Enumeration control flags
938  *
939  * Starts the enumeration process. If somebody has enumerated our
940  * master port device, then give up. If not and we have an active
941  * link, then start recursive peer enumeration. Returns %0 if
942  * enumeration succeeds or %-EBUSY if enumeration fails.
943  */
944 static int rio_enum_mport(struct rio_mport *mport, u32 flags)
945 {
946 	struct rio_net *net = NULL;
947 	int rc = 0;
948 
949 	printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id,
950 	       mport->name);
951 
952 	/*
953 	 * To avoid multiple start requests (repeat enumeration is not supported
954 	 * by this method) check if enumeration/discovery was performed for this
955 	 * mport: if mport was added into the list of mports for a net exit
956 	 * with error.
957 	 */
958 	if (mport->nnode.next || mport->nnode.prev)
959 		return -EBUSY;
960 
961 	/* If somebody else enumerated our master port device, bail. */
962 	if (rio_enum_host(mport) < 0) {
963 		printk(KERN_INFO
964 		       "RIO: master port %d device has been enumerated by a remote host\n",
965 		       mport->id);
966 		rc = -EBUSY;
967 		goto out;
968 	}
969 
970 	/* If master port has an active link, allocate net and enum peers */
971 	if (rio_mport_is_active(mport)) {
972 		net = rio_scan_alloc_net(mport, 1, 0);
973 		if (!net) {
974 			printk(KERN_ERR "RIO: failed to allocate new net\n");
975 			rc = -ENOMEM;
976 			goto out;
977 		}
978 
979 		/* reserve mport destID in new net */
980 		rio_destid_reserve(net, mport->host_deviceid);
981 
982 		/* Enable Input Output Port (transmitter receiver) */
983 		rio_enable_rx_tx_port(mport, 1, 0, 0, 0);
984 
985 		/* Set component tag for host */
986 		rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR,
987 					  next_comptag++);
988 
989 		next_destid = rio_destid_alloc(net);
990 
991 		if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) {
992 			/* A higher priority host won enumeration, bail. */
993 			printk(KERN_INFO
994 			       "RIO: master port %d device has lost enumeration to a remote host\n",
995 			       mport->id);
996 			rio_clear_locks(net);
997 			rc = -EBUSY;
998 			goto out;
999 		}
1000 		/* free the last allocated destID (unused) */
1001 		rio_destid_free(net, next_destid);
1002 		rio_update_route_tables(net);
1003 		rio_clear_locks(net);
1004 		rio_pw_enable(mport, 1);
1005 	} else {
1006 		printk(KERN_INFO "RIO: master port %d link inactive\n",
1007 		       mport->id);
1008 		rc = -EINVAL;
1009 	}
1010 
1011       out:
1012 	return rc;
1013 }
1014 
1015 /**
1016  * rio_build_route_tables- Generate route tables from switch route entries
1017  * @net: RIO network to run route tables scan on
1018  *
1019  * For each switch device, generate a route table by copying existing
1020  * route entries from the switch.
1021  */
1022 static void rio_build_route_tables(struct rio_net *net)
1023 {
1024 	struct rio_switch *rswitch;
1025 	struct rio_dev *rdev;
1026 	int i;
1027 	u8 sport;
1028 
1029 	list_for_each_entry(rswitch, &net->switches, node) {
1030 		rdev = sw_to_rio_dev(rswitch);
1031 
1032 		rio_lock_device(net->hport, rdev->destid,
1033 				rdev->hopcount, 1000);
1034 		for (i = 0;
1035 		     i < RIO_MAX_ROUTE_ENTRIES(net->hport->sys_size);
1036 		     i++) {
1037 			if (rio_route_get_entry(rdev, RIO_GLOBAL_TABLE,
1038 						i, &sport, 0) < 0)
1039 				continue;
1040 			rswitch->route_table[i] = sport;
1041 		}
1042 
1043 		rio_unlock_device(net->hport, rdev->destid, rdev->hopcount);
1044 	}
1045 }
1046 
1047 /**
1048  * rio_disc_mport- Start discovery through a master port
1049  * @mport: Master port to send transactions
1050  * @flags: discovery control flags
1051  *
1052  * Starts the discovery process. If we have an active link,
1053  * then wait for the signal that enumeration is complete (if wait
1054  * is allowed).
1055  * When enumeration completion is signaled, start recursive
1056  * peer discovery. Returns %0 if discovery succeeds or %-EBUSY
1057  * on failure.
1058  */
1059 static int rio_disc_mport(struct rio_mport *mport, u32 flags)
1060 {
1061 	struct rio_net *net = NULL;
1062 	unsigned long to_end;
1063 
1064 	printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id,
1065 	       mport->name);
1066 
1067 	/* If master port has an active link, allocate net and discover peers */
1068 	if (rio_mport_is_active(mport)) {
1069 		if (rio_enum_complete(mport))
1070 			goto enum_done;
1071 		else if (flags & RIO_SCAN_ENUM_NO_WAIT)
1072 			return -EAGAIN;
1073 
1074 		pr_debug("RIO: wait for enumeration to complete...\n");
1075 
1076 		to_end = jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
1077 		while (time_before(jiffies, to_end)) {
1078 			if (rio_enum_complete(mport))
1079 				goto enum_done;
1080 			msleep(10);
1081 		}
1082 
1083 		pr_debug("RIO: discovery timeout on mport %d %s\n",
1084 			 mport->id, mport->name);
1085 		goto bail;
1086 enum_done:
1087 		pr_debug("RIO: ... enumeration done\n");
1088 
1089 		net = rio_scan_alloc_net(mport, 0, 0);
1090 		if (!net) {
1091 			printk(KERN_ERR "RIO: Failed to allocate new net\n");
1092 			goto bail;
1093 		}
1094 
1095 		/* Read DestID assigned by enumerator */
1096 		rio_local_read_config_32(mport, RIO_DID_CSR,
1097 					 &mport->host_deviceid);
1098 		mport->host_deviceid = RIO_GET_DID(mport->sys_size,
1099 						   mport->host_deviceid);
1100 
1101 		if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size),
1102 					0, NULL, 0) < 0) {
1103 			printk(KERN_INFO
1104 			       "RIO: master port %d device has failed discovery\n",
1105 			       mport->id);
1106 			goto bail;
1107 		}
1108 
1109 		rio_build_route_tables(net);
1110 	}
1111 
1112 	return 0;
1113 bail:
1114 	return -EBUSY;
1115 }
1116 
1117 static struct rio_scan rio_scan_ops = {
1118 	.owner = THIS_MODULE,
1119 	.enumerate = rio_enum_mport,
1120 	.discover = rio_disc_mport,
1121 };
1122 
1123 static bool scan;
1124 module_param(scan, bool, 0);
1125 MODULE_PARM_DESC(scan, "Start RapidIO network enumeration/discovery "
1126 			"(default = 0)");
1127 
1128 /**
1129  * rio_basic_attach:
1130  *
1131  * When this enumeration/discovery method is loaded as a module this function
1132  * registers its specific enumeration and discover routines for all available
1133  * RapidIO mport devices. The "scan" command line parameter controls ability of
1134  * the module to start RapidIO enumeration/discovery automatically.
1135  *
1136  * Returns 0 for success or -EIO if unable to register itself.
1137  *
1138  * This enumeration/discovery method cannot be unloaded and therefore does not
1139  * provide a matching cleanup_module routine.
1140  */
1141 
1142 static int __init rio_basic_attach(void)
1143 {
1144 	if (rio_register_scan(RIO_MPORT_ANY, &rio_scan_ops))
1145 		return -EIO;
1146 	if (scan)
1147 		rio_init_mports();
1148 	return 0;
1149 }
1150 
1151 late_initcall(rio_basic_attach);
1152 
1153 MODULE_DESCRIPTION("Basic RapidIO enumeration/discovery");
1154 MODULE_LICENSE("GPL");
1155