]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | ** ----------------------------------------------------------------------------- | |
3 | ** | |
4 | ** Perle Specialix driver for Linux | |
5 | ** ported from the existing SCO driver source | |
6 | ** | |
7 | * | |
8 | * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License as published by | |
12 | * the Free Software Foundation; either version 2 of the License, or | |
13 | * (at your option) any later version. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
23 | ** | |
24 | ** Module : riocmd.c | |
25 | ** SID : 1.2 | |
26 | ** Last Modified : 11/6/98 10:33:41 | |
27 | ** Retrieved : 11/6/98 10:33:49 | |
28 | ** | |
29 | ** ident @(#)riocmd.c 1.2 | |
30 | ** | |
31 | ** ----------------------------------------------------------------------------- | |
32 | */ | |
1da177e4 LT |
33 | |
34 | #include <linux/module.h> | |
d43c36dc | 35 | #include <linux/sched.h> |
1da177e4 LT |
36 | #include <linux/slab.h> |
37 | #include <linux/errno.h> | |
38 | #include <linux/tty.h> | |
39 | #include <asm/io.h> | |
40 | #include <asm/system.h> | |
41 | #include <asm/string.h> | |
00d83a54 | 42 | #include <asm/uaccess.h> |
1da177e4 LT |
43 | |
44 | #include <linux/termios.h> | |
45 | #include <linux/serial.h> | |
46 | ||
47 | #include <linux/generic_serial.h> | |
48 | ||
49 | #include "linux_compat.h" | |
50 | #include "rio_linux.h" | |
1da177e4 LT |
51 | #include "pkt.h" |
52 | #include "daemon.h" | |
53 | #include "rio.h" | |
54 | #include "riospace.h" | |
1da177e4 LT |
55 | #include "cmdpkt.h" |
56 | #include "map.h" | |
1da177e4 LT |
57 | #include "rup.h" |
58 | #include "port.h" | |
59 | #include "riodrvr.h" | |
60 | #include "rioinfo.h" | |
61 | #include "func.h" | |
62 | #include "errors.h" | |
63 | #include "pci.h" | |
64 | ||
65 | #include "parmmap.h" | |
66 | #include "unixrup.h" | |
67 | #include "board.h" | |
68 | #include "host.h" | |
1da177e4 LT |
69 | #include "phb.h" |
70 | #include "link.h" | |
71 | #include "cmdblk.h" | |
72 | #include "route.h" | |
1da177e4 LT |
73 | #include "cirrus.h" |
74 | ||
75 | ||
76 | static struct IdentifyRta IdRta; | |
77 | static struct KillNeighbour KillUnit; | |
78 | ||
8d8706e2 | 79 | int RIOFoadRta(struct Host *HostP, struct Map *MapP) |
1da177e4 LT |
80 | { |
81 | struct CmdBlk *CmdBlkP; | |
82 | ||
8d8706e2 | 83 | rio_dprintk(RIO_DEBUG_CMD, "FOAD RTA\n"); |
1da177e4 LT |
84 | |
85 | CmdBlkP = RIOGetCmdBlk(); | |
86 | ||
8d8706e2 AM |
87 | if (!CmdBlkP) { |
88 | rio_dprintk(RIO_DEBUG_CMD, "FOAD RTA: GetCmdBlk failed\n"); | |
1da177e4 LT |
89 | return -ENXIO; |
90 | } | |
91 | ||
92 | CmdBlkP->Packet.dest_unit = MapP->ID; | |
93 | CmdBlkP->Packet.dest_port = BOOT_RUP; | |
8d8706e2 AM |
94 | CmdBlkP->Packet.src_unit = 0; |
95 | CmdBlkP->Packet.src_port = BOOT_RUP; | |
96 | CmdBlkP->Packet.len = 0x84; | |
97 | CmdBlkP->Packet.data[0] = IFOAD; | |
98 | CmdBlkP->Packet.data[1] = 0; | |
99 | CmdBlkP->Packet.data[2] = IFOAD_MAGIC & 0xFF; | |
100 | CmdBlkP->Packet.data[3] = (IFOAD_MAGIC >> 8) & 0xFF; | |
101 | ||
102 | if (RIOQueueCmdBlk(HostP, MapP->ID - 1, CmdBlkP) == RIO_FAIL) { | |
103 | rio_dprintk(RIO_DEBUG_CMD, "FOAD RTA: Failed to queue foad command\n"); | |
1da177e4 LT |
104 | return -EIO; |
105 | } | |
106 | return 0; | |
107 | } | |
108 | ||
8d8706e2 | 109 | int RIOZombieRta(struct Host *HostP, struct Map *MapP) |
1da177e4 LT |
110 | { |
111 | struct CmdBlk *CmdBlkP; | |
112 | ||
8d8706e2 | 113 | rio_dprintk(RIO_DEBUG_CMD, "ZOMBIE RTA\n"); |
1da177e4 LT |
114 | |
115 | CmdBlkP = RIOGetCmdBlk(); | |
116 | ||
8d8706e2 AM |
117 | if (!CmdBlkP) { |
118 | rio_dprintk(RIO_DEBUG_CMD, "ZOMBIE RTA: GetCmdBlk failed\n"); | |
1da177e4 LT |
119 | return -ENXIO; |
120 | } | |
121 | ||
122 | CmdBlkP->Packet.dest_unit = MapP->ID; | |
123 | CmdBlkP->Packet.dest_port = BOOT_RUP; | |
8d8706e2 AM |
124 | CmdBlkP->Packet.src_unit = 0; |
125 | CmdBlkP->Packet.src_port = BOOT_RUP; | |
126 | CmdBlkP->Packet.len = 0x84; | |
127 | CmdBlkP->Packet.data[0] = ZOMBIE; | |
128 | CmdBlkP->Packet.data[1] = 0; | |
129 | CmdBlkP->Packet.data[2] = ZOMBIE_MAGIC & 0xFF; | |
130 | CmdBlkP->Packet.data[3] = (ZOMBIE_MAGIC >> 8) & 0xFF; | |
131 | ||
132 | if (RIOQueueCmdBlk(HostP, MapP->ID - 1, CmdBlkP) == RIO_FAIL) { | |
133 | rio_dprintk(RIO_DEBUG_CMD, "ZOMBIE RTA: Failed to queue zombie command\n"); | |
1da177e4 LT |
134 | return -EIO; |
135 | } | |
136 | return 0; | |
137 | } | |
138 | ||
00d83a54 | 139 | int RIOCommandRta(struct rio_info *p, unsigned long RtaUnique, int (*func) (struct Host * HostP, struct Map * MapP)) |
1da177e4 | 140 | { |
00d83a54 | 141 | unsigned int Host; |
1da177e4 | 142 | |
554b7c80 | 143 | rio_dprintk(RIO_DEBUG_CMD, "Command RTA 0x%lx func %p\n", RtaUnique, func); |
1da177e4 | 144 | |
8d8706e2 AM |
145 | if (!RtaUnique) |
146 | return (0); | |
1da177e4 | 147 | |
8d8706e2 | 148 | for (Host = 0; Host < p->RIONumHosts; Host++) { |
00d83a54 | 149 | unsigned int Rta; |
1da177e4 LT |
150 | struct Host *HostP = &p->RIOHosts[Host]; |
151 | ||
8d8706e2 | 152 | for (Rta = 0; Rta < RTAS_PER_HOST; Rta++) { |
1da177e4 LT |
153 | struct Map *MapP = &HostP->Mapping[Rta]; |
154 | ||
8d8706e2 | 155 | if (MapP->RtaUniqueNum == RtaUnique) { |
1da177e4 LT |
156 | uint Link; |
157 | ||
158 | /* | |
8d8706e2 AM |
159 | ** now, lets just check we have a route to it... |
160 | ** IF the routing stuff is working, then one of the | |
161 | ** topology entries for this unit will have a legit | |
162 | ** route *somewhere*. We care not where - if its got | |
163 | ** any connections, we can get to it. | |
164 | */ | |
165 | for (Link = 0; Link < LINKS_PER_UNIT; Link++) { | |
00d83a54 | 166 | if (MapP->Topology[Link].Unit <= (u8) MAX_RUP) { |
1da177e4 | 167 | /* |
8d8706e2 AM |
168 | ** Its worth trying the operation... |
169 | */ | |
170 | return (*func) (HostP, MapP); | |
1da177e4 LT |
171 | } |
172 | } | |
173 | } | |
174 | } | |
175 | } | |
176 | return -ENXIO; | |
177 | } | |
178 | ||
179 | ||
d886cb58 | 180 | int RIOIdentifyRta(struct rio_info *p, void __user * arg) |
1da177e4 | 181 | { |
00d83a54 | 182 | unsigned int Host; |
1da177e4 | 183 | |
00d83a54 | 184 | if (copy_from_user(&IdRta, arg, sizeof(IdRta))) { |
8d8706e2 | 185 | rio_dprintk(RIO_DEBUG_CMD, "RIO_IDENTIFY_RTA copy failed\n"); |
1da177e4 LT |
186 | p->RIOError.Error = COPYIN_FAILED; |
187 | return -EFAULT; | |
188 | } | |
189 | ||
8d8706e2 | 190 | for (Host = 0; Host < p->RIONumHosts; Host++) { |
00d83a54 | 191 | unsigned int Rta; |
1da177e4 LT |
192 | struct Host *HostP = &p->RIOHosts[Host]; |
193 | ||
8d8706e2 | 194 | for (Rta = 0; Rta < RTAS_PER_HOST; Rta++) { |
1da177e4 LT |
195 | struct Map *MapP = &HostP->Mapping[Rta]; |
196 | ||
8d8706e2 | 197 | if (MapP->RtaUniqueNum == IdRta.RtaUnique) { |
1da177e4 LT |
198 | uint Link; |
199 | /* | |
8d8706e2 AM |
200 | ** now, lets just check we have a route to it... |
201 | ** IF the routing stuff is working, then one of the | |
202 | ** topology entries for this unit will have a legit | |
203 | ** route *somewhere*. We care not where - if its got | |
204 | ** any connections, we can get to it. | |
205 | */ | |
206 | for (Link = 0; Link < LINKS_PER_UNIT; Link++) { | |
00d83a54 | 207 | if (MapP->Topology[Link].Unit <= (u8) MAX_RUP) { |
1da177e4 | 208 | /* |
8d8706e2 AM |
209 | ** Its worth trying the operation... |
210 | */ | |
1da177e4 LT |
211 | struct CmdBlk *CmdBlkP; |
212 | ||
8d8706e2 | 213 | rio_dprintk(RIO_DEBUG_CMD, "IDENTIFY RTA\n"); |
1da177e4 LT |
214 | |
215 | CmdBlkP = RIOGetCmdBlk(); | |
216 | ||
8d8706e2 AM |
217 | if (!CmdBlkP) { |
218 | rio_dprintk(RIO_DEBUG_CMD, "IDENTIFY RTA: GetCmdBlk failed\n"); | |
1da177e4 LT |
219 | return -ENXIO; |
220 | } | |
8d8706e2 | 221 | |
1da177e4 LT |
222 | CmdBlkP->Packet.dest_unit = MapP->ID; |
223 | CmdBlkP->Packet.dest_port = BOOT_RUP; | |
8d8706e2 AM |
224 | CmdBlkP->Packet.src_unit = 0; |
225 | CmdBlkP->Packet.src_port = BOOT_RUP; | |
226 | CmdBlkP->Packet.len = 0x84; | |
227 | CmdBlkP->Packet.data[0] = IDENTIFY; | |
228 | CmdBlkP->Packet.data[1] = 0; | |
229 | CmdBlkP->Packet.data[2] = IdRta.ID; | |
230 | ||
231 | if (RIOQueueCmdBlk(HostP, MapP->ID - 1, CmdBlkP) == RIO_FAIL) { | |
232 | rio_dprintk(RIO_DEBUG_CMD, "IDENTIFY RTA: Failed to queue command\n"); | |
1da177e4 LT |
233 | return -EIO; |
234 | } | |
235 | return 0; | |
236 | } | |
237 | } | |
238 | } | |
239 | } | |
8d8706e2 | 240 | } |
1da177e4 LT |
241 | return -ENOENT; |
242 | } | |
243 | ||
244 | ||
d886cb58 | 245 | int RIOKillNeighbour(struct rio_info *p, void __user * arg) |
1da177e4 LT |
246 | { |
247 | uint Host; | |
248 | uint ID; | |
249 | struct Host *HostP; | |
250 | struct CmdBlk *CmdBlkP; | |
251 | ||
8d8706e2 | 252 | rio_dprintk(RIO_DEBUG_CMD, "KILL HOST NEIGHBOUR\n"); |
1da177e4 | 253 | |
00d83a54 | 254 | if (copy_from_user(&KillUnit, arg, sizeof(KillUnit))) { |
8d8706e2 | 255 | rio_dprintk(RIO_DEBUG_CMD, "RIO_KILL_NEIGHBOUR copy failed\n"); |
1da177e4 LT |
256 | p->RIOError.Error = COPYIN_FAILED; |
257 | return -EFAULT; | |
258 | } | |
259 | ||
8d8706e2 | 260 | if (KillUnit.Link > 3) |
1da177e4 | 261 | return -ENXIO; |
8d8706e2 | 262 | |
1da177e4 LT |
263 | CmdBlkP = RIOGetCmdBlk(); |
264 | ||
8d8706e2 AM |
265 | if (!CmdBlkP) { |
266 | rio_dprintk(RIO_DEBUG_CMD, "UFOAD: GetCmdBlk failed\n"); | |
1da177e4 LT |
267 | return -ENXIO; |
268 | } | |
269 | ||
270 | CmdBlkP->Packet.dest_unit = 0; | |
8d8706e2 | 271 | CmdBlkP->Packet.src_unit = 0; |
1da177e4 | 272 | CmdBlkP->Packet.dest_port = BOOT_RUP; |
8d8706e2 AM |
273 | CmdBlkP->Packet.src_port = BOOT_RUP; |
274 | CmdBlkP->Packet.len = 0x84; | |
275 | CmdBlkP->Packet.data[0] = UFOAD; | |
276 | CmdBlkP->Packet.data[1] = KillUnit.Link; | |
277 | CmdBlkP->Packet.data[2] = UFOAD_MAGIC & 0xFF; | |
278 | CmdBlkP->Packet.data[3] = (UFOAD_MAGIC >> 8) & 0xFF; | |
279 | ||
280 | for (Host = 0; Host < p->RIONumHosts; Host++) { | |
1da177e4 LT |
281 | ID = 0; |
282 | HostP = &p->RIOHosts[Host]; | |
283 | ||
8d8706e2 AM |
284 | if (HostP->UniqueNum == KillUnit.UniqueNum) { |
285 | if (RIOQueueCmdBlk(HostP, RTAS_PER_HOST + KillUnit.Link, CmdBlkP) == RIO_FAIL) { | |
286 | rio_dprintk(RIO_DEBUG_CMD, "UFOAD: Failed queue command\n"); | |
1da177e4 LT |
287 | return -EIO; |
288 | } | |
289 | return 0; | |
290 | } | |
291 | ||
8d8706e2 AM |
292 | for (ID = 0; ID < RTAS_PER_HOST; ID++) { |
293 | if (HostP->Mapping[ID].RtaUniqueNum == KillUnit.UniqueNum) { | |
294 | CmdBlkP->Packet.dest_unit = ID + 1; | |
295 | if (RIOQueueCmdBlk(HostP, ID, CmdBlkP) == RIO_FAIL) { | |
296 | rio_dprintk(RIO_DEBUG_CMD, "UFOAD: Failed queue command\n"); | |
1da177e4 LT |
297 | return -EIO; |
298 | } | |
299 | return 0; | |
300 | } | |
301 | } | |
302 | } | |
8d8706e2 | 303 | RIOFreeCmdBlk(CmdBlkP); |
1da177e4 LT |
304 | return -ENXIO; |
305 | } | |
306 | ||
8d8706e2 | 307 | int RIOSuspendBootRta(struct Host *HostP, int ID, int Link) |
1da177e4 LT |
308 | { |
309 | struct CmdBlk *CmdBlkP; | |
310 | ||
8d8706e2 | 311 | rio_dprintk(RIO_DEBUG_CMD, "SUSPEND BOOT ON RTA ID %d, link %c\n", ID, 'A' + Link); |
1da177e4 LT |
312 | |
313 | CmdBlkP = RIOGetCmdBlk(); | |
314 | ||
8d8706e2 AM |
315 | if (!CmdBlkP) { |
316 | rio_dprintk(RIO_DEBUG_CMD, "SUSPEND BOOT ON RTA: GetCmdBlk failed\n"); | |
1da177e4 LT |
317 | return -ENXIO; |
318 | } | |
319 | ||
320 | CmdBlkP->Packet.dest_unit = ID; | |
321 | CmdBlkP->Packet.dest_port = BOOT_RUP; | |
8d8706e2 AM |
322 | CmdBlkP->Packet.src_unit = 0; |
323 | CmdBlkP->Packet.src_port = BOOT_RUP; | |
324 | CmdBlkP->Packet.len = 0x84; | |
325 | CmdBlkP->Packet.data[0] = IWAIT; | |
326 | CmdBlkP->Packet.data[1] = Link; | |
327 | CmdBlkP->Packet.data[2] = IWAIT_MAGIC & 0xFF; | |
328 | CmdBlkP->Packet.data[3] = (IWAIT_MAGIC >> 8) & 0xFF; | |
329 | ||
330 | if (RIOQueueCmdBlk(HostP, ID - 1, CmdBlkP) == RIO_FAIL) { | |
331 | rio_dprintk(RIO_DEBUG_CMD, "SUSPEND BOOT ON RTA: Failed to queue iwait command\n"); | |
1da177e4 LT |
332 | return -EIO; |
333 | } | |
334 | return 0; | |
335 | } | |
336 | ||
8d8706e2 | 337 | int RIOFoadWakeup(struct rio_info *p) |
1da177e4 LT |
338 | { |
339 | int port; | |
00d83a54 | 340 | struct Port *PortP; |
1da177e4 LT |
341 | unsigned long flags; |
342 | ||
8d8706e2 | 343 | for (port = 0; port < RIO_PORTS; port++) { |
1da177e4 LT |
344 | PortP = p->RIOPortp[port]; |
345 | ||
346 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
347 | PortP->Config = 0; | |
348 | PortP->State = 0; | |
349 | PortP->InUse = NOT_INUSE; | |
350 | PortP->PortState = 0; | |
351 | PortP->FlushCmdBodge = 0; | |
352 | PortP->ModemLines = 0; | |
353 | PortP->ModemState = 0; | |
354 | PortP->CookMode = 0; | |
355 | PortP->ParamSem = 0; | |
356 | PortP->Mapped = 0; | |
357 | PortP->WflushFlag = 0; | |
358 | PortP->MagicFlags = 0; | |
359 | PortP->RxDataStart = 0; | |
360 | PortP->TxBufferIn = 0; | |
361 | PortP->TxBufferOut = 0; | |
362 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
363 | } | |
8d8706e2 | 364 | return (0); |
1da177e4 LT |
365 | } |
366 | ||
367 | /* | |
368 | ** Incoming command on the COMMAND_RUP to be processed. | |
369 | */ | |
d886cb58 | 370 | static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, struct PKT __iomem *PacketP) |
1da177e4 | 371 | { |
d886cb58 | 372 | struct PktCmd __iomem *PktCmdP = (struct PktCmd __iomem *)PacketP->data; |
1da177e4 LT |
373 | struct Port *PortP; |
374 | struct UnixRup *UnixRupP; | |
00d83a54 AC |
375 | unsigned short SysPort; |
376 | unsigned short ReportedModemStatus; | |
377 | unsigned short rup; | |
378 | unsigned short subCommand; | |
1da177e4 LT |
379 | unsigned long flags; |
380 | ||
8d8706e2 | 381 | func_enter(); |
1da177e4 | 382 | |
1da177e4 | 383 | /* |
8d8706e2 AM |
384 | ** 16 port RTA note: |
385 | ** Command rup packets coming from the RTA will have pkt->data[1] (which | |
386 | ** translates to PktCmdP->PhbNum) set to the host port number for the | |
387 | ** particular unit. To access the correct BaseSysPort for a 16 port RTA, | |
388 | ** we can use PhbNum to get the rup number for the appropriate 8 port | |
389 | ** block (for the first block, this should be equal to 'Rup'). | |
390 | */ | |
00d83a54 | 391 | rup = readb(&PktCmdP->PhbNum) / (unsigned short) PORTS_PER_RTA; |
1da177e4 | 392 | UnixRupP = &HostP->UnixRups[rup]; |
00d83a54 | 393 | SysPort = UnixRupP->BaseSysPort + (readb(&PktCmdP->PhbNum) % (unsigned short) PORTS_PER_RTA); |
8d8706e2 | 394 | rio_dprintk(RIO_DEBUG_CMD, "Command on rup %d, port %d\n", rup, SysPort); |
1da177e4 | 395 | |
8d8706e2 AM |
396 | if (UnixRupP->BaseSysPort == NO_PORT) { |
397 | rio_dprintk(RIO_DEBUG_CMD, "OBSCURE ERROR!\n"); | |
398 | rio_dprintk(RIO_DEBUG_CMD, "Diagnostics follow. Please WRITE THESE DOWN and report them to Specialix Technical Support\n"); | |
00d83a54 | 399 | rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: Host number %Zd, name ``%s''\n", HostP - p->RIOHosts, HostP->Name); |
8d8706e2 AM |
400 | rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: Rup number 0x%x\n", rup); |
401 | ||
84ea7763 | 402 | if (Rup < (unsigned short) MAX_RUP) { |
8d8706e2 | 403 | rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: This is the RUP for RTA ``%s''\n", HostP->Mapping[Rup].Name); |
1da177e4 | 404 | } else |
8d8706e2 AM |
405 | rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: This is the RUP for link ``%c'' of host ``%s''\n", ('A' + Rup - MAX_RUP), HostP->Name); |
406 | ||
92af11cd AV |
407 | rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Destination 0x%x:0x%x\n", readb(&PacketP->dest_unit), readb(&PacketP->dest_port)); |
408 | rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Source 0x%x:0x%x\n", readb(&PacketP->src_unit), readb(&PacketP->src_port)); | |
409 | rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Length 0x%x (%d)\n", readb(&PacketP->len), readb(&PacketP->len)); | |
410 | rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Control 0x%x (%d)\n", readb(&PacketP->control), readb(&PacketP->control)); | |
411 | rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Check 0x%x (%d)\n", readw(&PacketP->csum), readw(&PacketP->csum)); | |
412 | rio_dprintk(RIO_DEBUG_CMD, "COMMAND information: Host Port Number 0x%x, " "Command Code 0x%x\n", readb(&PktCmdP->PhbNum), readb(&PktCmdP->Command)); | |
554b7c80 | 413 | return 1; |
1da177e4 | 414 | } |
8d8706e2 | 415 | PortP = p->RIOPortp[SysPort]; |
1da177e4 | 416 | rio_spin_lock_irqsave(&PortP->portSem, flags); |
00d83a54 | 417 | switch (readb(&PktCmdP->Command)) { |
d6f6341a | 418 | case RIOC_BREAK_RECEIVED: |
8d8706e2 AM |
419 | rio_dprintk(RIO_DEBUG_CMD, "Received a break!\n"); |
420 | /* If the current line disc. is not multi-threading and | |
421 | the current processor is not the default, reset rup_intr | |
554b7c80 | 422 | and return 0 to ensure that the command packet is |
8d8706e2 AM |
423 | not freed. */ |
424 | /* Call tmgr HANGUP HERE */ | |
425 | /* Fix this later when every thing works !!!! RAMRAJ */ | |
426 | gs_got_break(&PortP->gs); | |
427 | break; | |
428 | ||
d6f6341a | 429 | case RIOC_COMPLETE: |
00d83a54 | 430 | rio_dprintk(RIO_DEBUG_CMD, "Command complete on phb %d host %Zd\n", readb(&PktCmdP->PhbNum), HostP - p->RIOHosts); |
8d8706e2 | 431 | subCommand = 1; |
00d83a54 | 432 | switch (readb(&PktCmdP->SubCommand)) { |
d6f6341a | 433 | case RIOC_MEMDUMP: |
00d83a54 | 434 | rio_dprintk(RIO_DEBUG_CMD, "Memory dump cmd (0x%x) from addr 0x%x\n", readb(&PktCmdP->SubCommand), readw(&PktCmdP->SubAddr)); |
1da177e4 | 435 | break; |
d6f6341a | 436 | case RIOC_READ_REGISTER: |
00d83a54 | 437 | rio_dprintk(RIO_DEBUG_CMD, "Read register (0x%x)\n", readw(&PktCmdP->SubAddr)); |
d6f6341a | 438 | p->CdRegister = (readb(&PktCmdP->ModemStatus) & RIOC_MSVR1_HOST); |
8d8706e2 AM |
439 | break; |
440 | default: | |
441 | subCommand = 0; | |
442 | break; | |
443 | } | |
444 | if (subCommand) | |
445 | break; | |
00d83a54 AC |
446 | rio_dprintk(RIO_DEBUG_CMD, "New status is 0x%x was 0x%x\n", readb(&PktCmdP->PortStatus), PortP->PortState); |
447 | if (PortP->PortState != readb(&PktCmdP->PortStatus)) { | |
8d8706e2 | 448 | rio_dprintk(RIO_DEBUG_CMD, "Mark status & wakeup\n"); |
00d83a54 | 449 | PortP->PortState = readb(&PktCmdP->PortStatus); |
8d8706e2 AM |
450 | /* What should we do here ... |
451 | wakeup( &PortP->PortState ); | |
452 | */ | |
453 | } else | |
454 | rio_dprintk(RIO_DEBUG_CMD, "No change\n"); | |
1da177e4 | 455 | |
8d8706e2 | 456 | /* FALLTHROUGH */ |
d6f6341a | 457 | case RIOC_MODEM_STATUS: |
8d8706e2 AM |
458 | /* |
459 | ** Knock out the tbusy and tstop bits, as these are not relevant | |
460 | ** to the check for modem status change (they're just there because | |
461 | ** it's a convenient place to put them!). | |
462 | */ | |
00d83a54 | 463 | ReportedModemStatus = readb(&PktCmdP->ModemStatus); |
d6f6341a JS |
464 | if ((PortP->ModemState & RIOC_MSVR1_HOST) == |
465 | (ReportedModemStatus & RIOC_MSVR1_HOST)) { | |
8d8706e2 | 466 | rio_dprintk(RIO_DEBUG_CMD, "Modem status unchanged 0x%x\n", PortP->ModemState); |
1da177e4 | 467 | /* |
8d8706e2 AM |
468 | ** Update ModemState just in case tbusy or tstop states have |
469 | ** changed. | |
470 | */ | |
471 | PortP->ModemState = ReportedModemStatus; | |
472 | } else { | |
473 | rio_dprintk(RIO_DEBUG_CMD, "Modem status change from 0x%x to 0x%x\n", PortP->ModemState, ReportedModemStatus); | |
474 | PortP->ModemState = ReportedModemStatus; | |
1da177e4 | 475 | #ifdef MODEM_SUPPORT |
8d8706e2 | 476 | if (PortP->Mapped) { |
1da177e4 LT |
477 | /***********************************************************\ |
478 | ************************************************************* | |
479 | *** *** | |
480 | *** M O D E M S T A T E C H A N G E *** | |
481 | *** *** | |
482 | ************************************************************* | |
483 | \***********************************************************/ | |
484 | /* | |
8d8706e2 AM |
485 | ** If the device is a modem, then check the modem |
486 | ** carrier. | |
487 | */ | |
b5391e29 | 488 | if (PortP->gs.port.tty == NULL) |
1da177e4 | 489 | break; |
b5391e29 | 490 | if (PortP->gs.port.tty->termios == NULL) |
1da177e4 | 491 | break; |
1da177e4 | 492 | |
b5391e29 | 493 | if (!(PortP->gs.port.tty->termios->c_cflag & CLOCAL) && ((PortP->State & (RIO_MOPEN | RIO_WOPEN)))) { |
8d8706e2 AM |
494 | |
495 | rio_dprintk(RIO_DEBUG_CMD, "Is there a Carrier?\n"); | |
496 | /* | |
497 | ** Is there a carrier? | |
498 | */ | |
d6f6341a | 499 | if (PortP->ModemState & RIOC_MSVR1_CD) { |
8d8706e2 AM |
500 | /* |
501 | ** Has carrier just appeared? | |
502 | */ | |
1da177e4 | 503 | if (!(PortP->State & RIO_CARR_ON)) { |
8d8706e2 | 504 | rio_dprintk(RIO_DEBUG_CMD, "Carrier just came up.\n"); |
1da177e4 | 505 | PortP->State |= RIO_CARR_ON; |
8d8706e2 AM |
506 | /* |
507 | ** wakeup anyone in WOPEN | |
508 | */ | |
509 | if (PortP->State & (PORT_ISOPEN | RIO_WOPEN)) | |
b5391e29 | 510 | wake_up_interruptible(&PortP->gs.port.open_wait); |
8d8706e2 | 511 | } |
1da177e4 | 512 | } else { |
8d8706e2 AM |
513 | /* |
514 | ** Has carrier just dropped? | |
515 | */ | |
1da177e4 | 516 | if (PortP->State & RIO_CARR_ON) { |
8d8706e2 | 517 | if (PortP->State & (PORT_ISOPEN | RIO_WOPEN | RIO_MOPEN)) |
b5391e29 | 518 | tty_hangup(PortP->gs.port.tty); |
1da177e4 | 519 | PortP->State &= ~RIO_CARR_ON; |
8d8706e2 | 520 | rio_dprintk(RIO_DEBUG_CMD, "Carrirer just went down\n"); |
8d8706e2 AM |
521 | } |
522 | } | |
523 | } | |
1da177e4 | 524 | } |
1da177e4 | 525 | #endif |
8d8706e2 AM |
526 | } |
527 | break; | |
1da177e4 | 528 | |
8d8706e2 | 529 | default: |
00d83a54 | 530 | rio_dprintk(RIO_DEBUG_CMD, "Unknown command %d on CMD_RUP of host %Zd\n", readb(&PktCmdP->Command), HostP - p->RIOHosts); |
8d8706e2 | 531 | break; |
1da177e4 LT |
532 | } |
533 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
534 | ||
8d8706e2 | 535 | func_exit(); |
1da177e4 | 536 | |
554b7c80 | 537 | return 1; |
1da177e4 | 538 | } |
8d8706e2 | 539 | |
1da177e4 LT |
540 | /* |
541 | ** The command mechanism: | |
542 | ** Each rup has a chain of commands associated with it. | |
543 | ** This chain is maintained by routines in this file. | |
544 | ** Periodically we are called and we run a quick check of all the | |
545 | ** active chains to determine if there is a command to be executed, | |
546 | ** and if the rup is ready to accept it. | |
547 | ** | |
548 | */ | |
549 | ||
550 | /* | |
551 | ** Allocate an empty command block. | |
552 | */ | |
8d8706e2 | 553 | struct CmdBlk *RIOGetCmdBlk(void) |
1da177e4 LT |
554 | { |
555 | struct CmdBlk *CmdBlkP; | |
556 | ||
dd00cc48 | 557 | CmdBlkP = kzalloc(sizeof(struct CmdBlk), GFP_ATOMIC); |
1da177e4 LT |
558 | return CmdBlkP; |
559 | } | |
560 | ||
561 | /* | |
562 | ** Return a block to the head of the free list. | |
563 | */ | |
8d8706e2 | 564 | void RIOFreeCmdBlk(struct CmdBlk *CmdBlkP) |
1da177e4 | 565 | { |
00d83a54 | 566 | kfree(CmdBlkP); |
1da177e4 LT |
567 | } |
568 | ||
569 | /* | |
570 | ** attach a command block to the list of commands to be performed for | |
571 | ** a given rup. | |
572 | */ | |
8d8706e2 | 573 | int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP) |
1da177e4 LT |
574 | { |
575 | struct CmdBlk **Base; | |
576 | struct UnixRup *UnixRupP; | |
577 | unsigned long flags; | |
578 | ||
00d83a54 | 579 | if (Rup >= (unsigned short) (MAX_RUP + LINKS_PER_UNIT)) { |
8d8706e2 AM |
580 | rio_dprintk(RIO_DEBUG_CMD, "Illegal rup number %d in RIOQueueCmdBlk\n", Rup); |
581 | RIOFreeCmdBlk(CmdBlkP); | |
1da177e4 LT |
582 | return RIO_FAIL; |
583 | } | |
584 | ||
585 | UnixRupP = &HostP->UnixRups[Rup]; | |
586 | ||
587 | rio_spin_lock_irqsave(&UnixRupP->RupLock, flags); | |
588 | ||
589 | /* | |
8d8706e2 AM |
590 | ** If the RUP is currently inactive, then put the request |
591 | ** straight on the RUP.... | |
592 | */ | |
00d83a54 | 593 | if ((UnixRupP->CmdsWaitingP == NULL) && (UnixRupP->CmdPendingP == NULL) && (readw(&UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE) && (CmdBlkP->PreFuncP ? (*CmdBlkP->PreFuncP) (CmdBlkP->PreArg, CmdBlkP) |
554b7c80 | 594 | : 1)) { |
8d8706e2 | 595 | rio_dprintk(RIO_DEBUG_CMD, "RUP inactive-placing command straight on. Cmd byte is 0x%x\n", CmdBlkP->Packet.data[0]); |
1da177e4 LT |
596 | |
597 | /* | |
8d8706e2 AM |
598 | ** Whammy! blat that pack! |
599 | */ | |
92af11cd | 600 | HostP->Copy(&CmdBlkP->Packet, RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->txpkt)), sizeof(struct PKT)); |
1da177e4 LT |
601 | |
602 | /* | |
8d8706e2 AM |
603 | ** place command packet on the pending position. |
604 | */ | |
1da177e4 LT |
605 | UnixRupP->CmdPendingP = CmdBlkP; |
606 | ||
607 | /* | |
8d8706e2 AM |
608 | ** set the command register |
609 | */ | |
00d83a54 | 610 | writew(TX_PACKET_READY, &UnixRupP->RupP->txcontrol); |
1da177e4 LT |
611 | |
612 | rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags); | |
613 | ||
554b7c80 | 614 | return 0; |
1da177e4 | 615 | } |
8d8706e2 | 616 | rio_dprintk(RIO_DEBUG_CMD, "RUP active - en-queing\n"); |
1da177e4 | 617 | |
8d8706e2 AM |
618 | if (UnixRupP->CmdsWaitingP != NULL) |
619 | rio_dprintk(RIO_DEBUG_CMD, "Rup active - command waiting\n"); | |
620 | if (UnixRupP->CmdPendingP != NULL) | |
621 | rio_dprintk(RIO_DEBUG_CMD, "Rup active - command pending\n"); | |
00d83a54 | 622 | if (readw(&UnixRupP->RupP->txcontrol) != TX_RUP_INACTIVE) |
8d8706e2 | 623 | rio_dprintk(RIO_DEBUG_CMD, "Rup active - command rup not ready\n"); |
1da177e4 LT |
624 | |
625 | Base = &UnixRupP->CmdsWaitingP; | |
626 | ||
554b7c80 | 627 | rio_dprintk(RIO_DEBUG_CMD, "First try to queue cmdblk %p at %p\n", CmdBlkP, Base); |
1da177e4 | 628 | |
8d8706e2 | 629 | while (*Base) { |
554b7c80 | 630 | rio_dprintk(RIO_DEBUG_CMD, "Command cmdblk %p here\n", *Base); |
1da177e4 | 631 | Base = &((*Base)->NextP); |
554b7c80 | 632 | rio_dprintk(RIO_DEBUG_CMD, "Now try to queue cmd cmdblk %p at %p\n", CmdBlkP, Base); |
1da177e4 LT |
633 | } |
634 | ||
554b7c80 | 635 | rio_dprintk(RIO_DEBUG_CMD, "Will queue cmdblk %p at %p\n", CmdBlkP, Base); |
1da177e4 LT |
636 | |
637 | *Base = CmdBlkP; | |
638 | ||
639 | CmdBlkP->NextP = NULL; | |
640 | ||
641 | rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags); | |
642 | ||
554b7c80 | 643 | return 0; |
1da177e4 LT |
644 | } |
645 | ||
646 | /* | |
647 | ** Here we go - if there is an empty rup, fill it! | |
648 | ** must be called at splrio() or higher. | |
649 | */ | |
8d8706e2 | 650 | void RIOPollHostCommands(struct rio_info *p, struct Host *HostP) |
1da177e4 | 651 | { |
00d83a54 AC |
652 | struct CmdBlk *CmdBlkP; |
653 | struct UnixRup *UnixRupP; | |
d886cb58 | 654 | struct PKT __iomem *PacketP; |
00d83a54 | 655 | unsigned short Rup; |
1da177e4 LT |
656 | unsigned long flags; |
657 | ||
658 | ||
8d8706e2 | 659 | Rup = MAX_RUP + LINKS_PER_UNIT; |
1da177e4 | 660 | |
8d8706e2 | 661 | do { /* do this loop for each RUP */ |
1da177e4 | 662 | /* |
8d8706e2 AM |
663 | ** locate the rup we are processing & lock it |
664 | */ | |
1da177e4 LT |
665 | UnixRupP = &HostP->UnixRups[--Rup]; |
666 | ||
667 | spin_lock_irqsave(&UnixRupP->RupLock, flags); | |
668 | ||
669 | /* | |
8d8706e2 AM |
670 | ** First check for incoming commands: |
671 | */ | |
00d83a54 | 672 | if (readw(&UnixRupP->RupP->rxcontrol) != RX_RUP_INACTIVE) { |
1da177e4 LT |
673 | int FreeMe; |
674 | ||
d886cb58 | 675 | PacketP = (struct PKT __iomem *) RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->rxpkt)); |
1da177e4 | 676 | |
00d83a54 | 677 | switch (readb(&PacketP->dest_port)) { |
8d8706e2 | 678 | case BOOT_RUP: |
00d83a54 | 679 | rio_dprintk(RIO_DEBUG_CMD, "Incoming Boot %s packet '%x'\n", readb(&PacketP->len) & 0x80 ? "Command" : "Data", readb(&PacketP->data[0])); |
8d8706e2 AM |
680 | rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags); |
681 | FreeMe = RIOBootRup(p, Rup, HostP, PacketP); | |
682 | rio_spin_lock_irqsave(&UnixRupP->RupLock, flags); | |
683 | break; | |
1da177e4 | 684 | |
8d8706e2 AM |
685 | case COMMAND_RUP: |
686 | /* | |
687 | ** Free the RUP lock as loss of carrier causes a | |
688 | ** ttyflush which will (eventually) call another | |
689 | ** routine that uses the RUP lock. | |
690 | */ | |
691 | rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags); | |
692 | FreeMe = RIOCommandRup(p, Rup, HostP, PacketP); | |
d6f6341a | 693 | if (readb(&PacketP->data[5]) == RIOC_MEMDUMP) { |
92af11cd | 694 | rio_dprintk(RIO_DEBUG_CMD, "Memdump from 0x%x complete\n", readw(&(PacketP->data[6]))); |
1bf08719 | 695 | rio_memcpy_fromio(p->RIOMemDump, &(PacketP->data[8]), 32); |
8d8706e2 AM |
696 | } |
697 | rio_spin_lock_irqsave(&UnixRupP->RupLock, flags); | |
698 | break; | |
1da177e4 | 699 | |
8d8706e2 AM |
700 | case ROUTE_RUP: |
701 | rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags); | |
702 | FreeMe = RIORouteRup(p, Rup, HostP, PacketP); | |
703 | rio_spin_lock_irqsave(&UnixRupP->RupLock, flags); | |
704 | break; | |
1da177e4 | 705 | |
8d8706e2 | 706 | default: |
00d83a54 | 707 | rio_dprintk(RIO_DEBUG_CMD, "Unknown RUP %d\n", readb(&PacketP->dest_port)); |
8d8706e2 AM |
708 | FreeMe = 1; |
709 | break; | |
1da177e4 LT |
710 | } |
711 | ||
8d8706e2 AM |
712 | if (FreeMe) { |
713 | rio_dprintk(RIO_DEBUG_CMD, "Free processed incoming command packet\n"); | |
714 | put_free_end(HostP, PacketP); | |
1da177e4 | 715 | |
00d83a54 | 716 | writew(RX_RUP_INACTIVE, &UnixRupP->RupP->rxcontrol); |
1da177e4 | 717 | |
00d83a54 | 718 | if (readw(&UnixRupP->RupP->handshake) == PHB_HANDSHAKE_SET) { |
8d8706e2 | 719 | rio_dprintk(RIO_DEBUG_CMD, "Handshake rup %d\n", Rup); |
00d83a54 | 720 | writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &UnixRupP->RupP->handshake); |
1da177e4 LT |
721 | } |
722 | } | |
723 | } | |
724 | ||
725 | /* | |
8d8706e2 AM |
726 | ** IF a command was running on the port, |
727 | ** and it has completed, then tidy it up. | |
728 | */ | |
729 | if ((CmdBlkP = UnixRupP->CmdPendingP) && /* ASSIGN! */ | |
00d83a54 | 730 | (readw(&UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE)) { |
1da177e4 | 731 | /* |
8d8706e2 AM |
732 | ** we are idle. |
733 | ** there is a command in pending. | |
734 | ** Therefore, this command has finished. | |
735 | ** So, wakeup whoever is waiting for it (and tell them | |
736 | ** what happened). | |
737 | */ | |
738 | if (CmdBlkP->Packet.dest_port == BOOT_RUP) | |
739 | rio_dprintk(RIO_DEBUG_CMD, "Free Boot %s Command Block '%x'\n", CmdBlkP->Packet.len & 0x80 ? "Command" : "Data", CmdBlkP->Packet.data[0]); | |
740 | ||
554b7c80 | 741 | rio_dprintk(RIO_DEBUG_CMD, "Command %p completed\n", CmdBlkP); |
1da177e4 LT |
742 | |
743 | /* | |
8d8706e2 AM |
744 | ** Clear the Rup lock to prevent mutual exclusion. |
745 | */ | |
746 | if (CmdBlkP->PostFuncP) { | |
1da177e4 | 747 | rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags); |
8d8706e2 | 748 | (*CmdBlkP->PostFuncP) (CmdBlkP->PostArg, CmdBlkP); |
1da177e4 LT |
749 | rio_spin_lock_irqsave(&UnixRupP->RupLock, flags); |
750 | } | |
751 | ||
752 | /* | |
8d8706e2 AM |
753 | ** ....clear the pending flag.... |
754 | */ | |
1da177e4 LT |
755 | UnixRupP->CmdPendingP = NULL; |
756 | ||
757 | /* | |
8d8706e2 AM |
758 | ** ....and return the command block to the freelist. |
759 | */ | |
760 | RIOFreeCmdBlk(CmdBlkP); | |
1da177e4 LT |
761 | } |
762 | ||
763 | /* | |
8d8706e2 AM |
764 | ** If there is a command for this rup, and the rup |
765 | ** is idle, then process the command | |
766 | */ | |
767 | if ((CmdBlkP = UnixRupP->CmdsWaitingP) && /* ASSIGN! */ | |
00d83a54 | 768 | (UnixRupP->CmdPendingP == NULL) && (readw(&UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE)) { |
1da177e4 | 769 | /* |
8d8706e2 AM |
770 | ** if the pre-function is non-zero, call it. |
771 | ** If it returns RIO_FAIL then don't | |
772 | ** send this command yet! | |
773 | */ | |
554b7c80 AC |
774 | if (!(CmdBlkP->PreFuncP ? (*CmdBlkP->PreFuncP) (CmdBlkP->PreArg, CmdBlkP) : 1)) { |
775 | rio_dprintk(RIO_DEBUG_CMD, "Not ready to start command %p\n", CmdBlkP); | |
8d8706e2 | 776 | } else { |
554b7c80 | 777 | rio_dprintk(RIO_DEBUG_CMD, "Start new command %p Cmd byte is 0x%x\n", CmdBlkP, CmdBlkP->Packet.data[0]); |
1da177e4 | 778 | /* |
8d8706e2 AM |
779 | ** Whammy! blat that pack! |
780 | */ | |
92af11cd | 781 | HostP->Copy(&CmdBlkP->Packet, RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->txpkt)), sizeof(struct PKT)); |
1da177e4 LT |
782 | |
783 | /* | |
8d8706e2 AM |
784 | ** remove the command from the rup command queue... |
785 | */ | |
1da177e4 LT |
786 | UnixRupP->CmdsWaitingP = CmdBlkP->NextP; |
787 | ||
788 | /* | |
8d8706e2 AM |
789 | ** ...and place it on the pending position. |
790 | */ | |
1da177e4 LT |
791 | UnixRupP->CmdPendingP = CmdBlkP; |
792 | ||
793 | /* | |
8d8706e2 AM |
794 | ** set the command register |
795 | */ | |
00d83a54 | 796 | writew(TX_PACKET_READY, &UnixRupP->RupP->txcontrol); |
1da177e4 LT |
797 | |
798 | /* | |
8d8706e2 AM |
799 | ** the command block will be freed |
800 | ** when the command has been processed. | |
801 | */ | |
1da177e4 LT |
802 | } |
803 | } | |
804 | spin_unlock_irqrestore(&UnixRupP->RupLock, flags); | |
8d8706e2 | 805 | } while (Rup); |
1da177e4 LT |
806 | } |
807 | ||
00d83a54 | 808 | int RIOWFlushMark(unsigned long iPortP, struct CmdBlk *CmdBlkP) |
1da177e4 | 809 | { |
8d8706e2 | 810 | struct Port *PortP = (struct Port *) iPortP; |
1da177e4 LT |
811 | unsigned long flags; |
812 | ||
813 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
1da177e4 LT |
814 | PortP->WflushFlag++; |
815 | PortP->MagicFlags |= MAGIC_FLUSH; | |
816 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
8d8706e2 | 817 | return RIOUnUse(iPortP, CmdBlkP); |
1da177e4 LT |
818 | } |
819 | ||
00d83a54 | 820 | int RIORFlushEnable(unsigned long iPortP, struct CmdBlk *CmdBlkP) |
1da177e4 | 821 | { |
8d8706e2 | 822 | struct Port *PortP = (struct Port *) iPortP; |
d886cb58 | 823 | struct PKT __iomem *PacketP; |
1da177e4 LT |
824 | unsigned long flags; |
825 | ||
826 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
827 | ||
8d8706e2 | 828 | while (can_remove_receive(&PacketP, PortP)) { |
1da177e4 | 829 | remove_receive(PortP); |
8d8706e2 | 830 | put_free_end(PortP->HostP, PacketP); |
1da177e4 LT |
831 | } |
832 | ||
00d83a54 | 833 | if (readw(&PortP->PhbP->handshake) == PHB_HANDSHAKE_SET) { |
1da177e4 | 834 | /* |
8d8706e2 AM |
835 | ** MAGIC! (Basically, handshake the RX buffer, so that |
836 | ** the RTAs upstream can be re-enabled.) | |
837 | */ | |
838 | rio_dprintk(RIO_DEBUG_CMD, "Util: Set RX handshake bit\n"); | |
00d83a54 | 839 | writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &PortP->PhbP->handshake); |
1da177e4 LT |
840 | } |
841 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
8d8706e2 | 842 | return RIOUnUse(iPortP, CmdBlkP); |
1da177e4 LT |
843 | } |
844 | ||
00d83a54 | 845 | int RIOUnUse(unsigned long iPortP, struct CmdBlk *CmdBlkP) |
1da177e4 | 846 | { |
8d8706e2 | 847 | struct Port *PortP = (struct Port *) iPortP; |
1da177e4 LT |
848 | unsigned long flags; |
849 | ||
850 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
851 | ||
8d8706e2 | 852 | rio_dprintk(RIO_DEBUG_CMD, "Decrement in use count for port\n"); |
1da177e4 LT |
853 | |
854 | if (PortP->InUse) { | |
8d8706e2 | 855 | if (--PortP->InUse != NOT_INUSE) { |
1da177e4 LT |
856 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
857 | return 0; | |
858 | } | |
859 | } | |
860 | /* | |
8d8706e2 AM |
861 | ** While PortP->InUse is set (i.e. a preemptive command has been sent to |
862 | ** the RTA and is awaiting completion), any transmit data is prevented from | |
863 | ** being transferred from the write queue into the transmit packets | |
864 | ** (add_transmit) and no furthur transmit interrupt will be sent for that | |
865 | ** data. The next interrupt will occur up to 500ms later (RIOIntr is called | |
25985edc | 866 | ** twice a second as a safety measure). This was the case when kermit was |
8d8706e2 AM |
867 | ** used to send data into a RIO port. After each packet was sent, TCFLSH |
868 | ** was called to flush the read queue preemptively. PortP->InUse was | |
869 | ** incremented, thereby blocking the 6 byte acknowledgement packet | |
870 | ** transmitted back. This acknowledgment hung around for 500ms before | |
871 | ** being sent, thus reducing input performance substantially!. | |
872 | ** When PortP->InUse becomes NOT_INUSE, we must ensure that any data | |
873 | ** hanging around in the transmit buffer is sent immediately. | |
874 | */ | |
00d83a54 | 875 | writew(1, &PortP->HostP->ParmMapP->tx_intr); |
1da177e4 | 876 | /* What to do here .. |
8d8706e2 AM |
877 | wakeup( (caddr_t)&(PortP->InUse) ); |
878 | */ | |
1da177e4 LT |
879 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); |
880 | return 0; | |
881 | } | |
882 | ||
1da177e4 LT |
883 | /* |
884 | ** | |
885 | ** How to use this file: | |
886 | ** | |
887 | ** To send a command down a rup, you need to allocate a command block, fill | |
888 | ** in the packet information, fill in the command number, fill in the pre- | |
889 | ** and post- functions and arguments, and then add the command block to the | |
890 | ** queue of command blocks for the port in question. When the port is idle, | |
891 | ** then the pre-function will be called. If this returns RIO_FAIL then the | |
892 | ** command will be re-queued and tried again at a later date (probably in one | |
893 | ** clock tick). If the pre-function returns NOT RIO_FAIL, then the command | |
894 | ** packet will be queued on the RUP, and the txcontrol field set to the | |
895 | ** command number. When the txcontrol field has changed from being the | |
896 | ** command number, then the post-function will be called, with the argument | |
897 | ** specified earlier, a pointer to the command block, and the value of | |
898 | ** txcontrol. | |
899 | ** | |
900 | ** To allocate a command block, call RIOGetCmdBlk(). This returns a pointer | |
901 | ** to the command block structure allocated, or NULL if there aren't any. | |
902 | ** The block will have been zeroed for you. | |
903 | ** | |
904 | ** The structure has the following fields: | |
905 | ** | |
906 | ** struct CmdBlk | |
907 | ** { | |
908 | ** struct CmdBlk *NextP; ** Pointer to next command block ** | |
909 | ** struct PKT Packet; ** A packet, to copy to the rup ** | |
910 | ** int (*PreFuncP)(); ** The func to call to check if OK ** | |
911 | ** int PreArg; ** The arg for the func ** | |
912 | ** int (*PostFuncP)(); ** The func to call when completed ** | |
913 | ** int PostArg; ** The arg for the func ** | |
914 | ** }; | |
915 | ** | |
916 | ** You need to fill in ALL fields EXCEPT NextP, which is used to link the | |
917 | ** blocks together either on the free list or on the Rup list. | |
918 | ** | |
919 | ** Packet is an actual packet structure to be filled in with the packet | |
920 | ** information associated with the command. You need to fill in everything, | |
0779bf2d | 921 | ** as the command processor doesn't process the command packet in any way. |
1da177e4 LT |
922 | ** |
923 | ** The PreFuncP is called before the packet is enqueued on the host rup. | |
924 | ** PreFuncP is called as (*PreFuncP)(PreArg, CmdBlkP);. PreFuncP must | |
925 | ** return !RIO_FAIL to have the packet queued on the rup, and RIO_FAIL | |
926 | ** if the packet is NOT to be queued. | |
927 | ** | |
928 | ** The PostFuncP is called when the command has completed. It is called | |
929 | ** as (*PostFuncP)(PostArg, CmdBlkP, txcontrol);. PostFuncP is not expected | |
930 | ** to return a value. PostFuncP does NOT need to free the command block, | |
931 | ** as this happens automatically after PostFuncP returns. | |
932 | ** | |
933 | ** Once the command block has been filled in, it is attached to the correct | |
934 | ** queue by calling RIOQueueCmdBlk( HostP, Rup, CmdBlkP ) where HostP is | |
935 | ** a pointer to the struct Host, Rup is the NUMBER of the rup (NOT a pointer | |
936 | ** to it!), and CmdBlkP is the pointer to the command block allocated using | |
937 | ** RIOGetCmdBlk(). | |
938 | ** | |
939 | */ |