Don't verify checksum except after serial isolation
[people/lynusvaz/gpxe.git] / src / drivers / bus / isapnp.c
1 /**************************************************************************
2 *
3 *    isapnp.c -- Etherboot isapnp support for the 3Com 3c515
4 *    Written 2002-2003 by Timothy Legge <tlegge@rogers.com>
5 *
6 *    This program is free software; you can redistribute it and/or modify
7 *    it under the terms of the GNU General Public License as published by
8 *    the Free Software Foundation; either version 2 of the License, or
9 *    (at your option) any later version.
10 *
11 *    This program is distributed in the hope that it will be useful,
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *    GNU General Public License for more details.
15 *
16 *    You should have received a copy of the GNU General Public License
17 *    along with this program; if not, write to the Free Software
18 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 *    Portions of this code:
21 *       Copyright (C) 2001  P.J.H.Fox (fox@roestock.demon.co.uk)
22 *
23 *
24 *    REVISION HISTORY:
25 *    ================
26 *    Version 0.1 April 26, 2002 TJL
27 *    Version 0.2 01/08/2003     TJL Moved outside the 3c515.c driver file
28 *    Version 0.3 Sept 23, 2003  timlegge Change delay to currticks
29 *               
30 *
31 *    Generalised into an ISAPnP bus that can be used by more than just
32 *    the 3c515 by Michael Brown <mbrown@fensystems.co.uk>
33 *
34 ***************************************************************************/
35
36 #include "etherboot.h"
37 #include "timer.h"
38 #include "io.h"
39 #include "isapnp.h"
40
41 /*
42  * Ensure that there is sufficient space in the shared dev_bus
43  * structure for a struct isapnp_device.
44  *
45  */
46 DEV_BUS( struct isapnp_device, isapnp_dev );
47 static char isapnp_magic[0]; /* guaranteed unique symbol */
48
49 /*
50  * We can have only one ISAPnP bus in a system.  Once the read port is
51  * known and all cards have been allocated CSNs, there's nothing to be
52  * gained by re-scanning for cards.
53  *
54  * However, we shouldn't make scanning the ISAPnP bus an INIT_FN(),
55  * because even ISAPnP probing can still screw up other devices on the
56  * ISA bus.  We therefore probe only when we are first asked to find
57  * an ISAPnP device.
58  *
59  */
60 static uint16_t isapnp_read_port;
61 static uint16_t isapnp_max_csn;
62
63 /*
64  * ISAPnP utility functions
65  *
66  */
67
68 static inline void isapnp_write_address ( uint8_t address ) {
69         outb ( address, ISAPNP_ADDRESS );
70 }
71
72 static inline void isapnp_write_data ( uint8_t data ) {
73         outb ( data, ISAPNP_WRITE_DATA );
74 }
75
76 static inline uint8_t isapnp_read_data ( void ) {
77         return inb ( isapnp_read_port );
78 }
79
80 static inline void isapnp_write_byte ( uint8_t address, uint8_t value ) {
81         isapnp_write_address ( address );
82         isapnp_write_data ( value );
83 }
84
85 static inline uint8_t isapnp_read_byte ( uint8_t address ) {
86         isapnp_write_address ( address );
87         return isapnp_read_data ();
88 }
89
90 static inline void isapnp_set_read_port ( void ) {
91         isapnp_write_byte ( ISAPNP_READPORT, isapnp_read_port >> 2 );
92 }
93
94 static inline void isapnp_serialisolation ( void ) {
95         isapnp_write_address ( ISAPNP_SERIALISOLATION );
96 }
97
98 static inline void isapnp_wait_for_key ( void ) {
99         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_WAIT_FOR_KEY );
100 }
101
102 static inline void isapnp_reset_csn ( void ) {
103         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_RESET_CSN );
104 }
105
106 static inline void isapnp_wake ( uint8_t csn ) {
107         isapnp_write_byte ( ISAPNP_WAKE, csn );
108 }
109
110 static inline uint8_t isapnp_read_resourcedata ( void ) {
111         return isapnp_read_byte ( ISAPNP_RESOURCEDATA );
112 }
113
114 static inline uint8_t isapnp_read_status ( void ) {
115         return isapnp_read_byte ( ISAPNP_STATUS );
116 }
117
118 static inline void isapnp_write_csn ( uint8_t csn ) {
119         isapnp_write_byte ( ISAPNP_CARDSELECTNUMBER, csn );
120 }
121
122 static inline void isapnp_logicaldevice ( uint8_t logdev ) {
123         isapnp_write_byte ( ISAPNP_LOGICALDEVICENUMBER, logdev );
124 }
125
126 static inline void isapnp_activate ( uint8_t logdev ) {
127         isapnp_logicaldevice ( logdev );
128         isapnp_write_byte ( ISAPNP_ACTIVATE, 1 );
129 }
130
131 static inline void isapnp_deactivate ( uint8_t logdev ) {
132         isapnp_logicaldevice ( logdev );
133         isapnp_write_byte ( ISAPNP_ACTIVATE, 0 );
134 }
135
136 static void isapnp_delay ( void ) {
137         udelay ( 1000 );
138 }
139
140 /*
141  * The linear feedback shift register as described in Appendix B of
142  * the PnP ISA spec.  The hardware implementation uses eight D-type
143  * latches and two XOR gates.  I think this is probably the smallest
144  * possible implementation in software.  Six instructions when input_bit
145  * is a constant 0 (for isapnp_send_key).  :)
146  *
147  */
148 static inline uint8_t isapnp_lfsr_next ( uint8_t lfsr, int input_bit ) {
149         register uint8_t lfsr_next;
150
151         lfsr_next = lfsr >> 1;
152         lfsr_next |= ( ( ( lfsr ^ lfsr_next ) ^ input_bit ) ) << 7;
153         return lfsr_next;
154 }
155
156 /*
157  * Send the ISAPnP initiation key
158  *
159  */
160 static void isapnp_send_key ( void ) {
161         unsigned int i;
162         uint8_t lfsr;
163
164         isapnp_delay();
165         isapnp_write_address ( 0x00 );
166         isapnp_write_address ( 0x00 );
167
168         lfsr = ISAPNP_LFSR_SEED;
169         for ( i = 0 ; i < 32 ; i++ ) {
170                 isapnp_write_address ( lfsr );
171                 lfsr = isapnp_lfsr_next ( lfsr, 0 );
172         }
173 }
174
175 /*
176  *  Compute ISAPnP identifier checksum
177  *
178  */
179 static uint8_t isapnp_checksum ( union isapnp_identifier *identifier ) {
180         int i, j;
181         uint8_t lfsr;
182         uint8_t byte;
183
184         lfsr = ISAPNP_LFSR_SEED;
185         for ( i = 0 ; i < 8 ; i++ ) {
186                 byte = identifier->bytes[i];
187                 for ( j = 0 ; j < 8 ; j++ ) {
188                         lfsr = isapnp_lfsr_next ( lfsr, byte );
189                         byte >>= 1;
190                 }
191         }
192         return lfsr;
193 }
194
195 /*
196  * Read a byte of resource data from the current location
197  *
198  */
199 static inline uint8_t isapnp_peek_byte ( void ) {
200         int i;
201
202         /* Wait for data to be ready */
203         for ( i = 0 ; i < 20 ; i ++ ) {
204                 if ( isapnp_read_status() & 0x01 ) {
205                         /* Byte ready - read it */
206                         return isapnp_read_resourcedata();
207                 }
208                 isapnp_delay ();
209         }
210         /* Data never became ready - return 0xff */
211         return 0xff;
212 }
213
214 /*
215  * Read n bytes of resource data from the current location.  If buf is
216  * NULL, discard data.
217  *
218  */
219 static void isapnp_peek ( uint8_t *buf, size_t bytes ) {
220         unsigned int i;
221         uint8_t byte;
222
223         for ( i = 0 ; i < bytes ; i++) {
224                 byte = isapnp_peek_byte();
225                 if ( buf ) {
226                         buf[i] = byte;
227                 }
228         }
229 }
230
231 /*
232  * Try isolating ISAPnP cards at the current read port.  Return the
233  * number of ISAPnP cards found.
234  *
235  * The state diagram on page 18 (PDF page 24) of the PnP ISA spec
236  * gives the best overview of what happens here.
237  *
238  */
239 static int isapnp_try_isolate ( void ) {
240         union isapnp_identifier identifier;
241         int i, j, seen55aa;
242         uint16_t data;
243         uint8_t byte;
244
245         DBG ( "ISAPnP attempting isolation at read port %hx\n",
246               isapnp_read_port );
247
248         /* Place all cards into the Sleep state, whatever state
249          * they're currently in.
250          */
251         isapnp_wait_for_key ();
252         isapnp_send_key ();
253
254         /* Reset all assigned CSNs */
255         isapnp_reset_csn ();
256         isapnp_max_csn = 0;
257         isapnp_delay();
258         isapnp_delay();
259         
260         /* Place all cards into the Isolation state */
261         isapnp_wait_for_key ();
262         isapnp_send_key ();
263         isapnp_wake ( 0x00 );
264         
265         /* Set the read port */
266         isapnp_set_read_port ();
267         isapnp_delay();
268
269         while ( 1 ) {
270
271                 /* All cards that do not have assigned CSNs are
272                  * currently in the Isolation state, each time we go
273                  * through this loop.
274                  */
275
276                 /* Initiate serial isolation */
277                 isapnp_serialisolation ();
278                 isapnp_delay();
279
280                 /* Read identifier serially via the ISAPnP read port. */
281                 memset ( &identifier, 0, sizeof ( identifier ) );
282                 seen55aa = 0;
283                 for ( i = 0 ; i < 9 ; i++ ) {
284                         byte = 0;
285                         for ( j = 0 ; j < 8 ; j++ ) {
286                                 data = isapnp_read_data ();
287                                 isapnp_delay();
288                                 data = ( data << 8 ) | isapnp_read_data ();
289                                 isapnp_delay();
290                                 if ( data == 0x55aa ) {
291                                         byte |= 1;
292                                 }
293                                 byte <<= 1;
294                         }
295                         identifier.bytes[i] = byte;
296                         if ( byte ) {
297                                 seen55aa = 1;
298                         }
299                 }
300                                 
301                 /* If we didn't see a valid ISAPnP device, stop here */
302                 if ( ( ! seen55aa ) ||
303                      ( identifier.checksum != isapnp_checksum (&identifier) ) )
304                         break;
305
306                 /* Give the device a CSN */
307                 isapnp_max_csn++;
308                 DBG ( "ISAPnP isolation found device "
309                       "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx:%hhx:%hhx "
310                       "(checksum %hhx), assigning CSN %hhx\n",
311                       identifier.bytes[0], identifier.bytes[1],
312                       identifier.bytes[2], identifier.bytes[3],
313                       identifier.bytes[4], identifier.bytes[5],
314                       identifier.bytes[6], identifier.bytes[7],
315                       identifier.checksum, isapnp_max_csn );
316                 
317                 isapnp_write_csn ( isapnp_max_csn );
318                 isapnp_delay();
319
320                 /* Send this card back to Sleep and force all cards
321                  * without a CSN into Isolation state
322                  */
323                 isapnp_wake ( 0x00 );
324                 isapnp_delay();
325         }
326
327         /* Place all cards in Wait for Key state */
328         isapnp_wait_for_key ();
329
330         /* Return number of cards found */
331         DBG ( "ISAPnP found %d devices at read port %hx\n", isapnp_read_port );
332         return isapnp_max_csn;
333 }
334
335 /*
336  * Isolate all ISAPnP cards, locating a valid read port in the process.
337  *
338  */
339 static void isapnp_isolate ( void ) {
340         for ( isapnp_read_port = ISAPNP_READ_PORT_MIN ;
341               isapnp_read_port <= ISAPNP_READ_PORT_MAX ;
342               isapnp_read_port += ISAPNP_READ_PORT_STEP ) {
343                 /* Avoid problematic locations such as the NE2000
344                  * probe space
345                  */
346                 if ( ( isapnp_read_port >= 0x280 ) &&
347                      ( isapnp_read_port <= 0x380 ) )
348                         continue;
349                 
350                 /* If we detect any ISAPnP cards at this location, stop */
351                 if ( isapnp_try_isolate () )
352                         return;
353         }
354 }
355
356 /*
357  * Fill in parameters for an ISAPnP device based on CSN
358  *
359  * Return 1 if device present, 0 otherwise
360  *
361  */
362 static int fill_isapnp_device ( struct isapnp_device *isapnp ) {
363         union isapnp_identifier identifier;
364         
365         /* Ensure that all ISAPnP cards have CSNs allocated to them,
366          * if we haven't already done so.
367          */
368         if ( ! isapnp_read_port ) {
369                 isapnp_isolate();
370         }
371
372         /* Wake the specified CSN */
373         isapnp_wait_for_key ();
374         isapnp_send_key ();
375         isapnp_wake ( isapnp->csn );
376
377         /* Read the identifier.  Do *not* verify the checksum, because
378          * the PnP ISA spec explicitly states in section 4.5 that the
379          * checksum is invalid except when read via the serial
380          * isolation protocol.  (This is presumably to allow for lazy
381          * card designers who implement the checksum using the LFSR
382          * only and can't be bothered to write the same value into the
383          * EPROM).
384          */
385         isapnp_peek ( identifier.bytes, sizeof ( identifier ) );
386
387         /* Read information from identifier structure */
388         isapnp->vendor_id = identifier.vendor_id;
389         isapnp->prod_id = identifier.prod_id;
390
391         /* Return all cards to Wait for Key state */
392         isapnp_wait_for_key ();
393
394         DBG ( "ISAPnP found CSN %hhx ID %hx:%hx (\"%s\")\n",
395               isapnp->csn, isapnp->vendor_id, isapnp->prod_id,
396               isa_id_string ( isapnp->vendor_id, isapnp->prod_id ) );
397
398         return 1;
399 }
400
401 /*
402  * Find an ISAPnP device matching the specified driver
403  *
404  */
405 int find_isapnp_device ( struct isapnp_device *isapnp,
406                          struct isapnp_driver *driver ) {
407         unsigned int i;
408
409         /* Initialise struct isapnp if it's the first time it's been used. */
410         if ( isapnp->magic != isapnp_magic ) {
411                 memset ( isapnp, 0, sizeof ( *isapnp ) );
412                 isapnp->magic = isapnp_magic;
413                 isapnp->csn = 1;
414         }
415
416         /* Iterate through all possible ISAPNP CSNs, starting where we
417          * left off.
418          */
419         for ( ; isapnp->csn <= isapnp_max_csn ; isapnp->csn++ ) {
420                 /* If we've already used this device, skip it */
421                 if ( isapnp->already_tried ) {
422                         isapnp->already_tried = 0;
423                         continue;
424                 }
425
426                 /* Fill in device parameters */
427                 if ( ! fill_isapnp_device ( isapnp ) ) {
428                         continue;
429                 }
430
431                 /* Compare against driver's ID list */
432                 for ( i = 0 ; i < driver->id_count ; i++ ) {
433                         struct isapnp_id *id = &driver->ids[i];
434                         
435                         if ( ( isapnp->vendor_id == id->vendor_id ) &&
436                              ( ISA_PROD_ID ( isapnp->prod_id ) ==
437                                ISA_PROD_ID ( id->prod_id ) ) ) {
438                                 DBG ( "Device %s (driver %s) matches ID %s\n",
439                                       id->name, driver->name,
440                                       isa_id_string ( isapnp->vendor_id,
441                                                       isapnp->prod_id ) );
442                                 isapnp->name = id->name;
443                                 isapnp->already_tried = 1;
444                                 return 1;
445                         }
446                 }
447         }
448
449         /* No device found */
450         isapnp->csn = 1;
451         return 0;
452 }
453
454 /*
455  * Find the next ISAPNP device that can be used to boot using the
456  * specified driver.
457  *
458  */
459 int find_isapnp_boot_device ( struct dev *dev, struct isapnp_driver *driver ) {
460         struct isapnp_device *isapnp = ( struct isapnp_device * ) dev->bus;
461
462         if ( ! find_isapnp_device ( isapnp, driver ) )
463                 return 0;
464
465         dev->name = isapnp->name;
466         dev->devid.bus_type = ISA_BUS_TYPE;
467         dev->devid.vendor_id = isapnp->vendor_id;
468         dev->devid.device_id = isapnp->prod_id;
469
470         return 1;
471 }
472
473 /*
474  * Activate a logical function on an ISAPnP device
475  *
476  * This routine simply activates the device in its current
477  * configuration.  It does not attempt any kind of resource
478  * arbitration.
479  *
480  */
481 void activate_isapnp_device ( struct isapnp_device *isapnp,
482                               uint8_t logdev ) {
483         /* Wake the device */
484         isapnp_wait_for_key ();
485         isapnp_send_key ();
486         isapnp_wake ( isapnp->csn );
487
488         /* Select the specified logical device */
489         isapnp_activate ( logdev );
490         isapnp_delay();
491         
492         /* Return all cards to Wait for Key state */
493         isapnp_wait_for_key ();
494 }
495
496 /*
497  * Deactivate a logical function on an ISAPnP device
498  *
499  */
500 void deactivate_isapnp_device ( struct isapnp_device *isapnp,
501                               uint8_t logdev ) {
502         /* Wake the device */
503         isapnp_wait_for_key ();
504         isapnp_send_key ();
505         isapnp_wake ( isapnp->csn );
506
507         /* Select the specified logical device */
508         isapnp_deactivate ( logdev );
509         isapnp_delay();
510         
511         /* Return all cards to Wait for Key state */
512         isapnp_wait_for_key ();
513 }