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