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