projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of git://git.infradead.org/users/dedekind/mtd-tests-2.6
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / char / rio / riotable.c
CommitLineData
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 83int 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 403int 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 457int 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 584int 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 734int 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 891int 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}
kernel source for telekom puls (alcatel/mediatek)