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