ia64/linux-2.6.18-xen.hg

view drivers/char/rio/riotty.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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
37 #define __EXPLICIT_DEF_H__
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>
50 #include <linux/termios.h>
52 #include <linux/serial.h>
54 #include <linux/generic_serial.h>
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"
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"
85 static void RIOClearUp(struct Port *PortP);
87 /* Below belongs in func.h */
88 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
91 extern struct rio_info *p;
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;
102 func_enter();
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;
109 SysPort = rio_minor(tty);
111 if (p->RIOFailed) {
112 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
113 func_exit();
114 return -ENXIO;
115 }
117 rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped);
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 }
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 }
146 tty->driver_data = PortP;
148 PortP->gs.tty = tty;
149 PortP->gs.count++;
151 rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt);
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 }
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 }
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 }
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 }
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 }
236 if (p->RIOHalted) {
237 goto bombout;
238 }
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 }
251 if (!(PortP->firstOpen)) { /* First time ? */
252 rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n");
255 PortP->firstOpen++;
256 PortP->CookMode = 0; /* XXX RIOCookMode(tp); */
257 PortP->InUse = NOT_INUSE;
259 /* Tentative fix for bug PR27. Didn't work. */
260 /* PortP->gs.xmit_cnt = 0; */
262 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
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);
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 }
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;
345 if (p->RIOHalted)
346 goto bombout;
348 rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
350 /*
351 ** Count opens for port statistics reporting
352 */
353 if (PortP->statsGather)
354 PortP->opens++;
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 }
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;
380 rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
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);
388 if (PortP->gs.closing_wait)
389 end_time = jiffies + PortP->gs.closing_wait;
390 else
391 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
393 rio_spin_lock_irqsave(&PortP->portSem, flags);
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;
401 if ((PortP->State & RIO_DELETED)) {
402 rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n");
403 deleted = 1;
404 }
406 if (p->RIOHalted) {
407 RIOClearUp(PortP);
408 rv = -EIO;
409 goto close_end;
410 }
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 }
439 rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n");
441 PortP->State &= ~RIO_DYNOROD;
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");
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 }
469 PortP->TxBufferIn = PortP->TxBufferOut = 0;
470 repeat_this = 0xff;
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 }
486 if (p->RIOHalted) {
487 RIOClearUp(PortP);
488 goto close_end;
489 }
491 /* Can't call RIOShortCommand with the port locked. */
492 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
494 if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) {
495 RIOPreemptiveCmd(p, PortP, FCLOSE);
496 goto close_end;
497 }
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);
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);
522 /* RIOPreemptiveCmd(p, PortP, FCLOSE); */
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);
530 /*
531 ** Count opens for port statistics reporting
532 */
533 if (PortP->statsGather)
534 PortP->closes++;
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 }
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 }
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;
583 rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n");
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);
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 }
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 }
625 if (p->RIOHalted) {
626 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
627 return RIO_FAIL;
628 }
630 /*
631 ** set the command byte and the argument byte
632 */
633 writeb(command, &PacketP->data[0]);
635 if (len == 2)
636 writeb(arg, &PacketP->data[1]);
638 /*
639 ** set the length of the packet and set the command bit.
640 */
641 writeb(PKT_CMD_BIT | len, &PacketP->len);
643 add_transmit(PortP);
644 /*
645 ** Count characters transmitted for port statistics reporting
646 */
647 if (PortP->statsGather)
648 PortP->txchars += len;
650 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
651 return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL;
652 }