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