]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - drivers/staging/generic_serial/rio/rioroute.c
2 ** -----------------------------------------------------------------------------
4 ** Perle Specialix driver for Linux
5 ** Ported from existing RIO Driver for SCO sources.
7 * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 ** Module : rioroute.c
25 ** Last Modified : 11/6/98 10:33:46
26 ** Retrieved : 11/6/98 10:33:50
28 ** ident @(#)rioroute.c 1.3
30 ** -----------------------------------------------------------------------------
33 #include <linux/module.h>
34 #include <linux/errno.h>
36 #include <asm/system.h>
37 #include <asm/string.h>
38 #include <asm/uaccess.h>
40 #include <linux/termios.h>
41 #include <linux/serial.h>
43 #include <linux/generic_serial.h>
46 #include "linux_compat.h"
47 #include "rio_linux.h"
74 static int RIOCheckIsolated(struct rio_info
*, struct Host
*, unsigned int);
75 static int RIOIsolate(struct rio_info
*, struct Host
*, unsigned int);
76 static int RIOCheck(struct Host
*, unsigned int);
77 static void RIOConCon(struct rio_info
*, struct Host
*, unsigned int, unsigned int, unsigned int, unsigned int, int);
81 ** Incoming on the ROUTE_RUP
82 ** I wrote this while I was tired. Forgive me.
84 int RIORouteRup(struct rio_info
*p
, unsigned int Rup
, struct Host
*HostP
, struct PKT __iomem
* PacketP
)
86 struct PktCmd __iomem
*PktCmdP
= (struct PktCmd __iomem
*) PacketP
->data
;
87 struct PktCmd_M
*PktReplyP
;
88 struct CmdBlk
*CmdBlkP
;
92 int ThisLink
, ThisLinkMin
, ThisLinkMax
;
95 unsigned short RtaType
;
97 unsigned int ThisUnit
, ThisUnit2
; /* 2 ids to accommodate 16 port RTA */
98 unsigned int OldUnit
, NewUnit
, OldLink
, NewLink
;
99 char *MyType
, *MyName
;
104 ** Is this unit telling us it's current link topology?
106 if (readb(&PktCmdP
->Command
) == ROUTE_TOPOLOGY
) {
107 MapP
= HostP
->Mapping
;
110 ** The packet can be sent either by the host or by an RTA.
111 ** If it comes from the host, then we need to fill in the
112 ** Topology array in the host structure. If it came in
113 ** from an RTA then we need to fill in the Mapping structure's
114 ** Topology array for the unit.
116 if (Rup
>= (unsigned short) MAX_RUP
) {
118 TopP
= HostP
->Topology
;
120 MyName
= HostP
->Name
;
121 ThisLinkMin
= ThisLinkMax
= Rup
- MAX_RUP
;
124 TopP
= HostP
->Mapping
[Rup
].Topology
;
126 MyName
= HostP
->Mapping
[Rup
].Name
;
128 ThisLinkMax
= LINKS_PER_UNIT
- 1;
132 ** Lies will not be tolerated.
133 ** If any pair of links claim to be connected to the same
134 ** place, then ignore this packet completely.
137 for (ThisLink
= ThisLinkMin
+ 1; ThisLink
<= ThisLinkMax
; ThisLink
++) {
139 ** it won't lie about network interconnect, total disconnects
140 ** and no-IDs. (or at least, it doesn't *matter* if it does)
142 if (readb(&PktCmdP
->RouteTopology
[ThisLink
].Unit
) > (unsigned short) MAX_RUP
)
145 for (NewLink
= ThisLinkMin
; NewLink
< ThisLink
; NewLink
++) {
146 if ((readb(&PktCmdP
->RouteTopology
[ThisLink
].Unit
) == readb(&PktCmdP
->RouteTopology
[NewLink
].Unit
)) && (readb(&PktCmdP
->RouteTopology
[ThisLink
].Link
) == readb(&PktCmdP
->RouteTopology
[NewLink
].Link
))) {
153 rio_dprintk(RIO_DEBUG_ROUTE
, "LIES! DAMN LIES! %d LIES!\n", Lies
);
154 rio_dprintk(RIO_DEBUG_ROUTE
, "%d:%c %d:%c %d:%c %d:%c\n",
155 readb(&PktCmdP
->RouteTopology
[0].Unit
),
156 'A' + readb(&PktCmdP
->RouteTopology
[0].Link
),
157 readb(&PktCmdP
->RouteTopology
[1].Unit
),
158 'A' + readb(&PktCmdP
->RouteTopology
[1].Link
), readb(&PktCmdP
->RouteTopology
[2].Unit
), 'A' + readb(&PktCmdP
->RouteTopology
[2].Link
), readb(&PktCmdP
->RouteTopology
[3].Unit
), 'A' + readb(&PktCmdP
->RouteTopology
[3].Link
));
163 ** now, process each link.
165 for (ThisLink
= ThisLinkMin
; ThisLink
<= ThisLinkMax
; ThisLink
++) {
167 ** this is what it was connected to
169 OldUnit
= TopP
[ThisLink
].Unit
;
170 OldLink
= TopP
[ThisLink
].Link
;
173 ** this is what it is now connected to
175 NewUnit
= readb(&PktCmdP
->RouteTopology
[ThisLink
].Unit
);
176 NewLink
= readb(&PktCmdP
->RouteTopology
[ThisLink
].Link
);
178 if (OldUnit
!= NewUnit
|| OldLink
!= NewLink
) {
180 ** something has changed!
183 if (NewUnit
> MAX_RUP
&& NewUnit
!= ROUTE_DISCONNECT
&& NewUnit
!= ROUTE_NO_ID
&& NewUnit
!= ROUTE_INTERCONNECT
) {
184 rio_dprintk(RIO_DEBUG_ROUTE
, "I have a link from %s %s to unit %d:%d - I don't like it.\n", MyType
, MyName
, NewUnit
, NewLink
);
187 ** put the new values in
189 TopP
[ThisLink
].Unit
= NewUnit
;
190 TopP
[ThisLink
].Link
= NewLink
;
194 if (OldUnit
<= MAX_RUP
) {
196 ** If something has become bust, then re-enable them messages
198 if (!p
->RIONoMessage
)
199 RIOConCon(p
, HostP
, ThisUnit
, ThisLink
, OldUnit
, OldLink
, DISCONNECT
);
202 if ((NewUnit
<= MAX_RUP
) && !p
->RIONoMessage
)
203 RIOConCon(p
, HostP
, ThisUnit
, ThisLink
, NewUnit
, NewLink
, CONNECT
);
205 if (NewUnit
== ROUTE_NO_ID
)
206 rio_dprintk(RIO_DEBUG_ROUTE
, "%s %s (%c) is connected to an unconfigured unit.\n", MyType
, MyName
, 'A' + ThisLink
);
208 if (NewUnit
== ROUTE_INTERCONNECT
) {
209 if (!p
->RIONoMessage
)
210 printk(KERN_DEBUG
"rio: %s '%s' (%c) is connected to another network.\n", MyType
, MyName
, 'A' + ThisLink
);
214 ** perform an update for 'the other end', so that these messages
215 ** only appears once. Only disconnect the other end if it is pointing
218 if (OldUnit
== HOST_ID
) {
219 if (HostP
->Topology
[OldLink
].Unit
== ThisUnit
&& HostP
->Topology
[OldLink
].Link
== ThisLink
) {
220 rio_dprintk(RIO_DEBUG_ROUTE
, "SETTING HOST (%c) TO DISCONNECTED!\n", OldLink
+ 'A');
221 HostP
->Topology
[OldLink
].Unit
= ROUTE_DISCONNECT
;
222 HostP
->Topology
[OldLink
].Link
= NO_LINK
;
224 rio_dprintk(RIO_DEBUG_ROUTE
, "HOST(%c) WAS NOT CONNECTED TO %s (%c)!\n", OldLink
+ 'A', HostP
->Mapping
[ThisUnit
- 1].Name
, ThisLink
+ 'A');
226 } else if (OldUnit
<= MAX_RUP
) {
227 if (HostP
->Mapping
[OldUnit
- 1].Topology
[OldLink
].Unit
== ThisUnit
&& HostP
->Mapping
[OldUnit
- 1].Topology
[OldLink
].Link
== ThisLink
) {
228 rio_dprintk(RIO_DEBUG_ROUTE
, "SETTING RTA %s (%c) TO DISCONNECTED!\n", HostP
->Mapping
[OldUnit
- 1].Name
, OldLink
+ 'A');
229 HostP
->Mapping
[OldUnit
- 1].Topology
[OldLink
].Unit
= ROUTE_DISCONNECT
;
230 HostP
->Mapping
[OldUnit
- 1].Topology
[OldLink
].Link
= NO_LINK
;
232 rio_dprintk(RIO_DEBUG_ROUTE
, "RTA %s (%c) WAS NOT CONNECTED TO %s (%c)\n", HostP
->Mapping
[OldUnit
- 1].Name
, OldLink
+ 'A', HostP
->Mapping
[ThisUnit
- 1].Name
, ThisLink
+ 'A');
235 if (NewUnit
== HOST_ID
) {
236 rio_dprintk(RIO_DEBUG_ROUTE
, "MARKING HOST (%c) CONNECTED TO %s (%c)\n", NewLink
+ 'A', MyName
, ThisLink
+ 'A');
237 HostP
->Topology
[NewLink
].Unit
= ThisUnit
;
238 HostP
->Topology
[NewLink
].Link
= ThisLink
;
239 } else if (NewUnit
<= MAX_RUP
) {
240 rio_dprintk(RIO_DEBUG_ROUTE
, "MARKING RTA %s (%c) CONNECTED TO %s (%c)\n", HostP
->Mapping
[NewUnit
- 1].Name
, NewLink
+ 'A', MyName
, ThisLink
+ 'A');
241 HostP
->Mapping
[NewUnit
- 1].Topology
[NewLink
].Unit
= ThisUnit
;
242 HostP
->Mapping
[NewUnit
- 1].Topology
[NewLink
].Link
= ThisLink
;
246 RIOCheckIsolated(p
, HostP
, OldUnit
);
253 ** The only other command we recognise is a route_request command
255 if (readb(&PktCmdP
->Command
) != ROUTE_REQUEST
) {
256 rio_dprintk(RIO_DEBUG_ROUTE
, "Unknown command %d received on rup %d host %p ROUTE_RUP\n", readb(&PktCmdP
->Command
), Rup
, HostP
);
260 RtaUniq
= (readb(&PktCmdP
->UniqNum
[0])) + (readb(&PktCmdP
->UniqNum
[1]) << 8) + (readb(&PktCmdP
->UniqNum
[2]) << 16) + (readb(&PktCmdP
->UniqNum
[3]) << 24);
263 ** Determine if 8 or 16 port RTA
265 RtaType
= GetUnitType(RtaUniq
);
267 rio_dprintk(RIO_DEBUG_ROUTE
, "Received a request for an ID for serial number %x\n", RtaUniq
);
269 Mod
= readb(&PktCmdP
->ModuleTypes
);
271 if (RtaType
== TYPE_RTA16
) {
273 ** Only one ident is set for a 16 port RTA. To make compatible
274 ** with 8 port, set 2nd ident in Mod2 to the same as Mod1.
277 rio_dprintk(RIO_DEBUG_ROUTE
, "Backplane type is %s (all ports)\n", p
->RIOModuleTypes
[Mod1
].Name
);
280 rio_dprintk(RIO_DEBUG_ROUTE
, "Module types are %s (ports 0-3) and %s (ports 4-7)\n", p
->RIOModuleTypes
[Mod1
].Name
, p
->RIOModuleTypes
[Mod2
].Name
);
284 ** try to unhook a command block from the command free list.
286 if (!(CmdBlkP
= RIOGetCmdBlk())) {
287 rio_dprintk(RIO_DEBUG_ROUTE
, "No command blocks to route RTA! come back later.\n");
292 ** Fill in the default info on the command block
294 CmdBlkP
->Packet
.dest_unit
= Rup
;
295 CmdBlkP
->Packet
.dest_port
= ROUTE_RUP
;
296 CmdBlkP
->Packet
.src_unit
= HOST_ID
;
297 CmdBlkP
->Packet
.src_port
= ROUTE_RUP
;
298 CmdBlkP
->Packet
.len
= PKT_CMD_BIT
| 1;
299 CmdBlkP
->PreFuncP
= CmdBlkP
->PostFuncP
= NULL
;
300 PktReplyP
= (struct PktCmd_M
*) CmdBlkP
->Packet
.data
;
302 if (!RIOBootOk(p
, HostP
, RtaUniq
)) {
303 rio_dprintk(RIO_DEBUG_ROUTE
, "RTA %x tried to get an ID, but does not belong - FOAD it!\n", RtaUniq
);
304 PktReplyP
->Command
= ROUTE_FOAD
;
305 memcpy(PktReplyP
->CommandText
, "RT_FOAD", 7);
306 RIOQueueCmdBlk(HostP
, Rup
, CmdBlkP
);
311 ** Check to see if the RTA is configured for this host
313 for (ThisUnit
= 0; ThisUnit
< MAX_RUP
; ThisUnit
++) {
314 rio_dprintk(RIO_DEBUG_ROUTE
, "Entry %d Flags=%s %s UniqueNum=0x%x\n",
315 ThisUnit
, HostP
->Mapping
[ThisUnit
].Flags
& SLOT_IN_USE
? "Slot-In-Use" : "Not In Use", HostP
->Mapping
[ThisUnit
].Flags
& SLOT_TENTATIVE
? "Slot-Tentative" : "Not Tentative", HostP
->Mapping
[ThisUnit
].RtaUniqueNum
);
318 ** We have an entry for it.
320 if ((HostP
->Mapping
[ThisUnit
].Flags
& (SLOT_IN_USE
| SLOT_TENTATIVE
)) && (HostP
->Mapping
[ThisUnit
].RtaUniqueNum
== RtaUniq
)) {
321 if (RtaType
== TYPE_RTA16
) {
322 ThisUnit2
= HostP
->Mapping
[ThisUnit
].ID2
- 1;
323 rio_dprintk(RIO_DEBUG_ROUTE
, "Found unit 0x%x at slots %d+%d\n", RtaUniq
, ThisUnit
, ThisUnit2
);
325 rio_dprintk(RIO_DEBUG_ROUTE
, "Found unit 0x%x at slot %d\n", RtaUniq
, ThisUnit
);
327 ** If we have no knowledge of booting it, then the host has
328 ** been re-booted, and so we must kill the RTA, so that it
329 ** will be booted again (potentially with new bins)
330 ** and it will then re-ask for an ID, which we will service.
332 if ((HostP
->Mapping
[ThisUnit
].Flags
& SLOT_IN_USE
) && !(HostP
->Mapping
[ThisUnit
].Flags
& RTA_BOOTED
)) {
333 if (!(HostP
->Mapping
[ThisUnit
].Flags
& MSG_DONE
)) {
334 if (!p
->RIONoMessage
)
335 printk(KERN_DEBUG
"rio: RTA '%s' is being updated.\n", HostP
->Mapping
[ThisUnit
].Name
);
336 HostP
->Mapping
[ThisUnit
].Flags
|= MSG_DONE
;
338 PktReplyP
->Command
= ROUTE_FOAD
;
339 memcpy(PktReplyP
->CommandText
, "RT_FOAD", 7);
340 RIOQueueCmdBlk(HostP
, Rup
, CmdBlkP
);
345 ** Send the ID (entry) to this RTA. The ID number is implicit as
346 ** the offset into the table. It is worth noting at this stage
347 ** that offset zero in the table contains the entries for the
350 PktReplyP
->Command
= ROUTE_ALLOCATE
;
351 PktReplyP
->IDNum
= ThisUnit
+ 1;
352 if (RtaType
== TYPE_RTA16
) {
353 if (HostP
->Mapping
[ThisUnit
].Flags
& SLOT_IN_USE
)
355 ** Adjust the phb and tx pkt dest_units for 2nd block of 8
356 ** only if the RTA has ports associated (SLOT_IN_USE)
358 RIOFixPhbs(p
, HostP
, ThisUnit2
);
359 PktReplyP
->IDNum2
= ThisUnit2
+ 1;
360 rio_dprintk(RIO_DEBUG_ROUTE
, "RTA '%s' has been allocated IDs %d+%d\n", HostP
->Mapping
[ThisUnit
].Name
, PktReplyP
->IDNum
, PktReplyP
->IDNum2
);
362 PktReplyP
->IDNum2
= ROUTE_NO_ID
;
363 rio_dprintk(RIO_DEBUG_ROUTE
, "RTA '%s' has been allocated ID %d\n", HostP
->Mapping
[ThisUnit
].Name
, PktReplyP
->IDNum
);
365 memcpy(PktReplyP
->CommandText
, "RT_ALLOCAT", 10);
367 RIOQueueCmdBlk(HostP
, Rup
, CmdBlkP
);
370 ** If this is a freshly booted RTA, then we need to re-open
371 ** the ports, if any where open, so that data may once more
372 ** flow around the system!
374 if ((HostP
->Mapping
[ThisUnit
].Flags
& RTA_NEWBOOT
) && (HostP
->Mapping
[ThisUnit
].SysPort
!= NO_PORT
)) {
376 ** look at the ports associated with this beast and
377 ** see if any where open. If they was, then re-open
378 ** them, using the info from the tty flags.
380 for (port
= 0; port
< PORTS_PER_RTA
; port
++) {
381 PortP
= p
->RIOPortp
[port
+ HostP
->Mapping
[ThisUnit
].SysPort
];
382 if (PortP
->State
& (RIO_MOPEN
| RIO_LOPEN
)) {
383 rio_dprintk(RIO_DEBUG_ROUTE
, "Re-opened this port\n");
384 rio_spin_lock_irqsave(&PortP
->portSem
, flags
);
385 PortP
->MagicFlags
|= MAGIC_REBOOT
;
386 rio_spin_unlock_irqrestore(&PortP
->portSem
, flags
);
389 if (RtaType
== TYPE_RTA16
) {
390 for (port
= 0; port
< PORTS_PER_RTA
; port
++) {
391 PortP
= p
->RIOPortp
[port
+ HostP
->Mapping
[ThisUnit2
].SysPort
];
392 if (PortP
->State
& (RIO_MOPEN
| RIO_LOPEN
)) {
393 rio_dprintk(RIO_DEBUG_ROUTE
, "Re-opened this port\n");
394 rio_spin_lock_irqsave(&PortP
->portSem
, flags
);
395 PortP
->MagicFlags
|= MAGIC_REBOOT
;
396 rio_spin_unlock_irqrestore(&PortP
->portSem
, flags
);
403 ** keep a copy of the module types!
405 HostP
->UnixRups
[ThisUnit
].ModTypes
= Mod
;
406 if (RtaType
== TYPE_RTA16
)
407 HostP
->UnixRups
[ThisUnit2
].ModTypes
= Mod
;
410 ** If either of the modules on this unit is read-only or write-only
411 ** or none-xprint, then we need to transfer that info over to the
414 if (HostP
->Mapping
[ThisUnit
].SysPort
!= NO_PORT
) {
415 for (port
= 0; port
< PORTS_PER_MODULE
; port
++) {
416 p
->RIOPortp
[port
+ HostP
->Mapping
[ThisUnit
].SysPort
]->Config
&= ~RIO_NOMASK
;
417 p
->RIOPortp
[port
+ HostP
->Mapping
[ThisUnit
].SysPort
]->Config
|= p
->RIOModuleTypes
[Mod1
].Flags
[port
];
418 p
->RIOPortp
[port
+ PORTS_PER_MODULE
+ HostP
->Mapping
[ThisUnit
].SysPort
]->Config
&= ~RIO_NOMASK
;
419 p
->RIOPortp
[port
+ PORTS_PER_MODULE
+ HostP
->Mapping
[ThisUnit
].SysPort
]->Config
|= p
->RIOModuleTypes
[Mod2
].Flags
[port
];
421 if (RtaType
== TYPE_RTA16
) {
422 for (port
= 0; port
< PORTS_PER_MODULE
; port
++) {
423 p
->RIOPortp
[port
+ HostP
->Mapping
[ThisUnit2
].SysPort
]->Config
&= ~RIO_NOMASK
;
424 p
->RIOPortp
[port
+ HostP
->Mapping
[ThisUnit2
].SysPort
]->Config
|= p
->RIOModuleTypes
[Mod1
].Flags
[port
];
425 p
->RIOPortp
[port
+ PORTS_PER_MODULE
+ HostP
->Mapping
[ThisUnit2
].SysPort
]->Config
&= ~RIO_NOMASK
;
426 p
->RIOPortp
[port
+ PORTS_PER_MODULE
+ HostP
->Mapping
[ThisUnit2
].SysPort
]->Config
|= p
->RIOModuleTypes
[Mod2
].Flags
[port
];
432 ** Job done, get on with the interrupts!
438 ** There is no table entry for this RTA at all.
440 ** Lets check to see if we actually booted this unit - if not,
441 ** then we reset it and it will go round the loop of being booted
442 ** we can then worry about trying to fit it into the table.
444 for (ThisUnit
= 0; ThisUnit
< HostP
->NumExtraBooted
; ThisUnit
++)
445 if (HostP
->ExtraUnits
[ThisUnit
] == RtaUniq
)
447 if (ThisUnit
== HostP
->NumExtraBooted
&& ThisUnit
!= MAX_EXTRA_UNITS
) {
449 ** if the unit wasn't in the table, and the table wasn't full, then
450 ** we reset the unit, because we didn't boot it.
451 ** However, if the table is full, it could be that we did boot
452 ** this unit, and so we won't reboot it, because it isn't really
453 ** all that disastrous to keep the old bins in most cases. This
454 ** is a rather tacky feature, but we are on the edge of reallity
455 ** here, because the implication is that someone has connected
456 ** 16+MAX_EXTRA_UNITS onto one host.
458 static int UnknownMesgDone
= 0;
460 if (!UnknownMesgDone
) {
461 if (!p
->RIONoMessage
)
462 printk(KERN_DEBUG
"rio: One or more unknown RTAs are being updated.\n");
466 PktReplyP
->Command
= ROUTE_FOAD
;
467 memcpy(PktReplyP
->CommandText
, "RT_FOAD", 7);
470 ** we did boot it (as an extra), and there may now be a table
471 ** slot free (because of a delete), so we will try to make
472 ** a tentative entry for it, so that the configurator can see it
473 ** and fill in the details for us.
475 if (RtaType
== TYPE_RTA16
) {
476 if (RIOFindFreeID(p
, HostP
, &ThisUnit
, &ThisUnit2
) == 0) {
477 RIODefaultName(p
, HostP
, ThisUnit
);
478 rio_fill_host_slot(ThisUnit
, ThisUnit2
, RtaUniq
, HostP
);
481 if (RIOFindFreeID(p
, HostP
, &ThisUnit
, NULL
) == 0) {
482 RIODefaultName(p
, HostP
, ThisUnit
);
483 rio_fill_host_slot(ThisUnit
, 0, RtaUniq
, HostP
);
486 PktReplyP
->Command
= ROUTE_USED
;
487 memcpy(PktReplyP
->CommandText
, "RT_USED", 7);
489 RIOQueueCmdBlk(HostP
, Rup
, CmdBlkP
);
494 void RIOFixPhbs(struct rio_info
*p
, struct Host
*HostP
, unsigned int unit
)
496 unsigned short link
, port
;
499 int PortN
= HostP
->Mapping
[unit
].SysPort
;
501 rio_dprintk(RIO_DEBUG_ROUTE
, "RIOFixPhbs unit %d sysport %d\n", unit
, PortN
);
504 unsigned short dest_unit
= HostP
->Mapping
[unit
].ID2
;
507 ** Get the link number used for the 1st 8 phbs on this unit.
509 PortP
= p
->RIOPortp
[HostP
->Mapping
[dest_unit
- 1].SysPort
];
511 link
= readw(&PortP
->PhbP
->link
);
513 for (port
= 0; port
< PORTS_PER_RTA
; port
++, PortN
++) {
514 unsigned short dest_port
= port
+ 8;
516 struct PKT __iomem
*Pkt
;
518 PortP
= p
->RIOPortp
[PortN
];
520 rio_spin_lock_irqsave(&PortP
->portSem
, flags
);
522 ** If RTA is not powered on, the tx packets will be
523 ** unset, so go no further.
525 if (!PortP
->TxStart
) {
526 rio_dprintk(RIO_DEBUG_ROUTE
, "Tx pkts not set up yet\n");
527 rio_spin_unlock_irqrestore(&PortP
->portSem
, flags
);
532 ** For the second slot of a 16 port RTA, the driver needs to
533 ** sort out the phb to port mappings. The dest_unit for this
534 ** group of 8 phbs is set to the dest_unit of the accompanying
535 ** 8 port block. The dest_port of the second unit is set to
536 ** be in the range 8-15 (i.e. 8 is added). Thus, for a 16 port
537 ** RTA with IDs 5 and 6, traffic bound for port 6 of unit 6
538 ** (being the second map ID) will be sent to dest_unit 5, port
539 ** 14. When this RTA is deleted, dest_unit for ID 6 will be
540 ** restored, and the dest_port will be reduced by 8.
541 ** Transmit packets also have a destination field which needs
542 ** adjusting in the same manner.
543 ** Note that the unit/port bytes in 'dest' are swapped.
544 ** We also need to adjust the phb and rup link numbers for the
545 ** second block of 8 ttys.
547 for (TxPktP
= PortP
->TxStart
; TxPktP
<= PortP
->TxEnd
; TxPktP
++) {
549 ** *TxPktP is the pointer to the transmit packet on the host
550 ** card. This needs to be translated into a 32 bit pointer
551 ** so it can be accessed from the driver.
553 Pkt
= (struct PKT __iomem
*) RIO_PTR(HostP
->Caddr
, readw(TxPktP
));
556 ** If the packet is used, reset it.
558 Pkt
= (struct PKT __iomem
*) ((unsigned long) Pkt
& ~PKT_IN_USE
);
559 writeb(dest_unit
, &Pkt
->dest_unit
);
560 writeb(dest_port
, &Pkt
->dest_port
);
562 rio_dprintk(RIO_DEBUG_ROUTE
, "phb dest: Old %x:%x New %x:%x\n", readw(&PortP
->PhbP
->destination
) & 0xff, (readw(&PortP
->PhbP
->destination
) >> 8) & 0xff, dest_unit
, dest_port
);
563 writew(dest_unit
+ (dest_port
<< 8), &PortP
->PhbP
->destination
);
564 writew(link
, &PortP
->PhbP
->link
);
566 rio_spin_unlock_irqrestore(&PortP
->portSem
, flags
);
569 ** Now make sure the range of ports to be serviced includes
570 ** the 2nd 8 on this 16 port RTA.
574 if (((unit
* 8) + 7) > readw(&HostP
->LinkStrP
[link
].last_port
)) {
575 rio_dprintk(RIO_DEBUG_ROUTE
, "last port on host link %d: %d\n", link
, (unit
* 8) + 7);
576 writew((unit
* 8) + 7, &HostP
->LinkStrP
[link
].last_port
);
582 ** Check to see if the new disconnection has isolated this unit.
583 ** If it has, then invalidate all its link information, and tell
584 ** the world about it. This is done to ensure that the configurator
585 ** only gets up-to-date information about what is going on.
587 static int RIOCheckIsolated(struct rio_info
*p
, struct Host
*HostP
, unsigned int UnitId
)
590 rio_spin_lock_irqsave(&HostP
->HostLock
, flags
);
592 if (RIOCheck(HostP
, UnitId
)) {
593 rio_dprintk(RIO_DEBUG_ROUTE
, "Unit %d is NOT isolated\n", UnitId
);
594 rio_spin_unlock_irqrestore(&HostP
->HostLock
, flags
);
598 RIOIsolate(p
, HostP
, UnitId
);
600 rio_spin_unlock_irqrestore(&HostP
->HostLock
, flags
);
605 ** Invalidate all the link interconnectivity of this unit, and of
606 ** all the units attached to it. This will mean that the entire
607 ** subnet will re-introduce itself.
609 static int RIOIsolate(struct rio_info
*p
, struct Host
*HostP
, unsigned int UnitId
)
611 unsigned int link
, unit
;
613 UnitId
--; /* this trick relies on the Unit Id being UNSIGNED! */
615 if (UnitId
>= MAX_RUP
) /* dontcha just lurv unsigned maths! */
618 if (HostP
->Mapping
[UnitId
].Flags
& BEEN_HERE
)
621 HostP
->Mapping
[UnitId
].Flags
|= BEEN_HERE
;
623 if (p
->RIOPrintDisabled
== DO_PRINT
)
624 rio_dprintk(RIO_DEBUG_ROUTE
, "RIOMesgIsolated %s", HostP
->Mapping
[UnitId
].Name
);
626 for (link
= 0; link
< LINKS_PER_UNIT
; link
++) {
627 unit
= HostP
->Mapping
[UnitId
].Topology
[link
].Unit
;
628 HostP
->Mapping
[UnitId
].Topology
[link
].Unit
= ROUTE_DISCONNECT
;
629 HostP
->Mapping
[UnitId
].Topology
[link
].Link
= NO_LINK
;
630 RIOIsolate(p
, HostP
, unit
);
632 HostP
->Mapping
[UnitId
].Flags
&= ~BEEN_HERE
;
636 static int RIOCheck(struct Host
*HostP
, unsigned int UnitId
)
640 /* rio_dprint(RIO_DEBUG_ROUTE, ("Check to see if unit %d has a route to the host\n",UnitId)); */
641 rio_dprintk(RIO_DEBUG_ROUTE
, "RIOCheck : UnitID = %d\n", UnitId
);
643 if (UnitId
== HOST_ID
) {
644 /* rio_dprint(RIO_DEBUG_ROUTE, ("Unit %d is NOT isolated - it IS the host!\n", UnitId)); */
650 if (UnitId
>= MAX_RUP
) {
651 /* rio_dprint(RIO_DEBUG_ROUTE, ("Unit %d - ignored.\n", UnitId)); */
655 for (link
= 0; link
< LINKS_PER_UNIT
; link
++) {
656 if (HostP
->Mapping
[UnitId
].Topology
[link
].Unit
== HOST_ID
) {
657 /* rio_dprint(RIO_DEBUG_ROUTE, ("Unit %d is connected directly to host via link (%c).\n",
658 UnitId, 'A'+link)); */
663 if (HostP
->Mapping
[UnitId
].Flags
& BEEN_HERE
) {
664 /* rio_dprint(RIO_DEBUG_ROUTE, ("Been to Unit %d before - ignoring\n", UnitId)); */
668 HostP
->Mapping
[UnitId
].Flags
|= BEEN_HERE
;
670 for (link
= 0; link
< LINKS_PER_UNIT
; link
++) {
671 /* rio_dprint(RIO_DEBUG_ROUTE, ("Unit %d check link (%c)\n", UnitId,'A'+link)); */
672 if (RIOCheck(HostP
, HostP
->Mapping
[UnitId
].Topology
[link
].Unit
)) {
673 /* rio_dprint(RIO_DEBUG_ROUTE, ("Unit %d is connected to something that knows the host via link (%c)\n", UnitId,link+'A')); */
674 HostP
->Mapping
[UnitId
].Flags
&= ~BEEN_HERE
;
679 HostP
->Mapping
[UnitId
].Flags
&= ~BEEN_HERE
;
681 /* rio_dprint(RIO_DEBUG_ROUTE, ("Unit %d DOESN'T KNOW THE HOST!\n", UnitId)); */
687 ** Returns the type of unit (host, 16/8 port RTA)
690 unsigned int GetUnitType(unsigned int Uniq
)
692 switch ((Uniq
>> 28) & 0xf) {
697 rio_dprintk(RIO_DEBUG_ROUTE
, "Unit type: Host\n");
700 rio_dprintk(RIO_DEBUG_ROUTE
, "Unit type: 16 port RTA\n");
703 rio_dprintk(RIO_DEBUG_ROUTE
, "Unit type: 8 port RTA\n");
706 rio_dprintk(RIO_DEBUG_ROUTE
, "Unit type: Unrecognised\n");
711 int RIOSetChange(struct rio_info
*p
)
713 if (p
->RIOQuickCheck
!= NOT_CHANGED
)
715 p
->RIOQuickCheck
= CHANGED
;
716 if (p
->RIOSignalProcess
) {
717 rio_dprintk(RIO_DEBUG_ROUTE
, "Send SIG-HUP");
719 psignal( RIOSignalProcess, SIGHUP );
725 static void RIOConCon(struct rio_info
*p
,
728 unsigned int FromLink
,
740 ** 15.10.1998 ARG - ESIL 0759
741 ** (Part) fix for port being trashed when opened whilst RTA "disconnected"
743 ** What's this doing in here anyway ?
744 ** It was causing the port to be 'unmapped' if opened whilst RTA "disconnected"
746 ** 09.12.1998 ARG - ESIL 0776 - part fix
747 ** Okay, We've found out what this was all about now !
748 ** Someone had botched this to use RIOHalted to indicated the number of RTAs
749 ** 'disconnected'. The value in RIOHalted was then being used in the
750 ** 'RIO_QUICK_CHECK' ioctl. A none zero value indicating that a least one RTA
751 ** is 'disconnected'. The change was put in to satisfy a customer's needs.
752 ** Having taken this bit of code out 'RIO_QUICK_CHECK' now no longer works for
755 if (Change == CONNECT) {
756 if (p->RIOHalted) p->RIOHalted --;
762 ** So - we need to implement it slightly differently - a new member of the
763 ** rio_info struct - RIORtaDisCons (RIO RTA connections) keeps track of RTA
764 ** connections and disconnections.
766 if (Change
== CONNECT
) {
767 if (p
->RIORtaDisCons
)
773 if (p
->RIOPrintDisabled
== DONT_PRINT
)
785 FromName
= FromId
? HostP
->Mapping
[FromId
- 1].Name
: HostP
->Name
;
786 FromType
= FromId
? "RTA" : "HOST";
787 ToName
= ToId
? HostP
->Mapping
[ToId
- 1].Name
: HostP
->Name
;
788 ToType
= ToId
? "RTA" : "HOST";
790 rio_dprintk(RIO_DEBUG_ROUTE
, "Link between %s '%s' (%c) and %s '%s' (%c) %s.\n", FromType
, FromName
, 'A' + FromLink
, ToType
, ToName
, 'A' + ToLink
, (Change
== CONNECT
) ? "established" : "disconnected");
791 printk(KERN_DEBUG
"rio: Link between %s '%s' (%c) and %s '%s' (%c) %s.\n", FromType
, FromName
, 'A' + FromLink
, ToType
, ToName
, 'A' + ToLink
, (Change
== CONNECT
) ? "established" : "disconnected");
795 ** RIORemoveFromSavedTable :
797 ** Delete and RTA entry from the saved table given to us
798 ** by the configuration program.
800 static int RIORemoveFromSavedTable(struct rio_info
*p
, struct Map
*pMap
)
805 ** We loop for all entries even after finding an entry and
806 ** zeroing it because we may have two entries to delete if
807 ** it's a 16 port RTA.
809 for (entry
= 0; entry
< TOTAL_MAP_ENTRIES
; entry
++) {
810 if (p
->RIOSavedTable
[entry
].RtaUniqueNum
== pMap
->RtaUniqueNum
) {
811 memset(&p
->RIOSavedTable
[entry
], 0, sizeof(struct Map
));
819 ** RIOCheckDisconnected :
821 ** Scan the unit links to and return zero if the unit is completely
824 static int RIOFreeDisconnected(struct rio_info
*p
, struct Host
*HostP
, int unit
)
829 rio_dprintk(RIO_DEBUG_ROUTE
, "RIOFreeDisconnect unit %d\n", unit
);
831 ** If the slot is tentative and does not belong to the
832 ** second half of a 16 port RTA then scan to see if
835 for (link
= 0; link
< LINKS_PER_UNIT
; link
++) {
836 if (HostP
->Mapping
[unit
].Topology
[link
].Unit
!= ROUTE_DISCONNECT
)
841 ** If not all links are disconnected then we can forget about it.
843 if (link
< LINKS_PER_UNIT
)
846 #ifdef NEED_TO_FIX_THIS
847 /* Ok so all the links are disconnected. But we may have only just
848 ** made this slot tentative and not yet received a topology update.
849 ** Lets check how long ago we made it tentative.
851 rio_dprintk(RIO_DEBUG_ROUTE
, "Just about to check LBOLT on entry %d\n", unit
);
852 if (drv_getparm(LBOLT
, (ulong_t
*) & current_time
))
853 rio_dprintk(RIO_DEBUG_ROUTE
, "drv_getparm(LBOLT,....) Failed.\n");
855 elapse_time
= current_time
- TentTime
[unit
];
856 rio_dprintk(RIO_DEBUG_ROUTE
, "elapse %d = current %d - tent %d (%d usec)\n", elapse_time
, current_time
, TentTime
[unit
], drv_hztousec(elapse_time
));
857 if (drv_hztousec(elapse_time
) < WAIT_TO_FINISH
) {
858 rio_dprintk(RIO_DEBUG_ROUTE
, "Skipping slot %d, not timed out yet %d\n", unit
, drv_hztousec(elapse_time
));
864 ** We have found an usable slot.
865 ** If it is half of a 16 port RTA then delete the other half.
867 if (HostP
->Mapping
[unit
].ID2
!= 0) {
868 int nOther
= (HostP
->Mapping
[unit
].ID2
) - 1;
870 rio_dprintk(RIO_DEBUG_ROUTE
, "RioFreedis second slot %d.\n", nOther
);
871 memset(&HostP
->Mapping
[nOther
], 0, sizeof(struct Map
));
873 RIORemoveFromSavedTable(p
, &HostP
->Mapping
[unit
]);
882 ** This function scans the given host table for either one
883 ** or two free unit ID's.
886 int RIOFindFreeID(struct rio_info
*p
, struct Host
*HostP
, unsigned int * pID1
, unsigned int * pID2
)
891 ** Initialise the ID's to MAX_RUP.
892 ** We do this to make the loop for setting the ID's as simple as
900 ** Scan all entries of the host mapping table for free slots.
901 ** We scan for free slots first and then if that is not successful
902 ** we start all over again looking for tentative slots we can re-use.
904 for (unit
= 0; unit
< MAX_RUP
; unit
++) {
905 rio_dprintk(RIO_DEBUG_ROUTE
, "Scanning unit %d\n", unit
);
907 ** If the flags are zero then the slot is empty.
909 if (HostP
->Mapping
[unit
].Flags
== 0) {
910 rio_dprintk(RIO_DEBUG_ROUTE
, " This slot is empty.\n");
912 ** If we haven't allocated the first ID then do it now.
914 if (*pID1
== MAX_RUP
) {
915 rio_dprintk(RIO_DEBUG_ROUTE
, "Make tentative entry for first unit %d\n", unit
);
919 ** If the second ID is not needed then we can return
926 ** Allocate the second slot and return.
928 rio_dprintk(RIO_DEBUG_ROUTE
, "Make tentative entry for second unit %d\n", unit
);
936 ** If we manage to come out of the free slot loop then we
937 ** need to start all over again looking for tentative slots
938 ** that we can re-use.
940 rio_dprintk(RIO_DEBUG_ROUTE
, "Starting to scan for tentative slots\n");
941 for (unit
= 0; unit
< MAX_RUP
; unit
++) {
942 if (((HostP
->Mapping
[unit
].Flags
& SLOT_TENTATIVE
) || (HostP
->Mapping
[unit
].Flags
== 0)) && !(HostP
->Mapping
[unit
].Flags
& RTA16_SECOND_SLOT
)) {
943 rio_dprintk(RIO_DEBUG_ROUTE
, " Slot %d looks promising.\n", unit
);
946 rio_dprintk(RIO_DEBUG_ROUTE
, " No it isn't, its the 1st half\n");
951 ** Slot is Tentative or Empty, but not a tentative second
952 ** slot of a 16 porter.
953 ** Attempt to free up this slot (and its parnter if
954 ** it is a 16 port slot. The second slot will become
955 ** empty after a call to RIOFreeDisconnected so thats why
956 ** we look for empty slots above as well).
958 if (HostP
->Mapping
[unit
].Flags
!= 0)
959 if (RIOFreeDisconnected(p
, HostP
, unit
) != 0)
962 ** If we haven't allocated the first ID then do it now.
964 if (*pID1
== MAX_RUP
) {
965 rio_dprintk(RIO_DEBUG_ROUTE
, "Grab tentative entry for first unit %d\n", unit
);
969 ** Clear out this slot now that we intend to use it.
971 memset(&HostP
->Mapping
[unit
], 0, sizeof(struct Map
));
974 ** If the second ID is not needed then we can return
981 ** Allocate the second slot and return.
983 rio_dprintk(RIO_DEBUG_ROUTE
, "Grab tentative/empty entry for second unit %d\n", unit
);
987 ** Clear out this slot now that we intend to use it.
989 memset(&HostP
->Mapping
[unit
], 0, sizeof(struct Map
));
991 /* At this point under the right(wrong?) conditions
992 ** we may have a first unit ID being higher than the
993 ** second unit ID. This is a bad idea if we are about
994 ** to fill the slots with a 16 port RTA.
995 ** Better check and swap them over.
999 rio_dprintk(RIO_DEBUG_ROUTE
, "Swapping IDS %d %d\n", *pID1
, *pID2
);
1010 ** If we manage to get to the end of the second loop then we
1011 ** can give up and return a failure.
1018 ** The link switch scenario.
1020 ** Rta Wun (A) is connected to Tuw (A).
1021 ** The tables are all up to date, and the system is OK.
1023 ** If Wun (A) is now moved to Wun (B) before Wun (A) can
1024 ** become disconnected, then the follow happens:
1026 ** Tuw (A) spots the change of unit:link at the other end
1027 ** of its link and Tuw sends a topology packet reflecting
1028 ** the change: Tuw (A) now disconnected from Wun (A), and
1029 ** this is closely followed by a packet indicating that
1030 ** Tuw (A) is now connected to Wun (B).
1032 ** Wun (B) will spot that it has now become connected, and
1033 ** Wun will send a topology packet, which indicates that
1034 ** both Wun (A) and Wun (B) is connected to Tuw (A).
1036 ** Eventually Wun (A) realises that it is now disconnected
1037 ** and Wun will send out a topology packet indicating that
1038 ** Wun (A) is now disconnected.