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