← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/char/rio/riotable.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/char/rio/riotable.c
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
 
*/
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>
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"
52
 
#include "pkt.h"
53
 
#include "daemon.h"
54
 
#include "rio.h"
55
 
#include "riospace.h"
56
 
#include "cmdpkt.h"
57
 
#include "map.h"
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"
70
 
#include "phb.h"
71
 
#include "link.h"
72
 
#include "cmdblk.h"
73
 
#include "route.h"
74
 
#include "cirrus.h"
75
 
#include "rioioctl.h"
76
 
#include "param.h"
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
 
*/
83
 
int RIONewTable(struct rio_info *p)
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
 
        /*
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
 
         */
97
 
        /*
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) */
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
 
 
121
 
        for (Entry = 0; Entry < TOTAL_MAP_ENTRIES; Entry++) {
122
 
                MapP = &p->RIOConnectTable[Entry];
123
 
                if ((MapP->Flags & RTA16_SECOND_SLOT) == 0) {
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') {
128
 
                                memcpy(MapP->Name, MapP->RtaUniqueNum ? "RTA    NN" : "HOST NN", 8);
129
 
                                MapP->Name[5] = '0' + Entry / 10;
130
 
                                MapP->Name[6] = '0' + Entry % 10;
131
 
                        }
132
 
                        while (*cptr) {
133
 
                                if (*cptr < ' ' || *cptr > '~') {
134
 
                                        p->RIOError.Error = BAD_CHARACTER_IN_NAME;
135
 
                                        p->RIOError.Entry = Entry;
136
 
                                        return -ENXIO;
137
 
                                }
138
 
                                cptr++;
139
 
                        }
140
 
                }
141
 
 
142
 
                /*
143
 
                 ** If the entry saved was a tentative entry then just forget
144
 
                 ** about it.
145
 
                 */
146
 
                if (MapP->Flags & SLOT_TENTATIVE) {
147
 
                        MapP->HostUniqueNum = 0;
148
 
                        MapP->RtaUniqueNum = 0;
149
 
                        continue;
150
 
                }
151
 
 
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);
156
 
                                p->RIOError.Error = TABLE_ENTRY_ISNT_PROPERLY_NULL;
157
 
                                p->RIOError.Entry = Entry;
158
 
                                return -ENXIO;
159
 
                        }
160
 
                        rio_dprintk(RIO_DEBUG_TABLE, "!RIO: Daemon: test (3) passes\n");
161
 
                        continue;
162
 
                }
163
 
 
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) {
167
 
                                HostP = &p->RIOHosts[Host];
168
 
                                /*
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
 
                                 */
172
 
                                MapP->Topology[0].Unit = Host;
173
 
                                break;
174
 
                        }
175
 
                }
176
 
 
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);
179
 
                        MapP->HostUniqueNum = 0;
180
 
                        /* MapP->RtaUniqueNum   = 0; */
181
 
                        /* MapP->ID                     = 0; */
182
 
                        /* MapP->Flags           = 0; */
183
 
                        /* MapP->SysPort                 = 0; */
184
 
                        /* MapP->Name[0]                 = 0; */
185
 
                        continue;
186
 
                }
187
 
 
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;
193
 
                                p->RIOError.Entry = Entry;
194
 
                                return -ENXIO;
195
 
                        }
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);
198
 
                                p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE;
199
 
                                p->RIOError.Entry = Entry;
200
 
                                return -ENXIO;
201
 
                        }
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);
205
 
                                        p->RIOError.Error = DUPLICATED_RTA_ID;
206
 
                                        p->RIOError.Entry = Entry;
207
 
                                        p->RIOError.Other = SubEnt;
208
 
                                        return -ENXIO;
209
 
                                }
210
 
                                /*
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);
218
 
                                        p->RIOError.Error = DUPLICATE_UNIQUE_NUMBER;
219
 
                                        p->RIOError.Entry = Entry;
220
 
                                        p->RIOError.Other = SubEnt;
221
 
                                        return -ENXIO;
222
 
                                }
223
 
                        }
224
 
                        rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(7a)\n");
225
 
                        /* (7a) */
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);
228
 
                                p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE;
229
 
                                p->RIOError.Entry = Entry;
230
 
                                return -ENXIO;
231
 
                        }
232
 
                        rio_dprintk(RIO_DEBUG_TABLE, "RIONewTable: entering(7b)\n");
233
 
                        /* (7b) */
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);
236
 
                                p->RIOError.Error = TTY_NUMBER_OUT_OF_RANGE;
237
 
                                p->RIOError.Entry = Entry;
238
 
                                return -ENXIO;
239
 
                        }
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");
245
 
                                        /* (8) */
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);
248
 
                                                p->RIOError.Error = TTY_NUMBER_IN_USE;
249
 
                                                p->RIOError.Entry = Entry;
250
 
                                                p->RIOError.Other = SubEnt;
251
 
                                                return -ENXIO;
252
 
                                        }
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);
256
 
                                                p->RIOError.Error = NAME_USED_TWICE;
257
 
                                                p->RIOError.Entry = Entry;
258
 
                                                p->RIOError.Other = SubEnt;
259
 
                                                return -ENXIO;
260
 
                                        }
261
 
                                }
262
 
                        }
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);
267
 
                                p->RIOError.Error = HOST_ID_NOT_ZERO;
268
 
                                p->RIOError.Entry = Entry;
269
 
                                return -ENXIO;
270
 
                        }
271
 
                        if (MapP->SysPort != NO_PORT) {
272
 
                                rio_dprintk(RIO_DEBUG_TABLE, "RIO: HOST %s has been allocated port numbers!\n", MapP->Name);
273
 
                                p->RIOError.Error = HOST_SYSPORT_BAD;
274
 
                                p->RIOError.Entry = Entry;
275
 
                                return -ENXIO;
276
 
                        }
277
 
                }
278
 
        }
279
 
 
280
 
        /*
281
 
         ** wow! if we get here then it's a goody!
282
 
         */
283
 
 
284
 
        /*
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++) {
289
 
                        memset(&p->RIOHosts[Host].Mapping[Entry], 0, sizeof(struct Map));
290
 
                }
291
 
                memset(&p->RIOHosts[Host].Name[0], 0, sizeof(p->RIOHosts[Host].Name));
292
 
        }
293
 
 
294
 
        /*
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);
299
 
                MapP = &p->RIOConnectTable[Entry];
300
 
 
301
 
                /*
302
 
                 ** Now, if it is an empty slot ignore it!
303
 
                 */
304
 
                if (MapP->HostUniqueNum == 0)
305
 
                        continue;
306
 
 
307
 
                /*
308
 
                 ** we saved the host number earlier, so grab it back
309
 
                 */
310
 
                HostP = &p->RIOHosts[MapP->Topology[0].Unit];
311
 
 
312
 
                /*
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);
317
 
                        memcpy(HostP->Name, MapP->Name, MAX_NAME_LEN);
318
 
                        continue;
319
 
                }
320
 
 
321
 
                /*
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];
327
 
 
328
 
                if (MapP->Flags & SLOT_IN_USE) {
329
 
                        rio_dprintk(RIO_DEBUG_TABLE, "Rta entry found. Name %s\n", MapP->Name);
330
 
                        /*
331
 
                         ** structure assign, then sort out the bits we shouldn't have done
332
 
                         */
333
 
                        *HostMapP = *MapP;
334
 
 
335
 
                        HostMapP->Flags = SLOT_IN_USE;
336
 
                        if (MapP->Flags & RTA16_SECOND_SLOT)
337
 
                                HostMapP->Flags |= RTA16_SECOND_SLOT;
338
 
 
339
 
                        RIOReMapPorts(p, HostP, HostMapP);
340
 
                } else {
341
 
                        rio_dprintk(RIO_DEBUG_TABLE, "TENTATIVE Rta entry found. Name %s\n", MapP->Name);
342
 
                }
343
 
        }
344
 
 
345
 
        for (Entry = 0; Entry < TOTAL_MAP_ENTRIES; Entry++) {
346
 
                p->RIOSavedTable[Entry] = p->RIOConnectTable[Entry];
347
 
        }
348
 
 
349
 
        for (Host = 0; Host < p->RIONumHosts; Host++) {
350
 
                for (SubEnt = 0; SubEnt < LINKS_PER_UNIT; SubEnt++) {
351
 
                        p->RIOHosts[Host].Topology[SubEnt].Unit = ROUTE_DISCONNECT;
352
 
                        p->RIOHosts[Host].Topology[SubEnt].Link = NO_LINK;
353
 
                }
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;
358
 
                        }
359
 
                }
360
 
                if (!p->RIOHosts[Host].Name[0]) {
361
 
                        memcpy(p->RIOHosts[Host].Name, "HOST 1", 7);
362
 
                        p->RIOHosts[Host].Name[5] += Host;
363
 
                }
364
 
                /*
365
 
                 ** Check that default name assigned is unique.
366
 
                 */
367
 
                Host1 = Host;
368
 
                NameIsUnique = 0;
369
 
                while (!NameIsUnique) {
370
 
                        NameIsUnique = 1;
371
 
                        for (Host2 = 0; Host2 < p->RIONumHosts; Host2++) {
372
 
                                if (Host2 == Host)
373
 
                                        continue;
374
 
                                if (strcmp(p->RIOHosts[Host].Name, p->RIOHosts[Host2].Name)
375
 
                                    == 0) {
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
 
                /*
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);
389
 
                        memcpy(p->RIOHosts[Host].Name, "HOST 1", 7);
390
 
                        p->RIOHosts[Host].Name[5] += Host1;
391
 
                }
392
 
                rio_dprintk(RIO_DEBUG_TABLE, "Assigning default name %s\n", p->RIOHosts[Host].Name);
393
 
        }
394
 
        return 0;
395
 
}
396
 
 
397
 
/*
398
 
** User process needs the config table - build it from first
399
 
** principles.
400
 
**
401
 
*       FIXME: SMP locking
402
 
*/
403
 
int RIOApel(struct rio_info *p)
404
 
{
405
 
        int Host;
406
 
        int link;
407
 
        int Rup;
408
 
        int Next = 0;
409
 
        struct Map *MapP;
410
 
        struct Host *HostP;
411
 
        unsigned long flags;
412
 
 
413
 
        rio_dprintk(RIO_DEBUG_TABLE, "Generating a table to return to config.rio\n");
414
 
 
415
 
        memset(&p->RIOConnectTable[0], 0, sizeof(struct Map) * TOTAL_MAP_ENTRIES);
416
 
 
417
 
        for (Host = 0; Host < RIO_HOSTS; Host++) {
418
 
                rio_dprintk(RIO_DEBUG_TABLE, "Processing host %d\n", Host);
419
 
                HostP = &p->RIOHosts[Host];
420
 
                rio_spin_lock_irqsave(&HostP->HostLock, flags);
421
 
 
422
 
                MapP = &p->RIOConnectTable[Next++];
423
 
                MapP->HostUniqueNum = HostP->UniqueNum;
424
 
                if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
425
 
                        rio_spin_unlock_irqrestore(&HostP->HostLock, flags);
426
 
                        continue;
427
 
                }
428
 
                MapP->RtaUniqueNum = 0;
429
 
                MapP->ID = 0;
430
 
                MapP->Flags = SLOT_IN_USE;
431
 
                MapP->SysPort = NO_PORT;
432
 
                for (link = 0; link < LINKS_PER_UNIT; link++)
433
 
                        MapP->Topology[link] = HostP->Topology[link];
434
 
                memcpy(MapP->Name, HostP->Name, MAX_NAME_LEN);
435
 
                for (Rup = 0; Rup < MAX_RUP; Rup++) {
436
 
                        if (HostP->Mapping[Rup].Flags & (SLOT_IN_USE | SLOT_TENTATIVE)) {
437
 
                                p->RIOConnectTable[Next] = HostP->Mapping[Rup];
438
 
                                if (HostP->Mapping[Rup].Flags & SLOT_IN_USE)
439
 
                                        p->RIOConnectTable[Next].Flags |= SLOT_IN_USE;
440
 
                                if (HostP->Mapping[Rup].Flags & SLOT_TENTATIVE)
441
 
                                        p->RIOConnectTable[Next].Flags |= SLOT_TENTATIVE;
442
 
                                if (HostP->Mapping[Rup].Flags & RTA16_SECOND_SLOT)
443
 
                                        p->RIOConnectTable[Next].Flags |= RTA16_SECOND_SLOT;
444
 
                                Next++;
445
 
                        }
446
 
                }
447
 
                rio_spin_unlock_irqrestore(&HostP->HostLock, flags);
448
 
        }
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
 
*/
457
 
int RIODeleteRta(struct rio_info *p, struct Map *MapP)
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
 
 
467
 
        rio_dprintk(RIO_DEBUG_TABLE, "Delete entry on host %x, rta %x\n", MapP->HostUniqueNum, MapP->RtaUniqueNum);
468
 
 
469
 
        for (host = 0; host < p->RIONumHosts; host++) {
470
 
                HostP = &p->RIOHosts[host];
471
 
 
472
 
                rio_spin_lock_irqsave(&HostP->HostLock, lock_flags);
473
 
 
474
 
                if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
475
 
                        rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags);
476
 
                        continue;
477
 
                }
478
 
 
479
 
                for (entry = 0; entry < MAX_RUP; entry++) {
480
 
                        if (MapP->RtaUniqueNum == HostP->Mapping[entry].RtaUniqueNum) {
481
 
                                HostMapP = &HostP->Mapping[entry];
482
 
                                rio_dprintk(RIO_DEBUG_TABLE, "Found entry offset %d on host %s\n", entry, HostP->Name);
483
 
 
484
 
                                /*
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");
490
 
                                                p->RIOError.Error = UNIT_IS_IN_USE;
491
 
                                                rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags);
492
 
                                                return -EBUSY;
493
 
                                        }
494
 
                                }
495
 
                                /*
496
 
                                 ** Slot has been allocated, BUT not booted/routed/
497
 
                                 ** connected/selected or anything else-ed
498
 
                                 */
499
 
                                SysPort = HostMapP->SysPort;
500
 
 
501
 
                                if (SysPort != NO_PORT) {
502
 
                                        for (port = SysPort; port < SysPort + PORTS_PER_RTA; port++) {
503
 
                                                PortP = p->RIOPortp[port];
504
 
                                                rio_dprintk(RIO_DEBUG_TABLE, "Unmap port\n");
505
 
 
506
 
                                                rio_spin_lock_irqsave(&PortP->portSem, sem_flags);
507
 
 
508
 
                                                PortP->Mapped = 0;
509
 
 
510
 
                                                if (PortP->State & (RIO_MOPEN | RIO_LOPEN)) {
511
 
 
512
 
                                                        rio_dprintk(RIO_DEBUG_TABLE, "Gob on port\n");
513
 
                                                        PortP->TxBufferIn = PortP->TxBufferOut = 0;
514
 
                                                        /* What should I do 
515
 
                                                           wakeup( &PortP->TxBufferIn );
516
 
                                                           wakeup( &PortP->TxBufferOut);
517
 
                                                         */
518
 
                                                        PortP->InUse = NOT_INUSE;
519
 
                                                        /* What should I do 
520
 
                                                           wakeup( &PortP->InUse );
521
 
                                                           signal(PortP->TtyP->t_pgrp,SIGKILL);
522
 
                                                           ttyflush(PortP->TtyP,(FREAD|FWRITE));
523
 
                                                         */
524
 
                                                        PortP->State |= RIO_CLOSING | RIO_DELETED;
525
 
                                                }
526
 
 
527
 
                                                /*
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
 
                                                 */
532
 
                                                if (PortP->SecondBlock) {
533
 
                                                        u16 dest_unit = HostMapP->ID;
534
 
                                                        u16 dest_port = port - SysPort;
535
 
                                                        u16 __iomem *TxPktP;
536
 
                                                        struct PKT __iomem *Pkt;
537
 
 
538
 
                                                        for (TxPktP = PortP->TxStart; TxPktP <= PortP->TxEnd; TxPktP++) {
539
 
                                                                /*
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
 
                                                                 */
546
 
                                                                Pkt = (struct PKT __iomem *) RIO_PTR(HostP->Caddr, readw(&*TxPktP));
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);
548
 
                                                                writew(dest_unit, &Pkt->dest_unit);
549
 
                                                                writew(dest_port, &Pkt->dest_port);
550
 
                                                        }
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);
552
 
                                                        writew(dest_unit + (dest_port << 8), &PortP->PhbP->destination);
553
 
                                                }
554
 
                                                rio_spin_unlock_irqrestore(&PortP->portSem, sem_flags);
555
 
                                        }
556
 
                                }
557
 
                                rio_dprintk(RIO_DEBUG_TABLE, "Entry nulled.\n");
558
 
                                memset(HostMapP, 0, sizeof(struct Map));
559
 
                                work_done++;
560
 
                        }
561
 
                }
562
 
                rio_spin_unlock_irqrestore(&HostP->HostLock, lock_flags);
563
 
        }
564
 
 
565
 
        /* XXXXX lock me up */
566
 
        for (entry = 0; entry < TOTAL_MAP_ENTRIES; entry++) {
567
 
                if (p->RIOSavedTable[entry].RtaUniqueNum == MapP->RtaUniqueNum) {
568
 
                        memset(&p->RIOSavedTable[entry], 0, sizeof(struct Map));
569
 
                        work_done++;
570
 
                }
571
 
                if (p->RIOConnectTable[entry].RtaUniqueNum == MapP->RtaUniqueNum) {
572
 
                        memset(&p->RIOConnectTable[entry], 0, sizeof(struct Map));
573
 
                        work_done++;
574
 
                }
575
 
        }
576
 
        if (work_done)
577
 
                return 0;
578
 
 
579
 
        rio_dprintk(RIO_DEBUG_TABLE, "Couldn't find entry to be deleted\n");
580
 
        p->RIOError.Error = COULDNT_FIND_ENTRY;
581
 
        return -ENXIO;
582
 
}
583
 
 
584
 
int RIOAssignRta(struct rio_info *p, struct Map *MapP)
585
 
{
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
 
 
594
 
        if ((MapP->ID != (u16) - 1) && ((int) MapP->ID < (int) 1 || (int) MapP->ID > MAX_RUP)) {
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;
625
 
                }
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
 
                        }
635
 
 
636
 
                        /*
637
 
                         ** Now we have a host we need to allocate an ID
638
 
                         ** if the entry does not already have one.
639
 
                         */
640
 
                        if (MapP->ID == (u16) - 1) {
641
 
                                int nNewID;
642
 
 
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
 
                                }
659
 
                                MapP->ID = (u16) nNewID + 1;
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)
700
 
                                memcpy(HostMapP->Name, MapP->Name, MAX_NAME_LEN);
701
 
                        HostMapP->Flags = SLOT_IN_USE | RTA_BOOTED;
702
 
#ifdef NEED_TO_FIX
703
 
                        RIO_SV_BROADCAST(p->RIOHosts[host].svFlags[MapP->ID - 1]);
704
 
#endif
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
 
                }
727
 
        }
728
 
        p->RIOError.Error = UNKNOWN_HOST_NUMBER;
729
 
        rio_dprintk(RIO_DEBUG_TABLE, "Unknown host %x\n", MapP->HostUniqueNum);
730
 
        return -ENXIO;
731
 
}
732
 
 
733
 
 
734
 
int RIOReMapPorts(struct rio_info *p, struct Host *HostP, struct Map *HostMapP)
735
 
{
736
 
        struct Port *PortP;
737
 
        unsigned int SubEnt;
738
 
        unsigned int HostPort;
739
 
        unsigned int SysPort;
740
 
        u16 RtaType;
741
 
        unsigned long flags;
742
 
 
743
 
        rio_dprintk(RIO_DEBUG_TABLE, "Mapping sysport %d to id %d\n", (int) HostMapP->SysPort, HostMapP->ID);
744
 
 
745
 
        /*
746
 
         ** We need to tell the UnixRups which sysport the rup corresponds to
747
 
         */
748
 
        HostP->UnixRups[HostMapP->ID - 1].BaseSysPort = HostMapP->SysPort;
749
 
 
750
 
        if (HostMapP->SysPort == NO_PORT)
751
 
                return (0);
752
 
 
753
 
        RtaType = GetUnitType(HostMapP->RtaUniqueNum);
754
 
        rio_dprintk(RIO_DEBUG_TABLE, "Mapping sysport %d-%d\n", (int) HostMapP->SysPort, (int) HostMapP->SysPort + PORTS_PER_RTA - 1);
755
 
 
756
 
        /*
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);
767
 
                PortP = p->RIOPortp[SysPort];
768
 
                rio_dprintk(RIO_DEBUG_TABLE, "Map port\n");
769
 
 
770
 
                /*
771
 
                 ** Point at all the real neat data structures
772
 
                 */
773
 
                rio_spin_lock_irqsave(&PortP->portSem, flags);
774
 
                PortP->HostP = HostP;
775
 
                PortP->Caddr = HostP->Caddr;
776
 
 
777
 
                /*
778
 
                 ** The PhbP cannot be filled in yet
779
 
                 ** unless the host has been booted
780
 
                 */
781
 
                if ((HostP->Flags & RUN_STATE) == RC_RUNNING) {
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));
789
 
                } else
790
 
                        PortP->PhbP = NULL;
791
 
 
792
 
                /*
793
 
                 ** port related flags
794
 
                 */
795
 
                PortP->HostPort = HostPort;
796
 
                /*
797
 
                 ** For each part of a 16 port RTA, RupNum is ID - 1.
798
 
                 */
799
 
                PortP->RupNum = HostMapP->ID - 1;
800
 
                if (HostMapP->Flags & RTA16_SECOND_SLOT) {
801
 
                        PortP->ID2 = HostMapP->ID2 - 1;
802
 
                        PortP->SecondBlock = 1;
803
 
                } else {
804
 
                        PortP->ID2 = 0;
805
 
                        PortP->SecondBlock = 0;
806
 
                }
807
 
                PortP->RtaUniqueNum = HostMapP->RtaUniqueNum;
808
 
 
809
 
                /*
810
 
                 ** If the port was already mapped then thats all we need to do.
811
 
                 */
812
 
                if (PortP->Mapped) {
813
 
                        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
814
 
                        continue;
815
 
                } else
816
 
                        HostMapP->Flags &= ~RTA_NEWBOOT;
817
 
 
818
 
                PortP->State = 0;
819
 
                PortP->Config = 0;
820
 
                /*
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
 
                 */
825
 
                if (RtaType == TYPE_RTA16) {
826
 
                        PortP->Config |= p->RIOModuleTypes[HostP->UnixRups[HostMapP->ID - 1].ModTypes].Flags[SubEnt % PORTS_PER_MODULE];
827
 
                } else {
828
 
                        if (SubEnt < PORTS_PER_MODULE)
829
 
                                PortP->Config |= p->RIOModuleTypes[LONYBLE(HostP->UnixRups[HostMapP->ID - 1].ModTypes)].Flags[SubEnt % PORTS_PER_MODULE];
830
 
                        else
831
 
                                PortP->Config |= p->RIOModuleTypes[HINYBLE(HostP->UnixRups[HostMapP->ID - 1].ModTypes)].Flags[SubEnt % PORTS_PER_MODULE];
832
 
                }
833
 
 
834
 
                /*
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;
848
 
 
849
 
                /*
850
 
                 ** Buffers 'n things
851
 
                 */
852
 
                PortP->RxDataStart = 0;
853
 
                PortP->Cor2Copy = 0;
854
 
                PortP->Name = &HostMapP->Name[0];
855
 
                PortP->statsGather = 0;
856
 
                PortP->txchars = 0;
857
 
                PortP->rxchars = 0;
858
 
                PortP->opens = 0;
859
 
                PortP->closes = 0;
860
 
                PortP->ioctls = 0;
861
 
                if (PortP->TxRingBuffer)
862
 
                        memset(PortP->TxRingBuffer, 0, p->RIOBufferSize);
863
 
                else if (p->RIOBufferSize) {
864
 
                        PortP->TxRingBuffer = kzalloc(p->RIOBufferSize, GFP_KERNEL);
865
 
                }
866
 
                PortP->TxBufferOut = 0;
867
 
                PortP->TxBufferIn = 0;
868
 
                PortP->Debug = 0;
869
 
                /*
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
 
                 */
875
 
                PortP->LastRxTgl = ~(u8) PHB_RX_TGL;
876
 
 
877
 
                /*
878
 
                 ** and mark the port as usable
879
 
                 */
880
 
                PortP->Mapped = 1;
881
 
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
882
 
        }
883
 
        if (HostMapP->SysPort < p->RIOFirstPortsMapped)
884
 
                p->RIOFirstPortsMapped = HostMapP->SysPort;
885
 
        if (HostMapP->SysPort > p->RIOLastPortsMapped)
886
 
                p->RIOLastPortsMapped = HostMapP->SysPort;
887
 
 
888
 
        return 0;
889
 
}
890
 
 
891
 
int RIOChangeName(struct rio_info *p, struct Map *MapP)
892
 
{
893
 
        int host;
894
 
        struct Map *HostMapP;
895
 
        char *sptr;
896
 
 
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);
898
 
 
899
 
        if (MapP->ID > MAX_RUP) {
900
 
                rio_dprintk(RIO_DEBUG_TABLE, "Bad ID in map entry!\n");
901
 
                p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE;
902
 
                return -EINVAL;
903
 
        }
904
 
 
905
 
        MapP->Name[MAX_NAME_LEN - 1] = '\0';
906
 
        sptr = MapP->Name;
907
 
 
908
 
        while (*sptr) {
909
 
                if (*sptr < ' ' || *sptr > '~') {
910
 
                        rio_dprintk(RIO_DEBUG_TABLE, "Name entry contains non-printing characters!\n");
911
 
                        p->RIOError.Error = BAD_CHARACTER_IN_NAME;
912
 
                        return -EINVAL;
913
 
                }
914
 
                sptr++;
915
 
        }
916
 
 
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) {
920
 
                                p->RIOError.Error = HOST_NOT_RUNNING;
921
 
                                return -ENXIO;
922
 
                        }
923
 
                        if (MapP->ID == 0) {
924
 
                                memcpy(p->RIOHosts[host].Name, MapP->Name, MAX_NAME_LEN);
925
 
                                return 0;
926
 
                        }
927
 
 
928
 
                        HostMapP = &p->RIOHosts[host].Mapping[MapP->ID - 1];
929
 
 
930
 
                        if (HostMapP->RtaUniqueNum != MapP->RtaUniqueNum) {
931
 
                                p->RIOError.Error = RTA_NUMBER_WRONG;
932
 
                                return -ENXIO;
933
 
                        }
934
 
                        memcpy(HostMapP->Name, MapP->Name, MAX_NAME_LEN);
935
 
                        return 0;
936
 
                }
937
 
        }
938
 
        p->RIOError.Error = UNKNOWN_HOST_NUMBER;
939
 
        rio_dprintk(RIO_DEBUG_TABLE, "Unknown host %x\n", MapP->HostUniqueNum);
940
 
        return -ENXIO;
941
 
}