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 : rioparam.c
24 ** SID : 1.3
25 ** Last Modified : 11/6/98 10:33:45
26 ** Retrieved : 11/6/98 10:33:50
27 **
28 ** ident @(#)rioparam.c 1.3
29 **
30 ** -----------------------------------------------------------------------------
31 */
32
33 #ifdef SCCS_LABELS
34 static char *_rioparam_c_sccs_ = "@(#)rioparam.c 1.3";
35 #endif
36
37 #define __NO_VERSION__
38 #include <linux/module.h>
39 #include <linux/slab.h>
40 #include <linux/errno.h>
41 #include <linux/tty.h>
42 #include <asm/io.h>
43 #include <asm/system.h>
44 #include <asm/string.h>
45 #include <asm/semaphore.h>
46 #include <asm/uaccess.h>
47
48 #include <linux/termios.h>
49 #include <linux/serial.h>
50
51 #include <linux/compatmac.h>
52 #include <linux/generic_serial.h>
53
54
55 #include "linux_compat.h"
56 #include "rio_linux.h"
57 #include "typdef.h"
58 #include "pkt.h"
59 #include "daemon.h"
60 #include "rio.h"
61 #include "riospace.h"
62 #include "top.h"
63 #include "cmdpkt.h"
64 #include "map.h"
65 #include "riotypes.h"
66 #include "rup.h"
67 #include "port.h"
68 #include "riodrvr.h"
69 #include "rioinfo.h"
70 #include "func.h"
71 #include "errors.h"
72 #include "pci.h"
73
74 #include "parmmap.h"
75 #include "unixrup.h"
76 #include "board.h"
77 #include "host.h"
78 #include "error.h"
79 #include "phb.h"
80 #include "link.h"
81 #include "cmdblk.h"
82 #include "route.h"
83 #include "control.h"
84 #include "cirrus.h"
85 #include "rioioctl.h"
86 #include "param.h"
87 #include "list.h"
88 #include "sam.h"
89
90
91
92 /*
93 ** The Scam, based on email from jeremyr@bugs.specialix.co.uk....
94 **
95 ** To send a command on a particular port, you put a packet with the
96 ** command bit set onto the port. The command bit is in the len field,
97 ** and gets ORed in with the actual byte count.
98 **
99 ** When you send a packet with the command bit set, then the first
100 ** data byte ( data[0] ) is interpretted as the command to execute.
101 ** It also governs what data structure overlay should accompany the packet.
102 ** Commands are defined in cirrus/cirrus.h
103 **
104 ** If you want the command to pre-emt data already on the queue for the
105 ** port, set the pre-emptive bit in conjunction with the command bit.
106 ** It is not defined what will happen if you set the preemptive bit
107 ** on a packet that is NOT a command.
108 **
109 ** Pre-emptive commands should be queued at the head of the queue using
110 ** add_start(), whereas normal commands and data are enqueued using
111 ** add_end().
112 **
113 ** Most commands do not use the remaining bytes in the data array. The
114 ** exceptions are OPEN MOPEN and CONFIG. (NB. As with the SI CONFIG and
115 ** OPEN are currently analagous). With these three commands the following
116 ** 11 data bytes are all used to pass config information such as baud rate etc.
117 ** The fields are also defined in cirrus.h. Some contain straightforward
118 ** information such as the transmit XON character. Two contain the transmit and
119 ** receive baud rates respectively. For most baud rates there is a direct
120 ** mapping between the rates defined in <sys/termio.h> and the byte in the
121 ** packet. There are additional (non UNIX-standard) rates defined in
122 ** /u/dos/rio/cirrus/h/brates.h.
123 **
124 ** The rest of the data fields contain approximations to the Cirrus registers
125 ** that are used to program number of bits etc. Each registers bit fields is
126 ** defined in cirrus.h.
127 **
128 ** NB. Only use those bits that are defined as being driver specific
129 ** or common to the RTA and the driver.
130 **
131 ** All commands going from RTA->Host will be dealt with by the Host code - you
132 ** will never see them. As with the SI there will be three fields to look out
133 ** for in each phb (not yet defined - needs defining a.s.a.p).
134 **
135 ** modem_status - current state of handshake pins.
136 **
137 ** port_status - current port status - equivalent to hi_stat for SI, indicates
138 ** if port is IDLE_OPEN, IDLE_CLOSED etc.
139 **
140 ** break_status - bit X set if break has been received.
141 **
142 ** Happy hacking.
143 **
144 */
145
146 /*
147 ** RIOParam is used to open or configure a port. You pass it a PortP,
148 ** which will have a tty struct attached to it. You also pass a command,
149 ** either OPEN or CONFIG. The port's setup is taken from the t_ fields
150 ** of the tty struct inside the PortP, and the port is either opened
151 ** or re-configured. You must also tell RIOParam if the device is a modem
152 ** device or not (i.e. top bit of minor number set or clear - take special
153 ** care when deciding on this!).
154 ** RIOParam neither flushes nor waits for drain, and is NOT preemptive.
155 **
156 ** RIOParam assumes it will be called at splrio(), and also assumes
157 ** that CookMode is set correctly in the port structure.
158 **
159 ** NB. for MPX
160 ** tty lock must NOT have been previously acquired.
161 */
162 int
RIOParam(PortP,cmd,Modem,SleepFlag)163 RIOParam(PortP, cmd, Modem, SleepFlag)
164 struct Port *PortP;
165 int cmd;
166 int Modem;
167 int SleepFlag;
168 {
169 register struct tty_struct *TtyP;
170 int retval;
171 register struct phb_param *phb_param_ptr;
172 PKT *PacketP;
173 int res;
174 uchar Cor1=0, Cor2=0, Cor4=0, Cor5=0;
175 uchar TxXon=0, TxXoff=0, RxXon=0, RxXoff=0;
176 uchar LNext=0, TxBaud=0, RxBaud=0;
177 int retries = 0xff;
178 unsigned long flags;
179
180 func_enter ();
181
182 TtyP = PortP->gs.tty;
183
184 rio_dprintk (RIO_DEBUG_PARAM, "RIOParam: Port:%d cmd:%d Modem:%d SleepFlag:%d Mapped: %d, tty=%p\n",
185 PortP->PortNum, cmd, Modem, SleepFlag, PortP->Mapped, TtyP);
186
187 if (!TtyP) {
188 rio_dprintk (RIO_DEBUG_PARAM, "Can't call rioparam with null tty.\n");
189
190 func_exit ();
191
192 return RIO_FAIL;
193 }
194 rio_spin_lock_irqsave(&PortP->portSem, flags );
195
196 if (cmd == OPEN) {
197 /*
198 ** If the port is set to store or lock the parameters, and it is
199 ** paramed with OPEN, we want to restore the saved port termio, but
200 ** only if StoredTermio has been saved, i.e. NOT 1st open after reboot.
201 */
202 #if 0
203 if (PortP->FirstOpen) {
204 PortP->StoredTty.iflag = TtyP->tm.c_iflag;
205 PortP->StoredTty.oflag = TtyP->tm.c_oflag;
206 PortP->StoredTty.cflag = TtyP->tm.c_cflag;
207 PortP->StoredTty.lflag = TtyP->tm.c_lflag;
208 PortP->StoredTty.line = TtyP->tm.c_line;
209 for (i = 0; i < NCC + 5; i++)
210 PortP->StoredTty.cc[i] = TtyP->tm.c_cc[i];
211 PortP->FirstOpen = 0;
212 }
213 else if (PortP->Store || PortP->Lock) {
214 rio_dprintk (RIO_DEBUG_PARAM, "OPEN: Restoring stored/locked params\n");
215 TtyP->tm.c_iflag = PortP->StoredTty.iflag;
216 TtyP->tm.c_oflag = PortP->StoredTty.oflag;
217 TtyP->tm.c_cflag = PortP->StoredTty.cflag;
218 TtyP->tm.c_lflag = PortP->StoredTty.lflag;
219 TtyP->tm.c_line = PortP->StoredTty.line;
220 for (i = 0; i < NCC + 5; i++)
221 TtyP->tm.c_cc[i] = PortP->StoredTty.cc[i];
222 }
223 #endif
224 }
225
226 /*
227 ** wait for space
228 */
229 while ( !(res=can_add_transmit(&PacketP,PortP)) ||
230 (PortP->InUse != NOT_INUSE) ) {
231 if (retries -- <= 0) {
232 break;
233 }
234 if ( PortP->InUse != NOT_INUSE ) {
235 rio_dprintk (RIO_DEBUG_PARAM, "Port IN_USE for pre-emptive command\n");
236 }
237
238 if ( !res ) {
239 rio_dprintk (RIO_DEBUG_PARAM, "Port has no space on transmit queue\n");
240 }
241
242 if ( SleepFlag != OK_TO_SLEEP ) {
243 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
244 func_exit();
245
246 return RIO_FAIL;
247 }
248
249 rio_dprintk (RIO_DEBUG_PARAM, "wait for can_add_transmit\n");
250 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
251 retval = RIODelay(PortP, HUNDRED_MS);
252 rio_spin_lock_irqsave( &PortP->portSem, flags);
253 if (retval == RIO_FAIL) {
254 rio_dprintk (RIO_DEBUG_PARAM, "wait for can_add_transmit broken by signal\n");
255 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
256 pseterr(EINTR);
257 func_exit();
258
259 return RIO_FAIL;
260 }
261 if ( PortP->State & RIO_DELETED ) {
262 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
263 func_exit ();
264
265 return RIO_SUCCESS;
266 }
267 }
268
269 if (!res) {
270 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
271 func_exit ();
272
273 return RIO_FAIL;
274 }
275
276 rio_dprintk (RIO_DEBUG_PARAM, "can_add_transmit() returns %x\n",res);
277 rio_dprintk (RIO_DEBUG_PARAM, "Packet is 0x%x\n",(int) PacketP);
278
279 phb_param_ptr = (struct phb_param *)PacketP->data;
280
281
282 #if 0
283 /*
284 ** COR 1
285 */
286 if ( TtyP->tm.c_iflag & INPCK ) {
287 rio_dprintk (RIO_DEBUG_PARAM, "Parity checking on input enabled\n");
288 Cor1 |= COR1_INPCK;
289 }
290 #endif
291
292 switch ( TtyP->termios->c_cflag & CSIZE ) {
293 case CS5:
294 {
295 rio_dprintk (RIO_DEBUG_PARAM, "5 bit data\n");
296 Cor1 |= COR1_5BITS;
297 break;
298 }
299 case CS6:
300 {
301 rio_dprintk (RIO_DEBUG_PARAM, "6 bit data\n");
302 Cor1 |= COR1_6BITS;
303 break;
304 }
305 case CS7:
306 {
307 rio_dprintk (RIO_DEBUG_PARAM, "7 bit data\n");
308 Cor1 |= COR1_7BITS;
309 break;
310 }
311 case CS8:
312 {
313 rio_dprintk (RIO_DEBUG_PARAM, "8 bit data\n");
314 Cor1 |= COR1_8BITS;
315 break;
316 }
317 }
318
319 if ( TtyP->termios->c_cflag & CSTOPB ) {
320 rio_dprintk (RIO_DEBUG_PARAM, "2 stop bits\n");
321 Cor1 |= COR1_2STOP;
322 }
323 else {
324 rio_dprintk (RIO_DEBUG_PARAM, "1 stop bit\n");
325 Cor1 |= COR1_1STOP;
326 }
327
328 if ( TtyP->termios->c_cflag & PARENB ) {
329 rio_dprintk (RIO_DEBUG_PARAM, "Enable parity\n");
330 Cor1 |= COR1_NORMAL;
331 }
332 else {
333 rio_dprintk (RIO_DEBUG_PARAM, "Disable parity\n");
334 Cor1 |= COR1_NOP;
335 }
336 if ( TtyP->termios->c_cflag & PARODD ) {
337 rio_dprintk (RIO_DEBUG_PARAM, "Odd parity\n");
338 Cor1 |= COR1_ODD;
339 }
340 else {
341 rio_dprintk (RIO_DEBUG_PARAM, "Even parity\n");
342 Cor1 |= COR1_EVEN;
343 }
344
345 /*
346 ** COR 2
347 */
348 if ( TtyP->termios->c_iflag & IXON ) {
349 rio_dprintk (RIO_DEBUG_PARAM, "Enable start/stop output control\n");
350 Cor2 |= COR2_IXON;
351 }
352 else {
353 if ( PortP->Config & RIO_IXON ) {
354 rio_dprintk (RIO_DEBUG_PARAM, "Force enable start/stop output control\n");
355 Cor2 |= COR2_IXON;
356 }
357 else
358 rio_dprintk (RIO_DEBUG_PARAM, "IXON has been disabled.\n");
359 }
360
361 if (TtyP->termios->c_iflag & IXANY) {
362 if ( PortP->Config & RIO_IXANY ) {
363 rio_dprintk (RIO_DEBUG_PARAM, "Enable any key to restart output\n");
364 Cor2 |= COR2_IXANY;
365 }
366 else
367 rio_dprintk (RIO_DEBUG_PARAM, "IXANY has been disabled due to sanity reasons.\n");
368 }
369
370 if ( TtyP->termios->c_iflag & IXOFF ) {
371 rio_dprintk (RIO_DEBUG_PARAM, "Enable start/stop input control 2\n");
372 Cor2 |= COR2_IXOFF;
373 }
374
375 if ( TtyP->termios->c_cflag & HUPCL ) {
376 rio_dprintk (RIO_DEBUG_PARAM, "Hangup on last close\n");
377 Cor2 |= COR2_HUPCL;
378 }
379
380 if ( C_CRTSCTS (TtyP)) {
381 rio_dprintk (RIO_DEBUG_PARAM, "Rx hardware flow control enabled\n");
382 Cor2 |= COR2_CTSFLOW;
383 Cor2 |= COR2_RTSFLOW;
384 } else {
385 rio_dprintk (RIO_DEBUG_PARAM, "Rx hardware flow control disabled\n");
386 Cor2 &= ~COR2_CTSFLOW;
387 Cor2 &= ~COR2_RTSFLOW;
388 }
389
390
391 if ( TtyP->termios->c_cflag & CLOCAL ) {
392 rio_dprintk (RIO_DEBUG_PARAM, "Local line\n");
393 }
394 else {
395 rio_dprintk (RIO_DEBUG_PARAM, "Possible Modem line\n");
396 }
397
398 /*
399 ** COR 4 (there is no COR 3)
400 */
401 if ( TtyP->termios->c_iflag & IGNBRK ) {
402 rio_dprintk (RIO_DEBUG_PARAM, "Ignore break condition\n");
403 Cor4 |= COR4_IGNBRK;
404 }
405 if ( !(TtyP->termios->c_iflag & BRKINT) ) {
406 rio_dprintk (RIO_DEBUG_PARAM, "Break generates NULL condition\n");
407 Cor4 |= COR4_NBRKINT;
408 } else {
409 rio_dprintk (RIO_DEBUG_PARAM, "Interrupt on break condition\n");
410 }
411
412 if ( TtyP->termios->c_iflag & INLCR ) {
413 rio_dprintk (RIO_DEBUG_PARAM, "Map newline to carriage return on input\n");
414 Cor4 |= COR4_INLCR;
415 }
416
417 if ( TtyP->termios->c_iflag & IGNCR ) {
418 rio_dprintk (RIO_DEBUG_PARAM, "Ignore carriage return on input\n");
419 Cor4 |= COR4_IGNCR;
420 }
421
422 if ( TtyP->termios->c_iflag & ICRNL ) {
423 rio_dprintk (RIO_DEBUG_PARAM, "Map carriage return to newline on input\n");
424 Cor4 |= COR4_ICRNL;
425 }
426 if ( TtyP->termios->c_iflag & IGNPAR ) {
427 rio_dprintk (RIO_DEBUG_PARAM, "Ignore characters with parity errors\n");
428 Cor4 |= COR4_IGNPAR;
429 }
430 if ( TtyP->termios->c_iflag & PARMRK ) {
431 rio_dprintk (RIO_DEBUG_PARAM, "Mark parity errors\n");
432 Cor4 |= COR4_PARMRK;
433 }
434
435 /*
436 ** Set the RAISEMOD flag to ensure that the modem lines are raised
437 ** on reception of a config packet.
438 ** The download code handles the zero baud condition.
439 */
440 Cor4 |= COR4_RAISEMOD;
441
442 /*
443 ** COR 5
444 */
445
446 Cor5 = COR5_CMOE;
447
448 /*
449 ** Set to monitor tbusy/tstop (or not).
450 */
451
452 if (PortP->MonitorTstate)
453 Cor5 |= COR5_TSTATE_ON;
454 else
455 Cor5 |= COR5_TSTATE_OFF;
456
457 /*
458 ** Could set LNE here if you wanted LNext processing. SVR4 will use it.
459 */
460 if ( TtyP->termios->c_iflag & ISTRIP ) {
461 rio_dprintk (RIO_DEBUG_PARAM, "Strip input characters\n");
462 if (! (PortP->State & RIO_TRIAD_MODE)) {
463 Cor5 |= COR5_ISTRIP;
464 }
465 }
466
467 if ( TtyP->termios->c_oflag & ONLCR ) {
468 rio_dprintk (RIO_DEBUG_PARAM, "Map newline to carriage-return, newline on output\n");
469 if ( PortP->CookMode == COOK_MEDIUM )
470 Cor5 |= COR5_ONLCR;
471 }
472 if ( TtyP->termios->c_oflag & OCRNL ) {
473 rio_dprintk (RIO_DEBUG_PARAM, "Map carriage return to newline on output\n");
474 if ( PortP->CookMode == COOK_MEDIUM )
475 Cor5 |= COR5_OCRNL;
476 }
477 if ( ( TtyP->termios->c_oflag & TABDLY) == TAB3 ) {
478 rio_dprintk (RIO_DEBUG_PARAM, "Tab delay 3 set\n");
479 if ( PortP->CookMode == COOK_MEDIUM )
480 Cor5 |= COR5_TAB3;
481 }
482
483 /*
484 ** Flow control bytes.
485 */
486 TxXon = TtyP->termios->c_cc[VSTART];
487 TxXoff = TtyP->termios->c_cc[VSTOP];
488 RxXon = TtyP->termios->c_cc[VSTART];
489 RxXoff = TtyP->termios->c_cc[VSTOP];
490 /*
491 ** LNEXT byte
492 */
493 LNext = 0;
494
495 /*
496 ** Baud rate bytes
497 */
498 rio_dprintk (RIO_DEBUG_PARAM, "Mapping of rx/tx baud %x (%x)\n",
499 TtyP->termios->c_cflag, CBAUD);
500
501 switch (TtyP->termios->c_cflag & CBAUD) {
502 #define e(b) case B ## b : RxBaud = TxBaud = RIO_B ## b ;break
503 e(50);e(75);e(110);e(134);e(150);e(200);e(300);e(600);e(1200);
504 e(1800);e(2400);e(4800);e(9600);e(19200);e(38400);e(57600);
505 e(115200); /* e(230400);e(460800); e(921600); */
506 }
507
508 /* XXX MIssing conversion table. XXX */
509 /* (TtyP->termios->c_cflag & V_CBAUD); */
510
511 rio_dprintk (RIO_DEBUG_PARAM, "tx baud 0x%x, rx baud 0x%x\n", TxBaud, RxBaud);
512
513
514 /*
515 ** Leftovers
516 */
517 if ( TtyP->termios->c_cflag & CREAD )
518 rio_dprintk (RIO_DEBUG_PARAM, "Enable receiver\n");
519 #ifdef RCV1EN
520 if ( TtyP->termios->c_cflag & RCV1EN )
521 rio_dprintk (RIO_DEBUG_PARAM, "RCV1EN (?)\n");
522 #endif
523 #ifdef XMT1EN
524 if ( TtyP->termios->c_cflag & XMT1EN )
525 rio_dprintk (RIO_DEBUG_PARAM, "XMT1EN (?)\n");
526 #endif
527 #if 0
528 if ( TtyP->termios->c_cflag & LOBLK )
529 rio_dprintk (RIO_DEBUG_PARAM, "LOBLK - JCL output blocks when not current\n");
530 #endif
531 if ( TtyP->termios->c_lflag & ISIG )
532 rio_dprintk (RIO_DEBUG_PARAM, "Input character signal generating enabled\n");
533 if ( TtyP->termios->c_lflag & ICANON )
534 rio_dprintk (RIO_DEBUG_PARAM, "Canonical input: erase and kill enabled\n");
535 if ( TtyP->termios->c_lflag & XCASE )
536 rio_dprintk (RIO_DEBUG_PARAM, "Canonical upper/lower presentation\n");
537 if ( TtyP->termios->c_lflag & ECHO )
538 rio_dprintk (RIO_DEBUG_PARAM, "Enable input echo\n");
539 if ( TtyP->termios->c_lflag & ECHOE )
540 rio_dprintk (RIO_DEBUG_PARAM, "Enable echo erase\n");
541 if ( TtyP->termios->c_lflag & ECHOK )
542 rio_dprintk (RIO_DEBUG_PARAM, "Enable echo kill\n");
543 if ( TtyP->termios->c_lflag & ECHONL )
544 rio_dprintk (RIO_DEBUG_PARAM, "Enable echo newline\n");
545 if ( TtyP->termios->c_lflag & NOFLSH )
546 rio_dprintk (RIO_DEBUG_PARAM, "Disable flush after interrupt or quit\n");
547 #ifdef TOSTOP
548 if ( TtyP->termios->c_lflag & TOSTOP )
549 rio_dprintk (RIO_DEBUG_PARAM, "Send SIGTTOU for background output\n");
550 #endif
551 #ifdef XCLUDE
552 if ( TtyP->termios->c_lflag & XCLUDE )
553 rio_dprintk (RIO_DEBUG_PARAM, "Exclusive use of this line\n");
554 #endif
555 if ( TtyP->termios->c_iflag & IUCLC )
556 rio_dprintk (RIO_DEBUG_PARAM, "Map uppercase to lowercase on input\n");
557 if ( TtyP->termios->c_oflag & OPOST )
558 rio_dprintk (RIO_DEBUG_PARAM, "Enable output post-processing\n");
559 if ( TtyP->termios->c_oflag & OLCUC )
560 rio_dprintk (RIO_DEBUG_PARAM, "Map lowercase to uppercase on output\n");
561 if ( TtyP->termios->c_oflag & ONOCR )
562 rio_dprintk (RIO_DEBUG_PARAM, "No carriage return output at column 0\n");
563 if ( TtyP->termios->c_oflag & ONLRET )
564 rio_dprintk (RIO_DEBUG_PARAM, "Newline performs carriage return function\n");
565 if ( TtyP->termios->c_oflag & OFILL )
566 rio_dprintk (RIO_DEBUG_PARAM, "Use fill characters for delay\n");
567 if ( TtyP->termios->c_oflag & OFDEL )
568 rio_dprintk (RIO_DEBUG_PARAM, "Fill character is DEL\n");
569 if ( TtyP->termios->c_oflag & NLDLY )
570 rio_dprintk (RIO_DEBUG_PARAM, "Newline delay set\n");
571 if ( TtyP->termios->c_oflag & CRDLY )
572 rio_dprintk (RIO_DEBUG_PARAM, "Carriage return delay set\n");
573 if ( TtyP->termios->c_oflag & TABDLY )
574 rio_dprintk (RIO_DEBUG_PARAM, "Tab delay set\n");
575 #if 0
576 if ( TtyP->termios->c_oflag & BSDLY )
577 rio_dprintk (RIO_DEBUG_PARAM, "Back-space delay set\n");
578 if ( TtyP->termios->c_oflag & VTDLY )
579 rio_dprintk (RIO_DEBUG_PARAM, "Vertical tab delay set\n");
580 if ( TtyP->termios->c_oflag & FFDLY )
581 rio_dprintk (RIO_DEBUG_PARAM, "Form-feed delay set\n");
582 #endif
583 /*
584 ** These things are kind of useful in a later life!
585 */
586 PortP->Cor2Copy = Cor2;
587
588 if ( PortP->State & RIO_DELETED ) {
589 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
590 func_exit ();
591
592 return RIO_FAIL;
593 }
594
595 /*
596 ** Actually write the info into the packet to be sent
597 */
598 WBYTE(phb_param_ptr->Cmd, cmd);
599 WBYTE(phb_param_ptr->Cor1, Cor1);
600 WBYTE(phb_param_ptr->Cor2, Cor2);
601 WBYTE(phb_param_ptr->Cor4, Cor4);
602 WBYTE(phb_param_ptr->Cor5, Cor5);
603 WBYTE(phb_param_ptr->TxXon, TxXon);
604 WBYTE(phb_param_ptr->RxXon, RxXon);
605 WBYTE(phb_param_ptr->TxXoff, TxXoff);
606 WBYTE(phb_param_ptr->RxXoff, RxXoff);
607 WBYTE(phb_param_ptr->LNext, LNext);
608 WBYTE(phb_param_ptr->TxBaud, TxBaud);
609 WBYTE(phb_param_ptr->RxBaud, RxBaud);
610
611 /*
612 ** Set the length/command field
613 */
614 WBYTE(PacketP->len , 12 | PKT_CMD_BIT);
615
616 /*
617 ** The packet is formed - now, whack it off
618 ** to its final destination:
619 */
620 add_transmit(PortP);
621 /*
622 ** Count characters transmitted for port statistics reporting
623 */
624 if (PortP->statsGather)
625 PortP->txchars += 12;
626
627 rio_spin_unlock_irqrestore( &PortP->portSem, flags);
628
629 rio_dprintk (RIO_DEBUG_PARAM, "add_transmit returned.\n");
630 /*
631 ** job done.
632 */
633 func_exit ();
634
635 return RIO_SUCCESS;
636 }
637
638
639 /*
640 ** We can add another packet to a transmit queue if the packet pointer pointed
641 ** to by the TxAdd pointer has PKT_IN_USE clear in its address.
642 */
643 int
can_add_transmit(PktP,PortP)644 can_add_transmit(PktP, PortP)
645 PKT **PktP;
646 struct Port *PortP;
647 {
648 register PKT *tp;
649
650 *PktP = tp = (PKT *)RIO_PTR(PortP->Caddr,RWORD(*PortP->TxAdd));
651
652 return !((uint)tp & PKT_IN_USE);
653 }
654
655 /*
656 ** To add a packet to the queue, you set the PKT_IN_USE bit in the address,
657 ** and then move the TxAdd pointer along one position to point to the next
658 ** packet pointer. You must wrap the pointer from the end back to the start.
659 */
660 void
add_transmit(PortP)661 add_transmit(PortP)
662 struct Port *PortP;
663 {
664 if (RWORD(*PortP->TxAdd) & PKT_IN_USE) {
665 rio_dprintk (RIO_DEBUG_PARAM, "add_transmit: Packet has been stolen!");
666 }
667 WWORD( *(ushort *)PortP->TxAdd, RWORD(*PortP->TxAdd) | PKT_IN_USE);
668 PortP->TxAdd = (PortP->TxAdd == PortP->TxEnd) ? PortP->TxStart :
669 PortP->TxAdd + 1;
670 WWORD( PortP->PhbP->tx_add , RIO_OFF(PortP->Caddr,PortP->TxAdd) );
671 }
672
673 /****************************************
674 * Put a packet onto the end of the
675 * free list
676 ****************************************/
677 void
put_free_end(HostP,PktP)678 put_free_end(HostP, PktP)
679 struct Host *HostP;
680 PKT *PktP;
681 {
682 FREE_LIST *tmp_pointer;
683 ushort old_end, new_end;
684 unsigned long flags;
685
686 rio_spin_lock_irqsave(&HostP->HostLock, flags);
687
688 /*************************************************
689 * Put a packet back onto the back of the free list
690 *
691 ************************************************/
692
693 rio_dprintk (RIO_DEBUG_PFE, "put_free_end(PktP=%x)\n",(int)PktP);
694
695 if ((old_end=RWORD(HostP->ParmMapP->free_list_end)) != TPNULL) {
696 new_end = RIO_OFF(HostP->Caddr,PktP);
697 tmp_pointer = (FREE_LIST *)RIO_PTR(HostP->Caddr,old_end);
698 WWORD(tmp_pointer->next , new_end );
699 WWORD(((FREE_LIST *)PktP)->prev , old_end);
700 WWORD(((FREE_LIST *)PktP)->next , TPNULL);
701 WWORD(HostP->ParmMapP->free_list_end, new_end);
702 }
703 else { /* First packet on the free list this should never happen! */
704 rio_dprintk (RIO_DEBUG_PFE, "put_free_end(): This should never happen\n");
705 WWORD(HostP->ParmMapP->free_list_end , RIO_OFF(HostP->Caddr,PktP));
706 tmp_pointer = (FREE_LIST *)PktP;
707 WWORD(tmp_pointer->prev , TPNULL);
708 WWORD(tmp_pointer->next , TPNULL);
709 }
710 rio_dprintk (RIO_DEBUG_CMD, "Before unlock: %p\n", &HostP->HostLock);
711 rio_spin_unlock_irqrestore(&HostP->HostLock, flags);
712 }
713
714 /*
715 ** can_remove_receive(PktP,P) returns non-zero if PKT_IN_USE is set
716 ** for the next packet on the queue. It will also set PktP to point to the
717 ** relevent packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear,
718 ** then can_remove_receive() returns 0.
719 */
720 int
can_remove_receive(PktP,PortP)721 can_remove_receive(PktP, PortP)
722 PKT **PktP;
723 struct Port *PortP;
724 {
725 if ( RWORD(*PortP->RxRemove) & PKT_IN_USE) {
726 *PktP = (PKT *)RIO_PTR(PortP->Caddr,
727 RWORD(*PortP->RxRemove) & ~PKT_IN_USE);
728 return 1;
729 }
730 return 0;
731 }
732
733 /*
734 ** To remove a packet from the receive queue you clear its PKT_IN_USE bit,
735 ** and then bump the pointers. Once the pointers get to the end, they must
736 ** be wrapped back to the start.
737 */
738 void
remove_receive(PortP)739 remove_receive(PortP)
740 struct Port *PortP;
741 {
742 WWORD( *PortP->RxRemove, RWORD(*PortP->RxRemove) & ~PKT_IN_USE );
743 PortP->RxRemove = (PortP->RxRemove == PortP->RxEnd) ? PortP->RxStart :
744 PortP->RxRemove + 1;
745 WWORD( PortP->PhbP->rx_remove , RIO_OFF(PortP->Caddr, PortP->RxRemove) );
746 }
747