Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | ** ----------------------------------------------------------------------------- | |
3 | ** | |
4 | ** Perle Specialix driver for Linux | |
5 | ** Ported from existing RIO Driver for SCO sources. | |
6 | * | |
7 | * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK. | |
8 | * | |
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. | |
13 | * | |
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. | |
18 | * | |
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. | |
22 | ** | |
23 | ** Module : riotable.c | |
24 | ** SID : 1.2 | |
25 | ** Last Modified : 11/6/98 10:33:47 | |
26 | ** Retrieved : 11/6/98 10:33:50 | |
27 | ** | |
28 | ** ident @(#)riotable.c 1.2 | |
29 | ** | |
30 | ** ----------------------------------------------------------------------------- | |
31 | */ | |
1da177e4 LT |
32 | |
33 | #include <linux/module.h> | |
34 | #include <linux/slab.h> | |
35 | #include <linux/errno.h> | |
36 | #include <linux/interrupt.h> | |
37 | #include <linux/string.h> | |
38 | ||
39 | #include <asm/io.h> | |
40 | #include <asm/system.h> | |
41 | #include <asm/string.h> | |
1da177e4 LT |
42 | #include <asm/uaccess.h> |
43 | ||
44 | #include <linux/termios.h> | |
45 | #include <linux/serial.h> | |
46 | ||
47 | #include <linux/generic_serial.h> | |
48 | ||
49 | ||
50 | #include "linux_compat.h" | |
51 | #include "rio_linux.h" | |
1da177e4 LT |
52 | #include "pkt.h" |
53 | #include "daemon.h" | |
54 | #include "rio.h" | |
55 | #include "riospace.h" | |
1da177e4 LT |
56 | #include "cmdpkt.h" |
57 | #include "map.h" | |
1da177e4 LT |
58 | #include "rup.h" |
59 | #include "port.h" | |
60 | #include "riodrvr.h" | |
61 | #include "rioinfo.h" | |
62 | #include "func.h" | |
63 | #include "errors.h" | |
64 | #include "pci.h" | |
65 | ||
66 | #include "parmmap.h" | |
67 | #include "unixrup.h" | |
68 | #include "board.h" | |
69 | #include "host.h" | |
1da177e4 LT |
70 | #include "phb.h" |
71 | #include "link.h" | |
72 | #include "cmdblk.h" | |
73 | #include "route.h" | |
1da177e4 LT |
74 | #include "cirrus.h" |
75 | #include "rioioctl.h" | |
76 | #include "param.h" | |
1da177e4 LT |
77 | #include "protsts.h" |
78 | ||
79 | /* | |
80 | ** A configuration table has been loaded. It is now up to us | |
81 | ** to sort it out and use the information contained therein. | |
82 | */ | |
e2b3afd6 | 83 | int RIONewTable(struct rio_info *p) |
1da177e4 LT |
84 | { |
85 | int Host, Host1, Host2, NameIsUnique, Entry, SubEnt; | |
86 | struct Map *MapP; | |
87 | struct Map *HostMapP; | |
88 | struct Host *HostP; | |
89 | ||
90 | char *cptr; | |
91 | ||
92 | /* | |
8d8706e2 AM |
93 | ** We have been sent a new table to install. We need to break |
94 | ** it down into little bits and spread it around a bit to see | |
95 | ** what we have got. | |
96 | */ | |
1da177e4 | 97 | /* |
8d8706e2 AM |
98 | ** Things to check: |
99 | ** (things marked 'xx' aren't checked any more!) | |
100 | ** (1) That there are no booted Hosts/RTAs out there. | |
101 | ** (2) That the names are properly formed | |
102 | ** (3) That blank entries really are. | |
103 | ** xx (4) That hosts mentioned in the table actually exist. xx | |
104 | ** (5) That the IDs are unique (per host). | |
105 | ** (6) That host IDs are zero | |
106 | ** (7) That port numbers are valid | |
107 | ** (8) That port numbers aren't duplicated | |
108 | ** (9) That names aren't duplicated | |
109 | ** xx (10) That hosts that actually exist are mentioned in the table. xx | |
110 | */ | |
111 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(1)\n"); | |
112 | if (p->RIOSystemUp) { /* (1) */ | |
1da177e4 LT |
113 | p->RIOError.Error = HOST_HAS_ALREADY_BEEN_BOOTED; |
114 | return -EBUSY; | |
115 | } | |
116 | ||
117 | p->RIOError.Error = NOTHING_WRONG_AT_ALL; | |
118 | p->RIOError.Entry = -1; | |
119 | p->RIOError.Other = -1; | |
120 | ||
8d8706e2 | 121 | for (Entry = 0; Entry < TOTAL_MAP_ENTRIES; Entry++) { |
1da177e4 LT |
122 | MapP = &p->RIOConnectTable[Entry]; |
123 | if ((MapP->Flags & RTA16_SECOND_SLOT) == 0) { | |
8d8706e2 AM |
124 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(2)\n"); |
125 | cptr = MapP->Name; /* (2) */ | |
126 | cptr[MAX_NAME_LEN - 1] = '\0'; | |
127 | if (cptr[0] == '\0') { | |
554b7c80 | 128 | memcpy(MapP->Name, MapP->RtaUniqueNum ? "RTA NN" : "HOST NN", 8); |
8d8706e2 AM |
129 | MapP->Name[5] = '0' + Entry / 10; |
130 | MapP->Name[6] = '0' + Entry % 10; | |
1da177e4 | 131 | } |
8d8706e2 AM |
132 | while (*cptr) { |
133 | if (*cptr < ' ' || *cptr > '~') { | |
1da177e4 LT |
134 | p->RIOError.Error = BAD_CHARACTER_IN_NAME; |
135 | p->RIOError.Entry = Entry; | |
136 | return -ENXIO; | |
137 | } | |
138 | cptr++; | |
139 | } | |
140 | } | |
141 | ||
142 | /* | |
8d8706e2 AM |
143 | ** If the entry saved was a tentative entry then just forget |
144 | ** about it. | |
145 | */ | |
146 | if (MapP->Flags & SLOT_TENTATIVE) { | |
1da177e4 LT |
147 | MapP->HostUniqueNum = 0; |
148 | MapP->RtaUniqueNum = 0; | |
149 | continue; | |
150 | } | |
151 | ||
8d8706e2 AM |
152 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(3)\n"); |
153 | if (!MapP->RtaUniqueNum && !MapP->HostUniqueNum) { /* (3) */ | |
154 | if (MapP->ID || MapP->SysPort || MapP->Flags) { | |
155 | rio_dprintk(RIO_DEBUG_TABLE, "%s pretending to be empty but isn't\n", MapP->Name); | |
1da177e4 LT |
156 | p->RIOError.Error = TABLE_ENTRY_ISNT_PROPERLY_NULL; |
157 | p->RIOError.Entry = Entry; | |
158 | return -ENXIO; | |
159 | } | |
8d8706e2 | 160 | rio_dprintk(RIO_DEBUG_TABLE, "!RIO: Daemon: test (3) passes\n"); |
1da177e4 LT |
161 | continue; |
162 | } | |
163 | ||
8d8706e2 AM |
164 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(4)\n"); |
165 | for (Host = 0; Host < p->RIONumHosts; Host++) { /* (4) */ | |
166 | if (p->RIOHosts[Host].UniqueNum == MapP->HostUniqueNum) { | |
1da177e4 LT |
167 | HostP = &p->RIOHosts[Host]; |
168 | /* | |
8d8706e2 AM |
169 | ** having done the lookup, we don't really want to do |
170 | ** it again, so hang the host number in a safe place | |
171 | */ | |
1da177e4 LT |
172 | MapP->Topology[0].Unit = Host; |
173 | break; | |
174 | } | |
175 | } | |
176 | ||
8d8706e2 AM |
177 | if (Host >= p->RIONumHosts) { |
178 | rio_dprintk(RIO_DEBUG_TABLE, "RTA %s has unknown host unique number 0x%x\n", MapP->Name, MapP->HostUniqueNum); | |
1da177e4 | 179 | MapP->HostUniqueNum = 0; |
8d8706e2 AM |
180 | /* MapP->RtaUniqueNum = 0; */ |
181 | /* MapP->ID = 0; */ | |
182 | /* MapP->Flags = 0; */ | |
183 | /* MapP->SysPort = 0; */ | |
184 | /* MapP->Name[0] = 0; */ | |
1da177e4 LT |
185 | continue; |
186 | } | |
187 | ||
8d8706e2 AM |
188 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(5)\n"); |
189 | if (MapP->RtaUniqueNum) { /* (5) */ | |
190 | if (!MapP->ID) { | |
191 | rio_dprintk(RIO_DEBUG_TABLE, "RIO: RTA %s has been allocated an ID of zero!\n", MapP->Name); | |
192 | p->RIOError.Error = ZERO_RTA_ID; | |
1da177e4 LT |
193 | p->RIOError.Entry = Entry; |
194 | return -ENXIO; | |
195 | } | |
8d8706e2 AM |
196 | if (MapP->ID > MAX_RUP) { |
197 | rio_dprintk(RIO_DEBUG_TABLE, "RIO: RTA %s has been allocated an invalid ID %d\n", MapP->Name, MapP->ID); | |
1da177e4 LT |
198 | p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE; |
199 | p->RIOError.Entry = Entry; | |
200 | return -ENXIO; | |
201 | } | |
8d8706e2 AM |
202 | for (SubEnt = 0; SubEnt < Entry; SubEnt++) { |
203 | if (MapP->HostUniqueNum == p->RIOConnectTable[SubEnt].HostUniqueNum && MapP->ID == p->RIOConnectTable[SubEnt].ID) { | |
204 | rio_dprintk(RIO_DEBUG_TABLE, "Dupl. ID number allocated to RTA %s and RTA %s\n", MapP->Name, p->RIOConnectTable[SubEnt].Name); | |
1da177e4 LT |
205 | p->RIOError.Error = DUPLICATED_RTA_ID; |
206 | p->RIOError.Entry = Entry; | |
207 | p->RIOError.Other = SubEnt; | |
208 | return -ENXIO; | |
209 | } | |
210 | /* | |
8d8706e2 AM |
211 | ** If the RtaUniqueNum is the same, it may be looking at both |
212 | ** entries for a 16 port RTA, so check the ids | |
213 | */ | |
214 | if ((MapP->RtaUniqueNum == p->RIOConnectTable[SubEnt].RtaUniqueNum) | |
215 | && (MapP->ID2 != p->RIOConnectTable[SubEnt].ID)) { | |
216 | rio_dprintk(RIO_DEBUG_TABLE, "RTA %s has duplicate unique number\n", MapP->Name); | |
217 | rio_dprintk(RIO_DEBUG_TABLE, "RTA %s has duplicate unique number\n", p->RIOConnectTable[SubEnt].Name); | |
1da177e4 LT |
218 | p->RIOError.Error = DUPLICATE_UNIQUE_NUMBER; |
219 | p->RIOError.Entry = Entry; | |
220 | p->RIOError.Other = SubEnt; | |
221 | return -ENXIO; | |
222 | } | |
223 | } | |
8d8706e2 | 224 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(7a)\n"); |
1da177e4 | 225 | /* (7a) */ |
8d8706e2 AM |
226 | if ((MapP->SysPort != NO_PORT) && (MapP->SysPort % PORTS_PER_RTA)) { |
227 | rio_dprintk(RIO_DEBUG_TABLE, "TTY Port number %d-RTA %s is not a multiple of %d!\n", (int) MapP->SysPort, MapP->Name, PORTS_PER_RTA); | |
1da177e4 LT |
228 | p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE; |
229 | p->RIOError.Entry = Entry; | |
230 | return -ENXIO; | |
231 | } | |
8d8706e2 | 232 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(7b)\n"); |
1da177e4 | 233 | /* (7b) */ |
8d8706e2 AM |
234 | if ((MapP->SysPort != NO_PORT) && (MapP->SysPort >= RIO_PORTS)) { |
235 | rio_dprintk(RIO_DEBUG_TABLE, "TTY Port number %d for RTA %s is too big\n", (int) MapP->SysPort, MapP->Name); | |
1da177e4 LT |
236 | p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE; |
237 | p->RIOError.Entry = Entry; | |
238 | return -ENXIO; | |
239 | } | |
8d8706e2 AM |
240 | for (SubEnt = 0; SubEnt < Entry; SubEnt++) { |
241 | if (p->RIOConnectTable[SubEnt].Flags & RTA16_SECOND_SLOT) | |
242 | continue; | |
243 | if (p->RIOConnectTable[SubEnt].RtaUniqueNum) { | |
244 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(8)\n"); | |
1da177e4 | 245 | /* (8) */ |
8d8706e2 AM |
246 | if ((MapP->SysPort != NO_PORT) && (MapP->SysPort == p->RIOConnectTable[SubEnt].SysPort)) { |
247 | rio_dprintk(RIO_DEBUG_TABLE, "RTA %s:same TTY port # as RTA %s (%d)\n", MapP->Name, p->RIOConnectTable[SubEnt].Name, (int) MapP->SysPort); | |
1da177e4 LT |
248 | p->RIOError.Error = TTY_NUMBER_IN_USE; |
249 | p->RIOError.Entry = Entry; | |
250 | p->RIOError.Other = SubEnt; | |
251 | return -ENXIO; | |
252 | } | |
8d8706e2 AM |
253 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(9)\n"); |
254 | if (strcmp(MapP->Name, p->RIOConnectTable[SubEnt].Name) == 0 && !(MapP->Flags & RTA16_SECOND_SLOT)) { /* (9) */ | |
255 | rio_dprintk(RIO_DEBUG_TABLE, "RTA name %s used twice\n", MapP->Name); | |
1da177e4 LT |
256 | p->RIOError.Error = NAME_USED_TWICE; |
257 | p->RIOError.Entry = Entry; | |
258 | p->RIOError.Other = SubEnt; | |
259 | return -ENXIO; | |
260 | } | |
261 | } | |
262 | } | |
8d8706e2 AM |
263 | } else { /* (6) */ |
264 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(6)\n"); | |
265 | if (MapP->ID) { | |
266 | rio_dprintk(RIO_DEBUG_TABLE, "RIO:HOST %s has been allocated ID that isn't zero!\n", MapP->Name); | |
1da177e4 LT |
267 | p->RIOError.Error = HOST_ID_NOT_ZERO; |
268 | p->RIOError.Entry = Entry; | |
269 | return -ENXIO; | |
270 | } | |
8d8706e2 AM |
271 | if (MapP->SysPort != NO_PORT) { |
272 | rio_dprintk(RIO_DEBUG_TABLE, "RIO: HOST %s has been allocated port numbers!\n", MapP->Name); | |
1da177e4 LT |
273 | p->RIOError.Error = HOST_SYSPORT_BAD; |
274 | p->RIOError.Entry = Entry; | |
275 | return -ENXIO; | |
276 | } | |
277 | } | |
278 | } | |
279 | ||
280 | /* | |
8d8706e2 AM |
281 | ** wow! if we get here then it's a goody! |
282 | */ | |
1da177e4 LT |
283 | |
284 | /* | |
8d8706e2 AM |
285 | ** Zero the (old) entries for each host... |
286 | */ | |
287 | for (Host = 0; Host < RIO_HOSTS; Host++) { | |
288 | for (Entry = 0; Entry < MAX_RUP; Entry++) { | |
e2b3afd6 | 289 | memset(&p->RIOHosts[Host].Mapping[Entry], 0, sizeof(struct Map)); |
1da177e4 | 290 | } |
e2b3afd6 | 291 | memset(&p->RIOHosts[Host].Name[0], 0, sizeof(p->RIOHosts[Host].Name)); |
1da177e4 LT |
292 | } |
293 | ||
294 | /* | |
8d8706e2 AM |
295 | ** Copy in the new table entries |
296 | */ | |
297 | for (Entry = 0; Entry < TOTAL_MAP_ENTRIES; Entry++) { | |
298 | rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: Copy table for Host entry %d\n", Entry); | |
1da177e4 LT |
299 | MapP = &p->RIOConnectTable[Entry]; |
300 | ||
301 | /* | |
8d8706e2 AM |
302 | ** Now, if it is an empty slot ignore it! |
303 | */ | |
304 | if (MapP->HostUniqueNum == 0) | |
1da177e4 LT |
305 | continue; |
306 | ||
307 | /* | |
8d8706e2 AM |
308 | ** we saved the host number earlier, so grab it back |
309 | */ | |
1da177e4 LT |
310 | HostP = &p->RIOHosts[MapP->Topology[0].Unit]; |
311 | ||
312 | /* | |
8d8706e2 AM |
313 | ** If it is a host, then we only need to fill in the name field. |
314 | */ | |
315 | if (MapP->ID == 0) { | |
316 | rio_dprintk(RIO_DEBUG_TABLE, "Host entry found. Name %s\n", MapP->Name); | |
554b7c80 | 317 | memcpy(HostP->Name, MapP->Name, MAX_NAME_LEN); |
1da177e4 LT |
318 | continue; |
319 | } | |
320 | ||
321 | /* | |
8d8706e2 AM |
322 | ** Its an RTA entry, so fill in the host mapping entries for it |
323 | ** and the port mapping entries. Notice that entry zero is for | |
324 | ** ID one. | |
325 | */ | |
326 | HostMapP = &HostP->Mapping[MapP->ID - 1]; | |
1da177e4 LT |
327 | |
328 | if (MapP->Flags & SLOT_IN_USE) { | |
8d8706e2 | 329 | rio_dprintk(RIO_DEBUG_TABLE, "Rta entry found. Name %s\n", MapP->Name); |
1da177e4 | 330 | /* |
8d8706e2 AM |
331 | ** structure assign, then sort out the bits we shouldn't have done |
332 | */ | |
1da177e4 LT |
333 | *HostMapP = *MapP; |
334 | ||
335 | HostMapP->Flags = SLOT_IN_USE; | |
336 | if (MapP->Flags & RTA16_SECOND_SLOT) | |
337 | HostMapP->Flags |= RTA16_SECOND_SLOT; | |
338 | ||
8d8706e2 AM |
339 | RIOReMapPorts(p, HostP, HostMapP); |
340 | } else { | |
341 | rio_dprintk(RIO_DEBUG_TABLE, "TENTATIVE Rta entry found. Name %s\n", MapP->Name); | |
1da177e4 LT |
342 | } |
343 | } | |
344 | ||
8d8706e2 | 345 | for (Entry = 0; Entry < TOTAL_MAP_ENTRIES; Entry++) { |
1da177e4 LT |
346 | p->RIOSavedTable[Entry] = p->RIOConnectTable[Entry]; |
347 | } | |
348 | ||
8d8706e2 AM |
349 | for (Host = 0; Host < p->RIONumHosts; Host++) { |
350 | for (SubEnt = 0; SubEnt < LINKS_PER_UNIT; SubEnt++) { | |
1da177e4 LT |
351 | p->RIOHosts[Host].Topology[SubEnt].Unit = ROUTE_DISCONNECT; |
352 | p->RIOHosts[Host].Topology[SubEnt].Link = NO_LINK; | |
353 | } | |
8d8706e2 AM |
354 | for (Entry = 0; Entry < MAX_RUP; Entry++) { |
355 | for (SubEnt = 0; SubEnt < LINKS_PER_UNIT; SubEnt++) { | |
356 | p->RIOHosts[Host].Mapping[Entry].Topology[SubEnt].Unit = ROUTE_DISCONNECT; | |
357 | p->RIOHosts[Host].Mapping[Entry].Topology[SubEnt].Link = NO_LINK; | |
1da177e4 LT |
358 | } |
359 | } | |
8d8706e2 | 360 | if (!p->RIOHosts[Host].Name[0]) { |
554b7c80 | 361 | memcpy(p->RIOHosts[Host].Name, "HOST 1", 7); |
1da177e4 LT |
362 | p->RIOHosts[Host].Name[5] += Host; |
363 | } | |
364 | /* | |
8d8706e2 AM |
365 | ** Check that default name assigned is unique. |
366 | */ | |
1da177e4 LT |
367 | Host1 = Host; |
368 | NameIsUnique = 0; | |
369 | while (!NameIsUnique) { | |
370 | NameIsUnique = 1; | |
8d8706e2 | 371 | for (Host2 = 0; Host2 < p->RIONumHosts; Host2++) { |
1da177e4 LT |
372 | if (Host2 == Host) |
373 | continue; | |
374 | if (strcmp(p->RIOHosts[Host].Name, p->RIOHosts[Host2].Name) | |
8d8706e2 | 375 | == 0) { |
1da177e4 LT |
376 | NameIsUnique = 0; |
377 | Host1++; | |
378 | if (Host1 >= p->RIONumHosts) | |
379 | Host1 = 0; | |
380 | p->RIOHosts[Host].Name[5] = '1' + Host1; | |
381 | } | |
382 | } | |
383 | } | |
384 | /* | |
8d8706e2 AM |
385 | ** Rename host if name already used. |
386 | */ | |
387 | if (Host1 != Host) { | |
388 | rio_dprintk(RIO_DEBUG_TABLE, "Default name %s already used\n", p->RIOHosts[Host].Name); | |
554b7c80 | 389 | memcpy(p->RIOHosts[Host].Name, "HOST 1", 7); |
1da177e4 LT |
390 | p->RIOHosts[Host].Name[5] += Host1; |
391 | } | |
8d8706e2 | 392 | rio_dprintk(RIO_DEBUG_TABLE, "Assigning default name %s\n", p->RIOHosts[Host].Name); |
1da177e4 LT |
393 | } |
394 | return 0; | |
395 | } | |
396 | ||
397 | /* | |
398 | ** User process needs the config table - build it from first | |
399 | ** principles. | |
e2b3afd6 AC |
400 | ** |
401 | * FIXME: SMP locking | |
1da177e4 | 402 | */ |
e2b3afd6 | 403 | int RIOApel(struct rio_info *p) |
1da177e4 LT |
404 | { |
405 | int Host; | |
406 | int link; | |
407 | int Rup; | |
408 | int Next = 0; | |
409 | struct Map *MapP; | |
410 | struct Host *HostP; | |
e2b3afd6 | 411 | unsigned long flags; |
8d8706e2 AM |
412 | |
413 | rio_dprintk(RIO_DEBUG_TABLE, "Generating a table to return to config.rio\n"); | |
1da177e4 | 414 | |
e2b3afd6 | 415 | memset(&p->RIOConnectTable[0], 0, sizeof(struct Map) * TOTAL_MAP_ENTRIES); |
1da177e4 | 416 | |
8d8706e2 AM |
417 | for (Host = 0; Host < RIO_HOSTS; Host++) { |
418 | rio_dprintk(RIO_DEBUG_TABLE, "Processing host %d\n", Host); | |
1da177e4 | 419 | HostP = &p->RIOHosts[Host]; |
e2b3afd6 AC |
420 | rio_spin_lock_irqsave(&HostP->HostLock, flags); |
421 | ||
1da177e4 LT |
422 | MapP = &p->RIOConnectTable[Next++]; |
423 | MapP->HostUniqueNum = HostP->UniqueNum; | |
212e7bb6 JS |
424 | if ((HostP->Flags & RUN_STATE) != RC_RUNNING) { |
425 | rio_spin_unlock_irqrestore(&HostP->HostLock, flags); | |
1da177e4 | 426 | continue; |
212e7bb6 | 427 | } |
1da177e4 LT |
428 | MapP->RtaUniqueNum = 0; |
429 | MapP->ID = 0; | |
430 | MapP->Flags = SLOT_IN_USE; | |
431 | MapP->SysPort = NO_PORT; | |
8d8706e2 | 432 | for (link = 0; link < LINKS_PER_UNIT; link++) |
1da177e4 | 433 | MapP->Topology[link] = HostP->Topology[link]; |
554b7c80 | 434 | memcpy(MapP->Name, HostP->Name, MAX_NAME_LEN); |
8d8706e2 AM |
435 | for (Rup = 0; Rup < MAX_RUP; Rup++) { |
436 | if (HostP->Mapping[Rup].Flags & (SLOT_IN_USE | SLOT_TENTATIVE)) { | |
1da177e4 | 437 | p->RIOConnectTable[Next] = HostP->Mapping[Rup]; |
8d8706e2 | 438 | if (HostP->Mapping[Rup].Flags & SLOT_IN_USE) |
1da177e4 | 439 | p->RIOConnectTable[Next].Flags |= SLOT_IN_USE; |
8d8706e2 | 440 | if (HostP->Mapping[Rup].Flags & SLOT_TENTATIVE) |
1da177e4 | 441 | p->RIOConnectTable[Next].Flags |= SLOT_TENTATIVE; |
8d8706e2 | 442 | if (HostP->Mapping[Rup].Flags & RTA16_SECOND_SLOT) |
1da177e4 LT |
443 | p->RIOConnectTable[Next].Flags |= RTA16_SECOND_SLOT; |
444 | Next++; | |
445 | } | |
446 | } | |
e2b3afd6 | 447 | rio_spin_unlock_irqrestore(&HostP->HostLock, flags); |
1da177e4 | 448 | } |
1da177e4 LT |
449 | return 0; |
450 | } | |
451 | ||
452 | /* | |
453 | ** config.rio has taken a dislike to one of the gross maps entries. | |
454 | ** if the entry is suitably inactive, then we can gob on it and remove | |
455 | ** it from the table. | |
456 | */ | |
e2b3afd6 | 457 | int RIODeleteRta(struct rio_info *p, struct Map *MapP) |
1da177e4 LT |
458 | { |
459 | int host, entry, port, link; | |
460 | int SysPort; | |
461 | struct Host *HostP; | |
462 | struct Map *HostMapP; | |
463 | struct Port *PortP; | |
464 | int work_done = 0; | |
465 | unsigned long lock_flags, sem_flags; | |
466 | ||
8d8706e2 | 467 | rio_dprintk(RIO_DEBUG_TABLE, "Delete entry on host %x, rta %x\n", MapP->HostUniqueNum, MapP->RtaUniqueNum); |
1da177e4 | 468 | |
8d8706e2 | 469 | for (host = 0; host < p->RIONumHosts; host++) { |
1da177e4 LT |
470 | HostP = &p->RIOHosts[host]; |
471 | ||
8d8706e2 | 472 | rio_spin_lock_irqsave(&HostP->HostLock, lock_flags); |
1da177e4 | 473 | |
8d8706e2 | 474 | if ((HostP->Flags & RUN_STATE) != RC_RUNNING) { |
1da177e4 LT |
475 | rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags); |
476 | continue; | |
477 | } | |
478 | ||
8d8706e2 AM |
479 | for (entry = 0; entry < MAX_RUP; entry++) { |
480 | if (MapP->RtaUniqueNum == HostP->Mapping[entry].RtaUniqueNum) { | |
1da177e4 | 481 | HostMapP = &HostP->Mapping[entry]; |
8d8706e2 | 482 | rio_dprintk(RIO_DEBUG_TABLE, "Found entry offset %d on host %s\n", entry, HostP->Name); |
1da177e4 LT |
483 | |
484 | /* | |
8d8706e2 AM |
485 | ** Check all four links of the unit are disconnected |
486 | */ | |
487 | for (link = 0; link < LINKS_PER_UNIT; link++) { | |
488 | if (HostMapP->Topology[link].Unit != ROUTE_DISCONNECT) { | |
489 | rio_dprintk(RIO_DEBUG_TABLE, "Entry is in use and cannot be deleted!\n"); | |
1da177e4 | 490 | p->RIOError.Error = UNIT_IS_IN_USE; |
8d8706e2 | 491 | rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags); |
1da177e4 LT |
492 | return -EBUSY; |
493 | } | |
494 | } | |
495 | /* | |
8d8706e2 AM |
496 | ** Slot has been allocated, BUT not booted/routed/ |
497 | ** connected/selected or anything else-ed | |
498 | */ | |
1da177e4 LT |
499 | SysPort = HostMapP->SysPort; |
500 | ||
8d8706e2 AM |
501 | if (SysPort != NO_PORT) { |
502 | for (port = SysPort; port < SysPort + PORTS_PER_RTA; port++) { | |
1da177e4 | 503 | PortP = p->RIOPortp[port]; |
8d8706e2 | 504 | rio_dprintk(RIO_DEBUG_TABLE, "Unmap port\n"); |
1da177e4 | 505 | |
8d8706e2 | 506 | rio_spin_lock_irqsave(&PortP->portSem, sem_flags); |
1da177e4 LT |
507 | |
508 | PortP->Mapped = 0; | |
509 | ||
8d8706e2 | 510 | if (PortP->State & (RIO_MOPEN | RIO_LOPEN)) { |
1da177e4 | 511 | |
8d8706e2 | 512 | rio_dprintk(RIO_DEBUG_TABLE, "Gob on port\n"); |
1da177e4 LT |
513 | PortP->TxBufferIn = PortP->TxBufferOut = 0; |
514 | /* What should I do | |
8d8706e2 AM |
515 | wakeup( &PortP->TxBufferIn ); |
516 | wakeup( &PortP->TxBufferOut); | |
517 | */ | |
1da177e4 LT |
518 | PortP->InUse = NOT_INUSE; |
519 | /* What should I do | |
8d8706e2 AM |
520 | wakeup( &PortP->InUse ); |
521 | signal(PortP->TtyP->t_pgrp,SIGKILL); | |
522 | ttyflush(PortP->TtyP,(FREAD|FWRITE)); | |
523 | */ | |
1da177e4 LT |
524 | PortP->State |= RIO_CLOSING | RIO_DELETED; |
525 | } | |
526 | ||
527 | /* | |
8d8706e2 AM |
528 | ** For the second slot of a 16 port RTA, the |
529 | ** driver needs to reset the changes made to | |
530 | ** the phb to port mappings in RIORouteRup. | |
531 | */ | |
1da177e4 | 532 | if (PortP->SecondBlock) { |
554b7c80 AC |
533 | u16 dest_unit = HostMapP->ID; |
534 | u16 dest_port = port - SysPort; | |
d886cb58 AV |
535 | u16 __iomem *TxPktP; |
536 | struct PKT __iomem *Pkt; | |
1da177e4 | 537 | |
8d8706e2 | 538 | for (TxPktP = PortP->TxStart; TxPktP <= PortP->TxEnd; TxPktP++) { |
1da177e4 | 539 | /* |
8d8706e2 AM |
540 | ** *TxPktP is the pointer to the |
541 | ** transmit packet on the host card. | |
542 | ** This needs to be translated into | |
543 | ** a 32 bit pointer so it can be | |
544 | ** accessed from the driver. | |
545 | */ | |
d886cb58 | 546 | Pkt = (struct PKT __iomem *) RIO_PTR(HostP->Caddr, readw(&*TxPktP)); |
92af11cd | 547 | rio_dprintk(RIO_DEBUG_TABLE, "Tx packet (%x) destination: Old %x:%x New %x:%x\n", readw(TxPktP), readb(&Pkt->dest_unit), readb(&Pkt->dest_port), dest_unit, dest_port); |
e2b3afd6 AC |
548 | writew(dest_unit, &Pkt->dest_unit); |
549 | writew(dest_port, &Pkt->dest_port); | |
1da177e4 | 550 | } |
92af11cd | 551 | rio_dprintk(RIO_DEBUG_TABLE, "Port %d phb destination: Old %x:%x New %x:%x\n", port, readb(&PortP->PhbP->destination) & 0xff, (readb(&PortP->PhbP->destination) >> 8) & 0xff, dest_unit, dest_port); |
e2b3afd6 | 552 | writew(dest_unit + (dest_port << 8), &PortP->PhbP->destination); |
1da177e4 LT |
553 | } |
554 | rio_spin_unlock_irqrestore(&PortP->portSem, sem_flags); | |
555 | } | |
556 | } | |
8d8706e2 | 557 | rio_dprintk(RIO_DEBUG_TABLE, "Entry nulled.\n"); |
e2b3afd6 | 558 | memset(HostMapP, 0, sizeof(struct Map)); |
1da177e4 LT |
559 | work_done++; |
560 | } | |
561 | } | |
562 | rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags); | |
563 | } | |
564 | ||
565 | /* XXXXX lock me up */ | |
8d8706e2 AM |
566 | for (entry = 0; entry < TOTAL_MAP_ENTRIES; entry++) { |
567 | if (p->RIOSavedTable[entry].RtaUniqueNum == MapP->RtaUniqueNum) { | |
e2b3afd6 | 568 | memset(&p->RIOSavedTable[entry], 0, sizeof(struct Map)); |
1da177e4 LT |
569 | work_done++; |
570 | } | |
8d8706e2 | 571 | if (p->RIOConnectTable[entry].RtaUniqueNum == MapP->RtaUniqueNum) { |
e2b3afd6 | 572 | memset(&p->RIOConnectTable[entry], 0, sizeof(struct Map)); |
1da177e4 LT |
573 | work_done++; |
574 | } | |
575 | } | |
8d8706e2 | 576 | if (work_done) |
1da177e4 LT |
577 | return 0; |
578 | ||
8d8706e2 | 579 | rio_dprintk(RIO_DEBUG_TABLE, "Couldn't find entry to be deleted\n"); |
1da177e4 LT |
580 | p->RIOError.Error = COULDNT_FIND_ENTRY; |
581 | return -ENXIO; | |
582 | } | |
583 | ||
8d8706e2 | 584 | int RIOAssignRta(struct rio_info *p, struct Map *MapP) |
1da177e4 | 585 | { |
8d8706e2 AM |
586 | int host; |
587 | struct Map *HostMapP; | |
588 | char *sptr; | |
589 | int link; | |
590 | ||
591 | ||
592 | rio_dprintk(RIO_DEBUG_TABLE, "Assign entry on host %x, rta %x, ID %d, Sysport %d\n", MapP->HostUniqueNum, MapP->RtaUniqueNum, MapP->ID, (int) MapP->SysPort); | |
593 | ||
554b7c80 | 594 | if ((MapP->ID != (u16) - 1) && ((int) MapP->ID < (int) 1 || (int) MapP->ID > MAX_RUP)) { |
8d8706e2 AM |
595 | rio_dprintk(RIO_DEBUG_TABLE, "Bad ID in map entry!\n"); |
596 | p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE; | |
597 | return -EINVAL; | |
598 | } | |
599 | if (MapP->RtaUniqueNum == 0) { | |
600 | rio_dprintk(RIO_DEBUG_TABLE, "Rta Unique number zero!\n"); | |
601 | p->RIOError.Error = RTA_UNIQUE_NUMBER_ZERO; | |
602 | return -EINVAL; | |
603 | } | |
604 | if ((MapP->SysPort != NO_PORT) && (MapP->SysPort % PORTS_PER_RTA)) { | |
605 | rio_dprintk(RIO_DEBUG_TABLE, "Port %d not multiple of %d!\n", (int) MapP->SysPort, PORTS_PER_RTA); | |
606 | p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE; | |
607 | return -EINVAL; | |
608 | } | |
609 | if ((MapP->SysPort != NO_PORT) && (MapP->SysPort >= RIO_PORTS)) { | |
610 | rio_dprintk(RIO_DEBUG_TABLE, "Port %d not valid!\n", (int) MapP->SysPort); | |
611 | p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE; | |
612 | return -EINVAL; | |
613 | } | |
614 | ||
615 | /* | |
616 | ** Copy the name across to the map entry. | |
617 | */ | |
618 | MapP->Name[MAX_NAME_LEN - 1] = '\0'; | |
619 | sptr = MapP->Name; | |
620 | while (*sptr) { | |
621 | if (*sptr < ' ' || *sptr > '~') { | |
622 | rio_dprintk(RIO_DEBUG_TABLE, "Name entry contains non-printing characters!\n"); | |
623 | p->RIOError.Error = BAD_CHARACTER_IN_NAME; | |
624 | return -EINVAL; | |
1da177e4 | 625 | } |
8d8706e2 AM |
626 | sptr++; |
627 | } | |
628 | ||
629 | for (host = 0; host < p->RIONumHosts; host++) { | |
630 | if (MapP->HostUniqueNum == p->RIOHosts[host].UniqueNum) { | |
631 | if ((p->RIOHosts[host].Flags & RUN_STATE) != RC_RUNNING) { | |
632 | p->RIOError.Error = HOST_NOT_RUNNING; | |
633 | return -ENXIO; | |
634 | } | |
1da177e4 | 635 | |
8d8706e2 AM |
636 | /* |
637 | ** Now we have a host we need to allocate an ID | |
638 | ** if the entry does not already have one. | |
639 | */ | |
554b7c80 | 640 | if (MapP->ID == (u16) - 1) { |
8d8706e2 | 641 | int nNewID; |
1da177e4 | 642 | |
8d8706e2 AM |
643 | rio_dprintk(RIO_DEBUG_TABLE, "Attempting to get a new ID for rta \"%s\"\n", MapP->Name); |
644 | /* | |
645 | ** The idea here is to allow RTA's to be assigned | |
646 | ** before they actually appear on the network. | |
647 | ** This allows the addition of RTA's without having | |
648 | ** to plug them in. | |
649 | ** What we do is: | |
650 | ** - Find a free ID and allocate it to the RTA. | |
651 | ** - If this map entry is the second half of a | |
652 | ** 16 port entry then find the other half and | |
653 | ** make sure the 2 cross reference each other. | |
654 | */ | |
655 | if (RIOFindFreeID(p, &p->RIOHosts[host], &nNewID, NULL) != 0) { | |
656 | p->RIOError.Error = COULDNT_FIND_ENTRY; | |
657 | return -EBUSY; | |
658 | } | |
554b7c80 | 659 | MapP->ID = (u16) nNewID + 1; |
8d8706e2 AM |
660 | rio_dprintk(RIO_DEBUG_TABLE, "Allocated ID %d for this new RTA.\n", MapP->ID); |
661 | HostMapP = &p->RIOHosts[host].Mapping[nNewID]; | |
662 | HostMapP->RtaUniqueNum = MapP->RtaUniqueNum; | |
663 | HostMapP->HostUniqueNum = MapP->HostUniqueNum; | |
664 | HostMapP->ID = MapP->ID; | |
665 | for (link = 0; link < LINKS_PER_UNIT; link++) { | |
666 | HostMapP->Topology[link].Unit = ROUTE_DISCONNECT; | |
667 | HostMapP->Topology[link].Link = NO_LINK; | |
668 | } | |
669 | if (MapP->Flags & RTA16_SECOND_SLOT) { | |
670 | int unit; | |
671 | ||
672 | for (unit = 0; unit < MAX_RUP; unit++) | |
673 | if (p->RIOHosts[host].Mapping[unit].RtaUniqueNum == MapP->RtaUniqueNum) | |
674 | break; | |
675 | if (unit == MAX_RUP) { | |
676 | p->RIOError.Error = COULDNT_FIND_ENTRY; | |
677 | return -EBUSY; | |
678 | } | |
679 | HostMapP->Flags |= RTA16_SECOND_SLOT; | |
680 | HostMapP->ID2 = MapP->ID2 = p->RIOHosts[host].Mapping[unit].ID; | |
681 | p->RIOHosts[host].Mapping[unit].ID2 = MapP->ID; | |
682 | rio_dprintk(RIO_DEBUG_TABLE, "Cross referenced id %d to ID %d.\n", MapP->ID, p->RIOHosts[host].Mapping[unit].ID); | |
683 | } | |
684 | } | |
685 | ||
686 | HostMapP = &p->RIOHosts[host].Mapping[MapP->ID - 1]; | |
687 | ||
688 | if (HostMapP->Flags & SLOT_IN_USE) { | |
689 | rio_dprintk(RIO_DEBUG_TABLE, "Map table slot for ID %d is already in use.\n", MapP->ID); | |
690 | p->RIOError.Error = ID_ALREADY_IN_USE; | |
691 | return -EBUSY; | |
692 | } | |
693 | ||
694 | /* | |
695 | ** Assign the sys ports and the name, and mark the slot as | |
696 | ** being in use. | |
697 | */ | |
698 | HostMapP->SysPort = MapP->SysPort; | |
699 | if ((MapP->Flags & RTA16_SECOND_SLOT) == 0) | |
554b7c80 | 700 | memcpy(HostMapP->Name, MapP->Name, MAX_NAME_LEN); |
8d8706e2 | 701 | HostMapP->Flags = SLOT_IN_USE | RTA_BOOTED; |
44456d37 | 702 | #ifdef NEED_TO_FIX |
8d8706e2 | 703 | RIO_SV_BROADCAST(p->RIOHosts[host].svFlags[MapP->ID - 1]); |
1da177e4 | 704 | #endif |
8d8706e2 AM |
705 | if (MapP->Flags & RTA16_SECOND_SLOT) |
706 | HostMapP->Flags |= RTA16_SECOND_SLOT; | |
707 | ||
708 | RIOReMapPorts(p, &p->RIOHosts[host], HostMapP); | |
709 | /* | |
710 | ** Adjust 2nd block of 8 phbs | |
711 | */ | |
712 | if (MapP->Flags & RTA16_SECOND_SLOT) | |
713 | RIOFixPhbs(p, &p->RIOHosts[host], HostMapP->ID - 1); | |
714 | ||
715 | if (HostMapP->SysPort != NO_PORT) { | |
716 | if (HostMapP->SysPort < p->RIOFirstPortsBooted) | |
717 | p->RIOFirstPortsBooted = HostMapP->SysPort; | |
718 | if (HostMapP->SysPort > p->RIOLastPortsBooted) | |
719 | p->RIOLastPortsBooted = HostMapP->SysPort; | |
720 | } | |
721 | if (MapP->Flags & RTA16_SECOND_SLOT) | |
722 | rio_dprintk(RIO_DEBUG_TABLE, "Second map of RTA %s added to configuration\n", p->RIOHosts[host].Mapping[MapP->ID2 - 1].Name); | |
723 | else | |
724 | rio_dprintk(RIO_DEBUG_TABLE, "RTA %s added to configuration\n", MapP->Name); | |
725 | return 0; | |
726 | } | |
1da177e4 | 727 | } |
8d8706e2 AM |
728 | p->RIOError.Error = UNKNOWN_HOST_NUMBER; |
729 | rio_dprintk(RIO_DEBUG_TABLE, "Unknown host %x\n", MapP->HostUniqueNum); | |
730 | return -ENXIO; | |
1da177e4 LT |
731 | } |
732 | ||
733 | ||
e2b3afd6 | 734 | int RIOReMapPorts(struct rio_info *p, struct Host *HostP, struct Map *HostMapP) |
1da177e4 | 735 | { |
e2b3afd6 | 736 | struct Port *PortP; |
554b7c80 AC |
737 | unsigned int SubEnt; |
738 | unsigned int HostPort; | |
739 | unsigned int SysPort; | |
740 | u16 RtaType; | |
1da177e4 LT |
741 | unsigned long flags; |
742 | ||
8d8706e2 | 743 | rio_dprintk(RIO_DEBUG_TABLE, "Mapping sysport %d to id %d\n", (int) HostMapP->SysPort, HostMapP->ID); |
1da177e4 LT |
744 | |
745 | /* | |
8d8706e2 AM |
746 | ** We need to tell the UnixRups which sysport the rup corresponds to |
747 | */ | |
748 | HostP->UnixRups[HostMapP->ID - 1].BaseSysPort = HostMapP->SysPort; | |
1da177e4 | 749 | |
8d8706e2 AM |
750 | if (HostMapP->SysPort == NO_PORT) |
751 | return (0); | |
1da177e4 LT |
752 | |
753 | RtaType = GetUnitType(HostMapP->RtaUniqueNum); | |
8d8706e2 | 754 | rio_dprintk(RIO_DEBUG_TABLE, "Mapping sysport %d-%d\n", (int) HostMapP->SysPort, (int) HostMapP->SysPort + PORTS_PER_RTA - 1); |
1da177e4 LT |
755 | |
756 | /* | |
8d8706e2 AM |
757 | ** now map each of its eight ports |
758 | */ | |
759 | for (SubEnt = 0; SubEnt < PORTS_PER_RTA; SubEnt++) { | |
760 | rio_dprintk(RIO_DEBUG_TABLE, "subent = %d, HostMapP->SysPort = %d\n", SubEnt, (int) HostMapP->SysPort); | |
761 | SysPort = HostMapP->SysPort + SubEnt; /* portnumber within system */ | |
762 | /* portnumber on host */ | |
763 | ||
764 | HostPort = (HostMapP->ID - 1) * PORTS_PER_RTA + SubEnt; | |
765 | ||
766 | rio_dprintk(RIO_DEBUG_TABLE, "c1 p = %p, p->rioPortp = %p\n", p, p->RIOPortp); | |
1da177e4 | 767 | PortP = p->RIOPortp[SysPort]; |
8d8706e2 | 768 | rio_dprintk(RIO_DEBUG_TABLE, "Map port\n"); |
1da177e4 LT |
769 | |
770 | /* | |
8d8706e2 AM |
771 | ** Point at all the real neat data structures |
772 | */ | |
1da177e4 LT |
773 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
774 | PortP->HostP = HostP; | |
775 | PortP->Caddr = HostP->Caddr; | |
776 | ||
777 | /* | |
8d8706e2 AM |
778 | ** The PhbP cannot be filled in yet |
779 | ** unless the host has been booted | |
780 | */ | |
1da177e4 | 781 | if ((HostP->Flags & RUN_STATE) == RC_RUNNING) { |
d886cb58 AV |
782 | struct PHB __iomem *PhbP = PortP->PhbP = &HostP->PhbP[HostPort]; |
783 | PortP->TxAdd = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_add)); | |
784 | PortP->TxStart = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_start)); | |
785 | PortP->TxEnd = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_end)); | |
786 | PortP->RxRemove = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_remove)); | |
787 | PortP->RxStart = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_start)); | |
788 | PortP->RxEnd = (u16 __iomem *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_end)); | |
8d8706e2 | 789 | } else |
1da177e4 LT |
790 | PortP->PhbP = NULL; |
791 | ||
792 | /* | |
8d8706e2 AM |
793 | ** port related flags |
794 | */ | |
795 | PortP->HostPort = HostPort; | |
1da177e4 | 796 | /* |
8d8706e2 AM |
797 | ** For each part of a 16 port RTA, RupNum is ID - 1. |
798 | */ | |
1da177e4 LT |
799 | PortP->RupNum = HostMapP->ID - 1; |
800 | if (HostMapP->Flags & RTA16_SECOND_SLOT) { | |
8d8706e2 | 801 | PortP->ID2 = HostMapP->ID2 - 1; |
554b7c80 | 802 | PortP->SecondBlock = 1; |
8d8706e2 AM |
803 | } else { |
804 | PortP->ID2 = 0; | |
554b7c80 | 805 | PortP->SecondBlock = 0; |
1da177e4 | 806 | } |
8d8706e2 | 807 | PortP->RtaUniqueNum = HostMapP->RtaUniqueNum; |
1da177e4 LT |
808 | |
809 | /* | |
8d8706e2 AM |
810 | ** If the port was already mapped then thats all we need to do. |
811 | */ | |
1da177e4 | 812 | if (PortP->Mapped) { |
8d8706e2 | 813 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
1da177e4 | 814 | continue; |
8d8706e2 AM |
815 | } else |
816 | HostMapP->Flags &= ~RTA_NEWBOOT; | |
1da177e4 | 817 | |
8d8706e2 AM |
818 | PortP->State = 0; |
819 | PortP->Config = 0; | |
1da177e4 | 820 | /* |
8d8706e2 AM |
821 | ** Check out the module type - if it is special (read only etc.) |
822 | ** then we need to set flags in the PortP->Config. | |
823 | ** Note: For 16 port RTA, all ports are of the same type. | |
824 | */ | |
1da177e4 | 825 | if (RtaType == TYPE_RTA16) { |
8d8706e2 | 826 | PortP->Config |= p->RIOModuleTypes[HostP->UnixRups[HostMapP->ID - 1].ModTypes].Flags[SubEnt % PORTS_PER_MODULE]; |
1da177e4 | 827 | } else { |
8d8706e2 AM |
828 | if (SubEnt < PORTS_PER_MODULE) |
829 | PortP->Config |= p->RIOModuleTypes[LONYBLE(HostP->UnixRups[HostMapP->ID - 1].ModTypes)].Flags[SubEnt % PORTS_PER_MODULE]; | |
1da177e4 | 830 | else |
8d8706e2 | 831 | PortP->Config |= p->RIOModuleTypes[HINYBLE(HostP->UnixRups[HostMapP->ID - 1].ModTypes)].Flags[SubEnt % PORTS_PER_MODULE]; |
1da177e4 LT |
832 | } |
833 | ||
834 | /* | |
8d8706e2 AM |
835 | ** more port related flags |
836 | */ | |
837 | PortP->PortState = 0; | |
838 | PortP->ModemLines = 0; | |
839 | PortP->ModemState = 0; | |
840 | PortP->CookMode = COOK_WELL; | |
841 | PortP->ParamSem = 0; | |
842 | PortP->FlushCmdBodge = 0; | |
843 | PortP->WflushFlag = 0; | |
844 | PortP->MagicFlags = 0; | |
845 | PortP->Lock = 0; | |
846 | PortP->Store = 0; | |
847 | PortP->FirstOpen = 1; | |
1da177e4 LT |
848 | |
849 | /* | |
8d8706e2 AM |
850 | ** Buffers 'n things |
851 | */ | |
852 | PortP->RxDataStart = 0; | |
853 | PortP->Cor2Copy = 0; | |
854 | PortP->Name = &HostMapP->Name[0]; | |
1da177e4 LT |
855 | PortP->statsGather = 0; |
856 | PortP->txchars = 0; | |
857 | PortP->rxchars = 0; | |
858 | PortP->opens = 0; | |
859 | PortP->closes = 0; | |
860 | PortP->ioctls = 0; | |
8d8706e2 | 861 | if (PortP->TxRingBuffer) |
e2b3afd6 | 862 | memset(PortP->TxRingBuffer, 0, p->RIOBufferSize); |
8d8706e2 | 863 | else if (p->RIOBufferSize) { |
dd00cc48 | 864 | PortP->TxRingBuffer = kzalloc(p->RIOBufferSize, GFP_KERNEL); |
1da177e4 | 865 | } |
8d8706e2 AM |
866 | PortP->TxBufferOut = 0; |
867 | PortP->TxBufferIn = 0; | |
868 | PortP->Debug = 0; | |
1da177e4 | 869 | /* |
8d8706e2 AM |
870 | ** LastRxTgl stores the state of the rx toggle bit for this |
871 | ** port, to be compared with the state of the next pkt received. | |
872 | ** If the same, we have received the same rx pkt from the RTA | |
873 | ** twice. Initialise to a value not equal to PHB_RX_TGL or 0. | |
874 | */ | |
e2b3afd6 | 875 | PortP->LastRxTgl = ~(u8) PHB_RX_TGL; |
1da177e4 LT |
876 | |
877 | /* | |
8d8706e2 AM |
878 | ** and mark the port as usable |
879 | */ | |
1da177e4 LT |
880 | PortP->Mapped = 1; |
881 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
882 | } | |
8d8706e2 | 883 | if (HostMapP->SysPort < p->RIOFirstPortsMapped) |
1da177e4 | 884 | p->RIOFirstPortsMapped = HostMapP->SysPort; |
8d8706e2 | 885 | if (HostMapP->SysPort > p->RIOLastPortsMapped) |
1da177e4 LT |
886 | p->RIOLastPortsMapped = HostMapP->SysPort; |
887 | ||
888 | return 0; | |
889 | } | |
890 | ||
e2b3afd6 | 891 | int RIOChangeName(struct rio_info *p, struct Map *MapP) |
1da177e4 LT |
892 | { |
893 | int host; | |
894 | struct Map *HostMapP; | |
895 | char *sptr; | |
896 | ||
8d8706e2 | 897 | rio_dprintk(RIO_DEBUG_TABLE, "Change name entry on host %x, rta %x, ID %d, Sysport %d\n", MapP->HostUniqueNum, MapP->RtaUniqueNum, MapP->ID, (int) MapP->SysPort); |
1da177e4 | 898 | |
8d8706e2 AM |
899 | if (MapP->ID > MAX_RUP) { |
900 | rio_dprintk(RIO_DEBUG_TABLE, "Bad ID in map entry!\n"); | |
1da177e4 LT |
901 | p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE; |
902 | return -EINVAL; | |
903 | } | |
904 | ||
8d8706e2 | 905 | MapP->Name[MAX_NAME_LEN - 1] = '\0'; |
1da177e4 LT |
906 | sptr = MapP->Name; |
907 | ||
8d8706e2 AM |
908 | while (*sptr) { |
909 | if (*sptr < ' ' || *sptr > '~') { | |
910 | rio_dprintk(RIO_DEBUG_TABLE, "Name entry contains non-printing characters!\n"); | |
1da177e4 LT |
911 | p->RIOError.Error = BAD_CHARACTER_IN_NAME; |
912 | return -EINVAL; | |
913 | } | |
914 | sptr++; | |
915 | } | |
916 | ||
8d8706e2 AM |
917 | for (host = 0; host < p->RIONumHosts; host++) { |
918 | if (MapP->HostUniqueNum == p->RIOHosts[host].UniqueNum) { | |
919 | if ((p->RIOHosts[host].Flags & RUN_STATE) != RC_RUNNING) { | |
1da177e4 LT |
920 | p->RIOError.Error = HOST_NOT_RUNNING; |
921 | return -ENXIO; | |
922 | } | |
8d8706e2 | 923 | if (MapP->ID == 0) { |
554b7c80 | 924 | memcpy(p->RIOHosts[host].Name, MapP->Name, MAX_NAME_LEN); |
1da177e4 LT |
925 | return 0; |
926 | } | |
927 | ||
8d8706e2 | 928 | HostMapP = &p->RIOHosts[host].Mapping[MapP->ID - 1]; |
1da177e4 | 929 | |
8d8706e2 | 930 | if (HostMapP->RtaUniqueNum != MapP->RtaUniqueNum) { |
1da177e4 LT |
931 | p->RIOError.Error = RTA_NUMBER_WRONG; |
932 | return -ENXIO; | |
933 | } | |
554b7c80 | 934 | memcpy(HostMapP->Name, MapP->Name, MAX_NAME_LEN); |
1da177e4 LT |
935 | return 0; |
936 | } | |
937 | } | |
938 | p->RIOError.Error = UNKNOWN_HOST_NUMBER; | |
8d8706e2 | 939 | rio_dprintk(RIO_DEBUG_TABLE, "Unknown host %x\n", MapP->HostUniqueNum); |
1da177e4 LT |
940 | return -ENXIO; |
941 | } |