?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rapidio: add device object linking into discovery
[linux/fpc-iii.git] / drivers / rapidio / rio-scan.c
blobe655756e118590a42585d493bba5fabebdac2b68
1 /*
2 * RapidIO enumeration and discovery support
3 *
4 * Copyright 2005 MontaVista Software, Inc.
5 * Matt Porter <mporter@kernel.crashing.org>
6 *
7 * Copyright 2009 Integrated Device Technology, Inc.
8 * Alex Bounine <alexandre.bounine@idt.com>
9 * - Added Port-Write/Error Management initialization and handling
10 *
11 * Copyright 2009 Sysgo AG
12 * Thomas Moll <thomas.moll@sysgo.com>
13 * - Added Input- Output- enable functionality, to allow full communication
14 *
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the
17 * Free Software Foundation; either version 2 of the License, or (at your
18 * option) any later version.
19 */
20
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23
24 #include <linux/delay.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/init.h>
27 #include <linux/rio.h>
28 #include <linux/rio_drv.h>
29 #include <linux/rio_ids.h>
30 #include <linux/rio_regs.h>
31 #include <linux/module.h>
32 #include <linux/spinlock.h>
33 #include <linux/timer.h>
34 #include <linux/jiffies.h>
35 #include <linux/slab.h>
36
37 #include "rio.h"
38
39 LIST_HEAD(rio_devices);
40 static LIST_HEAD(rio_switches);
41
42 static void rio_enum_timeout(unsigned long);
43
44 static void rio_init_em(struct rio_dev *rdev);
45
46 DEFINE_SPINLOCK(rio_global_list_lock);
47
48 static int next_destid = 0;
49 static int next_switchid = 0;
50 static int next_net = 0;
51 static int next_comptag = 1;
52
53 static struct timer_list rio_enum_timer =
54 TIMER_INITIALIZER(rio_enum_timeout, 0, 0);
55
56 static int rio_mport_phys_table[] = {
57 RIO_EFB_PAR_EP_ID,
58 RIO_EFB_PAR_EP_REC_ID,
59 RIO_EFB_SER_EP_ID,
60 RIO_EFB_SER_EP_REC_ID,
61 -1,
62 };
63
64 /**
65 * rio_get_device_id - Get the base/extended device id for a device
66 * @port: RIO master port
67 * @destid: Destination ID of device
68 * @hopcount: Hopcount to device
69 *
70 * Reads the base/extended device id from a device. Returns the
71 * 8/16-bit device ID.
72 */
73 static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount)
74 {
75 u32 result;
76
77 rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result);
78
79 return RIO_GET_DID(port->sys_size, result);
80 }
81
82 /**
83 * rio_set_device_id - Set the base/extended device id for a device
84 * @port: RIO master port
85 * @destid: Destination ID of device
86 * @hopcount: Hopcount to device
87 * @did: Device ID value to be written
88 *
89 * Writes the base/extended device id from a device.
90 */
91 static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did)
92 {
93 rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR,
94 RIO_SET_DID(port->sys_size, did));
95 }
96
97 /**
98 * rio_local_set_device_id - Set the base/extended device id for a port
99 * @port: RIO master port
100 * @did: Device ID value to be written
101 *
102 * Writes the base/extended device id from a device.
103 */
104 static void rio_local_set_device_id(struct rio_mport *port, u16 did)
105 {
106 rio_local_write_config_32(port, RIO_DID_CSR, RIO_SET_DID(port->sys_size,
107 did));
108 }
109
110 /**
111 * rio_clear_locks- Release all host locks and signal enumeration complete
112 * @port: Master port to issue transaction
113 *
114 * Marks the component tag CSR on each device with the enumeration
115 * complete flag. When complete, it then release the host locks on
116 * each device. Returns 0 on success or %-EINVAL on failure.
117 */
118 static int rio_clear_locks(struct rio_mport *port)
119 {
120 struct rio_dev *rdev;
121 u32 result;
122 int ret = 0;
123
124 /* Release host device id locks */
125 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
126 port->host_deviceid);
127 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
128 if ((result & 0xffff) != 0xffff) {
129 printk(KERN_INFO
130 "RIO: badness when releasing host lock on master port, result %8.8x\n",
131 result);
132 ret = -EINVAL;
133 }
134 list_for_each_entry(rdev, &rio_devices, global_list) {
135 rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR,
136 port->host_deviceid);
137 rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result);
138 if ((result & 0xffff) != 0xffff) {
139 printk(KERN_INFO
140 "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n",
141 rdev->vid, rdev->did);
142 ret = -EINVAL;
143 }
144
145 /* Mark device as discovered and enable master */
146 rio_read_config_32(rdev,
147 rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
148 &result);
149 result |= RIO_PORT_GEN_DISCOVERED | RIO_PORT_GEN_MASTER;
150 rio_write_config_32(rdev,
151 rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
152 result);
153 }
154
155 return ret;
156 }
157
158 /**
159 * rio_enum_host- Set host lock and initialize host destination ID
160 * @port: Master port to issue transaction
161 *
162 * Sets the local host master port lock and destination ID register
163 * with the host device ID value. The host device ID value is provided
164 * by the platform. Returns %0 on success or %-1 on failure.
165 */
166 static int rio_enum_host(struct rio_mport *port)
167 {
168 u32 result;
169
170 /* Set master port host device id lock */
171 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
172 port->host_deviceid);
173
174 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
175 if ((result & 0xffff) != port->host_deviceid)
176 return -1;
177
178 /* Set master port destid and init destid ctr */
179 rio_local_set_device_id(port, port->host_deviceid);
180
181 if (next_destid == port->host_deviceid)
182 next_destid++;
183
184 return 0;
185 }
186
187 /**
188 * rio_device_has_destid- Test if a device contains a destination ID register
189 * @port: Master port to issue transaction
190 * @src_ops: RIO device source operations
191 * @dst_ops: RIO device destination operations
192 *
193 * Checks the provided @src_ops and @dst_ops for the necessary transaction
194 * capabilities that indicate whether or not a device will implement a
195 * destination ID register. Returns 1 if true or 0 if false.
196 */
197 static int rio_device_has_destid(struct rio_mport *port, int src_ops,
198 int dst_ops)
199 {
200 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;
201
202 return !!((src_ops | dst_ops) & mask);
203 }
204
205 /**
206 * rio_release_dev- Frees a RIO device struct
207 * @dev: LDM device associated with a RIO device struct
208 *
209 * Gets the RIO device struct associated a RIO device struct.
210 * The RIO device struct is freed.
211 */
212 static void rio_release_dev(struct device *dev)
213 {
214 struct rio_dev *rdev;
215
216 rdev = to_rio_dev(dev);
217 kfree(rdev);
218 }
219
220 /**
221 * rio_is_switch- Tests if a RIO device has switch capabilities
222 * @rdev: RIO device
223 *
224 * Gets the RIO device Processing Element Features register
225 * contents and tests for switch capabilities. Returns 1 if
226 * the device is a switch or 0 if it is not a switch.
227 * The RIO device struct is freed.
228 */
229 static int rio_is_switch(struct rio_dev *rdev)
230 {
231 if (rdev->pef & RIO_PEF_SWITCH)
232 return 1;
233 return 0;
234 }
235
236 /**
237 * rio_switch_init - Sets switch operations for a particular vendor switch
238 * @rdev: RIO device
239 * @do_enum: Enumeration/Discovery mode flag
240 *
241 * Searches the RIO switch ops table for known switch types. If the vid
242 * and did match a switch table entry, then call switch initialization
243 * routine to setup switch-specific routines.
244 */
245 static void rio_switch_init(struct rio_dev *rdev, int do_enum)
246 {
247 struct rio_switch_ops *cur = __start_rio_switch_ops;
248 struct rio_switch_ops *end = __end_rio_switch_ops;
249
250 while (cur < end) {
251 if ((cur->vid == rdev->vid) && (cur->did == rdev->did)) {
252 pr_debug("RIO: calling init routine for %s\n",
253 rio_name(rdev));
254 cur->init_hook(rdev, do_enum);
255 break;
256 }
257 cur++;
258 }
259
260 if ((cur >= end) && (rdev->pef & RIO_PEF_STD_RT)) {
261 pr_debug("RIO: adding STD routing ops for %s\n",
262 rio_name(rdev));
263 rdev->rswitch->add_entry = rio_std_route_add_entry;
264 rdev->rswitch->get_entry = rio_std_route_get_entry;
265 rdev->rswitch->clr_table = rio_std_route_clr_table;
266 }
267
268 if (!rdev->rswitch->add_entry || !rdev->rswitch->get_entry)
269 printk(KERN_ERR "RIO: missing routing ops for %s\n",
270 rio_name(rdev));
271 }
272
273 /**
274 * rio_add_device- Adds a RIO device to the device model
275 * @rdev: RIO device
276 *
277 * Adds the RIO device to the global device list and adds the RIO
278 * device to the RIO device list. Creates the generic sysfs nodes
279 * for an RIO device.
280 */
281 static int __devinit rio_add_device(struct rio_dev *rdev)
282 {
283 int err;
284
285 err = device_add(&rdev->dev);
286 if (err)
287 return err;
288
289 spin_lock(&rio_global_list_lock);
290 list_add_tail(&rdev->global_list, &rio_devices);
291 spin_unlock(&rio_global_list_lock);
292
293 rio_create_sysfs_dev_files(rdev);
294
295 return 0;
296 }
297
298 /**
299 * rio_enable_rx_tx_port - enable input reciever and output transmitter of
300 * given port
301 * @port: Master port associated with the RIO network
302 * @local: local=1 select local port otherwise a far device is reached
303 * @destid: Destination ID of the device to check host bit
304 * @hopcount: Number of hops to reach the target
305 * @port_num: Port (-number on switch) to enable on a far end device
306 *
307 * Returns 0 or 1 from on General Control Command and Status Register
308 * (EXT_PTR+0x3C)
309 */
310 inline int rio_enable_rx_tx_port(struct rio_mport *port,
311 int local, u16 destid,
312 u8 hopcount, u8 port_num) {
313 #ifdef CONFIG_RAPIDIO_ENABLE_RX_TX_PORTS
314 u32 regval;
315 u32 ext_ftr_ptr;
316
317 /*
318 * enable rx input tx output port
319 */
320 pr_debug("rio_enable_rx_tx_port(local = %d, destid = %d, hopcount = "
321 "%d, port_num = %d)\n", local, destid, hopcount, port_num);
322
323 ext_ftr_ptr = rio_mport_get_physefb(port, local, destid, hopcount);
324
325 if (local) {
326 rio_local_read_config_32(port, ext_ftr_ptr +
327 RIO_PORT_N_CTL_CSR(0),
328 &regval);
329 } else {
330 if (rio_mport_read_config_32(port, destid, hopcount,
331 ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), &regval) < 0)
332 return -EIO;
333 }
334
335 if (regval & RIO_PORT_N_CTL_P_TYP_SER) {
336 /* serial */
337 regval = regval | RIO_PORT_N_CTL_EN_RX_SER
338 | RIO_PORT_N_CTL_EN_TX_SER;
339 } else {
340 /* parallel */
341 regval = regval | RIO_PORT_N_CTL_EN_RX_PAR
342 | RIO_PORT_N_CTL_EN_TX_PAR;
343 }
344
345 if (local) {
346 rio_local_write_config_32(port, ext_ftr_ptr +
347 RIO_PORT_N_CTL_CSR(0), regval);
348 } else {
349 if (rio_mport_write_config_32(port, destid, hopcount,
350 ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), regval) < 0)
351 return -EIO;
352 }
353 #endif
354 return 0;
355 }
356
357 /**
358 * rio_setup_device- Allocates and sets up a RIO device
359 * @net: RIO network
360 * @port: Master port to send transactions
361 * @destid: Current destination ID
362 * @hopcount: Current hopcount
363 * @do_enum: Enumeration/Discovery mode flag
364 *
365 * Allocates a RIO device and configures fields based on configuration
366 * space contents. If device has a destination ID register, a destination
367 * ID is either assigned in enumeration mode or read from configuration
368 * space in discovery mode. If the device has switch capabilities, then
369 * a switch is allocated and configured appropriately. Returns a pointer
370 * to a RIO device on success or NULL on failure.
371 *
372 */
373 static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
374 struct rio_mport *port, u16 destid,
375 u8 hopcount, int do_enum)
376 {
377 int ret = 0;
378 struct rio_dev *rdev;
379 struct rio_switch *rswitch = NULL;
380 int result, rdid;
381 size_t size;
382 u32 swpinfo = 0;
383
384 size = sizeof(struct rio_dev);
385 if (rio_mport_read_config_32(port, destid, hopcount,
386 RIO_PEF_CAR, &result))
387 return NULL;
388
389 if (result & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) {
390 rio_mport_read_config_32(port, destid, hopcount,
391 RIO_SWP_INFO_CAR, &swpinfo);
392 if (result & RIO_PEF_SWITCH) {
393 size += (RIO_GET_TOTAL_PORTS(swpinfo) *
394 sizeof(rswitch->nextdev[0])) + sizeof(*rswitch);
395 }
396 }
397
398 rdev = kzalloc(size, GFP_KERNEL);
399 if (!rdev)
400 return NULL;
401
402 rdev->net = net;
403 rdev->pef = result;
404 rdev->swpinfo = swpinfo;
405 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR,
406 &result);
407 rdev->did = result >> 16;
408 rdev->vid = result & 0xffff;
409 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR,
410 &rdev->device_rev);
411 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR,
412 &result);
413 rdev->asm_did = result >> 16;
414 rdev->asm_vid = result & 0xffff;
415 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR,
416 &result);
417 rdev->asm_rev = result >> 16;
418 if (rdev->pef & RIO_PEF_EXT_FEATURES) {
419 rdev->efptr = result & 0xffff;
420 rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid,
421 hopcount);
422
423 rdev->em_efptr = rio_mport_get_feature(port, 0, destid,
424 hopcount, RIO_EFB_ERR_MGMNT);
425 }
426
427 rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
428 &rdev->src_ops);
429 rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR,
430 &rdev->dst_ops);
431
432 if (do_enum) {
433 /* Assign component tag to device */
434 if (next_comptag >= 0x10000) {
435 pr_err("RIO: Component Tag Counter Overflow\n");
436 goto cleanup;
437 }
438 rio_mport_write_config_32(port, destid, hopcount,
439 RIO_COMPONENT_TAG_CSR, next_comptag);
440 rdev->comp_tag = next_comptag++;
441 }
442
443 if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) {
444 if (do_enum) {
445 rio_set_device_id(port, destid, hopcount, next_destid);
446 rdev->destid = next_destid++;
447 if (next_destid == port->host_deviceid)
448 next_destid++;
449 } else
450 rdev->destid = rio_get_device_id(port, destid, hopcount);
451
452 rdev->hopcount = 0xff;
453 } else {
454 /* Switch device has an associated destID which
455 * will be adjusted later
456 */
457 rdev->destid = destid;
458 rdev->hopcount = hopcount;
459 }
460
461 /* If a PE has both switch and other functions, show it as a switch */
462 if (rio_is_switch(rdev)) {
463 rswitch = rdev->rswitch;
464 rswitch->switchid = next_switchid;
465 rswitch->port_ok = 0;
466 rswitch->route_table = kzalloc(sizeof(u8)*
467 RIO_MAX_ROUTE_ENTRIES(port->sys_size),
468 GFP_KERNEL);
469 if (!rswitch->route_table)
470 goto cleanup;
471 /* Initialize switch route table */
472 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size);
473 rdid++)
474 rswitch->route_table[rdid] = RIO_INVALID_ROUTE;
475 dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id,
476 rswitch->switchid);
477 rio_switch_init(rdev, do_enum);
478
479 if (do_enum && rswitch->clr_table)
480 rswitch->clr_table(port, destid, hopcount,
481 RIO_GLOBAL_TABLE);
482
483 list_add_tail(&rswitch->node, &rio_switches);
484
485 } else {
486 if (do_enum)
487 /*Enable Input Output Port (transmitter reviever)*/
488 rio_enable_rx_tx_port(port, 0, destid, hopcount, 0);
489
490 dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id,
491 rdev->destid);
492 }
493
494 rdev->dev.bus = &rio_bus_type;
495 rdev->dev.parent = &rio_bus;
496
497 device_initialize(&rdev->dev);
498 rdev->dev.release = rio_release_dev;
499 rio_dev_get(rdev);
500
501 rdev->dma_mask = DMA_BIT_MASK(32);
502 rdev->dev.dma_mask = &rdev->dma_mask;
503 rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
504
505 if ((rdev->pef & RIO_PEF_INB_DOORBELL) &&
506 (rdev->dst_ops & RIO_DST_OPS_DOORBELL))
507 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
508 0, 0xffff);
509
510 ret = rio_add_device(rdev);
511 if (ret)
512 goto cleanup;
513
514 return rdev;
515
516 cleanup:
517 if (rswitch->route_table)
518 kfree(rswitch->route_table);
519
520 kfree(rdev);
521 return NULL;
522 }
523
524 /**
525 * rio_sport_is_active- Tests if a switch port has an active connection.
526 * @port: Master port to send transaction
527 * @destid: Associated destination ID for switch
528 * @hopcount: Hopcount to reach switch
529 * @sport: Switch port number
530 *
531 * Reads the port error status CSR for a particular switch port to
532 * determine if the port has an active link. Returns
533 * %RIO_PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is
534 * inactive.
535 */
536 static int
537 rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
538 {
539 u32 result = 0;
540 u32 ext_ftr_ptr;
541
542 ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount, 0);
543
544 while (ext_ftr_ptr) {
545 rio_mport_read_config_32(port, destid, hopcount,
546 ext_ftr_ptr, &result);
547 result = RIO_GET_BLOCK_ID(result);
548 if ((result == RIO_EFB_SER_EP_FREE_ID) ||
549 (result == RIO_EFB_SER_EP_FREE_ID_V13P) ||
550 (result == RIO_EFB_SER_EP_FREC_ID))
551 break;
552
553 ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount,
554 ext_ftr_ptr);
555 }
556
557 if (ext_ftr_ptr)
558 rio_mport_read_config_32(port, destid, hopcount,
559 ext_ftr_ptr +
560 RIO_PORT_N_ERR_STS_CSR(sport),
561 &result);
562
563 return result & RIO_PORT_N_ERR_STS_PORT_OK;
564 }
565
566 /**
567 * rio_lock_device - Acquires host device lock for specified device
568 * @port: Master port to send transaction
569 * @destid: Destination ID for device/switch
570 * @hopcount: Hopcount to reach switch
571 * @wait_ms: Max wait time in msec (0 = no timeout)
572 *
573 * Attepts to acquire host device lock for specified device
574 * Returns 0 if device lock acquired or EINVAL if timeout expires.
575 */
576 static int
577 rio_lock_device(struct rio_mport *port, u16 destid, u8 hopcount, int wait_ms)
578 {
579 u32 result;
580 int tcnt = 0;
581
582 /* Attempt to acquire device lock */
583 rio_mport_write_config_32(port, destid, hopcount,
584 RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
585 rio_mport_read_config_32(port, destid, hopcount,
586 RIO_HOST_DID_LOCK_CSR, &result);
587
588 while (result != port->host_deviceid) {
589 if (wait_ms != 0 && tcnt == wait_ms) {
590 pr_debug("RIO: timeout when locking device %x:%x\n",
591 destid, hopcount);
592 return -EINVAL;
593 }
594
595 /* Delay a bit */
596 mdelay(1);
597 tcnt++;
598 /* Try to acquire device lock again */
599 rio_mport_write_config_32(port, destid,
600 hopcount,
601 RIO_HOST_DID_LOCK_CSR,
602 port->host_deviceid);
603 rio_mport_read_config_32(port, destid,
604 hopcount,
605 RIO_HOST_DID_LOCK_CSR, &result);
606 }
607
608 return 0;
609 }
610
611 /**
612 * rio_unlock_device - Releases host device lock for specified device
613 * @port: Master port to send transaction
614 * @destid: Destination ID for device/switch
615 * @hopcount: Hopcount to reach switch
616 *
617 * Returns 0 if device lock released or EINVAL if fails.
618 */
619 static int
620 rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount)
621 {
622 u32 result;
623
624 /* Release device lock */
625 rio_mport_write_config_32(port, destid,
626 hopcount,
627 RIO_HOST_DID_LOCK_CSR,
628 port->host_deviceid);
629 rio_mport_read_config_32(port, destid, hopcount,
630 RIO_HOST_DID_LOCK_CSR, &result);
631 if ((result & 0xffff) != 0xffff) {
632 pr_debug("RIO: badness when releasing device lock %x:%x\n",
633 destid, hopcount);
634 return -EINVAL;
635 }
636
637 return 0;
638 }
639
640 /**
641 * rio_route_add_entry- Add a route entry to a switch routing table
642 * @rdev: RIO device
643 * @table: Routing table ID
644 * @route_destid: Destination ID to be routed
645 * @route_port: Port number to be routed
646 * @lock: lock switch device flag
647 *
648 * Calls the switch specific add_entry() method to add a route entry
649 * on a switch. The route table can be specified using the @table
650 * argument if a switch has per port routing tables or the normal
651 * use is to specific all tables (or the global table) by passing
652 * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL
653 * on failure.
654 */
655 static int
656 rio_route_add_entry(struct rio_dev *rdev,
657 u16 table, u16 route_destid, u8 route_port, int lock)
658 {
659 int rc;
660
661 if (lock) {
662 rc = rio_lock_device(rdev->net->hport, rdev->destid,
663 rdev->hopcount, 1000);
664 if (rc)
665 return rc;
666 }
667
668 rc = rdev->rswitch->add_entry(rdev->net->hport, rdev->destid,
669 rdev->hopcount, table,
670 route_destid, route_port);
671 if (lock)
672 rio_unlock_device(rdev->net->hport, rdev->destid,
673 rdev->hopcount);
674
675 return rc;
676 }
677
678 /**
679 * rio_route_get_entry- Read a route entry in a switch routing table
680 * @rdev: RIO device
681 * @table: Routing table ID
682 * @route_destid: Destination ID to be routed
683 * @route_port: Pointer to read port number into
684 * @lock: lock switch device flag
685 *
686 * Calls the switch specific get_entry() method to read a route entry
687 * in a switch. The route table can be specified using the @table
688 * argument if a switch has per port routing tables or the normal
689 * use is to specific all tables (or the global table) by passing
690 * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL
691 * on failure.
692 */
693 static int
694 rio_route_get_entry(struct rio_dev *rdev, u16 table,
695 u16 route_destid, u8 *route_port, int lock)
696 {
697 int rc;
698
699 if (lock) {
700 rc = rio_lock_device(rdev->net->hport, rdev->destid,
701 rdev->hopcount, 1000);
702 if (rc)
703 return rc;
704 }
705
706 rc = rdev->rswitch->get_entry(rdev->net->hport, rdev->destid,
707 rdev->hopcount, table,
708 route_destid, route_port);
709 if (lock)
710 rio_unlock_device(rdev->net->hport, rdev->destid,
711 rdev->hopcount);
712
713 return rc;
714 }
715
716 /**
717 * rio_get_host_deviceid_lock- Reads the Host Device ID Lock CSR on a device
718 * @port: Master port to send transaction
719 * @hopcount: Number of hops to the device
720 *
721 * Used during enumeration to read the Host Device ID Lock CSR on a
722 * RIO device. Returns the value of the lock register.
723 */
724 static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)
725 {
726 u32 result;
727
728 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), hopcount,
729 RIO_HOST_DID_LOCK_CSR, &result);
730
731 return (u16) (result & 0xffff);
732 }
733
734 /**
735 * rio_enum_peer- Recursively enumerate a RIO network through a master port
736 * @net: RIO network being enumerated
737 * @port: Master port to send transactions
738 * @hopcount: Number of hops into the network
739 * @prev: Previous RIO device connected to the enumerated one
740 * @prev_port: Port on previous RIO device
741 *
742 * Recursively enumerates a RIO network. Transactions are sent via the
743 * master port passed in @port.
744 */
745 static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
746 u8 hopcount, struct rio_dev *prev, int prev_port)
747 {
748 int port_num;
749 int cur_destid;
750 int sw_destid;
751 int sw_inport;
752 struct rio_dev *rdev;
753 u16 destid;
754 u32 regval;
755 int tmp;
756
757 if (rio_mport_chk_dev_access(port,
758 RIO_ANY_DESTID(port->sys_size), hopcount)) {
759 pr_debug("RIO: device access check failed\n");
760 return -1;
761 }
762
763 if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) {
764 pr_debug("RIO: PE already discovered by this host\n");
765 /*
766 * Already discovered by this host. Add it as another
767 * link to the existing device.
768 */
769 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size),
770 hopcount, RIO_COMPONENT_TAG_CSR, &regval);
771
772 if (regval) {
773 rdev = rio_get_comptag((regval & 0xffff), NULL);
774
775 if (rdev && prev && rio_is_switch(prev)) {
776 pr_debug("RIO: redundant path to %s\n",
777 rio_name(rdev));
778 prev->rswitch->nextdev[prev_port] = rdev;
779 }
780 }
781
782 return 0;
783 }
784
785 /* Attempt to acquire device lock */
786 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
787 hopcount,
788 RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
789 while ((tmp = rio_get_host_deviceid_lock(port, hopcount))
790 < port->host_deviceid) {
791 /* Delay a bit */
792 mdelay(1);
793 /* Attempt to acquire device lock again */
794 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
795 hopcount,
796 RIO_HOST_DID_LOCK_CSR,
797 port->host_deviceid);
798 }
799
800 if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) {
801 pr_debug(
802 "RIO: PE locked by a higher priority host...retreating\n");
803 return -1;
804 }
805
806 /* Setup new RIO device */
807 rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size),
808 hopcount, 1);
809 if (rdev) {
810 /* Add device to the global and bus/net specific list. */
811 list_add_tail(&rdev->net_list, &net->devices);
812 rdev->prev = prev;
813 if (prev && rio_is_switch(prev))
814 prev->rswitch->nextdev[prev_port] = rdev;
815 } else
816 return -1;
817
818 if (rio_is_switch(rdev)) {
819 next_switchid++;
820 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo);
821 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
822 port->host_deviceid, sw_inport, 0);
823 rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
824
825 for (destid = 0; destid < next_destid; destid++) {
826 if (destid == port->host_deviceid)
827 continue;
828 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
829 destid, sw_inport, 0);
830 rdev->rswitch->route_table[destid] = sw_inport;
831 }
832
833 pr_debug(
834 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
835 rio_name(rdev), rdev->vid, rdev->did,
836 RIO_GET_TOTAL_PORTS(rdev->swpinfo));
837 sw_destid = next_destid;
838 for (port_num = 0;
839 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
840 port_num++) {
841 /*Enable Input Output Port (transmitter reviever)*/
842 rio_enable_rx_tx_port(port, 0,
843 RIO_ANY_DESTID(port->sys_size),
844 hopcount, port_num);
845
846 if (sw_inport == port_num) {
847 rdev->rswitch->port_ok |= (1 << port_num);
848 continue;
849 }
850
851 cur_destid = next_destid;
852
853 if (rio_sport_is_active
854 (port, RIO_ANY_DESTID(port->sys_size), hopcount,
855 port_num)) {
856 pr_debug(
857 "RIO: scanning device on port %d\n",
858 port_num);
859 rdev->rswitch->port_ok |= (1 << port_num);
860 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
861 RIO_ANY_DESTID(port->sys_size),
862 port_num, 0);
863
864 if (rio_enum_peer(net, port, hopcount + 1,
865 rdev, port_num) < 0)
866 return -1;
867
868 /* Update routing tables */
869 if (next_destid > cur_destid) {
870 for (destid = cur_destid;
871 destid < next_destid; destid++) {
872 if (destid == port->host_deviceid)
873 continue;
874 rio_route_add_entry(rdev,
875 RIO_GLOBAL_TABLE,
876 destid,
877 port_num,
878 0);
879 rdev->rswitch->
880 route_table[destid] =
881 port_num;
882 }
883 }
884 } else {
885 /* If switch supports Error Management,
886 * set PORT_LOCKOUT bit for unused port
887 */
888 if (rdev->em_efptr)
889 rio_set_port_lockout(rdev, port_num, 1);
890
891 rdev->rswitch->port_ok &= ~(1 << port_num);
892 }
893 }
894
895 /* Direct Port-write messages to the enumeratiing host */
896 if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) &&
897 (rdev->em_efptr)) {
898 rio_write_config_32(rdev,
899 rdev->em_efptr + RIO_EM_PW_TGT_DEVID,
900 (port->host_deviceid << 16) |
901 (port->sys_size << 15));
902 }
903
904 rio_init_em(rdev);
905
906 /* Check for empty switch */
907 if (next_destid == sw_destid) {
908 next_destid++;
909 if (next_destid == port->host_deviceid)
910 next_destid++;
911 }
912
913 rdev->destid = sw_destid;
914 } else
915 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
916 rio_name(rdev), rdev->vid, rdev->did);
917
918 return 0;
919 }
920
921 /**
922 * rio_enum_complete- Tests if enumeration of a network is complete
923 * @port: Master port to send transaction
924 *
925 * Tests the Component Tag CSR for non-zero value (enumeration
926 * complete flag). Return %1 if enumeration is complete or %0 if
927 * enumeration is incomplete.
928 */
929 static int rio_enum_complete(struct rio_mport *port)
930 {
931 u32 regval;
932
933 rio_local_read_config_32(port, port->phys_efptr + RIO_PORT_GEN_CTL_CSR,
934 &regval);
935 return (regval & RIO_PORT_GEN_MASTER) ? 1 : 0;
936 }
937
938 /**
939 * rio_disc_peer- Recursively discovers a RIO network through a master port
940 * @net: RIO network being discovered
941 * @port: Master port to send transactions
942 * @destid: Current destination ID in network
943 * @hopcount: Number of hops into the network
944 *
945 * Recursively discovers a RIO network. Transactions are sent via the
946 * master port passed in @port.
947 */
948 static int __devinit
949 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
950 u8 hopcount, struct rio_dev *prev, int prev_port)
951 {
952 u8 port_num, route_port;
953 struct rio_dev *rdev;
954 u16 ndestid;
955
956 /* Setup new RIO device */
957 if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) {
958 /* Add device to the global and bus/net specific list. */
959 list_add_tail(&rdev->net_list, &net->devices);
960 rdev->prev = prev;
961 if (prev && rio_is_switch(prev))
962 prev->rswitch->nextdev[prev_port] = rdev;
963 } else
964 return -1;
965
966 if (rio_is_switch(rdev)) {
967 next_switchid++;
968
969 /* Associated destid is how we accessed this switch */
970 rdev->destid = destid;
971
972 pr_debug(
973 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
974 rio_name(rdev), rdev->vid, rdev->did,
975 RIO_GET_TOTAL_PORTS(rdev->swpinfo));
976 for (port_num = 0;
977 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
978 port_num++) {
979 if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num)
980 continue;
981
982 if (rio_sport_is_active
983 (port, destid, hopcount, port_num)) {
984 pr_debug(
985 "RIO: scanning device on port %d\n",
986 port_num);
987
988 rio_lock_device(port, destid, hopcount, 1000);
989
990 for (ndestid = 0;
991 ndestid < RIO_ANY_DESTID(port->sys_size);
992 ndestid++) {
993 rio_route_get_entry(rdev,
994 RIO_GLOBAL_TABLE,
995 ndestid,
996 &route_port, 0);
997 if (route_port == port_num)
998 break;
999 }
1000
1001 if (ndestid == RIO_ANY_DESTID(port->sys_size))
1002 continue;
1003 rio_unlock_device(port, destid, hopcount);
1004 if (rio_disc_peer(net, port, ndestid,
1005 hopcount + 1, rdev, port_num) < 0)
1006 return -1;
1007 }
1008 }
1009 } else
1010 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
1011 rio_name(rdev), rdev->vid, rdev->did);
1012
1013 return 0;
1014 }
1015
1016 /**
1017 * rio_mport_is_active- Tests if master port link is active
1018 * @port: Master port to test
1019 *
1020 * Reads the port error status CSR for the master port to
1021 * determine if the port has an active link. Returns
1022 * %RIO_PORT_N_ERR_STS_PORT_OK if the master port is active
1023 * or %0 if it is inactive.
1024 */
1025 static int rio_mport_is_active(struct rio_mport *port)
1026 {
1027 u32 result = 0;
1028 u32 ext_ftr_ptr;
1029 int *entry = rio_mport_phys_table;
1030
1031 do {
1032 if ((ext_ftr_ptr =
1033 rio_mport_get_feature(port, 1, 0, 0, *entry)))
1034 break;
1035 } while (*++entry >= 0);
1036
1037 if (ext_ftr_ptr)
1038 rio_local_read_config_32(port,
1039 ext_ftr_ptr +
1040 RIO_PORT_N_ERR_STS_CSR(port->index),
1041 &result);
1042
1043 return result & RIO_PORT_N_ERR_STS_PORT_OK;
1044 }
1045
1046 /**
1047 * rio_alloc_net- Allocate and configure a new RIO network
1048 * @port: Master port associated with the RIO network
1049 *
1050 * Allocates a RIO network structure, initializes per-network
1051 * list heads, and adds the associated master port to the
1052 * network list of associated master ports. Returns a
1053 * RIO network pointer on success or %NULL on failure.
1054 */
1055 static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port)
1056 {
1057 struct rio_net *net;
1058
1059 net = kzalloc(sizeof(struct rio_net), GFP_KERNEL);
1060 if (net) {
1061 INIT_LIST_HEAD(&net->node);
1062 INIT_LIST_HEAD(&net->devices);
1063 INIT_LIST_HEAD(&net->mports);
1064 list_add_tail(&port->nnode, &net->mports);
1065 net->hport = port;
1066 net->id = next_net++;
1067 }
1068 return net;
1069 }
1070
1071 /**
1072 * rio_update_route_tables- Updates route tables in switches
1073 * @port: Master port associated with the RIO network
1074 *
1075 * For each enumerated device, ensure that each switch in a system
1076 * has correct routing entries. Add routes for devices that where
1077 * unknown dirung the first enumeration pass through the switch.
1078 */
1079 static void rio_update_route_tables(struct rio_mport *port)
1080 {
1081 struct rio_dev *rdev, *swrdev;
1082 struct rio_switch *rswitch;
1083 u8 sport;
1084 u16 destid;
1085
1086 list_for_each_entry(rdev, &rio_devices, global_list) {
1087
1088 destid = rdev->destid;
1089
1090 list_for_each_entry(rswitch, &rio_switches, node) {
1091
1092 if (rio_is_switch(rdev) && (rdev->rswitch == rswitch))
1093 continue;
1094
1095 if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) {
1096 swrdev = sw_to_rio_dev(rswitch);
1097
1098 /* Skip if destid ends in empty switch*/
1099 if (swrdev->destid == destid)
1100 continue;
1101
1102 sport = RIO_GET_PORT_NUM(swrdev->swpinfo);
1103
1104 if (rswitch->add_entry) {
1105 rio_route_add_entry(swrdev,
1106 RIO_GLOBAL_TABLE, destid,
1107 sport, 0);
1108 rswitch->route_table[destid] = sport;
1109 }
1110 }
1111 }
1112 }
1113 }
1114
1115 /**
1116 * rio_init_em - Initializes RIO Error Management (for switches)
1117 * @rdev: RIO device
1118 *
1119 * For each enumerated switch, call device-specific error management
1120 * initialization routine (if supplied by the switch driver).
1121 */
1122 static void rio_init_em(struct rio_dev *rdev)
1123 {
1124 if (rio_is_switch(rdev) && (rdev->em_efptr) &&
1125 (rdev->rswitch->em_init)) {
1126 rdev->rswitch->em_init(rdev);
1127 }
1128 }
1129
1130 /**
1131 * rio_pw_enable - Enables/disables port-write handling by a master port
1132 * @port: Master port associated with port-write handling
1133 * @enable: 1=enable, 0=disable
1134 */
1135 static void rio_pw_enable(struct rio_mport *port, int enable)
1136 {
1137 if (port->ops->pwenable)
1138 port->ops->pwenable(port, enable);
1139 }
1140
1141 /**
1142 * rio_enum_mport- Start enumeration through a master port
1143 * @mport: Master port to send transactions
1144 *
1145 * Starts the enumeration process. If somebody has enumerated our
1146 * master port device, then give up. If not and we have an active
1147 * link, then start recursive peer enumeration. Returns %0 if
1148 * enumeration succeeds or %-EBUSY if enumeration fails.
1149 */
1150 int __devinit rio_enum_mport(struct rio_mport *mport)
1151 {
1152 struct rio_net *net = NULL;
1153 int rc = 0;
1154
1155 printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id,
1156 mport->name);
1157 /* If somebody else enumerated our master port device, bail. */
1158 if (rio_enum_host(mport) < 0) {
1159 printk(KERN_INFO
1160 "RIO: master port %d device has been enumerated by a remote host\n",
1161 mport->id);
1162 rc = -EBUSY;
1163 goto out;
1164 }
1165
1166 /* If master port has an active link, allocate net and enum peers */
1167 if (rio_mport_is_active(mport)) {
1168 if (!(net = rio_alloc_net(mport))) {
1169 printk(KERN_ERR "RIO: failed to allocate new net\n");
1170 rc = -ENOMEM;
1171 goto out;
1172 }
1173
1174 /* Enable Input Output Port (transmitter reviever) */
1175 rio_enable_rx_tx_port(mport, 1, 0, 0, 0);
1176
1177 /* Set component tag for host */
1178 rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR,
1179 next_comptag++);
1180
1181 if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) {
1182 /* A higher priority host won enumeration, bail. */
1183 printk(KERN_INFO
1184 "RIO: master port %d device has lost enumeration to a remote host\n",
1185 mport->id);
1186 rio_clear_locks(mport);
1187 rc = -EBUSY;
1188 goto out;
1189 }
1190 rio_update_route_tables(mport);
1191 rio_clear_locks(mport);
1192 rio_pw_enable(mport, 1);
1193 } else {
1194 printk(KERN_INFO "RIO: master port %d link inactive\n",
1195 mport->id);
1196 rc = -EINVAL;
1197 }
1198
1199 out:
1200 return rc;
1201 }
1202
1203 /**
1204 * rio_build_route_tables- Generate route tables from switch route entries
1205 *
1206 * For each switch device, generate a route table by copying existing
1207 * route entries from the switch.
1208 */
1209 static void rio_build_route_tables(void)
1210 {
1211 struct rio_dev *rdev;
1212 int i;
1213 u8 sport;
1214
1215 list_for_each_entry(rdev, &rio_devices, global_list)
1216 if (rio_is_switch(rdev)) {
1217 rio_lock_device(rdev->net->hport, rdev->destid,
1218 rdev->hopcount, 1000);
1219 for (i = 0;
1220 i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
1221 i++) {
1222 if (rio_route_get_entry(rdev,
1223 RIO_GLOBAL_TABLE, i, &sport, 0) < 0)
1224 continue;
1225 rdev->rswitch->route_table[i] = sport;
1226 }
1227
1228 rio_unlock_device(rdev->net->hport,
1229 rdev->destid,
1230 rdev->hopcount);
1231 }
1232 }
1233
1234 /**
1235 * rio_enum_timeout- Signal that enumeration timed out
1236 * @data: Address of timeout flag.
1237 *
1238 * When the enumeration complete timer expires, set a flag that
1239 * signals to the discovery process that enumeration did not
1240 * complete in a sane amount of time.
1241 */
1242 static void rio_enum_timeout(unsigned long data)
1243 {
1244 /* Enumeration timed out, set flag */
1245 *(int *)data = 1;
1246 }
1247
1248 /**
1249 * rio_disc_mport- Start discovery through a master port
1250 * @mport: Master port to send transactions
1251 *
1252 * Starts the discovery process. If we have an active link,
1253 * then wait for the signal that enumeration is complete.
1254 * When enumeration completion is signaled, start recursive
1255 * peer discovery. Returns %0 if discovery succeeds or %-EBUSY
1256 * on failure.
1257 */
1258 int __devinit rio_disc_mport(struct rio_mport *mport)
1259 {
1260 struct rio_net *net = NULL;
1261 int enum_timeout_flag = 0;
1262
1263 printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id,
1264 mport->name);
1265
1266 /* If master port has an active link, allocate net and discover peers */
1267 if (rio_mport_is_active(mport)) {
1268 if (!(net = rio_alloc_net(mport))) {
1269 printk(KERN_ERR "RIO: Failed to allocate new net\n");
1270 goto bail;
1271 }
1272
1273 pr_debug("RIO: wait for enumeration complete...");
1274
1275 rio_enum_timer.expires =
1276 jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
1277 rio_enum_timer.data = (unsigned long)&enum_timeout_flag;
1278 add_timer(&rio_enum_timer);
1279 while (!rio_enum_complete(mport)) {
1280 mdelay(1);
1281 if (enum_timeout_flag) {
1282 del_timer_sync(&rio_enum_timer);
1283 goto timeout;
1284 }
1285 }
1286 del_timer_sync(&rio_enum_timer);
1287
1288 pr_debug("done\n");
1289
1290 /* Read DestID assigned by enumerator */
1291 rio_local_read_config_32(mport, RIO_DID_CSR,
1292 &mport->host_deviceid);
1293 mport->host_deviceid = RIO_GET_DID(mport->sys_size,
1294 mport->host_deviceid);
1295
1296 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size),
1297 0, NULL, 0) < 0) {
1298 printk(KERN_INFO
1299 "RIO: master port %d device has failed discovery\n",
1300 mport->id);
1301 goto bail;
1302 }
1303
1304 rio_build_route_tables();
1305 }
1306
1307 return 0;
1308
1309 timeout:
1310 pr_debug("timeout\n");
1311 bail:
1312 return -EBUSY;
1313 }
Linux with added FPC-III support