Merge branch 'sched-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / drivers / char / ip2 / i2ellis.c
1 /*******************************************************************************
2 *
3 *   (c) 1998 by Computone Corporation
4 *
5 ********************************************************************************
6 *
7 *
8 *   PACKAGE:     Linux tty Device Driver for IntelliPort family of multiport
9 *                serial I/O controllers.
10 *
11 *   DESCRIPTION: Low-level interface code for the device driver
12 *                (This is included source code, not a separate compilation
13 *                module.)
14 *
15 *******************************************************************************/
16 //---------------------------------------------
17 // Function declarations private to this module
18 //---------------------------------------------
19 // Functions called only indirectly through i2eBordStr entries.
20
21 static int iiWriteBuf16(i2eBordStrPtr, unsigned char *, int);
22 static int iiWriteBuf8(i2eBordStrPtr, unsigned char *, int);
23 static int iiReadBuf16(i2eBordStrPtr, unsigned char *, int);
24 static int iiReadBuf8(i2eBordStrPtr, unsigned char *, int);
25
26 static unsigned short iiReadWord16(i2eBordStrPtr);
27 static unsigned short iiReadWord8(i2eBordStrPtr);
28 static void iiWriteWord16(i2eBordStrPtr, unsigned short);
29 static void iiWriteWord8(i2eBordStrPtr, unsigned short);
30
31 static int iiWaitForTxEmptyII(i2eBordStrPtr, int);
32 static int iiWaitForTxEmptyIIEX(i2eBordStrPtr, int);
33 static int iiTxMailEmptyII(i2eBordStrPtr);
34 static int iiTxMailEmptyIIEX(i2eBordStrPtr);
35 static int iiTrySendMailII(i2eBordStrPtr, unsigned char);
36 static int iiTrySendMailIIEX(i2eBordStrPtr, unsigned char);
37
38 static unsigned short iiGetMailII(i2eBordStrPtr);
39 static unsigned short iiGetMailIIEX(i2eBordStrPtr);
40
41 static void iiEnableMailIrqII(i2eBordStrPtr);
42 static void iiEnableMailIrqIIEX(i2eBordStrPtr);
43 static void iiWriteMaskII(i2eBordStrPtr, unsigned char);
44 static void iiWriteMaskIIEX(i2eBordStrPtr, unsigned char);
45
46 static void ii2Nop(void);
47
48 //***************
49 //* Static Data *
50 //***************
51
52 static int ii2Safe;         // Safe I/O address for delay routine
53
54 static int iiDelayed;   // Set when the iiResetDelay function is
55                                                         // called. Cleared when ANY board is reset.
56 static DEFINE_RWLOCK(Dl_spinlock);
57
58 //********
59 //* Code *
60 //********
61
62 //=======================================================
63 // Initialization Routines
64 //
65 // iiSetAddress
66 // iiReset
67 // iiResetDelay
68 // iiInitialize
69 //=======================================================
70
71 //******************************************************************************
72 // Function:   iiSetAddress(pB, address, delay)
73 // Parameters: pB      - pointer to the board structure
74 //             address - the purported I/O address of the board
75 //             delay   - pointer to the 1-ms delay function to use
76 //                       in this and any future operations to this board
77 //
78 // Returns:    True if everything appears copacetic.
79 //             False if there is any error: the pB->i2eError field has the error
80 //
81 // Description:
82 //
83 // This routine (roughly) checks for address validity, sets the i2eValid OK and
84 // sets the state to II_STATE_COLD which means that we haven't even sent a reset
85 // yet.
86 //
87 //******************************************************************************
88 static int
89 iiSetAddress( i2eBordStrPtr pB, int address, delayFunc_t delay )
90 {
91         // Should any failure occur before init is finished...
92         pB->i2eValid = I2E_INCOMPLETE;
93
94         // Cannot check upper limit except extremely: Might be microchannel
95         // Address must be on an 8-byte boundary
96
97         if ((unsigned int)address <= 0x100
98                 || (unsigned int)address >= 0xfff8
99                 || (address & 0x7)
100                 )
101         {
102                 I2_COMPLETE(pB, I2EE_BADADDR);
103         }
104
105         // Initialize accelerators
106         pB->i2eBase    = address;
107         pB->i2eData    = address + FIFO_DATA;
108         pB->i2eStatus  = address + FIFO_STATUS;
109         pB->i2ePointer = address + FIFO_PTR;
110         pB->i2eXMail   = address + FIFO_MAIL;
111         pB->i2eXMask   = address + FIFO_MASK;
112
113         // Initialize i/o address for ii2DelayIO
114         ii2Safe = address + FIFO_NOP;
115
116         // Initialize the delay routine
117         pB->i2eDelay = ((delay != (delayFunc_t)NULL) ? delay : (delayFunc_t)ii2Nop);
118
119         pB->i2eValid = I2E_MAGIC;
120         pB->i2eState = II_STATE_COLD;
121
122         I2_COMPLETE(pB, I2EE_GOOD);
123 }
124
125 //******************************************************************************
126 // Function:   iiReset(pB)
127 // Parameters: pB - pointer to the board structure
128 //
129 // Returns:    True if everything appears copacetic.
130 //             False if there is any error: the pB->i2eError field has the error
131 //
132 // Description:
133 //
134 // Attempts to reset the board (see also i2hw.h). Normally, we would use this to
135 // reset a board immediately after iiSetAddress(), but it is valid to reset a
136 // board from any state, say, in order to change or re-load loadware. (Under
137 // such circumstances, no reason to re-run iiSetAddress(), which is why it is a
138 // separate routine and not included in this routine.
139 //
140 //******************************************************************************
141 static int
142 iiReset(i2eBordStrPtr pB)
143 {
144         // Magic number should be set, else even the address is suspect
145         if (pB->i2eValid != I2E_MAGIC)
146         {
147                 I2_COMPLETE(pB, I2EE_BADMAGIC);
148         }
149
150         outb(0, pB->i2eBase + FIFO_RESET);  /* Any data will do */
151         iiDelay(pB, 50);                    // Pause between resets
152         outb(0, pB->i2eBase + FIFO_RESET);  /* Second reset */
153
154         // We must wait before even attempting to read anything from the FIFO: the
155         // board's P.O.S.T may actually attempt to read and write its end of the
156         // FIFO in order to check flags, loop back (where supported), etc. On
157         // completion of this testing it would reset the FIFO, and on completion
158         // of all // P.O.S.T., write the message. We must not mistake data which
159         // might have been sent for testing as part of the reset message. To
160         // better utilize time, say, when resetting several boards, we allow the
161         // delay to be performed externally; in this way the caller can reset 
162         // several boards, delay a single time, then call the initialization
163         // routine for all.
164
165         pB->i2eState = II_STATE_RESET;
166
167         iiDelayed = 0;  // i.e., the delay routine hasn't been called since the most
168                                         // recent reset.
169
170         // Ensure anything which would have been of use to standard loadware is
171         // blanked out, since board has now forgotten everything!.
172
173         pB->i2eUsingIrq = I2_IRQ_UNDEFINED; /* to not use an interrupt so far */
174         pB->i2eWaitingForEmptyFifo = 0;
175         pB->i2eOutMailWaiting = 0;
176         pB->i2eChannelPtr = NULL;
177         pB->i2eChannelCnt = 0;
178
179         pB->i2eLeadoffWord[0] = 0;
180         pB->i2eFifoInInts = 0;
181         pB->i2eFifoOutInts = 0;
182         pB->i2eFatalTrap = NULL;
183         pB->i2eFatal = 0;
184
185         I2_COMPLETE(pB, I2EE_GOOD);
186 }
187
188 //******************************************************************************
189 // Function:   iiResetDelay(pB)
190 // Parameters: pB - pointer to the board structure
191 //
192 // Returns:    True if everything appears copacetic.
193 //             False if there is any error: the pB->i2eError field has the error
194 //
195 // Description:
196 //
197 // Using the delay defined in board structure, waits two seconds (for board to
198 // reset).
199 //
200 //******************************************************************************
201 static int
202 iiResetDelay(i2eBordStrPtr pB)
203 {
204         if (pB->i2eValid != I2E_MAGIC) {
205                 I2_COMPLETE(pB, I2EE_BADMAGIC);
206         }
207         if (pB->i2eState != II_STATE_RESET) {
208                 I2_COMPLETE(pB, I2EE_BADSTATE);
209         }
210         iiDelay(pB,2000);       /* Now we wait for two seconds. */
211         iiDelayed = 1;          /* Delay has been called: ok to initialize */
212         I2_COMPLETE(pB, I2EE_GOOD);
213 }
214
215 //******************************************************************************
216 // Function:   iiInitialize(pB)
217 // Parameters: pB - pointer to the board structure
218 //
219 // Returns:    True if everything appears copacetic.
220 //             False if there is any error: the pB->i2eError field has the error
221 //
222 // Description:
223 //
224 // Attempts to read the Power-on reset message. Initializes any remaining fields
225 // in the pB structure.
226 //
227 // This should be called as the third step of a process beginning with
228 // iiReset(), then iiResetDelay(). This routine checks to see that the structure
229 // is "valid" and in the reset state, also confirms that the delay routine has
230 // been called since the latest reset (to any board! overly strong!).
231 //
232 //******************************************************************************
233 static int
234 iiInitialize(i2eBordStrPtr pB)
235 {
236         int itemp;
237         unsigned char c;
238         unsigned short utemp;
239         unsigned int ilimit;
240
241         if (pB->i2eValid != I2E_MAGIC)
242         {
243                 I2_COMPLETE(pB, I2EE_BADMAGIC);
244         }
245
246         if (pB->i2eState != II_STATE_RESET || !iiDelayed)
247         {
248                 I2_COMPLETE(pB, I2EE_BADSTATE);
249         }
250
251         // In case there is a failure short of our completely reading the power-up
252         // message.
253         pB->i2eValid = I2E_INCOMPLETE;
254
255
256         // Now attempt to read the message.
257
258         for (itemp = 0; itemp < sizeof(porStr); itemp++)
259         {
260                 // We expect the entire message is ready.
261                 if (!I2_HAS_INPUT(pB)) {
262                         pB->i2ePomSize = itemp;
263                         I2_COMPLETE(pB, I2EE_PORM_SHORT);
264                 }
265
266                 pB->i2ePom.c[itemp] = c = inb(pB->i2eData);
267
268                 // We check the magic numbers as soon as they are supposed to be read
269                 // (rather than after) to minimize effect of reading something we
270                 // already suspect can't be "us".
271                 if (  (itemp == POR_1_INDEX && c != POR_MAGIC_1) ||
272                                 (itemp == POR_2_INDEX && c != POR_MAGIC_2))
273                 {
274                         pB->i2ePomSize = itemp+1;
275                         I2_COMPLETE(pB, I2EE_BADMAGIC);
276                 }
277         }
278
279         pB->i2ePomSize = itemp;
280
281         // Ensure that this was all the data...
282         if (I2_HAS_INPUT(pB))
283                 I2_COMPLETE(pB, I2EE_PORM_LONG);
284
285         // For now, we'll fail to initialize if P.O.S.T reports bad chip mapper:
286         // Implying we will not be able to download any code either:  That's ok: the
287         // condition is pretty explicit.
288         if (pB->i2ePom.e.porDiag1 & POR_BAD_MAPPER)
289         {
290                 I2_COMPLETE(pB, I2EE_POSTERR);
291         }
292
293         // Determine anything which must be done differently depending on the family
294         // of boards!
295         switch (pB->i2ePom.e.porID & POR_ID_FAMILY)
296         {
297         case POR_ID_FII:  // IntelliPort-II
298
299                 pB->i2eFifoStyle   = FIFO_II;
300                 pB->i2eFifoSize    = 512;     // 512 bytes, always
301                 pB->i2eDataWidth16 = false;
302
303                 pB->i2eMaxIrq = 15;     // Because board cannot tell us it is in an 8-bit
304                                                         // slot, we do allow it to be done (documentation!)
305
306                 pB->i2eGoodMap[1] =
307                 pB->i2eGoodMap[2] =
308                 pB->i2eGoodMap[3] =
309                 pB->i2eChannelMap[1] =
310                 pB->i2eChannelMap[2] =
311                 pB->i2eChannelMap[3] = 0;
312
313                 switch (pB->i2ePom.e.porID & POR_ID_SIZE)
314                 {
315                 case POR_ID_II_4:
316                         pB->i2eGoodMap[0] =
317                         pB->i2eChannelMap[0] = 0x0f;  // four-port
318
319                         // Since porPorts1 is based on the Hardware ID register, the numbers
320                         // should always be consistent for IntelliPort-II.  Ditto below...
321                         if (pB->i2ePom.e.porPorts1 != 4)
322                         {
323                                 I2_COMPLETE(pB, I2EE_INCONSIST);
324                         }
325                         break;
326
327                 case POR_ID_II_8:
328                 case POR_ID_II_8R:
329                         pB->i2eGoodMap[0] =
330                         pB->i2eChannelMap[0] = 0xff;  // Eight port
331                         if (pB->i2ePom.e.porPorts1 != 8)
332                         {
333                                 I2_COMPLETE(pB, I2EE_INCONSIST);
334                         }
335                         break;
336
337                 case POR_ID_II_6:
338                         pB->i2eGoodMap[0] =
339                         pB->i2eChannelMap[0] = 0x3f;  // Six Port
340                         if (pB->i2ePom.e.porPorts1 != 6)
341                         {
342                                 I2_COMPLETE(pB, I2EE_INCONSIST);
343                         }
344                         break;
345                 }
346
347                 // Fix up the "good channel list based on any errors reported.
348                 if (pB->i2ePom.e.porDiag1 & POR_BAD_UART1)
349                 {
350                         pB->i2eGoodMap[0] &= ~0x0f;
351                 }
352
353                 if (pB->i2ePom.e.porDiag1 & POR_BAD_UART2)
354                 {
355                         pB->i2eGoodMap[0] &= ~0xf0;
356                 }
357
358                 break;   // POR_ID_FII case
359
360         case POR_ID_FIIEX:   // IntelliPort-IIEX
361
362                 pB->i2eFifoStyle = FIFO_IIEX;
363
364                 itemp = pB->i2ePom.e.porFifoSize;
365
366                 // Implicit assumption that fifo would not grow beyond 32k, 
367                 // nor would ever be less than 256.
368
369                 if (itemp < 8 || itemp > 15)
370                 {
371                         I2_COMPLETE(pB, I2EE_INCONSIST);
372                 }
373                 pB->i2eFifoSize = (1 << itemp);
374
375                 // These are based on what P.O.S.T thinks should be there, based on
376                 // box ID registers
377                 ilimit = pB->i2ePom.e.porNumBoxes;
378                 if (ilimit > ABS_MAX_BOXES)
379                 {
380                         ilimit = ABS_MAX_BOXES;
381                 }
382
383                 // For as many boxes as EXIST, gives the type of box.
384                 // Added 8/6/93: check for the ISA-4 (asic) which looks like an
385                 // expandable but for whom "8 or 16?" is not the right question.
386
387                 utemp = pB->i2ePom.e.porFlags;
388                 if (utemp & POR_CEX4)
389                 {
390                         pB->i2eChannelMap[0] = 0x000f;
391                 } else {
392                         utemp &= POR_BOXES;
393                         for (itemp = 0; itemp < ilimit; itemp++)
394                         {
395                                 pB->i2eChannelMap[itemp] = 
396                                         ((utemp & POR_BOX_16) ? 0xffff : 0x00ff);
397                                 utemp >>= 1;
398                         }
399                 }
400
401                 // These are based on what P.O.S.T actually found.
402
403                 utemp = (pB->i2ePom.e.porPorts2 << 8) + pB->i2ePom.e.porPorts1;
404
405                 for (itemp = 0; itemp < ilimit; itemp++)
406                 {
407                         pB->i2eGoodMap[itemp] = 0;
408                         if (utemp & 1) pB->i2eGoodMap[itemp] |= 0x000f;
409                         if (utemp & 2) pB->i2eGoodMap[itemp] |= 0x00f0;
410                         if (utemp & 4) pB->i2eGoodMap[itemp] |= 0x0f00;
411                         if (utemp & 8) pB->i2eGoodMap[itemp] |= 0xf000;
412                         utemp >>= 4;
413                 }
414
415                 // Now determine whether we should transfer in 8 or 16-bit mode.
416                 switch (pB->i2ePom.e.porBus & (POR_BUS_SLOT16 | POR_BUS_DIP16) )
417                 {
418                 case POR_BUS_SLOT16 | POR_BUS_DIP16:
419                         pB->i2eDataWidth16 = true;
420                         pB->i2eMaxIrq = 15;
421                         break;
422
423                 case POR_BUS_SLOT16:
424                         pB->i2eDataWidth16 = false;
425                         pB->i2eMaxIrq = 15;
426                         break;
427
428                 case 0:
429                 case POR_BUS_DIP16:     // In an 8-bit slot, DIP switch don't care.
430                 default:
431                         pB->i2eDataWidth16 = false;
432                         pB->i2eMaxIrq = 7;
433                         break;
434                 }
435                 break;   // POR_ID_FIIEX case
436
437         default:    // Unknown type of board
438                 I2_COMPLETE(pB, I2EE_BAD_FAMILY);
439                 break;
440         }  // End the switch based on family
441
442         // Temporarily, claim there is no room in the outbound fifo. 
443         // We will maintain this whenever we check for an empty outbound FIFO.
444         pB->i2eFifoRemains = 0;
445
446         // Now, based on the bus type, should we expect to be able to re-configure
447         // interrupts (say, for testing purposes).
448         switch (pB->i2ePom.e.porBus & POR_BUS_TYPE)
449         {
450         case POR_BUS_T_ISA:
451         case POR_BUS_T_UNK:  // If the type of bus is undeclared, assume ok.
452         case POR_BUS_T_MCA:
453         case POR_BUS_T_EISA:
454                 break;
455         default:
456                 I2_COMPLETE(pB, I2EE_BADBUS);
457         }
458
459         if (pB->i2eDataWidth16)
460         {
461                 pB->i2eWriteBuf  = iiWriteBuf16;
462                 pB->i2eReadBuf   = iiReadBuf16;
463                 pB->i2eWriteWord = iiWriteWord16;
464                 pB->i2eReadWord  = iiReadWord16;
465         } else {
466                 pB->i2eWriteBuf  = iiWriteBuf8;
467                 pB->i2eReadBuf   = iiReadBuf8;
468                 pB->i2eWriteWord = iiWriteWord8;
469                 pB->i2eReadWord  = iiReadWord8;
470         }
471
472         switch(pB->i2eFifoStyle)
473         {
474         case FIFO_II:
475                 pB->i2eWaitForTxEmpty = iiWaitForTxEmptyII;
476                 pB->i2eTxMailEmpty    = iiTxMailEmptyII;
477                 pB->i2eTrySendMail    = iiTrySendMailII;
478                 pB->i2eGetMail        = iiGetMailII;
479                 pB->i2eEnableMailIrq  = iiEnableMailIrqII;
480                 pB->i2eWriteMask      = iiWriteMaskII;
481
482                 break;
483
484         case FIFO_IIEX:
485                 pB->i2eWaitForTxEmpty = iiWaitForTxEmptyIIEX;
486                 pB->i2eTxMailEmpty    = iiTxMailEmptyIIEX;
487                 pB->i2eTrySendMail    = iiTrySendMailIIEX;
488                 pB->i2eGetMail        = iiGetMailIIEX;
489                 pB->i2eEnableMailIrq  = iiEnableMailIrqIIEX;
490                 pB->i2eWriteMask      = iiWriteMaskIIEX;
491
492                 break;
493
494         default:
495                 I2_COMPLETE(pB, I2EE_INCONSIST);
496         }
497
498         // Initialize state information.
499         pB->i2eState = II_STATE_READY;   // Ready to load loadware.
500
501         // Some Final cleanup:
502         // For some boards, the bootstrap firmware may perform some sort of test
503         // resulting in a stray character pending in the incoming mailbox. If one is
504         // there, it should be read and discarded, especially since for the standard
505         // firmware, it's the mailbox that interrupts the host.
506
507         pB->i2eStartMail = iiGetMail(pB);
508
509         // Throw it away and clear the mailbox structure element
510         pB->i2eStartMail = NO_MAIL_HERE;
511
512         // Everything is ok now, return with good status/
513
514         pB->i2eValid = I2E_MAGIC;
515         I2_COMPLETE(pB, I2EE_GOOD);
516 }
517
518 //******************************************************************************
519 // Function:   ii2DelayTimer(mseconds)
520 // Parameters: mseconds - number of milliseconds to delay
521 //
522 // Returns:    Nothing
523 //
524 // Description:
525 //
526 // This routine delays for approximately mseconds milliseconds and is intended
527 // to be called indirectly through i2Delay field in i2eBordStr. It uses the
528 // Linux timer_list mechanism.
529 //
530 // The Linux timers use a unit called "jiffies" which are 10mS in the Intel
531 // architecture. This function rounds the delay period up to the next "jiffy".
532 // In the Alpha architecture the "jiffy" is 1mS, but this driver is not intended
533 // for Alpha platforms at this time.
534 //
535 //******************************************************************************
536 static void
537 ii2DelayTimer(unsigned int mseconds)
538 {
539         msleep_interruptible(mseconds);
540 }
541
542 #if 0
543 //static void ii2DelayIO(unsigned int);
544 //******************************************************************************
545 // !!! Not Used, this is DOS crap, some of you young folks may be interested in
546 //     in how things were done in the stone age of caculating machines       !!!
547 // Function:   ii2DelayIO(mseconds)
548 // Parameters: mseconds - number of milliseconds to delay
549 //
550 // Returns:    Nothing
551 //
552 // Description:
553 //
554 // This routine delays for approximately mseconds milliseconds and is intended
555 // to be called indirectly through i2Delay field in i2eBordStr. It is intended
556 // for use where a clock-based function is impossible: for example, DOS drivers.
557 //
558 // This function uses the IN instruction to place bounds on the timing and
559 // assumes that ii2Safe has been set. This is because I/O instructions are not
560 // subject to caching and will therefore take a certain minimum time. To ensure
561 // the delay is at least long enough on fast machines, it is based on some
562 // fastest-case calculations.  On slower machines this may cause VERY long
563 // delays. (3 x fastest case). In the fastest case, everything is cached except
564 // the I/O instruction itself.
565 //
566 // Timing calculations:
567 // The fastest bus speed for I/O operations is likely to be 10 MHz. The I/O
568 // operation in question is a byte operation to an odd address. For 8-bit
569 // operations, the architecture generally enforces two wait states. At 10 MHz, a
570 // single cycle time is 100nS. A read operation at two wait states takes 6
571 // cycles for a total time of 600nS. Therefore approximately 1666 iterations
572 // would be required to generate a single millisecond delay. The worst
573 // (reasonable) case would be an 8MHz system with no cacheing. In this case, the
574 // I/O instruction would take 125nS x 6 cyles = 750 nS. More importantly, code
575 // fetch of other instructions in the loop would take time (zero wait states,
576 // however) and would be hard to estimate. This is minimized by using in-line
577 // assembler for the in inner loop of IN instructions. This consists of just a
578 // few bytes. So we'll guess about four code fetches per loop. Each code fetch
579 // should take four cycles, so we have 125nS * 8 = 1000nS. Worst case then is
580 // that what should have taken 1 mS takes instead 1666 * (1750) = 2.9 mS.
581 //
582 // So much for theoretical timings: results using 1666 value on some actual
583 // machines:
584 // IBM      286      6MHz     3.15 mS
585 // Zenith   386      33MHz    2.45 mS
586 // (brandX) 386      33MHz    1.90 mS  (has cache)
587 // (brandY) 486      33MHz    2.35 mS
588 // NCR      486      ??       1.65 mS (microchannel)
589 //
590 // For most machines, it is probably safe to scale this number back (remember,
591 // for robust operation use an actual timed delay if possible), so we are using
592 // a value of 1190. This yields 1.17 mS for the fastest machine in our sample,
593 // 1.75 mS for typical 386 machines, and 2.25 mS the absolute slowest machine.
594 //
595 // 1/29/93:
596 // The above timings are too slow. Actual cycle times might be faster. ISA cycle
597 // times could approach 500 nS, and ...
598 // The IBM model 77 being microchannel has no wait states for 8-bit reads and
599 // seems to be accessing the I/O at 440 nS per access (from start of one to
600 // start of next). This would imply we need 1000/.440 = 2272 iterations to
601 // guarantee we are fast enough. In actual testing, we see that 2 * 1190 are in
602 // fact enough. For diagnostics, we keep the level at 1190, but developers note
603 // this needs tuning.
604 //
605 // Safe assumption:  2270 i/o reads = 1 millisecond
606 //
607 //******************************************************************************
608
609
610 static int ii2DelValue = 1190;  // See timing calculations below
611                                                 // 1666 for fastest theoretical machine
612                                                 // 1190 safe for most fast 386 machines
613                                                 // 1000 for fastest machine tested here
614                                                 //  540 (sic) for AT286/6Mhz
615 static void
616 ii2DelayIO(unsigned int mseconds)
617 {
618         if (!ii2Safe) 
619                 return;   /* Do nothing if this variable uninitialized */
620
621         while(mseconds--) {
622                 int i = ii2DelValue;
623                 while ( i-- ) {
624                         inb(ii2Safe);
625                 }
626         }
627 }
628 #endif 
629
630 //******************************************************************************
631 // Function:   ii2Nop()
632 // Parameters: None
633 //
634 // Returns:    Nothing
635 //
636 // Description:
637 //
638 // iiInitialize will set i2eDelay to this if the delay parameter is NULL. This
639 // saves checking for a NULL pointer at every call.
640 //******************************************************************************
641 static void
642 ii2Nop(void)
643 {
644         return; // no mystery here
645 }
646
647 //=======================================================
648 // Routines which are available in 8/16-bit versions, or
649 // in different fifo styles. These are ALL called
650 // indirectly through the board structure.
651 //=======================================================
652
653 //******************************************************************************
654 // Function:   iiWriteBuf16(pB, address, count)
655 // Parameters: pB      - pointer to board structure
656 //             address - address of data to write
657 //             count   - number of data bytes to write
658 //
659 // Returns:    True if everything appears copacetic.
660 //             False if there is any error: the pB->i2eError field has the error
661 //
662 // Description:
663 //
664 // Writes 'count' bytes from 'address' to the data fifo specified by the board
665 // structure pointer pB. Should count happen to be odd, an extra pad byte is
666 // sent (identity unknown...). Uses 16-bit (word) operations. Is called
667 // indirectly through pB->i2eWriteBuf.
668 //
669 //******************************************************************************
670 static int
671 iiWriteBuf16(i2eBordStrPtr pB, unsigned char *address, int count)
672 {
673         // Rudimentary sanity checking here.
674         if (pB->i2eValid != I2E_MAGIC)
675                 I2_COMPLETE(pB, I2EE_INVALID);
676
677         I2_OUTSW(pB->i2eData, address, count);
678
679         I2_COMPLETE(pB, I2EE_GOOD);
680 }
681
682 //******************************************************************************
683 // Function:   iiWriteBuf8(pB, address, count)
684 // Parameters: pB      - pointer to board structure
685 //             address - address of data to write
686 //             count   - number of data bytes to write
687 //
688 // Returns:    True if everything appears copacetic.
689 //             False if there is any error: the pB->i2eError field has the error
690 //
691 // Description:
692 //
693 // Writes 'count' bytes from 'address' to the data fifo specified by the board
694 // structure pointer pB. Should count happen to be odd, an extra pad byte is
695 // sent (identity unknown...). This is to be consistent with the 16-bit version.
696 // Uses 8-bit (byte) operations. Is called indirectly through pB->i2eWriteBuf.
697 //
698 //******************************************************************************
699 static int
700 iiWriteBuf8(i2eBordStrPtr pB, unsigned char *address, int count)
701 {
702         /* Rudimentary sanity checking here */
703         if (pB->i2eValid != I2E_MAGIC)
704                 I2_COMPLETE(pB, I2EE_INVALID);
705
706         I2_OUTSB(pB->i2eData, address, count);
707
708         I2_COMPLETE(pB, I2EE_GOOD);
709 }
710
711 //******************************************************************************
712 // Function:   iiReadBuf16(pB, address, count)
713 // Parameters: pB      - pointer to board structure
714 //             address - address to put data read
715 //             count   - number of data bytes to read
716 //
717 // Returns:    True if everything appears copacetic.
718 //             False if there is any error: the pB->i2eError field has the error
719 //
720 // Description:
721 //
722 // Reads 'count' bytes into 'address' from the data fifo specified by the board
723 // structure pointer pB. Should count happen to be odd, an extra pad byte is
724 // received (identity unknown...). Uses 16-bit (word) operations. Is called
725 // indirectly through pB->i2eReadBuf.
726 //
727 //******************************************************************************
728 static int
729 iiReadBuf16(i2eBordStrPtr pB, unsigned char *address, int count)
730 {
731         // Rudimentary sanity checking here.
732         if (pB->i2eValid != I2E_MAGIC)
733                 I2_COMPLETE(pB, I2EE_INVALID);
734
735         I2_INSW(pB->i2eData, address, count);
736
737         I2_COMPLETE(pB, I2EE_GOOD);
738 }
739
740 //******************************************************************************
741 // Function:   iiReadBuf8(pB, address, count)
742 // Parameters: pB      - pointer to board structure
743 //             address - address to put data read
744 //             count   - number of data bytes to read
745 //
746 // Returns:    True if everything appears copacetic.
747 //             False if there is any error: the pB->i2eError field has the error
748 //
749 // Description:
750 //
751 // Reads 'count' bytes into 'address' from the data fifo specified by the board
752 // structure pointer pB. Should count happen to be odd, an extra pad byte is
753 // received (identity unknown...). This to match the 16-bit behaviour. Uses
754 // 8-bit (byte) operations. Is called indirectly through pB->i2eReadBuf.
755 //
756 //******************************************************************************
757 static int
758 iiReadBuf8(i2eBordStrPtr pB, unsigned char *address, int count)
759 {
760         // Rudimentary sanity checking here.
761         if (pB->i2eValid != I2E_MAGIC)
762                 I2_COMPLETE(pB, I2EE_INVALID);
763
764         I2_INSB(pB->i2eData, address, count);
765
766         I2_COMPLETE(pB, I2EE_GOOD);
767 }
768
769 //******************************************************************************
770 // Function:   iiReadWord16(pB)
771 // Parameters: pB      - pointer to board structure
772 //
773 // Returns:    True if everything appears copacetic.
774 //             False if there is any error: the pB->i2eError field has the error
775 //
776 // Description:
777 //
778 // Returns the word read from the data fifo specified by the board-structure
779 // pointer pB. Uses a 16-bit operation. Is called indirectly through
780 // pB->i2eReadWord.
781 //
782 //******************************************************************************
783 static unsigned short
784 iiReadWord16(i2eBordStrPtr pB)
785 {
786         return inw(pB->i2eData);
787 }
788
789 //******************************************************************************
790 // Function:   iiReadWord8(pB)
791 // Parameters: pB      - pointer to board structure
792 //
793 // Returns:    True if everything appears copacetic.
794 //             False if there is any error: the pB->i2eError field has the error
795 //
796 // Description:
797 //
798 // Returns the word read from the data fifo specified by the board-structure
799 // pointer pB. Uses two 8-bit operations. Bytes are assumed to be LSB first. Is
800 // called indirectly through pB->i2eReadWord.
801 //
802 //******************************************************************************
803 static unsigned short
804 iiReadWord8(i2eBordStrPtr pB)
805 {
806         unsigned short urs;
807
808         urs = inb(pB->i2eData);
809
810         return (inb(pB->i2eData) << 8) | urs;
811 }
812
813 //******************************************************************************
814 // Function:   iiWriteWord16(pB, value)
815 // Parameters: pB    - pointer to board structure
816 //             value - data to write
817 //
818 // Returns:    True if everything appears copacetic.
819 //             False if there is any error: the pB->i2eError field has the error
820 //
821 // Description:
822 //
823 // Writes the word 'value' to the data fifo specified by the board-structure
824 // pointer pB. Uses 16-bit operation. Is called indirectly through
825 // pB->i2eWriteWord.
826 //
827 //******************************************************************************
828 static void
829 iiWriteWord16(i2eBordStrPtr pB, unsigned short value)
830 {
831         outw((int)value, pB->i2eData);
832 }
833
834 //******************************************************************************
835 // Function:   iiWriteWord8(pB, value)
836 // Parameters: pB    - pointer to board structure
837 //             value - data to write
838 //
839 // Returns:    True if everything appears copacetic.
840 //             False if there is any error: the pB->i2eError field has the error
841 //
842 // Description:
843 //
844 // Writes the word 'value' to the data fifo specified by the board-structure
845 // pointer pB. Uses two 8-bit operations (writes LSB first). Is called
846 // indirectly through pB->i2eWriteWord.
847 //
848 //******************************************************************************
849 static void
850 iiWriteWord8(i2eBordStrPtr pB, unsigned short value)
851 {
852         outb((char)value, pB->i2eData);
853         outb((char)(value >> 8), pB->i2eData);
854 }
855
856 //******************************************************************************
857 // Function:   iiWaitForTxEmptyII(pB, mSdelay)
858 // Parameters: pB      - pointer to board structure
859 //             mSdelay - period to wait before returning
860 //
861 // Returns:    True if the FIFO is empty.
862 //             False if it not empty in the required time: the pB->i2eError
863 //             field has the error.
864 //
865 // Description:
866 //
867 // Waits up to "mSdelay" milliseconds for the outgoing FIFO to become empty; if
868 // not empty by the required time, returns false and error in pB->i2eError,
869 // otherwise returns true.
870 //
871 // mSdelay == 0 is taken to mean must be empty on the first test.
872 //
873 // This version operates on IntelliPort-II - style FIFO's
874 //
875 // Note this routine is organized so that if status is ok there is no delay at
876 // all called either before or after the test.  Is called indirectly through
877 // pB->i2eWaitForTxEmpty.
878 //
879 //******************************************************************************
880 static int
881 iiWaitForTxEmptyII(i2eBordStrPtr pB, int mSdelay)
882 {
883         unsigned long   flags;
884         int itemp;
885
886         for (;;)
887         {
888                 // This routine hinges on being able to see the "other" status register
889                 // (as seen by the local processor).  His incoming fifo is our outgoing
890                 // FIFO.
891                 //
892                 // By the nature of this routine, you would be using this as part of a
893                 // larger atomic context: i.e., you would use this routine to ensure the
894                 // fifo empty, then act on this information. Between these two halves, 
895                 // you will generally not want to service interrupts or in any way 
896                 // disrupt the assumptions implicit in the larger context.
897                 //
898                 // Even worse, however, this routine "shifts" the status register to 
899                 // point to the local status register which is not the usual situation.
900                 // Therefore for extra safety, we force the critical section to be
901                 // completely atomic, and pick up after ourselves before allowing any
902                 // interrupts of any kind.
903
904
905                 write_lock_irqsave(&Dl_spinlock, flags);
906                 outb(SEL_COMMAND, pB->i2ePointer);
907                 outb(SEL_CMD_SH, pB->i2ePointer);
908
909                 itemp = inb(pB->i2eStatus);
910
911                 outb(SEL_COMMAND, pB->i2ePointer);
912                 outb(SEL_CMD_UNSH, pB->i2ePointer);
913
914                 if (itemp & ST_IN_EMPTY)
915                 {
916                         I2_UPDATE_FIFO_ROOM(pB);
917                         write_unlock_irqrestore(&Dl_spinlock, flags);
918                         I2_COMPLETE(pB, I2EE_GOOD);
919                 }
920
921                 write_unlock_irqrestore(&Dl_spinlock, flags);
922
923                 if (mSdelay-- == 0)
924                         break;
925
926                 iiDelay(pB, 1);      /* 1 mS granularity on checking condition */
927         }
928         I2_COMPLETE(pB, I2EE_TXE_TIME);
929 }
930
931 //******************************************************************************
932 // Function:   iiWaitForTxEmptyIIEX(pB, mSdelay)
933 // Parameters: pB      - pointer to board structure
934 //             mSdelay - period to wait before returning
935 //
936 // Returns:    True if the FIFO is empty.
937 //             False if it not empty in the required time: the pB->i2eError
938 //             field has the error.
939 //
940 // Description:
941 //
942 // Waits up to "mSdelay" milliseconds for the outgoing FIFO to become empty; if
943 // not empty by the required time, returns false and error in pB->i2eError,
944 // otherwise returns true.
945 //
946 // mSdelay == 0 is taken to mean must be empty on the first test.
947 //
948 // This version operates on IntelliPort-IIEX - style FIFO's
949 //
950 // Note this routine is organized so that if status is ok there is no delay at
951 // all called either before or after the test.  Is called indirectly through
952 // pB->i2eWaitForTxEmpty.
953 //
954 //******************************************************************************
955 static int
956 iiWaitForTxEmptyIIEX(i2eBordStrPtr pB, int mSdelay)
957 {
958         unsigned long   flags;
959
960         for (;;)
961         {
962                 // By the nature of this routine, you would be using this as part of a
963                 // larger atomic context: i.e., you would use this routine to ensure the
964                 // fifo empty, then act on this information. Between these two halves,
965                 // you will generally not want to service interrupts or in any way
966                 // disrupt the assumptions implicit in the larger context.
967
968                 write_lock_irqsave(&Dl_spinlock, flags);
969
970                 if (inb(pB->i2eStatus) & STE_OUT_MT) {
971                         I2_UPDATE_FIFO_ROOM(pB);
972                         write_unlock_irqrestore(&Dl_spinlock, flags);
973                         I2_COMPLETE(pB, I2EE_GOOD);
974                 }
975                 write_unlock_irqrestore(&Dl_spinlock, flags);
976
977                 if (mSdelay-- == 0)
978                         break;
979
980                 iiDelay(pB, 1);      // 1 mS granularity on checking condition
981         }
982         I2_COMPLETE(pB, I2EE_TXE_TIME);
983 }
984
985 //******************************************************************************
986 // Function:   iiTxMailEmptyII(pB)
987 // Parameters: pB      - pointer to board structure
988 //
989 // Returns:    True if the transmit mailbox is empty.
990 //             False if it not empty.
991 //
992 // Description:
993 //
994 // Returns true or false according to whether the transmit mailbox is empty (and
995 // therefore able to accept more mail)
996 //
997 // This version operates on IntelliPort-II - style FIFO's
998 //
999 //******************************************************************************
1000 static int
1001 iiTxMailEmptyII(i2eBordStrPtr pB)
1002 {
1003         int port = pB->i2ePointer;
1004         outb(SEL_OUTMAIL, port);
1005         return inb(port) == 0;
1006 }
1007
1008 //******************************************************************************
1009 // Function:   iiTxMailEmptyIIEX(pB)
1010 // Parameters: pB      - pointer to board structure
1011 //
1012 // Returns:    True if the transmit mailbox is empty.
1013 //             False if it not empty.
1014 //
1015 // Description:
1016 //
1017 // Returns true or false according to whether the transmit mailbox is empty (and
1018 // therefore able to accept more mail)
1019 //
1020 // This version operates on IntelliPort-IIEX - style FIFO's
1021 //
1022 //******************************************************************************
1023 static int
1024 iiTxMailEmptyIIEX(i2eBordStrPtr pB)
1025 {
1026         return !(inb(pB->i2eStatus) & STE_OUT_MAIL);
1027 }
1028
1029 //******************************************************************************
1030 // Function:   iiTrySendMailII(pB,mail)
1031 // Parameters: pB   - pointer to board structure
1032 //             mail - value to write to mailbox
1033 //
1034 // Returns:    True if the transmit mailbox is empty, and mail is sent.
1035 //             False if it not empty.
1036 //
1037 // Description:
1038 //
1039 // If outgoing mailbox is empty, sends mail and returns true. If outgoing
1040 // mailbox is not empty, returns false.
1041 //
1042 // This version operates on IntelliPort-II - style FIFO's
1043 //
1044 //******************************************************************************
1045 static int
1046 iiTrySendMailII(i2eBordStrPtr pB, unsigned char mail)
1047 {
1048         int port = pB->i2ePointer;
1049
1050         outb(SEL_OUTMAIL, port);
1051         if (inb(port) == 0) {
1052                 outb(SEL_OUTMAIL, port);
1053                 outb(mail, port);
1054                 return 1;
1055         }
1056         return 0;
1057 }
1058
1059 //******************************************************************************
1060 // Function:   iiTrySendMailIIEX(pB,mail)
1061 // Parameters: pB   - pointer to board structure
1062 //             mail - value to write to mailbox
1063 //
1064 // Returns:    True if the transmit mailbox is empty, and mail is sent.
1065 //             False if it not empty.
1066 //
1067 // Description:
1068 //
1069 // If outgoing mailbox is empty, sends mail and returns true. If outgoing
1070 // mailbox is not empty, returns false.
1071 //
1072 // This version operates on IntelliPort-IIEX - style FIFO's
1073 //
1074 //******************************************************************************
1075 static int
1076 iiTrySendMailIIEX(i2eBordStrPtr pB, unsigned char mail)
1077 {
1078         if (inb(pB->i2eStatus) & STE_OUT_MAIL)
1079                 return 0;
1080         outb(mail, pB->i2eXMail);
1081         return 1;
1082 }
1083
1084 //******************************************************************************
1085 // Function:   iiGetMailII(pB,mail)
1086 // Parameters: pB   - pointer to board structure
1087 //
1088 // Returns:    Mailbox data or NO_MAIL_HERE.
1089 //
1090 // Description:
1091 //
1092 // If no mail available, returns NO_MAIL_HERE otherwise returns the data from
1093 // the mailbox, which is guaranteed != NO_MAIL_HERE.
1094 //
1095 // This version operates on IntelliPort-II - style FIFO's
1096 //
1097 //******************************************************************************
1098 static unsigned short
1099 iiGetMailII(i2eBordStrPtr pB)
1100 {
1101         if (I2_HAS_MAIL(pB)) {
1102                 outb(SEL_INMAIL, pB->i2ePointer);
1103                 return inb(pB->i2ePointer);
1104         } else {
1105                 return NO_MAIL_HERE;
1106         }
1107 }
1108
1109 //******************************************************************************
1110 // Function:   iiGetMailIIEX(pB,mail)
1111 // Parameters: pB   - pointer to board structure
1112 //
1113 // Returns:    Mailbox data or NO_MAIL_HERE.
1114 //
1115 // Description:
1116 //
1117 // If no mail available, returns NO_MAIL_HERE otherwise returns the data from
1118 // the mailbox, which is guaranteed != NO_MAIL_HERE.
1119 //
1120 // This version operates on IntelliPort-IIEX - style FIFO's
1121 //
1122 //******************************************************************************
1123 static unsigned short
1124 iiGetMailIIEX(i2eBordStrPtr pB)
1125 {
1126         if (I2_HAS_MAIL(pB))
1127                 return inb(pB->i2eXMail);
1128         else
1129                 return NO_MAIL_HERE;
1130 }
1131
1132 //******************************************************************************
1133 // Function:   iiEnableMailIrqII(pB)
1134 // Parameters: pB - pointer to board structure
1135 //
1136 // Returns:    Nothing
1137 //
1138 // Description:
1139 //
1140 // Enables board to interrupt host (only) by writing to host's in-bound mailbox.
1141 //
1142 // This version operates on IntelliPort-II - style FIFO's
1143 //
1144 //******************************************************************************
1145 static void
1146 iiEnableMailIrqII(i2eBordStrPtr pB)
1147 {
1148         outb(SEL_MASK, pB->i2ePointer);
1149         outb(ST_IN_MAIL, pB->i2ePointer);
1150 }
1151
1152 //******************************************************************************
1153 // Function:   iiEnableMailIrqIIEX(pB)
1154 // Parameters: pB - pointer to board structure
1155 //
1156 // Returns:    Nothing
1157 //
1158 // Description:
1159 //
1160 // Enables board to interrupt host (only) by writing to host's in-bound mailbox.
1161 //
1162 // This version operates on IntelliPort-IIEX - style FIFO's
1163 //
1164 //******************************************************************************
1165 static void
1166 iiEnableMailIrqIIEX(i2eBordStrPtr pB)
1167 {
1168         outb(MX_IN_MAIL, pB->i2eXMask);
1169 }
1170
1171 //******************************************************************************
1172 // Function:   iiWriteMaskII(pB)
1173 // Parameters: pB - pointer to board structure
1174 //
1175 // Returns:    Nothing
1176 //
1177 // Description:
1178 //
1179 // Writes arbitrary value to the mask register.
1180 //
1181 // This version operates on IntelliPort-II - style FIFO's
1182 //
1183 //******************************************************************************
1184 static void
1185 iiWriteMaskII(i2eBordStrPtr pB, unsigned char value)
1186 {
1187         outb(SEL_MASK, pB->i2ePointer);
1188         outb(value, pB->i2ePointer);
1189 }
1190
1191 //******************************************************************************
1192 // Function:   iiWriteMaskIIEX(pB)
1193 // Parameters: pB - pointer to board structure
1194 //
1195 // Returns:    Nothing
1196 //
1197 // Description:
1198 //
1199 // Writes arbitrary value to the mask register.
1200 //
1201 // This version operates on IntelliPort-IIEX - style FIFO's
1202 //
1203 //******************************************************************************
1204 static void
1205 iiWriteMaskIIEX(i2eBordStrPtr pB, unsigned char value)
1206 {
1207         outb(value, pB->i2eXMask);
1208 }
1209
1210 //******************************************************************************
1211 // Function:   iiDownloadBlock(pB, pSource, isStandard)
1212 // Parameters: pB         - pointer to board structure
1213 //             pSource    - loadware block to download
1214 //             isStandard - True if "standard" loadware, else false.
1215 //
1216 // Returns:    Success or Failure
1217 //
1218 // Description:
1219 //
1220 // Downloads a single block (at pSource)to the board referenced by pB. Caller
1221 // sets isStandard to true/false according to whether the "standard" loadware is
1222 // what's being loaded. The normal process, then, is to perform an iiInitialize
1223 // to the board, then perform some number of iiDownloadBlocks using the returned
1224 // state to determine when download is complete.
1225 //
1226 // Possible return values: (see I2ELLIS.H)
1227 // II_DOWN_BADVALID
1228 // II_DOWN_BADFILE
1229 // II_DOWN_CONTINUING
1230 // II_DOWN_GOOD
1231 // II_DOWN_BAD
1232 // II_DOWN_BADSTATE
1233 // II_DOWN_TIMEOUT
1234 //
1235 // Uses the i2eState and i2eToLoad fields (initialized at iiInitialize) to
1236 // determine whether this is the first block, whether to check for magic
1237 // numbers, how many blocks there are to go...
1238 //
1239 //******************************************************************************
1240 static int
1241 iiDownloadBlock ( i2eBordStrPtr pB, loadHdrStrPtr pSource, int isStandard)
1242 {
1243         int itemp;
1244         int loadedFirst;
1245
1246         if (pB->i2eValid != I2E_MAGIC) return II_DOWN_BADVALID;
1247
1248         switch(pB->i2eState)
1249         {
1250         case II_STATE_READY:
1251
1252                 // Loading the first block after reset. Must check the magic number of the
1253                 // loadfile, store the number of blocks we expect to load.
1254                 if (pSource->e.loadMagic != MAGIC_LOADFILE)
1255                 {
1256                         return II_DOWN_BADFILE;
1257                 }
1258
1259                 // Next we store the total number of blocks to load, including this one.
1260                 pB->i2eToLoad = 1 + pSource->e.loadBlocksMore;
1261
1262                 // Set the state, store the version numbers. ('Cause this may have come
1263                 // from a file - we might want to report these versions and revisions in
1264                 // case of an error!
1265                 pB->i2eState = II_STATE_LOADING;
1266                 pB->i2eLVersion = pSource->e.loadVersion;
1267                 pB->i2eLRevision = pSource->e.loadRevision;
1268                 pB->i2eLSub = pSource->e.loadSubRevision;
1269
1270                 // The time and date of compilation is also available but don't bother
1271                 // storing it for normal purposes.
1272                 loadedFirst = 1;
1273                 break;
1274
1275         case II_STATE_LOADING:
1276                 loadedFirst = 0;
1277                 break;
1278
1279         default:
1280                 return II_DOWN_BADSTATE;
1281         }
1282
1283         // Now we must be in the II_STATE_LOADING state, and we assume i2eToLoad
1284         // must be positive still, because otherwise we would have cleaned up last
1285         // time and set the state to II_STATE_LOADED.
1286         if (!iiWaitForTxEmpty(pB, MAX_DLOAD_READ_TIME)) {
1287                 return II_DOWN_TIMEOUT;
1288         }
1289
1290         if (!iiWriteBuf(pB, pSource->c, LOADWARE_BLOCK_SIZE)) {
1291                 return II_DOWN_BADVALID;
1292         }
1293
1294         // If we just loaded the first block, wait for the fifo to empty an extra
1295         // long time to allow for any special startup code in the firmware, like
1296         // sending status messages to the LCD's.
1297
1298         if (loadedFirst) {
1299                 if (!iiWaitForTxEmpty(pB, MAX_DLOAD_START_TIME)) {
1300                         return II_DOWN_TIMEOUT;
1301                 }
1302         }
1303
1304         // Determine whether this was our last block!
1305         if (--(pB->i2eToLoad)) {
1306                 return II_DOWN_CONTINUING;    // more to come...
1307         }
1308
1309         // It WAS our last block: Clean up operations...
1310         // ...Wait for last buffer to drain from the board...
1311         if (!iiWaitForTxEmpty(pB, MAX_DLOAD_READ_TIME)) {
1312                 return II_DOWN_TIMEOUT;
1313         }
1314         // If there were only a single block written, this would come back
1315         // immediately and be harmless, though not strictly necessary.
1316         itemp = MAX_DLOAD_ACK_TIME/10;
1317         while (--itemp) {
1318                 if (I2_HAS_INPUT(pB)) {
1319                         switch (inb(pB->i2eData)) {
1320                         case LOADWARE_OK:
1321                                 pB->i2eState =
1322                                         isStandard ? II_STATE_STDLOADED :II_STATE_LOADED;
1323
1324                                 // Some revisions of the bootstrap firmware (e.g. ISA-8 1.0.2)
1325                                 // will, // if there is a debug port attached, require some
1326                                 // time to send information to the debug port now. It will do
1327                                 // this before // executing any of the code we just downloaded.
1328                                 // It may take up to 700 milliseconds.
1329                                 if (pB->i2ePom.e.porDiag2 & POR_DEBUG_PORT) {
1330                                         iiDelay(pB, 700);
1331                                 }
1332
1333                                 return II_DOWN_GOOD;
1334
1335                         case LOADWARE_BAD:
1336                         default:
1337                                 return II_DOWN_BAD;
1338                         }
1339                 }
1340
1341                 iiDelay(pB, 10);      // 10 mS granularity on checking condition
1342         }
1343
1344         // Drop-through --> timed out waiting for firmware confirmation
1345
1346         pB->i2eState = II_STATE_BADLOAD;
1347         return II_DOWN_TIMEOUT;
1348 }
1349
1350 //******************************************************************************
1351 // Function:   iiDownloadAll(pB, pSource, isStandard, size)
1352 // Parameters: pB         - pointer to board structure
1353 //             pSource    - loadware block to download
1354 //             isStandard - True if "standard" loadware, else false.
1355 //             size       - size of data to download (in bytes)
1356 //
1357 // Returns:    Success or Failure
1358 //
1359 // Description:
1360 //
1361 // Given a pointer to a board structure, a pointer to the beginning of some
1362 // loadware, whether it is considered the "standard loadware", and the size of
1363 // the array in bytes loads the entire array to the board as loadware.
1364 //
1365 // Assumes the board has been freshly reset and the power-up reset message read.
1366 // (i.e., in II_STATE_READY). Complains if state is bad, or if there seems to be
1367 // too much or too little data to load, or if iiDownloadBlock complains.
1368 //******************************************************************************
1369 static int
1370 iiDownloadAll(i2eBordStrPtr pB, loadHdrStrPtr pSource, int isStandard, int size)
1371 {
1372         int status;
1373
1374         // We know (from context) board should be ready for the first block of
1375         // download.  Complain if not.
1376         if (pB->i2eState != II_STATE_READY) return II_DOWN_BADSTATE;
1377
1378         while (size > 0) {
1379                 size -= LOADWARE_BLOCK_SIZE;    // How much data should there be left to
1380                                                                                 // load after the following operation ?
1381
1382                 // Note we just bump pSource by "one", because its size is actually that
1383                 // of an entire block, same as LOADWARE_BLOCK_SIZE.
1384                 status = iiDownloadBlock(pB, pSource++, isStandard);
1385
1386                 switch(status)
1387                 {
1388                 case II_DOWN_GOOD:
1389                         return ( (size > 0) ? II_DOWN_OVER : II_DOWN_GOOD);
1390
1391                 case II_DOWN_CONTINUING:
1392                         break;
1393
1394                 default:
1395                         return status;
1396                 }
1397         }
1398
1399         // We shouldn't drop out: it means "while" caught us with nothing left to
1400         // download, yet the previous DownloadBlock did not return complete. Ergo,
1401         // not enough data to match the size byte in the header.
1402         return II_DOWN_UNDER;
1403 }