Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / drivers / char / rio / riotty.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          : riotty.c
24 **      SID             : 1.3
25 **      Last Modified   : 11/6/98 10:33:47
26 **      Retrieved       : 11/6/98 10:33:50
27 **
28 **  ident @(#)riotty.c  1.3
29 **
30 ** -----------------------------------------------------------------------------
31 */
32 #ifdef SCCS_LABELS
33 static char *_riotty_c_sccs_ = "@(#)riotty.c    1.3";
34 #endif
35
36
37 #define __EXPLICIT_DEF_H__
38
39 #include <linux/module.h>
40 #include <linux/slab.h>
41 #include <linux/errno.h>
42 #include <linux/tty.h>
43 #include <linux/string.h>
44 #include <asm/io.h>
45 #include <asm/system.h>
46 #include <asm/string.h>
47 #include <asm/semaphore.h>
48 #include <asm/uaccess.h>
49
50 #include <linux/termios.h>
51
52 #include <linux/serial.h>
53
54 #include <linux/generic_serial.h>
55
56
57 #include "linux_compat.h"
58 #include "rio_linux.h"
59 #include "pkt.h"
60 #include "daemon.h"
61 #include "rio.h"
62 #include "riospace.h"
63 #include "cmdpkt.h"
64 #include "map.h"
65 #include "rup.h"
66 #include "port.h"
67 #include "riodrvr.h"
68 #include "rioinfo.h"
69 #include "func.h"
70 #include "errors.h"
71 #include "pci.h"
72
73 #include "parmmap.h"
74 #include "unixrup.h"
75 #include "board.h"
76 #include "host.h"
77 #include "phb.h"
78 #include "link.h"
79 #include "cmdblk.h"
80 #include "route.h"
81 #include "cirrus.h"
82 #include "rioioctl.h"
83 #include "param.h"
84
85 static void RIOClearUp(struct Port *PortP);
86
87 /* Below belongs in func.h */
88 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
89
90
91 extern struct rio_info *p;
92
93
94 int riotopen(struct tty_struct *tty, struct file *filp)
95 {
96         unsigned int SysPort;
97         int repeat_this = 250;
98         struct Port *PortP;     /* pointer to the port structure */
99         unsigned long flags;
100         int retval = 0;
101
102         func_enter();
103
104         /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close
105            is going to oops.
106          */
107         tty->driver_data = NULL;
108
109         SysPort = rio_minor(tty);
110
111         if (p->RIOFailed) {
112                 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
113                 func_exit();
114                 return -ENXIO;
115         }
116
117         rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped);
118
119         /*
120          ** Validate that we have received a legitimate request.
121          ** Currently, just check that we are opening a port on
122          ** a host card that actually exists, and that the port
123          ** has been mapped onto a host.
124          */
125         if (SysPort >= RIO_PORTS) {     /* out of range ? */
126                 rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort);
127                 func_exit();
128                 return -ENXIO;
129         }
130
131         /*
132          ** Grab pointer to the port stucture
133          */
134         PortP = p->RIOPortp[SysPort];   /* Get control struc */
135         rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP);
136         if (!PortP->Mapped) {   /* we aren't mapped yet! */
137                 /*
138                  ** The system doesn't know which RTA this port
139                  ** corresponds to.
140                  */
141                 rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n");
142                 func_exit();
143                 return -ENXIO;
144         }
145
146         tty->driver_data = PortP;
147
148         PortP->gs.tty = tty;
149         PortP->gs.count++;
150
151         rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt);
152
153         retval = gs_init_port(&PortP->gs);
154         if (retval) {
155                 PortP->gs.count--;
156                 return -ENXIO;
157         }
158         /*
159          ** If the host hasn't been booted yet, then
160          ** fail
161          */
162         if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) {
163                 rio_dprintk(RIO_DEBUG_TTY, "Host not running\n");
164                 func_exit();
165                 return -ENXIO;
166         }
167
168         /*
169          ** If the RTA has not booted yet and the user has choosen to block
170          ** until the RTA is present then we must spin here waiting for
171          ** the RTA to boot.
172          */
173         /* I find the above code a bit hairy. I find the below code
174            easier to read and shorter. Now, if it works too that would
175            be great... -- REW 
176          */
177         rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
178         while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
179                 if (!PortP->WaitUntilBooted) {
180                         rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n");
181                         func_exit();
182                         return -ENXIO;
183                 }
184
185                 /* Under Linux you'd normally use a wait instead of this
186                    busy-waiting. I'll stick with the old implementation for
187                    now. --REW
188                  */
189                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
190                         rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
191                         func_exit();
192                         return -EINTR;
193                 }
194                 if (repeat_this-- <= 0) {
195                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
196                         func_exit();
197                         return -EIO;
198                 }
199         }
200         rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n");
201         rio_spin_lock_irqsave(&PortP->portSem, flags);
202         if (p->RIOHalted) {
203                 goto bombout;
204         }
205
206         /*
207          ** If the port is in the final throws of being closed,
208          ** we should wait here (politely), waiting
209          ** for it to finish, so that it doesn't close us!
210          */
211         while ((PortP->State & RIO_CLOSING) && !p->RIOHalted) {
212                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
213                 if (repeat_this-- <= 0) {
214                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
215                         RIOPreemptiveCmd(p, PortP, FCLOSE);
216                         retval = -EINTR;
217                         goto bombout;
218                 }
219                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
220                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
221                         rio_spin_lock_irqsave(&PortP->portSem, flags);
222                         retval = -EINTR;
223                         goto bombout;
224                 }
225                 rio_spin_lock_irqsave(&PortP->portSem, flags);
226         }
227
228         if (!PortP->Mapped) {
229                 rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n");
230                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
231                 retval = -ENXIO;
232                 func_exit();
233                 return retval;
234         }
235
236         if (p->RIOHalted) {
237                 goto bombout;
238         }
239
240 /*
241 ** 15.10.1998 ARG - ESIL 0761 part fix
242 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,
243 ** we need to make sure that the flags are clear when the port is opened.
244 */
245         /* Uh? Suppose I turn these on and then another process opens
246            the port again? The flags get cleared! Not good. -- REW */
247         if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
248                 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
249         }
250
251         if (!(PortP->firstOpen)) {      /* First time ? */
252                 rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n");
253
254
255                 PortP->firstOpen++;
256                 PortP->CookMode = 0;    /* XXX RIOCookMode(tp); */
257                 PortP->InUse = NOT_INUSE;
258
259                 /* Tentative fix for bug PR27. Didn't work. */
260                 /* PortP->gs.xmit_cnt = 0; */
261
262                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
263
264                 /* Someone explain to me why this delay/config is
265                    here. If I read the docs correctly the "open"
266                    command piggybacks the parameters immediately.
267                    -- REW */
268                 RIOParam(PortP, OPEN, 1, OK_TO_SLEEP);  /* Open the port */
269                 rio_spin_lock_irqsave(&PortP->portSem, flags);
270
271                 /*
272                  ** wait for the port to be not closed.
273                  */
274                 while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) {
275                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState);
276                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
277                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
278                                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
279                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
280                                 func_exit();
281                                 return -EINTR;
282                         }
283                         rio_spin_lock_irqsave(&PortP->portSem, flags);
284                 }
285
286                 if (p->RIOHalted) {
287                         retval = -EIO;
288                       bombout:
289                         /*                    RIOClearUp( PortP ); */
290                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
291                         return retval;
292                 }
293                 rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
294         }
295         rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
296         /*
297          ** ACTION
298          ** insert test for carrier here. -- ???
299          ** I already see that test here. What's the deal? -- REW
300          */
301         if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD)) {
302                 rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
303                 /*
304                    tp->tm.c_state |= CARR_ON;
305                    wakeup((caddr_t) &tp->tm.c_canq);
306                  */
307                 PortP->State |= RIO_CARR_ON;
308                 wake_up_interruptible(&PortP->gs.open_wait);
309         } else {        /* no carrier - wait for DCD */
310                         /*
311                    while (!(PortP->gs.tty->termios->c_state & CARR_ON) &&
312                    !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
313                  */
314                 while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
315                                 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
316                         /*
317                            PortP->gs.tty->termios->c_state |= WOPEN;
318                          */
319                         PortP->State |= RIO_WOPEN;
320                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
321                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
322                                 /*
323                                  ** ACTION: verify that this is a good thing
324                                  ** to do here. -- ???
325                                  ** I think it's OK. -- REW
326                                  */
327                                 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
328                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
329                                 /*
330                                    tp->tm.c_state &= ~WOPEN;
331                                  */
332                                 PortP->State &= ~RIO_WOPEN;
333                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
334                                 func_exit();
335                                 return -EINTR;
336                         }
337                 }
338                 PortP->State &= ~RIO_WOPEN;
339         }
340         if (p->RIOHalted)
341                 goto bombout;
342         rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
343         PortP->State |= RIO_MOPEN;
344
345         if (p->RIOHalted)
346                 goto bombout;
347
348         rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
349
350         /*
351          ** Count opens for port statistics reporting
352          */
353         if (PortP->statsGather)
354                 PortP->opens++;
355
356         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
357         rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n");
358         func_exit();
359         return 0;
360 }
361
362 /*
363 ** RIOClose the port.
364 ** The operating system thinks that this is last close for the device.
365 ** As there are two interfaces to the port (Modem and tty), we need to
366 ** check that both are closed before we close the device.
367 */
368 int riotclose(void *ptr)
369 {
370         struct Port *PortP = ptr;       /* pointer to the port structure */
371         int deleted = 0;
372         int try = -1;           /* Disable the timeouts by setting them to -1 */
373         int repeat_this = -1;   /* Congrats to those having 15 years of
374                                    uptime! (You get to break the driver.) */
375         unsigned long end_time;
376         struct tty_struct *tty;
377         unsigned long flags;
378         int rv = 0;
379
380         rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
381
382         /* PortP = p->RIOPortp[SysPort]; */
383         rio_dprintk(RIO_DEBUG_TTY, "Port is at address %p\n", PortP);
384         /* tp = PortP->TtyP; *//* Get tty */
385         tty = PortP->gs.tty;
386         rio_dprintk(RIO_DEBUG_TTY, "TTY is at address %p\n", tty);
387
388         if (PortP->gs.closing_wait)
389                 end_time = jiffies + PortP->gs.closing_wait;
390         else
391                 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
392
393         rio_spin_lock_irqsave(&PortP->portSem, flags);
394
395         /*
396          ** Setting this flag will make any process trying to open
397          ** this port block until we are complete closing it.
398          */
399         PortP->State |= RIO_CLOSING;
400
401         if ((PortP->State & RIO_DELETED)) {
402                 rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n");
403                 deleted = 1;
404         }
405
406         if (p->RIOHalted) {
407                 RIOClearUp(PortP);
408                 rv = -EIO;
409                 goto close_end;
410         }
411
412         rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n");
413         /*
414          ** clear the open bits for this device
415          */
416         PortP->State &= ~RIO_MOPEN;
417         PortP->State &= ~RIO_CARR_ON;
418         PortP->ModemState &= ~MSVR1_CD;
419         /*
420          ** If the device was open as both a Modem and a tty line
421          ** then we need to wimp out here, as the port has not really
422          ** been finally closed (gee, whizz!) The test here uses the
423          ** bit for the OTHER mode of operation, to see if THAT is
424          ** still active!
425          */
426         if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
427                 /*
428                  ** The port is still open for the other task -
429                  ** return, pretending that we are still active.
430                  */
431                 rio_dprintk(RIO_DEBUG_TTY, "Channel %d still open !\n", PortP->PortNum);
432                 PortP->State &= ~RIO_CLOSING;
433                 if (PortP->firstOpen)
434                         PortP->firstOpen--;
435                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
436                 return -EIO;
437         }
438
439         rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n");
440
441         PortP->State &= ~RIO_DYNOROD;
442
443         /*
444          ** This is where we wait for the port
445          ** to drain down before closing. Bye-bye....
446          ** (We never meant to do this)
447          */
448         rio_dprintk(RIO_DEBUG_TTY, "Timeout 1 starts\n");
449
450         if (!deleted)
451                 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) {
452                         if (repeat_this-- <= 0) {
453                                 rv = -EINTR;
454                                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
455                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
456                                 goto close_end;
457                         }
458                         rio_dprintk(RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
459                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
460                         if (RIODelay_ni(PortP, HUNDRED_MS * 10) == RIO_FAIL) {
461                                 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
462                                 rv = -EINTR;
463                                 rio_spin_lock_irqsave(&PortP->portSem, flags);
464                                 goto close_end;
465                         }
466                         rio_spin_lock_irqsave(&PortP->portSem, flags);
467                 }
468
469         PortP->TxBufferIn = PortP->TxBufferOut = 0;
470         repeat_this = 0xff;
471
472         PortP->InUse = 0;
473         if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
474                 /*
475                  ** The port has been re-opened for the other task -
476                  ** return, pretending that we are still active.
477                  */
478                 rio_dprintk(RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
479                 PortP->State &= ~RIO_CLOSING;
480                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
481                 if (PortP->firstOpen)
482                         PortP->firstOpen--;
483                 return -EIO;
484         }
485
486         if (p->RIOHalted) {
487                 RIOClearUp(PortP);
488                 goto close_end;
489         }
490
491         /* Can't call RIOShortCommand with the port locked. */
492         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
493
494         if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) {
495                 RIOPreemptiveCmd(p, PortP, FCLOSE);
496                 goto close_end;
497         }
498
499         if (!deleted)
500                 while (try && (PortP->PortState & PORT_ISOPEN)) {
501                         try--;
502                         if (time_after(jiffies, end_time)) {
503                                 rio_dprintk(RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n");
504                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
505                                 break;
506                         }
507                         rio_dprintk(RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", PortP->PortState & PORT_ISOPEN);
508
509                         if (p->RIOHalted) {
510                                 RIOClearUp(PortP);
511                                 goto close_end;
512                         }
513                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
514                                 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
515                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
516                                 break;
517                         }
518                 }
519         rio_spin_lock_irqsave(&PortP->portSem, flags);
520         rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try);
521
522         /* RIOPreemptiveCmd(p, PortP, FCLOSE); */
523
524 /*
525 ** 15.10.1998 ARG - ESIL 0761 part fix
526 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,** we need to make sure that the flags are clear when the port is opened.
527 */
528         PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
529
530         /*
531          ** Count opens for port statistics reporting
532          */
533         if (PortP->statsGather)
534                 PortP->closes++;
535
536 close_end:
537         /* XXX: Why would a "DELETED" flag be reset here? I'd have
538            thought that a "deleted" flag means that the port was
539            permanently gone, but here we can make it reappear by it
540            being in close during the "deletion".
541          */
542         PortP->State &= ~(RIO_CLOSING | RIO_DELETED);
543         if (PortP->firstOpen)
544                 PortP->firstOpen--;
545         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
546         rio_dprintk(RIO_DEBUG_TTY, "Return from close\n");
547         return rv;
548 }
549
550
551
552 static void RIOClearUp(struct Port *PortP)
553 {
554         rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n");
555         PortP->Config = 0;      /* Direct semaphore */
556         PortP->PortState = 0;
557         PortP->firstOpen = 0;
558         PortP->FlushCmdBodge = 0;
559         PortP->ModemState = PortP->CookMode = 0;
560         PortP->Mapped = 0;
561         PortP->WflushFlag = 0;
562         PortP->MagicFlags = 0;
563         PortP->RxDataStart = 0;
564         PortP->TxBufferIn = 0;
565         PortP->TxBufferOut = 0;
566 }
567
568 /*
569 ** Put a command onto a port.
570 ** The PortPointer, command, length and arg are passed.
571 ** The len is the length *inclusive* of the command byte,
572 ** and so for a command that takes no data, len==1.
573 ** The arg is a single byte, and is only used if len==2.
574 ** Other values of len aren't allowed, and will cause
575 ** a panic.
576 */
577 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
578 {
579         struct PKT __iomem *PacketP;
580         int retries = 20;       /* at 10 per second -> 2 seconds */
581         unsigned long flags;
582
583         rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n");
584
585         if (PortP->State & RIO_DELETED) {
586                 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
587                 return RIO_FAIL;
588         }
589         rio_spin_lock_irqsave(&PortP->portSem, flags);
590
591         /*
592          ** If the port is in use for pre-emptive command, then wait for it to
593          ** be free again.
594          */
595         while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted) {
596                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", retries);
597                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
598                 if (retries-- <= 0) {
599                         return RIO_FAIL;
600                 }
601                 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
602                         return RIO_FAIL;
603                 }
604                 rio_spin_lock_irqsave(&PortP->portSem, flags);
605         }
606         if (PortP->State & RIO_DELETED) {
607                 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
608                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
609                 return RIO_FAIL;
610         }
611
612         while (!can_add_transmit(&PacketP, PortP) && !p->RIOHalted) {
613                 rio_dprintk(RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
614                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
615                 if (retries-- <= 0) {
616                         rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n");
617                         return RIO_FAIL;
618                 }
619                 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
620                         return RIO_FAIL;
621                 }
622                 rio_spin_lock_irqsave(&PortP->portSem, flags);
623         }
624
625         if (p->RIOHalted) {
626                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
627                 return RIO_FAIL;
628         }
629
630         /*
631          ** set the command byte and the argument byte
632          */
633         writeb(command, &PacketP->data[0]);
634
635         if (len == 2)
636                 writeb(arg, &PacketP->data[1]);
637
638         /*
639          ** set the length of the packet and set the command bit.
640          */
641         writeb(PKT_CMD_BIT | len, &PacketP->len);
642
643         add_transmit(PortP);
644         /*
645          ** Count characters transmitted for port statistics reporting
646          */
647         if (PortP->statsGather)
648                 PortP->txchars += len;
649
650         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
651         return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL;
652 }
653
654