git.oblomov.eu Git - linux-2.6/blob - drivers/char/rio/rioctrl.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          : rioctrl.c
  24 **      SID             : 1.3
  25 **      Last Modified   : 11/6/98 10:33:42
  26 **      Retrieved       : 11/6/98 10:33:49
  27 **
  28 **  ident @(#)rioctrl.c 1.3
  29 **
  30 ** -----------------------------------------------------------------------------
  31 */
  32 #ifdef SCCS_LABELS
  33 static char *_rioctrl_c_sccs_ = "@(#)rioctrl.c  1.3";
  34 #endif
  35
  36
  37 #include <linux/module.h>
  38 #include <linux/slab.h>
  39 #include <linux/errno.h>
  40 #include <asm/io.h>
  41 #include <asm/system.h>
  42 #include <asm/string.h>
  43 #include <asm/semaphore.h>
  44 #include <asm/uaccess.h>
  45
  46 #include <linux/termios.h>
  47 #include <linux/serial.h>
  48
  49 #include <linux/generic_serial.h>
  50
  51
  52 #include "linux_compat.h"
  53 #include "rio_linux.h"
  54 #include "pkt.h"
  55 #include "daemon.h"
  56 #include "rio.h"
  57 #include "riospace.h"
  58 #include "cmdpkt.h"
  59 #include "map.h"
  60 #include "rup.h"
  61 #include "port.h"
  62 #include "riodrvr.h"
  63 #include "rioinfo.h"
  64 #include "func.h"
  65 #include "errors.h"
  66 #include "pci.h"
  67
  68 #include "parmmap.h"
  69 #include "unixrup.h"
  70 #include "board.h"
  71 #include "host.h"
  72 #include "phb.h"
  73 #include "link.h"
  74 #include "cmdblk.h"
  75 #include "route.h"
  76 #include "cirrus.h"
  77 #include "rioioctl.h"
  78
  79
  80 static struct LpbReq LpbReq;
  81 static struct RupReq RupReq;
  82 static struct PortReq PortReq;
  83 static struct HostReq HostReq;
  84 static struct HostDpRam HostDpRam;
  85 static struct DebugCtrl DebugCtrl;
  86 static struct Map MapEnt;
  87 static struct PortSetup PortSetup;
  88 static struct DownLoad DownLoad;
  89 static struct SendPack SendPack;
  90 /* static struct StreamInfo     StreamInfo; */
  91 /* static char modemtable[RIO_PORTS]; */
  92 static struct SpecialRupCmd SpecialRupCmd;
  93 static struct PortParams PortParams;
  94 static struct portStats portStats;
  95
  96 static struct SubCmdStruct {
  97         ushort Host;
  98         ushort Rup;
  99         ushort Port;
 100         ushort Addr;
 101 } SubCmd;
 102
 103 struct PortTty {
 104         uint port;
 105         struct ttystatics Tty;
 106 };
 107
 108 static struct PortTty PortTty;
 109 typedef struct ttystatics TERMIO;
 110
 111 /*
 112 ** This table is used when the config.rio downloads bin code to the
 113 ** driver. We index the table using the product code, 0-F, and call
 114 ** the function pointed to by the entry, passing the information
 115 ** about the boot.
 116 ** The RIOBootCodeUNKNOWN entry is there to politely tell the calling
 117 ** process to bog off.
 118 */
 119 static int
 120  (*RIOBootTable[MAX_PRODUCT]) (struct rio_info *, struct DownLoad *) = {
 121                                         /* 0 */ RIOBootCodeHOST,
 122                                         /* Host Card */
 123                                         /* 1 */ RIOBootCodeRTA,
 124                                         /* RTA */
 125 };
 126
 127 #define drv_makedev(maj, min) ((((uint) maj & 0xff) << 8) | ((uint) min & 0xff))
 128
 129 int riocontrol(p, dev, cmd, arg, su)
 130 struct rio_info *p;
 131 dev_t dev;
 132 int cmd;
 133 caddr_t arg;
 134 int su;
 135 {
 136         uint Host;              /* leave me unsigned! */
 137         uint port;              /* and me! */
 138         struct Host *HostP;
 139         ushort loop;
 140         int Entry;
 141         struct Port *PortP;
 142         struct PKT *PacketP;
 143         int retval = 0;
 144         unsigned long flags;
 145
 146         func_enter();
 147
 148         /* Confuse the compiler to think that we've initialized these */
 149         Host = 0;
 150         PortP = NULL;
 151
 152         rio_dprintk(RIO_DEBUG_CTRL, "control ioctl cmd: 0x%x arg: %p\n", cmd, arg);
 153
 154         switch (cmd) {
 155                 /*
 156                  ** RIO_SET_TIMER
 157                  **
 158                  ** Change the value of the host card interrupt timer.
 159                  ** If the host card number is -1 then all host cards are changed
 160                  ** otherwise just the specified host card will be changed.
 161                  */
 162         case RIO_SET_TIMER:
 163                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_TIMER to %ldms\n", (unsigned long)arg);
 164                 {
 165                         int host, value;
 166                         host = ((unsigned long) arg >> 16) & 0x0000FFFF;
 167                         value = (unsigned long) arg & 0x0000ffff;
 168                         if (host == -1) {
 169                                 for (host = 0; host < p->RIONumHosts; host++) {
 170                                         if (p->RIOHosts[host].Flags == RC_RUNNING) {
 171                                                 writew(value, &p->RIOHosts[host].ParmMapP->timer);
 172                                         }
 173                                 }
 174                         } else if (host >= p->RIONumHosts) {
 175                                 return -EINVAL;
 176                         } else {
 177                                 if (p->RIOHosts[host].Flags == RC_RUNNING) {
 178                                         writew(value, &p->RIOHosts[host].ParmMapP->timer);
 179                                 }
 180                         }
 181                 }
 182                 return 0;
 183
 184         case RIO_FOAD_RTA:
 185                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_FOAD_RTA\n");
 186                 return RIOCommandRta(p, (unsigned long)arg, RIOFoadRta);
 187
 188         case RIO_ZOMBIE_RTA:
 189                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_ZOMBIE_RTA\n");
 190                 return RIOCommandRta(p, (unsigned long)arg, RIOZombieRta);
 191
 192         case RIO_IDENTIFY_RTA:
 193                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_IDENTIFY_RTA\n");
 194                 return RIOIdentifyRta(p, arg);
 195
 196         case RIO_KILL_NEIGHBOUR:
 197                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_KILL_NEIGHBOUR\n");
 198                 return RIOKillNeighbour(p, arg);
 199
 200         case SPECIAL_RUP_CMD:
 201                 {
 202                         struct CmdBlk *CmdBlkP;
 203
 204                         rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD\n");
 205                         if (copy_from_user(&SpecialRupCmd, arg, sizeof(SpecialRupCmd))) {
 206                                 rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD copy failed\n");
 207                                 p->RIOError.Error = COPYIN_FAILED;
 208                                 return -EFAULT;
 209                         }
 210                         CmdBlkP = RIOGetCmdBlk();
 211                         if (!CmdBlkP) {
 212                                 rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD GetCmdBlk failed\n");
 213                                 return -ENXIO;
 214                         }
 215                         CmdBlkP->Packet = SpecialRupCmd.Packet;
 216                         if (SpecialRupCmd.Host >= p->RIONumHosts)
 217                                 SpecialRupCmd.Host = 0;
 218                         rio_dprintk(RIO_DEBUG_CTRL, "Queue special rup command for host %d rup %d\n", SpecialRupCmd.Host, SpecialRupCmd.RupNum);
 219                         if (RIOQueueCmdBlk(&p->RIOHosts[SpecialRupCmd.Host], SpecialRupCmd.RupNum, CmdBlkP) == RIO_FAIL) {
 220                                 printk(KERN_WARNING "rio: FAILED TO QUEUE SPECIAL RUP COMMAND\n");
 221                         }
 222                         return 0;
 223                 }
 224
 225         case RIO_DEBUG_MEM:
 226                 return -EPERM;
 227
 228         case RIO_ALL_MODEM:
 229                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_ALL_MODEM\n");
 230                 p->RIOError.Error = IOCTL_COMMAND_UNKNOWN;
 231                 return -EINVAL;
 232
 233         case RIO_GET_TABLE:
 234                 /*
 235                  ** Read the routing table from the device driver to user space
 236                  */
 237                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_TABLE\n");
 238
 239                 if ((retval = RIOApel(p)) != 0)
 240                         return retval;
 241
 242                 if (copy_to_user(arg, p->RIOConnectTable, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
 243                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_TABLE copy failed\n");
 244                         p->RIOError.Error = COPYOUT_FAILED;
 245                         return -EFAULT;
 246                 }
 247
 248                 {
 249                         int entry;
 250                         rio_dprintk(RIO_DEBUG_CTRL, "*****\nMAP ENTRIES\n");
 251                         for (entry = 0; entry < TOTAL_MAP_ENTRIES; entry++) {
 252                                 if ((p->RIOConnectTable[entry].ID == 0) && (p->RIOConnectTable[entry].HostUniqueNum == 0) && (p->RIOConnectTable[entry].RtaUniqueNum == 0))
 253                                         continue;
 254
 255                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.HostUniqueNum = 0x%x\n", entry, p->RIOConnectTable[entry].HostUniqueNum);
 256                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.RtaUniqueNum = 0x%x\n", entry, p->RIOConnectTable[entry].RtaUniqueNum);
 257                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.ID = 0x%x\n", entry, p->RIOConnectTable[entry].ID);
 258                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.ID2 = 0x%x\n", entry, p->RIOConnectTable[entry].ID2);
 259                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Flags = 0x%x\n", entry, (int) p->RIOConnectTable[entry].Flags);
 260                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.SysPort = 0x%x\n", entry, (int) p->RIOConnectTable[entry].SysPort);
 261                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[0].Unit = %x\n", entry, p->RIOConnectTable[entry].Topology[0].Unit);
 262                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[0].Link = %x\n", entry, p->RIOConnectTable[entry].Topology[0].Link);
 263                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[1].Unit = %x\n", entry, p->RIOConnectTable[entry].Topology[1].Unit);
 264                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[1].Link = %x\n", entry, p->RIOConnectTable[entry].Topology[1].Link);
 265                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[2].Unit = %x\n", entry, p->RIOConnectTable[entry].Topology[2].Unit);
 266                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[2].Link = %x\n", entry, p->RIOConnectTable[entry].Topology[2].Link);
 267                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[3].Unit = %x\n", entry, p->RIOConnectTable[entry].Topology[3].Unit);
 268                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Top[4].Link = %x\n", entry, p->RIOConnectTable[entry].Topology[3].Link);
 269                                 rio_dprintk(RIO_DEBUG_CTRL, "Map entry %d.Name = %s\n", entry, p->RIOConnectTable[entry].Name);
 270                         }
 271                         rio_dprintk(RIO_DEBUG_CTRL, "*****\nEND MAP ENTRIES\n");
 272                 }
 273                 p->RIOQuickCheck = NOT_CHANGED; /* a table has been gotten */
 274                 return 0;
 275
 276         case RIO_PUT_TABLE:
 277                 /*
 278                  ** Write the routing table to the device driver from user space
 279                  */
 280                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_TABLE\n");
 281
 282                 if (!su) {
 283                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_TABLE !Root\n");
 284                         p->RIOError.Error = NOT_SUPER_USER;
 285                         return -EPERM;
 286                 }
 287                 if (copy_from_user(&p->RIOConnectTable[0], arg, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
 288                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_TABLE copy failed\n");
 289                         p->RIOError.Error = COPYIN_FAILED;
 290                         return -EFAULT;
 291                 }
 292 /*
 293 ***********************************
 294                                 {
 295                                         int entry;
 296                                         rio_dprint(RIO_DEBUG_CTRL,  ("*****\nMAP ENTRIES\n") );
 297                                         for ( entry=0; entry<TOTAL_MAP_ENTRIES; entry++ )
 298                                         {
 299                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.HostUniqueNum = 0x%x\n", entry, p->RIOConnectTable[entry].HostUniqueNum ) );
 300                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.RtaUniqueNum = 0x%x\n", entry, p->RIOConnectTable[entry].RtaUniqueNum ) );
 301                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.ID = 0x%x\n", entry, p->RIOConnectTable[entry].ID ) );
 302                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.ID2 = 0x%x\n", entry, p->RIOConnectTable[entry].ID2 ) );
 303                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Flags = 0x%x\n", entry, p->RIOConnectTable[entry].Flags ) );
 304                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.SysPort = 0x%x\n", entry, p->RIOConnectTable[entry].SysPort ) );
 305                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[0].Unit = %b\n", entry, p->RIOConnectTable[entry].Topology[0].Unit ) );
 306                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[0].Link = %b\n", entry, p->RIOConnectTable[entry].Topology[0].Link ) );
 307                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[1].Unit = %b\n", entry, p->RIOConnectTable[entry].Topology[1].Unit ) );
 308                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[1].Link = %b\n", entry, p->RIOConnectTable[entry].Topology[1].Link ) );
 309                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[2].Unit = %b\n", entry, p->RIOConnectTable[entry].Topology[2].Unit ) );
 310                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[2].Link = %b\n", entry, p->RIOConnectTable[entry].Topology[2].Link ) );
 311                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[3].Unit = %b\n", entry, p->RIOConnectTable[entry].Topology[3].Unit ) );
 312                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Top[4].Link = %b\n", entry, p->RIOConnectTable[entry].Topology[3].Link ) );
 313                                                 rio_dprint(RIO_DEBUG_CTRL,  ("Map entry %d.Name = %s\n", entry, p->RIOConnectTable[entry].Name ) );
 314                                         }
 315                                         rio_dprint(RIO_DEBUG_CTRL,  ("*****\nEND MAP ENTRIES\n") );
 316                                 }
 317 ***********************************
 318 */
 319                 return RIONewTable(p);
 320
 321         case RIO_GET_BINDINGS:
 322                 /*
 323                  ** Send bindings table, containing unique numbers of RTAs owned
 324                  ** by this system to user space
 325                  */
 326                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_BINDINGS\n");
 327
 328                 if (!su) {
 329                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_BINDINGS !Root\n");
 330                         p->RIOError.Error = NOT_SUPER_USER;
 331                         return -EPERM;
 332                 }
 333                 if (copy_to_user(arg, p->RIOBindTab, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
 334                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_BINDINGS copy failed\n");
 335                         p->RIOError.Error = COPYOUT_FAILED;
 336                         return -EFAULT;
 337                 }
 338                 return 0;
 339
 340         case RIO_PUT_BINDINGS:
 341                 /*
 342                  ** Receive a bindings table, containing unique numbers of RTAs owned
 343                  ** by this system
 344                  */
 345                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_BINDINGS\n");
 346
 347                 if (!su) {
 348                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_BINDINGS !Root\n");
 349                         p->RIOError.Error = NOT_SUPER_USER;
 350                         return -EPERM;
 351                 }
 352                 if (copy_from_user(&p->RIOBindTab[0], arg, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
 353                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_BINDINGS copy failed\n");
 354                         p->RIOError.Error = COPYIN_FAILED;
 355                         return -EFAULT;
 356                 }
 357                 return 0;
 358
 359         case RIO_BIND_RTA:
 360                 {
 361                         int EmptySlot = -1;
 362                         /*
 363                          ** Bind this RTA to host, so that it will be booted by
 364                          ** host in 'boot owned RTAs' mode.
 365                          */
 366                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_BIND_RTA\n");
 367
 368                         if (!su) {
 369                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_BIND_RTA !Root\n");
 370                                 p->RIOError.Error = NOT_SUPER_USER;
 371                                 return -EPERM;
 372                         }
 373                         for (Entry = 0; Entry < MAX_RTA_BINDINGS; Entry++) {
 374                                 if ((EmptySlot == -1) && (p->RIOBindTab[Entry] == 0L))
 375                                         EmptySlot = Entry;
 376                                 else if (p->RIOBindTab[Entry] == (long)arg) {
 377                                         /*
 378                                          ** Already exists - delete
 379                                          */
 380                                         p->RIOBindTab[Entry] = 0L;
 381                                         rio_dprintk(RIO_DEBUG_CTRL, "Removing Rta %ld from p->RIOBindTab\n", (unsigned long)arg);
 382                                         return 0;
 383                                 }
 384                         }
 385                         /*
 386                          ** Dosen't exist - add
 387                          */
 388                         if (EmptySlot != -1) {
 389                                 p->RIOBindTab[EmptySlot] = (unsigned long)arg;
 390                                 rio_dprintk(RIO_DEBUG_CTRL, "Adding Rta %lx to p->RIOBindTab\n", (unsigned long) arg);
 391                         } else {
 392                                 rio_dprintk(RIO_DEBUG_CTRL, "p->RIOBindTab full! - Rta %lx not added\n", (unsigned long) arg);
 393                                 return -ENOMEM;
 394                         }
 395                         return 0;
 396                 }
 397
 398         case RIO_RESUME:
 399                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME\n");
 400                 port = (unsigned long) arg;
 401                 if ((port < 0) || (port > 511)) {
 402                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME: Bad port number %d\n", port);
 403                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 404                         return -EINVAL;
 405                 }
 406                 PortP = p->RIOPortp[port];
 407                 if (!PortP->Mapped) {
 408                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME: Port %d not mapped\n", port);
 409                         p->RIOError.Error = PORT_NOT_MAPPED_INTO_SYSTEM;
 410                         return -EINVAL;
 411                 }
 412                 if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
 413                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME: Port %d not open\n", port);
 414                         return -EINVAL;
 415                 }
 416
 417                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 418                 if (RIOPreemptiveCmd(p, (p->RIOPortp[port]), RESUME) == RIO_FAIL) {
 419                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME failed\n");
 420                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 421                         return -EBUSY;
 422                 } else {
 423                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME: Port %d resumed\n", port);
 424                         PortP->State |= RIO_BUSY;
 425                 }
 426                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 427                 return retval;
 428
 429         case RIO_ASSIGN_RTA:
 430                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_ASSIGN_RTA\n");
 431                 if (!su) {
 432                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_ASSIGN_RTA !Root\n");
 433                         p->RIOError.Error = NOT_SUPER_USER;
 434                         return -EPERM;
 435                 }
 436                 if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
 437                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from user space failed\n");
 438                         p->RIOError.Error = COPYIN_FAILED;
 439                         return -EFAULT;
 440                 }
 441                 return RIOAssignRta(p, &MapEnt);
 442
 443         case RIO_CHANGE_NAME:
 444                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_CHANGE_NAME\n");
 445                 if (!su) {
 446                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_CHANGE_NAME !Root\n");
 447                         p->RIOError.Error = NOT_SUPER_USER;
 448                         return -EPERM;
 449                 }
 450                 if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
 451                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from user space failed\n");
 452                         p->RIOError.Error = COPYIN_FAILED;
 453                         return -EFAULT;
 454                 }
 455                 return RIOChangeName(p, &MapEnt);
 456
 457         case RIO_DELETE_RTA:
 458                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_DELETE_RTA\n");
 459                 if (!su) {
 460                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_DELETE_RTA !Root\n");
 461                         p->RIOError.Error = NOT_SUPER_USER;
 462                         return -EPERM;
 463                 }
 464                 if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
 465                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from data space failed\n");
 466                         p->RIOError.Error = COPYIN_FAILED;
 467                         return -EFAULT;
 468                 }
 469                 return RIODeleteRta(p, &MapEnt);
 470
 471         case RIO_QUICK_CHECK:
 472                 if (copy_to_user(arg, &p->RIORtaDisCons, sizeof(unsigned int))) {
 473                         p->RIOError.Error = COPYOUT_FAILED;
 474                         return -EFAULT;
 475                 }
 476                 return 0;
 477
 478         case RIO_LAST_ERROR:
 479                 if (copy_to_user(arg, &p->RIOError, sizeof(struct Error)))
 480                         return -EFAULT;
 481                 return 0;
 482
 483         case RIO_GET_LOG:
 484                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_LOG\n");
 485                 return -EINVAL;
 486
 487         case RIO_GET_MODTYPE:
 488                 if (copy_from_user(&port, arg, sizeof(unsigned int))) {
 489                         p->RIOError.Error = COPYIN_FAILED;
 490                         return -EFAULT;
 491                 }
 492                 rio_dprintk(RIO_DEBUG_CTRL, "Get module type for port %d\n", port);
 493                 if (port < 0 || port > 511) {
 494                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_MODTYPE: Bad port number %d\n", port);
 495                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 496                         return -EINVAL;
 497                 }
 498                 PortP = (p->RIOPortp[port]);
 499                 if (!PortP->Mapped) {
 500                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_MODTYPE: Port %d not mapped\n", port);
 501                         p->RIOError.Error = PORT_NOT_MAPPED_INTO_SYSTEM;
 502                         return -EINVAL;
 503                 }
 504                 /*
 505                  ** Return module type of port
 506                  */
 507                 port = PortP->HostP->UnixRups[PortP->RupNum].ModTypes;
 508                 if (copy_to_user(arg, &port, sizeof(unsigned int))) {
 509                         p->RIOError.Error = COPYOUT_FAILED;
 510                         return -EFAULT;
 511                 }
 512                 return (0);
 513         case RIO_BLOCK_OPENS:
 514                 rio_dprintk(RIO_DEBUG_CTRL, "Opens block until booted\n");
 515                 for (Entry = 0; Entry < RIO_PORTS; Entry++) {
 516                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 517                         p->RIOPortp[Entry]->WaitUntilBooted = 1;
 518                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 519                 }
 520                 return 0;
 521
 522         case RIO_SETUP_PORTS:
 523                 rio_dprintk(RIO_DEBUG_CTRL, "Setup ports\n");
 524                 if (copy_from_user(&PortSetup, arg, sizeof(PortSetup))) {
 525                         p->RIOError.Error = COPYIN_FAILED;
 526                         rio_dprintk(RIO_DEBUG_CTRL, "EFAULT");
 527                         return -EFAULT;
 528                 }
 529                 if (PortSetup.From > PortSetup.To || PortSetup.To >= RIO_PORTS) {
 530                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 531                         rio_dprintk(RIO_DEBUG_CTRL, "ENXIO");
 532                         return -ENXIO;
 533                 }
 534                 if (PortSetup.XpCps > p->RIOConf.MaxXpCps || PortSetup.XpCps < p->RIOConf.MinXpCps) {
 535                         p->RIOError.Error = XPRINT_CPS_OUT_OF_RANGE;
 536                         rio_dprintk(RIO_DEBUG_CTRL, "EINVAL");
 537                         return -EINVAL;
 538                 }
 539                 if (!p->RIOPortp) {
 540                         printk(KERN_ERR "rio: No p->RIOPortp array!\n");
 541                         rio_dprintk(RIO_DEBUG_CTRL, "No p->RIOPortp array!\n");
 542                         return -EIO;
 543                 }
 544                 rio_dprintk(RIO_DEBUG_CTRL, "entering loop (%d %d)!\n", PortSetup.From, PortSetup.To);
 545                 for (loop = PortSetup.From; loop <= PortSetup.To; loop++) {
 546                         rio_dprintk(RIO_DEBUG_CTRL, "in loop (%d)!\n", loop);
 547                 }
 548                 rio_dprintk(RIO_DEBUG_CTRL, "after loop (%d)!\n", loop);
 549                 rio_dprintk(RIO_DEBUG_CTRL, "Retval:%x\n", retval);
 550                 return retval;
 551
 552         case RIO_GET_PORT_SETUP:
 553                 rio_dprintk(RIO_DEBUG_CTRL, "Get port setup\n");
 554                 if (copy_from_user(&PortSetup, arg, sizeof(PortSetup))) {
 555                         p->RIOError.Error = COPYIN_FAILED;
 556                         return -EFAULT;
 557                 }
 558                 if (PortSetup.From >= RIO_PORTS) {
 559                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 560                         return -ENXIO;
 561                 }
 562
 563                 port = PortSetup.To = PortSetup.From;
 564                 PortSetup.IxAny = (p->RIOPortp[port]->Config & RIO_IXANY) ? 1 : 0;
 565                 PortSetup.IxOn = (p->RIOPortp[port]->Config & RIO_IXON) ? 1 : 0;
 566                 PortSetup.Drain = (p->RIOPortp[port]->Config & RIO_WAITDRAIN) ? 1 : 0;
 567                 PortSetup.Store = p->RIOPortp[port]->Store;
 568                 PortSetup.Lock = p->RIOPortp[port]->Lock;
 569                 PortSetup.XpCps = p->RIOPortp[port]->Xprint.XpCps;
 570                 memcpy(PortSetup.XpOn, p->RIOPortp[port]->Xprint.XpOn, MAX_XP_CTRL_LEN);
 571                 memcpy(PortSetup.XpOff, p->RIOPortp[port]->Xprint.XpOff, MAX_XP_CTRL_LEN);
 572                 PortSetup.XpOn[MAX_XP_CTRL_LEN - 1] = '\0';
 573                 PortSetup.XpOff[MAX_XP_CTRL_LEN - 1] = '\0';
 574
 575                 if (copy_to_user(arg, &PortSetup, sizeof(PortSetup))) {
 576                         p->RIOError.Error = COPYOUT_FAILED;
 577                         return -EFAULT;
 578                 }
 579                 return retval;
 580
 581         case RIO_GET_PORT_PARAMS:
 582                 rio_dprintk(RIO_DEBUG_CTRL, "Get port params\n");
 583                 if (copy_from_user(&PortParams, arg, sizeof(struct PortParams))) {
 584                         p->RIOError.Error = COPYIN_FAILED;
 585                         return -EFAULT;
 586                 }
 587                 if (PortParams.Port >= RIO_PORTS) {
 588                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 589                         return -ENXIO;
 590                 }
 591                 PortP = (p->RIOPortp[PortParams.Port]);
 592                 PortParams.Config = PortP->Config;
 593                 PortParams.State = PortP->State;
 594                 rio_dprintk(RIO_DEBUG_CTRL, "Port %d\n", PortParams.Port);
 595
 596                 if (copy_to_user(arg, &PortParams, sizeof(struct PortParams))) {
 597                         p->RIOError.Error = COPYOUT_FAILED;
 598                         return -EFAULT;
 599                 }
 600                 return retval;
 601
 602         case RIO_GET_PORT_TTY:
 603                 rio_dprintk(RIO_DEBUG_CTRL, "Get port tty\n");
 604                 if (copy_from_user(&PortTty, arg, sizeof(struct PortTty))) {
 605                         p->RIOError.Error = COPYIN_FAILED;
 606                         return -EFAULT;
 607                 }
 608                 if (PortTty.port >= RIO_PORTS) {
 609                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 610                         return -ENXIO;
 611                 }
 612
 613                 rio_dprintk(RIO_DEBUG_CTRL, "Port %d\n", PortTty.port);
 614                 PortP = (p->RIOPortp[PortTty.port]);
 615                 if (copy_to_user(arg, &PortTty, sizeof(struct PortTty))) {
 616                         p->RIOError.Error = COPYOUT_FAILED;
 617                         return -EFAULT;
 618                 }
 619                 return retval;
 620
 621         case RIO_SET_PORT_TTY:
 622                 if (copy_from_user(&PortTty, arg, sizeof(struct PortTty))) {
 623                         p->RIOError.Error = COPYIN_FAILED;
 624                         return -EFAULT;
 625                 }
 626                 rio_dprintk(RIO_DEBUG_CTRL, "Set port %d tty\n", PortTty.port);
 627                 if (PortTty.port >= (ushort) RIO_PORTS) {
 628                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 629                         return -ENXIO;
 630                 }
 631                 PortP = (p->RIOPortp[PortTty.port]);
 632                 RIOParam(PortP, CONFIG, PortP->State & RIO_MODEM, OK_TO_SLEEP);
 633                 return retval;
 634
 635         case RIO_SET_PORT_PARAMS:
 636                 rio_dprintk(RIO_DEBUG_CTRL, "Set port params\n");
 637                 if (copy_from_user(&PortParams, arg, sizeof(PortParams))) {
 638                         p->RIOError.Error = COPYIN_FAILED;
 639                         return -EFAULT;
 640                 }
 641                 if (PortParams.Port >= (ushort) RIO_PORTS) {
 642                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 643                         return -ENXIO;
 644                 }
 645                 PortP = (p->RIOPortp[PortParams.Port]);
 646                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 647                 PortP->Config = PortParams.Config;
 648                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 649                 return retval;
 650
 651         case RIO_GET_PORT_STATS:
 652                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_PORT_STATS\n");
 653                 if (copy_from_user(&portStats, arg, sizeof(struct portStats))) {
 654                         p->RIOError.Error = COPYIN_FAILED;
 655                         return -EFAULT;
 656                 }
 657                 if (portStats.port >= RIO_PORTS) {
 658                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 659                         return -ENXIO;
 660                 }
 661                 PortP = (p->RIOPortp[portStats.port]);
 662                 portStats.gather = PortP->statsGather;
 663                 portStats.txchars = PortP->txchars;
 664                 portStats.rxchars = PortP->rxchars;
 665                 portStats.opens = PortP->opens;
 666                 portStats.closes = PortP->closes;
 667                 portStats.ioctls = PortP->ioctls;
 668                 if (copy_to_user(arg, &portStats, sizeof(struct portStats))) {
 669                         p->RIOError.Error = COPYOUT_FAILED;
 670                         return -EFAULT;
 671                 }
 672                 return retval;
 673
 674         case RIO_RESET_PORT_STATS:
 675                 port = (unsigned long) arg;
 676                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESET_PORT_STATS\n");
 677                 if (port >= RIO_PORTS) {
 678                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 679                         return -ENXIO;
 680                 }
 681                 PortP = (p->RIOPortp[port]);
 682                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 683                 PortP->txchars = 0;
 684                 PortP->rxchars = 0;
 685                 PortP->opens = 0;
 686                 PortP->closes = 0;
 687                 PortP->ioctls = 0;
 688                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 689                 return retval;
 690
 691         case RIO_GATHER_PORT_STATS:
 692                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GATHER_PORT_STATS\n");
 693                 if (copy_from_user(&portStats, arg, sizeof(struct portStats))) {
 694                         p->RIOError.Error = COPYIN_FAILED;
 695                         return -EFAULT;
 696                 }
 697                 if (portStats.port >= RIO_PORTS) {
 698                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 699                         return -ENXIO;
 700                 }
 701                 PortP = (p->RIOPortp[portStats.port]);
 702                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 703                 PortP->statsGather = portStats.gather;
 704                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 705                 return retval;
 706
 707         case RIO_READ_CONFIG:
 708                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_CONFIG\n");
 709                 if (copy_to_user(arg, &p->RIOConf, sizeof(struct Conf))) {
 710                         p->RIOError.Error = COPYOUT_FAILED;
 711                         return -EFAULT;
 712                 }
 713                 return retval;
 714
 715         case RIO_SET_CONFIG:
 716                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_CONFIG\n");
 717                 if (!su) {
 718                         p->RIOError.Error = NOT_SUPER_USER;
 719                         return -EPERM;
 720                 }
 721                 if (copy_from_user(&p->RIOConf, arg, sizeof(struct Conf))) {
 722                         p->RIOError.Error = COPYIN_FAILED;
 723                         return -EFAULT;
 724                 }
 725                 /*
 726                  ** move a few value around
 727                  */
 728                 for (Host = 0; Host < p->RIONumHosts; Host++)
 729                         if ((p->RIOHosts[Host].Flags & RUN_STATE) == RC_RUNNING)
 730                                 writew(p->RIOConf.Timer, &p->RIOHosts[Host].ParmMapP->timer);
 731                 return retval;
 732
 733         case RIO_START_POLLER:
 734                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_START_POLLER\n");
 735                 return -EINVAL;
 736
 737         case RIO_STOP_POLLER:
 738                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_STOP_POLLER\n");
 739                 if (!su) {
 740                         p->RIOError.Error = NOT_SUPER_USER;
 741                         return -EPERM;
 742                 }
 743                 p->RIOPolling = NOT_POLLING;
 744                 return retval;
 745
 746         case RIO_SETDEBUG:
 747         case RIO_GETDEBUG:
 748                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SETDEBUG/RIO_GETDEBUG\n");
 749                 if (copy_from_user(&DebugCtrl, arg, sizeof(DebugCtrl))) {
 750                         p->RIOError.Error = COPYIN_FAILED;
 751                         return -EFAULT;
 752                 }
 753                 if (DebugCtrl.SysPort == NO_PORT) {
 754                         if (cmd == RIO_SETDEBUG) {
 755                                 if (!su) {
 756                                         p->RIOError.Error = NOT_SUPER_USER;
 757                                         return -EPERM;
 758                                 }
 759                                 p->rio_debug = DebugCtrl.Debug;
 760                                 p->RIODebugWait = DebugCtrl.Wait;
 761                                 rio_dprintk(RIO_DEBUG_CTRL, "Set global debug to 0x%x set wait to 0x%x\n", p->rio_debug, p->RIODebugWait);
 762                         } else {
 763                                 rio_dprintk(RIO_DEBUG_CTRL, "Get global debug 0x%x wait 0x%x\n", p->rio_debug, p->RIODebugWait);
 764                                 DebugCtrl.Debug = p->rio_debug;
 765                                 DebugCtrl.Wait = p->RIODebugWait;
 766                                 if (copy_to_user(arg, &DebugCtrl, sizeof(DebugCtrl))) {
 767                                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET/GET DEBUG: bad port number %d\n", DebugCtrl.SysPort);
 768                                         p->RIOError.Error = COPYOUT_FAILED;
 769                                         return -EFAULT;
 770                                 }
 771                         }
 772                 } else if (DebugCtrl.SysPort >= RIO_PORTS && DebugCtrl.SysPort != NO_PORT) {
 773                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET/GET DEBUG: bad port number %d\n", DebugCtrl.SysPort);
 774                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 775                         return -ENXIO;
 776                 } else if (cmd == RIO_SETDEBUG) {
 777                         if (!su) {
 778                                 p->RIOError.Error = NOT_SUPER_USER;
 779                                 return -EPERM;
 780                         }
 781                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 782                         p->RIOPortp[DebugCtrl.SysPort]->Debug = DebugCtrl.Debug;
 783                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 784                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SETDEBUG 0x%x\n", p->RIOPortp[DebugCtrl.SysPort]->Debug);
 785                 } else {
 786                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GETDEBUG 0x%x\n", p->RIOPortp[DebugCtrl.SysPort]->Debug);
 787                         DebugCtrl.Debug = p->RIOPortp[DebugCtrl.SysPort]->Debug;
 788                         if (copy_to_user(arg, &DebugCtrl, sizeof(DebugCtrl))) {
 789                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GETDEBUG: Bad copy to user space\n");
 790                                 p->RIOError.Error = COPYOUT_FAILED;
 791                                 return -EFAULT;
 792                         }
 793                 }
 794                 return retval;
 795
 796         case RIO_VERSID:
 797                 /*
 798                  ** Enquire about the release and version.
 799                  ** We return MAX_VERSION_LEN bytes, being a
 800                  ** textual null terminated string.
 801                  */
 802                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_VERSID\n");
 803                 if (copy_to_user(arg, RIOVersid(), sizeof(struct rioVersion))) {
 804                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_VERSID: Bad copy to user space (host=%d)\n", Host);
 805                         p->RIOError.Error = COPYOUT_FAILED;
 806                         return -EFAULT;
 807                 }
 808                 return retval;
 809
 810         case RIO_NUM_HOSTS:
 811                 /*
 812                  ** Enquire as to the number of hosts located
 813                  ** at init time.
 814                  */
 815                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_NUM_HOSTS\n");
 816                 if (copy_to_user(arg, &p->RIONumHosts, sizeof(p->RIONumHosts))) {
 817                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_NUM_HOSTS: Bad copy to user space\n");
 818                         p->RIOError.Error = COPYOUT_FAILED;
 819                         return -EFAULT;
 820                 }
 821                 return retval;
 822
 823         case RIO_HOST_FOAD:
 824                 /*
 825                  ** Kill host. This may not be in the final version...
 826                  */
 827                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD %ld\n", (unsigned long) arg);
 828                 if (!su) {
 829                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD: Not super user\n");
 830                         p->RIOError.Error = NOT_SUPER_USER;
 831                         return -EPERM;
 832                 }
 833                 p->RIOHalted = 1;
 834                 p->RIOSystemUp = 0;
 835
 836                 for (Host = 0; Host < p->RIONumHosts; Host++) {
 837                         (void) RIOBoardTest(p->RIOHosts[Host].PaddrP, p->RIOHosts[Host].Caddr, p->RIOHosts[Host].Type, p->RIOHosts[Host].Slot);
 838                         memset(&p->RIOHosts[Host].Flags, 0, ((char *) &p->RIOHosts[Host].____end_marker____) - ((char *) &p->RIOHosts[Host].Flags));
 839                         p->RIOHosts[Host].Flags = RC_WAITING;
 840                 }
 841                 RIOFoadWakeup(p);
 842                 p->RIONumBootPkts = 0;
 843                 p->RIOBooting = 0;
 844                 printk("HEEEEELP!\n");
 845
 846                 for (loop = 0; loop < RIO_PORTS; loop++) {
 847                         spin_lock_init(&p->RIOPortp[loop]->portSem);
 848                         p->RIOPortp[loop]->InUse = NOT_INUSE;
 849                 }
 850
 851                 p->RIOSystemUp = 0;
 852                 return retval;
 853
 854         case RIO_DOWNLOAD:
 855                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_DOWNLOAD\n");
 856                 if (!su) {
 857                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_DOWNLOAD: Not super user\n");
 858                         p->RIOError.Error = NOT_SUPER_USER;
 859                         return -EPERM;
 860                 }
 861                 if (copy_from_user(&DownLoad, arg, sizeof(DownLoad))) {
 862                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_DOWNLOAD: Copy in from user space failed\n");
 863                         p->RIOError.Error = COPYIN_FAILED;
 864                         return -EFAULT;
 865                 }
 866                 rio_dprintk(RIO_DEBUG_CTRL, "Copied in download code for product code 0x%x\n", DownLoad.ProductCode);
 867
 868                 /*
 869                  ** It is important that the product code is an unsigned object!
 870                  */
 871                 if (DownLoad.ProductCode > MAX_PRODUCT) {
 872                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_DOWNLOAD: Bad product code %d passed\n", DownLoad.ProductCode);
 873                         p->RIOError.Error = NO_SUCH_PRODUCT;
 874                         return -ENXIO;
 875                 }
 876                 /*
 877                  ** do something!
 878                  */
 879                 retval = (*(RIOBootTable[DownLoad.ProductCode])) (p, &DownLoad);
 880                 /* <-- Panic */
 881                 p->RIOHalted = 0;
 882                 /*
 883                  ** and go back, content with a job well completed.
 884                  */
 885                 return retval;
 886
 887         case RIO_PARMS:
 888                 {
 889                         unsigned int host;
 890
 891                         if (copy_from_user(&host, arg, sizeof(host))) {
 892                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Copy in from user space failed\n");
 893                                 p->RIOError.Error = COPYIN_FAILED;
 894                                 return -EFAULT;
 895                         }
 896                         /*
 897                          ** Fetch the parmmap
 898                          */
 899                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PARMS\n");
 900                         if (copy_to_user(arg, p->RIOHosts[host].ParmMapP, sizeof(PARM_MAP))) {
 901                                 p->RIOError.Error = COPYOUT_FAILED;
 902                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_PARMS: Copy out to user space failed\n");
 903                                 return -EFAULT;
 904                         }
 905                 }
 906                 return retval;
 907
 908         case RIO_HOST_REQ:
 909                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ\n");
 910                 if (copy_from_user(&HostReq, arg, sizeof(HostReq))) {
 911                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Copy in from user space failed\n");
 912                         p->RIOError.Error = COPYIN_FAILED;
 913                         return -EFAULT;
 914                 }
 915                 if (HostReq.HostNum >= p->RIONumHosts) {
 916                         p->RIOError.Error = HOST_NUMBER_OUT_OF_RANGE;
 917                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Illegal host number %d\n", HostReq.HostNum);
 918                         return -ENXIO;
 919                 }
 920                 rio_dprintk(RIO_DEBUG_CTRL, "Request for host %d\n", HostReq.HostNum);
 921
 922                 if (copy_to_user(HostReq.HostP, &p->RIOHosts[HostReq.HostNum], sizeof(struct Host))) {
 923                         p->RIOError.Error = COPYOUT_FAILED;
 924                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Bad copy to user space\n");
 925                         return -EFAULT;
 926                 }
 927                 return retval;
 928
 929         case RIO_HOST_DPRAM:
 930                 rio_dprintk(RIO_DEBUG_CTRL, "Request for DPRAM\n");
 931                 if (copy_from_user(&HostDpRam, arg, sizeof(HostDpRam))) {
 932                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Copy in from user space failed\n");
 933                         p->RIOError.Error = COPYIN_FAILED;
 934                         return -EFAULT;
 935                 }
 936                 if (HostDpRam.HostNum >= p->RIONumHosts) {
 937                         p->RIOError.Error = HOST_NUMBER_OUT_OF_RANGE;
 938                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Illegal host number %d\n", HostDpRam.HostNum);
 939                         return -ENXIO;
 940                 }
 941                 rio_dprintk(RIO_DEBUG_CTRL, "Request for host %d\n", HostDpRam.HostNum);
 942
 943                 if (p->RIOHosts[HostDpRam.HostNum].Type == RIO_PCI) {
 944                         int off;
 945                         /* It's hardware like this that really gets on my tits. */
 946                         static unsigned char copy[sizeof(struct DpRam)];
 947                         for (off = 0; off < sizeof(struct DpRam); off++)
 948                                 copy[off] = readb(&p->RIOHosts[HostDpRam.HostNum].Caddr[off]);
 949                         if (copy_to_user(HostDpRam.DpRamP, copy, sizeof(struct DpRam))) {
 950                                 p->RIOError.Error = COPYOUT_FAILED;
 951                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Bad copy to user space\n");
 952                                 return -EFAULT;
 953                         }
 954                 } else if (copy_to_user(HostDpRam.DpRamP, p->RIOHosts[HostDpRam.HostNum].Caddr, sizeof(struct DpRam))) {
 955                         p->RIOError.Error = COPYOUT_FAILED;
 956                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Bad copy to user space\n");
 957                         return -EFAULT;
 958                 }
 959                 return retval;
 960
 961         case RIO_SET_BUSY:
 962                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY\n");
 963                 if ((unsigned long) arg > 511) {
 964                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY: Bad port number %ld\n", (unsigned long) arg);
 965                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 966                         return -EINVAL;
 967                 }
 968                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 969                 p->RIOPortp[(unsigned long) arg]->State |= RIO_BUSY;
 970                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 971                 return retval;
 972
 973         case RIO_HOST_PORT:
 974                 /*
 975                  ** The daemon want port information
 976                  ** (probably for debug reasons)
 977                  */
 978                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT\n");
 979                 if (copy_from_user(&PortReq, arg, sizeof(PortReq))) {
 980                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT: Copy in from user space failed\n");
 981                         p->RIOError.Error = COPYIN_FAILED;
 982                         return -EFAULT;
 983                 }
 984
 985                 if (PortReq.SysPort >= RIO_PORTS) {     /* SysPort is unsigned */
 986                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT: Illegal port number %d\n", PortReq.SysPort);
 987                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
 988                         return -ENXIO;
 989                 }
 990                 rio_dprintk(RIO_DEBUG_CTRL, "Request for port %d\n", PortReq.SysPort);
 991                 if (copy_to_user(PortReq.PortP, p->RIOPortp[PortReq.SysPort], sizeof(struct Port))) {
 992                         p->RIOError.Error = COPYOUT_FAILED;
 993                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT: Bad copy to user space\n");
 994                         return -EFAULT;
 995                 }
 996                 return retval;
 997
 998         case RIO_HOST_RUP:
 999                 /*
1000                  ** The daemon want rup information
1001                  ** (probably for debug reasons)
1002                  */
1003                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP\n");
1004                 if (copy_from_user(&RupReq, arg, sizeof(RupReq))) {
1005                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Copy in from user space failed\n");
1006                         p->RIOError.Error = COPYIN_FAILED;
1007                         return -EFAULT;
1008                 }
1009                 if (RupReq.HostNum >= p->RIONumHosts) { /* host is unsigned */
1010                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Illegal host number %d\n", RupReq.HostNum);
1011                         p->RIOError.Error = HOST_NUMBER_OUT_OF_RANGE;
1012                         return -ENXIO;
1013                 }
1014                 if (RupReq.RupNum >= MAX_RUP + LINKS_PER_UNIT) {        /* eek! */
1015                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Illegal rup number %d\n", RupReq.RupNum);
1016                         p->RIOError.Error = RUP_NUMBER_OUT_OF_RANGE;
1017                         return -EINVAL;
1018                 }
1019                 HostP = &p->RIOHosts[RupReq.HostNum];
1020
1021                 if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
1022                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Host %d not running\n", RupReq.HostNum);
1023                         p->RIOError.Error = HOST_NOT_RUNNING;
1024                         return -EIO;
1025                 }
1026                 rio_dprintk(RIO_DEBUG_CTRL, "Request for rup %d from host %d\n", RupReq.RupNum, RupReq.HostNum);
1027
1028                 if (copy_to_user(HostP->UnixRups[RupReq.RupNum].RupP, RupReq.RupP, sizeof(struct RUP))) {
1029                         p->RIOError.Error = COPYOUT_FAILED;
1030                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Bad copy to user space\n");
1031                         return -EFAULT;
1032                 }
1033                 return retval;
1034
1035         case RIO_HOST_LPB:
1036                 /*
1037                  ** The daemon want lpb information
1038                  ** (probably for debug reasons)
1039                  */
1040                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB\n");
1041                 if (copy_from_user(&LpbReq, arg, sizeof(LpbReq))) {
1042                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Bad copy from user space\n");
1043                         p->RIOError.Error = COPYIN_FAILED;
1044                         return -EFAULT;
1045                 }
1046                 if (LpbReq.Host >= p->RIONumHosts) {    /* host is unsigned */
1047                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Illegal host number %d\n", LpbReq.Host);
1048                         p->RIOError.Error = HOST_NUMBER_OUT_OF_RANGE;
1049                         return -ENXIO;
1050                 }
1051                 if (LpbReq.Link >= LINKS_PER_UNIT) {    /* eek! */
1052                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Illegal link number %d\n", LpbReq.Link);
1053                         p->RIOError.Error = LINK_NUMBER_OUT_OF_RANGE;
1054                         return -EINVAL;
1055                 }
1056                 HostP = &p->RIOHosts[LpbReq.Host];
1057
1058                 if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
1059                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Host %d not running\n", LpbReq.Host);
1060                         p->RIOError.Error = HOST_NOT_RUNNING;
1061                         return -EIO;
1062                 }
1063                 rio_dprintk(RIO_DEBUG_CTRL, "Request for lpb %d from host %d\n", LpbReq.Link, LpbReq.Host);
1064
1065                 if (copy_to_user(LpbReq.LpbP, &HostP->LinkStrP[LpbReq.Link], sizeof(struct LPB))) {
1066                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Bad copy to user space\n");
1067                         p->RIOError.Error = COPYOUT_FAILED;
1068                         return -EFAULT;
1069                 }
1070                 return retval;
1071
1072                 /*
1073                  ** Here 3 IOCTL's that allow us to change the way in which
1074                  ** rio logs errors. send them just to syslog or send them
1075                  ** to both syslog and console or send them to just the console.
1076                  **
1077                  ** See RioStrBuf() in util.c for the other half.
1078                  */
1079         case RIO_SYSLOG_ONLY:
1080                 p->RIOPrintLogState = PRINT_TO_LOG;     /* Just syslog */
1081                 return 0;
1082
1083         case RIO_SYSLOG_CONS:
1084                 p->RIOPrintLogState = PRINT_TO_LOG_CONS;        /* syslog and console */
1085                 return 0;
1086
1087         case RIO_CONS_ONLY:
1088                 p->RIOPrintLogState = PRINT_TO_CONS;    /* Just console */
1089                 return 0;
1090
1091         case RIO_SIGNALS_ON:
1092                 if (p->RIOSignalProcess) {
1093                         p->RIOError.Error = SIGNALS_ALREADY_SET;
1094                         return -EBUSY;
1095                 }
1096                 /* FIXME: PID tracking */
1097                 p->RIOSignalProcess = current->pid;
1098                 p->RIOPrintDisabled = DONT_PRINT;
1099                 return retval;
1100
1101         case RIO_SIGNALS_OFF:
1102                 if (p->RIOSignalProcess != current->pid) {
1103                         p->RIOError.Error = NOT_RECEIVING_PROCESS;
1104                         return -EPERM;
1105                 }
1106                 rio_dprintk(RIO_DEBUG_CTRL, "Clear signal process to zero\n");
1107                 p->RIOSignalProcess = 0;
1108                 return retval;
1109
1110         case RIO_SET_BYTE_MODE:
1111                 for (Host = 0; Host < p->RIONumHosts; Host++)
1112                         if (p->RIOHosts[Host].Type == RIO_AT)
1113                                 p->RIOHosts[Host].Mode &= ~WORD_OPERATION;
1114                 return retval;
1115
1116         case RIO_SET_WORD_MODE:
1117                 for (Host = 0; Host < p->RIONumHosts; Host++)
1118                         if (p->RIOHosts[Host].Type == RIO_AT)
1119                                 p->RIOHosts[Host].Mode |= WORD_OPERATION;
1120                 return retval;
1121
1122         case RIO_SET_FAST_BUS:
1123                 for (Host = 0; Host < p->RIONumHosts; Host++)
1124                         if (p->RIOHosts[Host].Type == RIO_AT)
1125                                 p->RIOHosts[Host].Mode |= FAST_AT_BUS;
1126                 return retval;
1127
1128         case RIO_SET_SLOW_BUS:
1129                 for (Host = 0; Host < p->RIONumHosts; Host++)
1130                         if (p->RIOHosts[Host].Type == RIO_AT)
1131                                 p->RIOHosts[Host].Mode &= ~FAST_AT_BUS;
1132                 return retval;
1133
1134         case RIO_MAP_B50_TO_50:
1135         case RIO_MAP_B50_TO_57600:
1136         case RIO_MAP_B110_TO_110:
1137         case RIO_MAP_B110_TO_115200:
1138                 rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping\n");
1139                 port = (unsigned long) arg;
1140                 if (port < 0 || port > 511) {
1141                         rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping: Bad port number %d\n", port);
1142                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
1143                         return -EINVAL;
1144                 }
1145                 rio_spin_lock_irqsave(&PortP->portSem, flags);
1146                 switch (cmd) {
1147                 case RIO_MAP_B50_TO_50:
1148                         p->RIOPortp[port]->Config |= RIO_MAP_50_TO_50;
1149                         break;
1150                 case RIO_MAP_B50_TO_57600:
1151                         p->RIOPortp[port]->Config &= ~RIO_MAP_50_TO_50;
1152                         break;
1153                 case RIO_MAP_B110_TO_110:
1154                         p->RIOPortp[port]->Config |= RIO_MAP_110_TO_110;
1155                         break;
1156                 case RIO_MAP_B110_TO_115200:
1157                         p->RIOPortp[port]->Config &= ~RIO_MAP_110_TO_110;
1158                         break;
1159                 }
1160                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1161                 return retval;
1162
1163         case RIO_STREAM_INFO:
1164                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_STREAM_INFO\n");
1165                 return -EINVAL;
1166
1167         case RIO_SEND_PACKET:
1168                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SEND_PACKET\n");
1169                 if (copy_from_user(&SendPack, arg, sizeof(SendPack))) {
1170                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SEND_PACKET: Bad copy from user space\n");
1171                         p->RIOError.Error = COPYIN_FAILED;
1172                         return -EFAULT;
1173                 }
1174                 if (SendPack.PortNum >= 128) {
1175                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
1176                         return -ENXIO;
1177                 }
1178
1179                 PortP = p->RIOPortp[SendPack.PortNum];
1180                 rio_spin_lock_irqsave(&PortP->portSem, flags);
1181
1182                 if (!can_add_transmit(&PacketP, PortP)) {
1183                         p->RIOError.Error = UNIT_IS_IN_USE;
1184                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1185                         return -ENOSPC;
1186                 }
1187
1188                 for (loop = 0; loop < (ushort) (SendPack.Len & 127); loop++)
1189                         writeb(SendPack.Data[loop], &PacketP->data[loop]);
1190
1191                 writeb(SendPack.Len, &PacketP->len);
1192
1193                 add_transmit(PortP);
1194                 /*
1195                  ** Count characters transmitted for port statistics reporting
1196                  */
1197                 if (PortP->statsGather)
1198                         PortP->txchars += (SendPack.Len & 127);
1199                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1200                 return retval;
1201
1202         case RIO_NO_MESG:
1203                 if (su)
1204                         p->RIONoMessage = 1;
1205                 return su ? 0 : -EPERM;
1206
1207         case RIO_MESG:
1208                 if (su)
1209                         p->RIONoMessage = 0;
1210                 return su ? 0 : -EPERM;
1211
1212         case RIO_WHAT_MESG:
1213                 if (copy_to_user(arg, &p->RIONoMessage, sizeof(p->RIONoMessage))) {
1214                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_WHAT_MESG: Bad copy to user space\n");
1215                         p->RIOError.Error = COPYOUT_FAILED;
1216                         return -EFAULT;
1217                 }
1218                 return 0;
1219
1220         case RIO_MEM_DUMP:
1221                 if (copy_from_user(&SubCmd, arg, sizeof(struct SubCmdStruct))) {
1222                         p->RIOError.Error = COPYIN_FAILED;
1223                         return -EFAULT;
1224                 }
1225                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_MEM_DUMP host %d rup %d addr %x\n", SubCmd.Host, SubCmd.Rup, SubCmd.Addr);
1226
1227                 if (SubCmd.Rup >= MAX_RUP + LINKS_PER_UNIT) {
1228                         p->RIOError.Error = RUP_NUMBER_OUT_OF_RANGE;
1229                         return -EINVAL;
1230                 }
1231
1232                 if (SubCmd.Host >= p->RIONumHosts) {
1233                         p->RIOError.Error = HOST_NUMBER_OUT_OF_RANGE;
1234                         return -EINVAL;
1235                 }
1236
1237                 port = p->RIOHosts[SubCmd.Host].UnixRups[SubCmd.Rup].BaseSysPort;
1238
1239                 PortP = p->RIOPortp[port];
1240
1241                 rio_spin_lock_irqsave(&PortP->portSem, flags);
1242
1243                 if (RIOPreemptiveCmd(p, PortP, MEMDUMP) == RIO_FAIL) {
1244                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_MEM_DUMP failed\n");
1245                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1246                         return -EBUSY;
1247                 } else
1248                         PortP->State |= RIO_BUSY;
1249
1250                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1251                 if (copy_to_user(arg, p->RIOMemDump, MEMDUMP_SIZE)) {
1252                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_MEM_DUMP copy failed\n");
1253                         p->RIOError.Error = COPYOUT_FAILED;
1254                         return -EFAULT;
1255                 }
1256                 return 0;
1257
1258         case RIO_TICK:
1259                 if ((unsigned long) arg >= p->RIONumHosts)
1260                         return -EINVAL;
1261                 rio_dprintk(RIO_DEBUG_CTRL, "Set interrupt for host %ld\n", (unsigned long) arg);
1262                 writeb(0xFF, &p->RIOHosts[(unsigned long) arg].SetInt);
1263                 return 0;
1264
1265         case RIO_TOCK:
1266                 if ((unsigned long) arg >= p->RIONumHosts)
1267                         return -EINVAL;
1268                 rio_dprintk(RIO_DEBUG_CTRL, "Clear interrupt for host %ld\n", (unsigned long) arg);
1269                 writeb(0xFF, &p->RIOHosts[(unsigned long) arg].ResetInt);
1270                 return 0;
1271
1272         case RIO_READ_CHECK:
1273                 /* Check reads for pkts with data[0] the same */
1274                 p->RIOReadCheck = !p->RIOReadCheck;
1275                 if (copy_to_user(arg, &p->RIOReadCheck, sizeof(unsigned int))) {
1276                         p->RIOError.Error = COPYOUT_FAILED;
1277                         return -EFAULT;
1278                 }
1279                 return 0;
1280
1281         case RIO_READ_REGISTER:
1282                 if (copy_from_user(&SubCmd, arg, sizeof(struct SubCmdStruct))) {
1283                         p->RIOError.Error = COPYIN_FAILED;
1284                         return -EFAULT;
1285                 }
1286                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_REGISTER host %d rup %d port %d reg %x\n", SubCmd.Host, SubCmd.Rup, SubCmd.Port, SubCmd.Addr);
1287
1288                 if (SubCmd.Port > 511) {
1289                         rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping: Bad port number %d\n", SubCmd.Port);
1290                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
1291                         return -EINVAL;
1292                 }
1293
1294                 if (SubCmd.Rup >= MAX_RUP + LINKS_PER_UNIT) {
1295                         p->RIOError.Error = RUP_NUMBER_OUT_OF_RANGE;
1296                         return -EINVAL;
1297                 }
1298
1299                 if (SubCmd.Host >= p->RIONumHosts) {
1300                         p->RIOError.Error = HOST_NUMBER_OUT_OF_RANGE;
1301                         return -EINVAL;
1302                 }
1303
1304                 port = p->RIOHosts[SubCmd.Host].UnixRups[SubCmd.Rup].BaseSysPort + SubCmd.Port;
1305                 PortP = p->RIOPortp[port];
1306
1307                 rio_spin_lock_irqsave(&PortP->portSem, flags);
1308
1309                 if (RIOPreemptiveCmd(p, PortP, READ_REGISTER) == RIO_FAIL) {
1310                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_REGISTER failed\n");
1311                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1312                         return -EBUSY;
1313                 } else
1314                         PortP->State |= RIO_BUSY;
1315
1316                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1317                 if (copy_to_user(arg, &p->CdRegister, sizeof(unsigned int))) {
1318                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_REGISTER copy failed\n");
1319                         p->RIOError.Error = COPYOUT_FAILED;
1320                         return -EFAULT;
1321                 }
1322                 return 0;
1323                 /*
1324                  ** rio_make_dev: given port number (0-511) ORed with port type
1325                  ** (RIO_DEV_DIRECT, RIO_DEV_MODEM, RIO_DEV_XPRINT) return dev_t
1326                  ** value to pass to mknod to create the correct device node.
1327                  */
1328         case RIO_MAKE_DEV:
1329                 {
1330                         unsigned int port = (unsigned long) arg & RIO_MODEM_MASK;
1331                         unsigned int ret;
1332
1333                         switch ((unsigned long) arg & RIO_DEV_MASK) {
1334                         case RIO_DEV_DIRECT:
1335                                 ret = drv_makedev(MAJOR(dev), port);
1336                                 rio_dprintk(RIO_DEBUG_CTRL, "Makedev direct 0x%x is 0x%x\n", port, ret);
1337                                 return ret;
1338                         case RIO_DEV_MODEM:
1339                                 ret = drv_makedev(MAJOR(dev), (port | RIO_MODEM_BIT));
1340                                 rio_dprintk(RIO_DEBUG_CTRL, "Makedev modem 0x%x is 0x%x\n", port, ret);
1341                                 return ret;
1342                         case RIO_DEV_XPRINT:
1343                                 ret = drv_makedev(MAJOR(dev), port);
1344                                 rio_dprintk(RIO_DEBUG_CTRL, "Makedev printer 0x%x is 0x%x\n", port, ret);
1345                                 return ret;
1346                         }
1347                         rio_dprintk(RIO_DEBUG_CTRL, "MAKE Device is called\n");
1348                         return -EINVAL;
1349                 }
1350                 /*
1351                  ** rio_minor: given a dev_t from a stat() call, return
1352                  ** the port number (0-511) ORed with the port type
1353                  ** ( RIO_DEV_DIRECT, RIO_DEV_MODEM, RIO_DEV_XPRINT )
1354                  */
1355         case RIO_MINOR:
1356                 {
1357                         dev_t dv;
1358                         int mino;
1359                         unsigned long ret;
1360
1361                         dv = (dev_t) ((unsigned long) arg);
1362                         mino = RIO_UNMODEM(dv);
1363
1364                         if (RIO_ISMODEM(dv)) {
1365                                 rio_dprintk(RIO_DEBUG_CTRL, "Minor for device 0x%x: modem %d\n", dv, mino);
1366                                 ret = mino | RIO_DEV_MODEM;
1367                         } else {
1368                                 rio_dprintk(RIO_DEBUG_CTRL, "Minor for device 0x%x: direct %d\n", dv, mino);
1369                                 ret = mino | RIO_DEV_DIRECT;
1370                         }
1371                         return ret;
1372                 }
1373         }
1374         rio_dprintk(RIO_DEBUG_CTRL, "INVALID DAEMON IOCTL 0x%x\n", cmd);
1375         p->RIOError.Error = IOCTL_COMMAND_UNKNOWN;
1376
1377         func_exit();
1378         return -EINVAL;
1379 }
1380
1381 /*
1382 ** Pre-emptive commands go on RUPs and are only one byte long.
1383 */
1384 int RIOPreemptiveCmd(struct rio_info *p, struct Port *PortP, u8 Cmd)
1385 {
1386         struct CmdBlk *CmdBlkP;
1387         struct PktCmd_M *PktCmdP;
1388         int Ret;
1389         ushort rup;
1390         int port;
1391
1392         if (PortP->State & RIO_DELETED) {
1393                 rio_dprintk(RIO_DEBUG_CTRL, "Preemptive command to deleted RTA ignored\n");
1394                 return RIO_FAIL;
1395         }
1396
1397         if (((int) ((char) PortP->InUse) == -1) || !(CmdBlkP = RIOGetCmdBlk())) {
1398                 rio_dprintk(RIO_DEBUG_CTRL, "Cannot allocate command block for command %d on port %d\n", Cmd, PortP->PortNum);
1399                 return RIO_FAIL;
1400         }
1401
1402         rio_dprintk(RIO_DEBUG_CTRL, "Command blk %p - InUse now %d\n", CmdBlkP, PortP->InUse);
1403
1404         PktCmdP = (struct PktCmd_M *) &CmdBlkP->Packet.data[0];
1405
1406         CmdBlkP->Packet.src_unit = 0;
1407         if (PortP->SecondBlock)
1408                 rup = PortP->ID2;
1409         else
1410                 rup = PortP->RupNum;
1411         CmdBlkP->Packet.dest_unit = rup;
1412         CmdBlkP->Packet.src_port = COMMAND_RUP;
1413         CmdBlkP->Packet.dest_port = COMMAND_RUP;
1414         CmdBlkP->Packet.len = PKT_CMD_BIT | 2;
1415         CmdBlkP->PostFuncP = RIOUnUse;
1416         CmdBlkP->PostArg = (unsigned long) PortP;
1417         PktCmdP->Command = Cmd;
1418         port = PortP->HostPort % (ushort) PORTS_PER_RTA;
1419         /*
1420          ** Index ports 8-15 for 2nd block of 16 port RTA.
1421          */
1422         if (PortP->SecondBlock)
1423                 port += (ushort) PORTS_PER_RTA;
1424         PktCmdP->PhbNum = port;
1425
1426         switch (Cmd) {
1427         case MEMDUMP:
1428                 rio_dprintk(RIO_DEBUG_CTRL, "Queue MEMDUMP command blk %p (addr 0x%x)\n", CmdBlkP, (int) SubCmd.Addr);
1429                 PktCmdP->SubCommand = MEMDUMP;
1430                 PktCmdP->SubAddr = SubCmd.Addr;
1431                 break;
1432         case FCLOSE:
1433                 rio_dprintk(RIO_DEBUG_CTRL, "Queue FCLOSE command blk %p\n", CmdBlkP);
1434                 break;
1435         case READ_REGISTER:
1436                 rio_dprintk(RIO_DEBUG_CTRL, "Queue READ_REGISTER (0x%x) command blk %p\n", (int) SubCmd.Addr, CmdBlkP);
1437                 PktCmdP->SubCommand = READ_REGISTER;
1438                 PktCmdP->SubAddr = SubCmd.Addr;
1439                 break;
1440         case RESUME:
1441                 rio_dprintk(RIO_DEBUG_CTRL, "Queue RESUME command blk %p\n", CmdBlkP);
1442                 break;
1443         case RFLUSH:
1444                 rio_dprintk(RIO_DEBUG_CTRL, "Queue RFLUSH command blk %p\n", CmdBlkP);
1445                 CmdBlkP->PostFuncP = RIORFlushEnable;
1446                 break;
1447         case SUSPEND:
1448                 rio_dprintk(RIO_DEBUG_CTRL, "Queue SUSPEND command blk %p\n", CmdBlkP);
1449                 break;
1450
1451         case MGET:
1452                 rio_dprintk(RIO_DEBUG_CTRL, "Queue MGET command blk %p\n", CmdBlkP);
1453                 break;
1454
1455         case MSET:
1456         case MBIC:
1457         case MBIS:
1458                 CmdBlkP->Packet.data[4] = (char) PortP->ModemLines;
1459                 rio_dprintk(RIO_DEBUG_CTRL, "Queue MSET/MBIC/MBIS command blk %p\n", CmdBlkP);
1460                 break;
1461
1462         case WFLUSH:
1463                 /*
1464                  ** If we have queued up the maximum number of Write flushes
1465                  ** allowed then we should not bother sending any more to the
1466                  ** RTA.
1467                  */
1468                 if ((int) ((char) PortP->WflushFlag) == (int) -1) {
1469                         rio_dprintk(RIO_DEBUG_CTRL, "Trashed WFLUSH, WflushFlag about to wrap!");
1470                         RIOFreeCmdBlk(CmdBlkP);
1471                         return (RIO_FAIL);
1472                 } else {
1473                         rio_dprintk(RIO_DEBUG_CTRL, "Queue WFLUSH command blk %p\n", CmdBlkP);
1474                         CmdBlkP->PostFuncP = RIOWFlushMark;
1475                 }
1476                 break;
1477         }
1478
1479         PortP->InUse++;
1480
1481         Ret = RIOQueueCmdBlk(PortP->HostP, rup, CmdBlkP);
1482
1483         return Ret;
1484 }