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 : riotty.c | |
24 | ** SID : 1.3 | |
25 | ** Last Modified : 11/6/98 10:33:47 | |
26 | ** Retrieved : 11/6/98 10:33:50 | |
27 | ** | |
28 | ** ident @(#)riotty.c 1.3 | |
29 | ** | |
30 | ** ----------------------------------------------------------------------------- | |
31 | */ | |
32 | #ifdef SCCS_LABELS | |
33 | static char *_riotty_c_sccs_ = "@(#)riotty.c 1.3"; | |
34 | #endif | |
35 | ||
36 | ||
37 | #define __EXPLICIT_DEF_H__ | |
38 | ||
39 | #include <linux/module.h> | |
40 | #include <linux/slab.h> | |
41 | #include <linux/errno.h> | |
42 | #include <linux/tty.h> | |
43 | #include <linux/string.h> | |
44 | #include <asm/io.h> | |
45 | #include <asm/system.h> | |
46 | #include <asm/string.h> | |
47 | #include <asm/semaphore.h> | |
48 | #include <asm/uaccess.h> | |
49 | ||
50 | #include <linux/termios.h> | |
51 | ||
52 | #include <linux/serial.h> | |
53 | ||
54 | #include <linux/generic_serial.h> | |
55 | ||
56 | ||
57 | #include "linux_compat.h" | |
58 | #include "rio_linux.h" | |
1da177e4 LT |
59 | #include "pkt.h" |
60 | #include "daemon.h" | |
61 | #include "rio.h" | |
62 | #include "riospace.h" | |
1da177e4 LT |
63 | #include "cmdpkt.h" |
64 | #include "map.h" | |
1da177e4 LT |
65 | #include "rup.h" |
66 | #include "port.h" | |
67 | #include "riodrvr.h" | |
68 | #include "rioinfo.h" | |
69 | #include "func.h" | |
70 | #include "errors.h" | |
71 | #include "pci.h" | |
72 | ||
73 | #include "parmmap.h" | |
74 | #include "unixrup.h" | |
75 | #include "board.h" | |
76 | #include "host.h" | |
1da177e4 LT |
77 | #include "phb.h" |
78 | #include "link.h" | |
79 | #include "cmdblk.h" | |
80 | #include "route.h" | |
1da177e4 LT |
81 | #include "cirrus.h" |
82 | #include "rioioctl.h" | |
83 | #include "param.h" | |
1da177e4 | 84 | |
1da177e4 | 85 | static void RIOClearUp(struct Port *PortP); |
1da177e4 | 86 | |
554b7c80 AC |
87 | /* Below belongs in func.h */ |
88 | int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg); | |
1da177e4 LT |
89 | |
90 | ||
91 | extern struct rio_info *p; | |
92 | ||
93 | ||
8d8706e2 | 94 | int riotopen(struct tty_struct *tty, struct file *filp) |
1da177e4 | 95 | { |
e2b3afd6 | 96 | unsigned int SysPort; |
1da177e4 | 97 | int repeat_this = 250; |
8d8706e2 | 98 | struct Port *PortP; /* pointer to the port structure */ |
1da177e4 LT |
99 | unsigned long flags; |
100 | int retval = 0; | |
101 | ||
8d8706e2 | 102 | func_enter(); |
1da177e4 LT |
103 | |
104 | /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close | |
105 | is going to oops. | |
8d8706e2 | 106 | */ |
1da177e4 | 107 | tty->driver_data = NULL; |
8d8706e2 | 108 | |
1da177e4 | 109 | SysPort = rio_minor(tty); |
1da177e4 | 110 | |
8d8706e2 AM |
111 | if (p->RIOFailed) { |
112 | rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n"); | |
8d8706e2 | 113 | func_exit(); |
1da177e4 LT |
114 | return -ENXIO; |
115 | } | |
116 | ||
554b7c80 | 117 | rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped); |
1da177e4 LT |
118 | |
119 | /* | |
8d8706e2 AM |
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 | */ | |
1da177e4 | 125 | if (SysPort >= RIO_PORTS) { /* out of range ? */ |
8d8706e2 | 126 | rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort); |
1da177e4 LT |
127 | func_exit(); |
128 | return -ENXIO; | |
129 | } | |
130 | ||
131 | /* | |
8d8706e2 AM |
132 | ** Grab pointer to the port stucture |
133 | */ | |
1da177e4 | 134 | PortP = p->RIOPortp[SysPort]; /* Get control struc */ |
8d8706e2 AM |
135 | rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP); |
136 | if (!PortP->Mapped) { /* we aren't mapped yet! */ | |
1da177e4 | 137 | /* |
8d8706e2 AM |
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(); | |
1da177e4 LT |
143 | return -ENXIO; |
144 | } | |
145 | ||
146 | tty->driver_data = PortP; | |
147 | ||
148 | PortP->gs.tty = tty; | |
149 | PortP->gs.count++; | |
150 | ||
8d8706e2 | 151 | rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt); |
1da177e4 | 152 | |
8d8706e2 | 153 | retval = gs_init_port(&PortP->gs); |
1da177e4 LT |
154 | if (retval) { |
155 | PortP->gs.count--; | |
156 | return -ENXIO; | |
157 | } | |
158 | /* | |
8d8706e2 AM |
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"); | |
8d8706e2 | 164 | func_exit(); |
1da177e4 LT |
165 | return -ENXIO; |
166 | } | |
167 | ||
168 | /* | |
8d8706e2 AM |
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 | */ | |
1da177e4 | 173 | /* I find the above code a bit hairy. I find the below code |
8d8706e2 | 174 | easier to read and shorter. Now, if it works too that would |
1da177e4 | 175 | be great... -- REW |
8d8706e2 AM |
176 | */ |
177 | rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n"); | |
1da177e4 | 178 | while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) { |
8d8706e2 AM |
179 | if (!PortP->WaitUntilBooted) { |
180 | rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n"); | |
181 | func_exit(); | |
182 | return -ENXIO; | |
183 | } | |
184 | ||
185 | /* Under Linux you'd normally use a wait instead of this | |
186 | busy-waiting. I'll stick with the old implementation for | |
187 | now. --REW | |
188 | */ | |
189 | if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { | |
190 | rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n"); | |
191 | func_exit(); | |
192 | return -EINTR; | |
193 | } | |
194 | if (repeat_this-- <= 0) { | |
195 | rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n"); | |
196 | func_exit(); | |
197 | return -EIO; | |
198 | } | |
1da177e4 | 199 | } |
8d8706e2 | 200 | rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n"); |
1da177e4 | 201 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
8d8706e2 | 202 | if (p->RIOHalted) { |
1da177e4 LT |
203 | goto bombout; |
204 | } | |
1da177e4 LT |
205 | |
206 | /* | |
8d8706e2 AM |
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); | |
1da177e4 LT |
216 | retval = -EINTR; |
217 | goto bombout; | |
218 | } | |
219 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
220 | if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { | |
8d8706e2 | 221 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
1da177e4 LT |
222 | retval = -EINTR; |
223 | goto bombout; | |
224 | } | |
8d8706e2 | 225 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
1da177e4 LT |
226 | } |
227 | ||
8d8706e2 AM |
228 | if (!PortP->Mapped) { |
229 | rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n"); | |
1da177e4 LT |
230 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
231 | retval = -ENXIO; | |
8d8706e2 | 232 | func_exit(); |
1da177e4 LT |
233 | return retval; |
234 | } | |
235 | ||
8d8706e2 | 236 | if (p->RIOHalted) { |
1da177e4 LT |
237 | goto bombout; |
238 | } | |
239 | ||
240 | /* | |
241 | ** 15.10.1998 ARG - ESIL 0761 part fix | |
242 | ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure, | |
243 | ** we need to make sure that the flags are clear when the port is opened. | |
244 | */ | |
245 | /* Uh? Suppose I turn these on and then another process opens | |
246 | the port again? The flags get cleared! Not good. -- REW */ | |
8d8706e2 AM |
247 | if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) { |
248 | PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW); | |
1da177e4 LT |
249 | } |
250 | ||
251 | if (!(PortP->firstOpen)) { /* First time ? */ | |
8d8706e2 AM |
252 | rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n"); |
253 | ||
1da177e4 LT |
254 | |
255 | PortP->firstOpen++; | |
8d8706e2 | 256 | PortP->CookMode = 0; /* XXX RIOCookMode(tp); */ |
1da177e4 LT |
257 | PortP->InUse = NOT_INUSE; |
258 | ||
259 | /* Tentative fix for bug PR27. Didn't work. */ | |
260 | /* PortP->gs.xmit_cnt = 0; */ | |
261 | ||
262 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
1da177e4 LT |
263 | |
264 | /* Someone explain to me why this delay/config is | |
8d8706e2 AM |
265 | here. If I read the docs correctly the "open" |
266 | command piggybacks the parameters immediately. | |
1da177e4 | 267 | -- REW */ |
554b7c80 | 268 | RIOParam(PortP, OPEN, 1, OK_TO_SLEEP); /* Open the port */ |
1da177e4 LT |
269 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
270 | ||
271 | /* | |
8d8706e2 AM |
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); | |
1da177e4 LT |
276 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
277 | if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) { | |
8d8706e2 AM |
278 | rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n"); |
279 | RIOPreemptiveCmd(p, PortP, FCLOSE); | |
280 | func_exit(); | |
1da177e4 LT |
281 | return -EINTR; |
282 | } | |
283 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
284 | } | |
285 | ||
8d8706e2 AM |
286 | if (p->RIOHalted) { |
287 | retval = -EIO; | |
288 | bombout: | |
289 | /* RIOClearUp( PortP ); */ | |
1da177e4 LT |
290 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
291 | return retval; | |
292 | } | |
8d8706e2 | 293 | rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n"); |
1da177e4 | 294 | } |
554b7c80 AC |
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); | |
1da177e4 | 303 | /* |
554b7c80 AC |
304 | tp->tm.c_state |= CARR_ON; |
305 | wakeup((caddr_t) &tp->tm.c_canq); | |
8d8706e2 | 306 | */ |
554b7c80 AC |
307 | PortP->State |= RIO_CARR_ON; |
308 | wake_up_interruptible(&PortP->gs.open_wait); | |
309 | } else { /* no carrier - wait for DCD */ | |
1da177e4 | 310 | /* |
554b7c80 AC |
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); | |
8d8706e2 | 316 | /* |
554b7c80 | 317 | PortP->gs.tty->termios->c_state |= WOPEN; |
8d8706e2 | 318 | */ |
554b7c80 AC |
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); | |
1da177e4 | 329 | /* |
554b7c80 | 330 | tp->tm.c_state &= ~WOPEN; |
8d8706e2 | 331 | */ |
554b7c80 | 332 | PortP->State &= ~RIO_WOPEN; |
1da177e4 | 333 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
554b7c80 AC |
334 | func_exit(); |
335 | return -EINTR; | |
1da177e4 | 336 | } |
1da177e4 | 337 | } |
554b7c80 | 338 | PortP->State &= ~RIO_WOPEN; |
1da177e4 | 339 | } |
554b7c80 AC |
340 | if (p->RIOHalted) |
341 | goto bombout; | |
342 | rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n"); | |
343 | PortP->State |= RIO_MOPEN; | |
1da177e4 | 344 | |
554b7c80 | 345 | if (p->RIOHalted) |
1da177e4 | 346 | goto bombout; |
1da177e4 | 347 | |
8d8706e2 | 348 | rio_dprintk(RIO_DEBUG_TTY, "high level open done\n"); |
1da177e4 | 349 | |
1da177e4 | 350 | /* |
8d8706e2 AM |
351 | ** Count opens for port statistics reporting |
352 | */ | |
1da177e4 LT |
353 | if (PortP->statsGather) |
354 | PortP->opens++; | |
355 | ||
356 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
8d8706e2 AM |
357 | rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n"); |
358 | func_exit(); | |
1da177e4 LT |
359 | return 0; |
360 | } | |
361 | ||
362 | /* | |
363 | ** RIOClose the port. | |
364 | ** The operating system thinks that this is last close for the device. | |
365 | ** As there are two interfaces to the port (Modem and tty), we need to | |
366 | ** check that both are closed before we close the device. | |
8d8706e2 AM |
367 | */ |
368 | int riotclose(void *ptr) | |
1da177e4 | 369 | { |
d2a457cf | 370 | struct Port *PortP = ptr; /* pointer to the port structure */ |
1da177e4 | 371 | int deleted = 0; |
8d8706e2 AM |
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.) */ | |
d2a457cf | 375 | unsigned long end_time; |
8d8706e2 | 376 | struct tty_struct *tty; |
1da177e4 | 377 | unsigned long flags; |
d2a457cf | 378 | int rv = 0; |
8d8706e2 AM |
379 | |
380 | rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum); | |
1da177e4 LT |
381 | |
382 | /* PortP = p->RIOPortp[SysPort]; */ | |
554b7c80 | 383 | rio_dprintk(RIO_DEBUG_TTY, "Port is at address %p\n", PortP); |
8d8706e2 | 384 | /* tp = PortP->TtyP; *//* Get tty */ |
1da177e4 | 385 | tty = PortP->gs.tty; |
554b7c80 | 386 | rio_dprintk(RIO_DEBUG_TTY, "TTY is at address %p\n", tty); |
1da177e4 | 387 | |
8d8706e2 | 388 | if (PortP->gs.closing_wait) |
1da177e4 | 389 | end_time = jiffies + PortP->gs.closing_wait; |
8d8706e2 | 390 | else |
1da177e4 LT |
391 | end_time = jiffies + MAX_SCHEDULE_TIMEOUT; |
392 | ||
1da177e4 LT |
393 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
394 | ||
395 | /* | |
8d8706e2 AM |
396 | ** Setting this flag will make any process trying to open |
397 | ** this port block until we are complete closing it. | |
398 | */ | |
1da177e4 LT |
399 | PortP->State |= RIO_CLOSING; |
400 | ||
8d8706e2 AM |
401 | if ((PortP->State & RIO_DELETED)) { |
402 | rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n"); | |
1da177e4 LT |
403 | deleted = 1; |
404 | } | |
8d8706e2 AM |
405 | |
406 | if (p->RIOHalted) { | |
407 | RIOClearUp(PortP); | |
1da177e4 LT |
408 | rv = -EIO; |
409 | goto close_end; | |
410 | } | |
411 | ||
8d8706e2 | 412 | rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n"); |
1da177e4 | 413 | /* |
8d8706e2 AM |
414 | ** clear the open bits for this device |
415 | */ | |
554b7c80 | 416 | PortP->State &= ~RIO_MOPEN; |
1da177e4 LT |
417 | PortP->State &= ~RIO_CARR_ON; |
418 | PortP->ModemState &= ~MSVR1_CD; | |
419 | /* | |
8d8706e2 AM |
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))) { | |
1da177e4 | 427 | /* |
8d8706e2 AM |
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); | |
1da177e4 LT |
432 | PortP->State &= ~RIO_CLOSING; |
433 | if (PortP->firstOpen) | |
434 | PortP->firstOpen--; | |
435 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
436 | return -EIO; | |
437 | } | |
438 | ||
8d8706e2 | 439 | rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n"); |
1da177e4 LT |
440 | |
441 | PortP->State &= ~RIO_DYNOROD; | |
442 | ||
443 | /* | |
8d8706e2 AM |
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"); | |
1da177e4 LT |
449 | |
450 | if (!deleted) | |
8d8706e2 | 451 | while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) { |
8d8706e2 AM |
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 | } | |
1da177e4 | 466 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
1da177e4 | 467 | } |
1da177e4 LT |
468 | |
469 | PortP->TxBufferIn = PortP->TxBufferOut = 0; | |
470 | repeat_this = 0xff; | |
471 | ||
472 | PortP->InUse = 0; | |
8d8706e2 | 473 | if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) { |
1da177e4 | 474 | /* |
8d8706e2 AM |
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); | |
1da177e4 LT |
479 | PortP->State &= ~RIO_CLOSING; |
480 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
481 | if (PortP->firstOpen) | |
482 | PortP->firstOpen--; | |
483 | return -EIO; | |
484 | } | |
485 | ||
8d8706e2 AM |
486 | if (p->RIOHalted) { |
487 | RIOClearUp(PortP); | |
1da177e4 LT |
488 | goto close_end; |
489 | } | |
490 | ||
1da177e4 LT |
491 | /* Can't call RIOShortCommand with the port locked. */ |
492 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
493 | ||
494 | if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) { | |
d2a457cf BD |
495 | RIOPreemptiveCmd(p, PortP, FCLOSE); |
496 | goto close_end; | |
1da177e4 LT |
497 | } |
498 | ||
499 | if (!deleted) | |
8d8706e2 AM |
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); | |
1da177e4 | 508 | |
8d8706e2 AM |
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 | } | |
1da177e4 | 518 | } |
1da177e4 | 519 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
8d8706e2 AM |
520 | rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try); |
521 | ||
1da177e4 LT |
522 | /* RIOPreemptiveCmd(p, PortP, FCLOSE); */ |
523 | ||
524 | /* | |
525 | ** 15.10.1998 ARG - ESIL 0761 part fix | |
526 | ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,** we need to make sure that the flags are clear when the port is opened. | |
527 | */ | |
8d8706e2 | 528 | PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW); |
1da177e4 | 529 | |
1da177e4 | 530 | /* |
8d8706e2 AM |
531 | ** Count opens for port statistics reporting |
532 | */ | |
1da177e4 LT |
533 | if (PortP->statsGather) |
534 | PortP->closes++; | |
535 | ||
554b7c80 | 536 | close_end: |
1da177e4 LT |
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". | |
8d8706e2 AM |
541 | */ |
542 | PortP->State &= ~(RIO_CLOSING | RIO_DELETED); | |
1da177e4 LT |
543 | if (PortP->firstOpen) |
544 | PortP->firstOpen--; | |
545 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
8d8706e2 | 546 | rio_dprintk(RIO_DEBUG_TTY, "Return from close\n"); |
1da177e4 LT |
547 | return rv; |
548 | } | |
549 | ||
550 | ||
1da177e4 | 551 | |
554b7c80 | 552 | static void RIOClearUp(struct Port *PortP) |
1da177e4 | 553 | { |
8d8706e2 AM |
554 | rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n"); |
555 | PortP->Config = 0; /* Direct semaphore */ | |
1da177e4 LT |
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; | |
8d8706e2 | 562 | PortP->MagicFlags = 0; |
1da177e4 LT |
563 | PortP->RxDataStart = 0; |
564 | PortP->TxBufferIn = 0; | |
565 | PortP->TxBufferOut = 0; | |
566 | } | |
567 | ||
568 | /* | |
569 | ** Put a command onto a port. | |
570 | ** The PortPointer, command, length and arg are passed. | |
571 | ** The len is the length *inclusive* of the command byte, | |
572 | ** and so for a command that takes no data, len==1. | |
573 | ** The arg is a single byte, and is only used if len==2. | |
574 | ** Other values of len aren't allowed, and will cause | |
575 | ** a panic. | |
576 | */ | |
8d8706e2 | 577 | int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg) |
1da177e4 | 578 | { |
d886cb58 | 579 | struct PKT __iomem *PacketP; |
8d8706e2 | 580 | int retries = 20; /* at 10 per second -> 2 seconds */ |
1da177e4 LT |
581 | unsigned long flags; |
582 | ||
8d8706e2 | 583 | rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n"); |
1da177e4 | 584 | |
8d8706e2 AM |
585 | if (PortP->State & RIO_DELETED) { |
586 | rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n"); | |
1da177e4 LT |
587 | return RIO_FAIL; |
588 | } | |
589 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
590 | ||
591 | /* | |
8d8706e2 AM |
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); | |
1da177e4 LT |
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 | } | |
8d8706e2 AM |
606 | if (PortP->State & RIO_DELETED) { |
607 | rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n"); | |
1da177e4 LT |
608 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
609 | return RIO_FAIL; | |
610 | } | |
611 | ||
8d8706e2 AM |
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); | |
1da177e4 LT |
614 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
615 | if (retries-- <= 0) { | |
8d8706e2 | 616 | rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n"); |
1da177e4 LT |
617 | return RIO_FAIL; |
618 | } | |
8d8706e2 | 619 | if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) { |
1da177e4 LT |
620 | return RIO_FAIL; |
621 | } | |
622 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
623 | } | |
624 | ||
8d8706e2 | 625 | if (p->RIOHalted) { |
1da177e4 LT |
626 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
627 | return RIO_FAIL; | |
628 | } | |
629 | ||
630 | /* | |
8d8706e2 AM |
631 | ** set the command byte and the argument byte |
632 | */ | |
e2b3afd6 | 633 | writeb(command, &PacketP->data[0]); |
1da177e4 | 634 | |
8d8706e2 | 635 | if (len == 2) |
e2b3afd6 | 636 | writeb(arg, &PacketP->data[1]); |
1da177e4 LT |
637 | |
638 | /* | |
8d8706e2 AM |
639 | ** set the length of the packet and set the command bit. |
640 | */ | |
e2b3afd6 | 641 | writeb(PKT_CMD_BIT | len, &PacketP->len); |
1da177e4 LT |
642 | |
643 | add_transmit(PortP); | |
644 | /* | |
8d8706e2 AM |
645 | ** Count characters transmitted for port statistics reporting |
646 | */ | |
1da177e4 LT |
647 | if (PortP->statsGather) |
648 | PortP->txchars += len; | |
649 | ||
650 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
651 | return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL; | |
652 | } | |
653 | ||
654 |