Need to do isolation when find_isapnp_device is first called,
[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 uint16_t isapnp_read_word ( uint8_t address ) {
91         /* Yes, they're in big-endian order */
92         return ( ( isapnp_read_byte ( address ) << 8 )
93                  + isapnp_read_byte ( address + 1 ) );
94 }
95
96 static inline void isapnp_set_read_port ( void ) {
97         isapnp_write_byte ( ISAPNP_READPORT, isapnp_read_port >> 2 );
98 }
99
100 static inline void isapnp_serialisolation ( void ) {
101         isapnp_write_address ( ISAPNP_SERIALISOLATION );
102 }
103
104 static inline void isapnp_wait_for_key ( void ) {
105         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_WAIT_FOR_KEY );
106 }
107
108 static inline void isapnp_reset_csn ( void ) {
109         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_RESET_CSN );
110 }
111
112 static inline void isapnp_wake ( uint8_t csn ) {
113         isapnp_write_byte ( ISAPNP_WAKE, csn );
114 }
115
116 static inline uint8_t isapnp_read_resourcedata ( void ) {
117         return isapnp_read_byte ( ISAPNP_RESOURCEDATA );
118 }
119
120 static inline uint8_t isapnp_read_status ( void ) {
121         return isapnp_read_byte ( ISAPNP_STATUS );
122 }
123
124 static inline void isapnp_write_csn ( uint8_t csn ) {
125         isapnp_write_byte ( ISAPNP_CARDSELECTNUMBER, csn );
126 }
127
128 static inline void isapnp_logicaldevice ( uint8_t logdev ) {
129         isapnp_write_byte ( ISAPNP_LOGICALDEVICENUMBER, logdev );
130 }
131
132 static inline void isapnp_activate ( uint8_t logdev ) {
133         isapnp_logicaldevice ( logdev );
134         isapnp_write_byte ( ISAPNP_ACTIVATE, 1 );
135 }
136
137 static inline void isapnp_deactivate ( uint8_t logdev ) {
138         isapnp_logicaldevice ( logdev );
139         isapnp_write_byte ( ISAPNP_ACTIVATE, 0 );
140 }
141
142 static inline uint16_t isapnp_read_iobase ( unsigned int index ) {
143         return isapnp_read_word ( ISAPNP_IOBASE ( index ) );
144 }
145
146 static inline uint8_t isapnp_read_irqno ( unsigned int index ) {
147         return isapnp_read_byte ( ISAPNP_IRQNO ( index ) );
148 }
149
150 static void isapnp_delay ( void ) {
151         udelay ( 1000 );
152 }
153
154 /*
155  * The linear feedback shift register as described in Appendix B of
156  * the PnP ISA spec.  The hardware implementation uses eight D-type
157  * latches and two XOR gates.  I think this is probably the smallest
158  * possible implementation in software.  Six instructions when input_bit
159  * is a constant 0 (for isapnp_send_key).  :)
160  *
161  */
162 static inline uint8_t isapnp_lfsr_next ( uint8_t lfsr, int input_bit ) {
163         register uint8_t lfsr_next;
164
165         lfsr_next = lfsr >> 1;
166         lfsr_next |= ( ( ( lfsr ^ lfsr_next ) ^ input_bit ) ) << 7;
167         return lfsr_next;
168 }
169
170 /*
171  * Send the ISAPnP initiation key
172  *
173  */
174 static void isapnp_send_key ( void ) {
175         unsigned int i;
176         uint8_t lfsr;
177
178         isapnp_delay();
179         isapnp_write_address ( 0x00 );
180         isapnp_write_address ( 0x00 );
181
182         lfsr = ISAPNP_LFSR_SEED;
183         for ( i = 0 ; i < 32 ; i++ ) {
184                 isapnp_write_address ( lfsr );
185                 lfsr = isapnp_lfsr_next ( lfsr, 0 );
186         }
187 }
188
189 /*
190  *  Compute ISAPnP identifier checksum
191  *
192  */
193 static uint8_t isapnp_checksum ( struct isapnp_identifier *identifier ) {
194         int i, j;
195         uint8_t lfsr;
196         uint8_t byte;
197
198         lfsr = ISAPNP_LFSR_SEED;
199         for ( i = 0 ; i < 8 ; i++ ) {
200                 byte = ( (char *) identifier )[i];
201                 for ( j = 0 ; j < 8 ; j++ ) {
202                         lfsr = isapnp_lfsr_next ( lfsr, byte );
203                         byte >>= 1;
204                 }
205         }
206         return lfsr;
207 }
208
209 /*
210  * Read a byte of resource data from the current location
211  *
212  */
213 static inline uint8_t isapnp_peek_byte ( void ) {
214         int i;
215
216         /* Wait for data to be ready */
217         for ( i = 0 ; i < 20 ; i ++ ) {
218                 if ( isapnp_read_status() & 0x01 ) {
219                         /* Byte ready - read it */
220                         return isapnp_read_resourcedata();
221                 }
222                 isapnp_delay ();
223         }
224         /* Data never became ready - return 0xff */
225         return 0xff;
226 }
227
228 /*
229  * Read n bytes of resource data from the current location.  If buf is
230  * NULL, discard data.
231  *
232  */
233 static void isapnp_peek ( uint8_t *buf, size_t bytes ) {
234         unsigned int i;
235         uint8_t byte;
236
237         for ( i = 0 ; i < bytes ; i++) {
238                 byte = isapnp_peek_byte();
239                 if ( buf ) {
240                         buf[i] = byte;
241                 }
242         }
243 }
244
245 /*
246  * Scan through the resource data until we find a particular tag, and
247  * read its contents into a buffer.
248  *
249  * It is the caller's responsibility to ensure that buf is large
250  * enough to contain a tag of the requested size.
251  *
252  */
253 static int isapnp_find_tag ( uint8_t wanted_tag, uint8_t *buf ) {
254         uint8_t tag;
255         uint16_t len;
256
257         do {
258                 tag = isapnp_peek_byte();
259                 if ( ISAPNP_IS_SMALL_TAG ( tag ) ) {
260                         len = ISAPNP_SMALL_TAG_LEN ( tag );
261                         tag = ISAPNP_SMALL_TAG_NAME ( tag );
262                 } else {
263                         len = isapnp_peek_byte() + ( isapnp_peek_byte() << 8 );
264                         tag = ISAPNP_LARGE_TAG_NAME ( tag );
265                 }
266                 DBG ( "ISAPnP read tag %hhx len %hhx\n", tag, len );
267                 if ( tag == wanted_tag ) {
268                         isapnp_peek ( buf, len );
269                         return 1;
270                 } else {
271                         isapnp_peek ( NULL, len );
272                 }
273         } while ( tag != ISAPNP_TAG_END );
274         return 0;
275 }
276
277 /*
278  * Try isolating ISAPnP cards at the current read port.  Return the
279  * number of ISAPnP cards found.
280  *
281  * The state diagram on page 18 (PDF page 24) of the PnP ISA spec
282  * gives the best overview of what happens here.
283  *
284  */
285 static int isapnp_try_isolate ( void ) {
286         struct isapnp_identifier identifier;
287         int i, j, seen55aa;
288         uint16_t data;
289         uint8_t byte;
290
291         DBG ( "ISAPnP attempting isolation at read port %hx\n",
292               isapnp_read_port );
293
294         /* Place all cards into the Sleep state, whatever state
295          * they're currently in.
296          */
297         isapnp_wait_for_key ();
298         isapnp_send_key ();
299
300         /* Reset all assigned CSNs */
301         isapnp_reset_csn ();
302         isapnp_max_csn = 0;
303         isapnp_delay();
304         isapnp_delay();
305         
306         /* Place all cards into the Isolation state */
307         isapnp_wait_for_key ();
308         isapnp_send_key ();
309         isapnp_wake ( 0x00 );
310         
311         /* Set the read port */
312         isapnp_set_read_port ();
313         isapnp_delay();
314
315         while ( 1 ) {
316
317                 /* All cards that do not have assigned CSNs are
318                  * currently in the Isolation state, each time we go
319                  * through this loop.
320                  */
321
322                 /* Initiate serial isolation */
323                 isapnp_serialisolation ();
324                 isapnp_delay();
325
326                 /* Read identifier serially via the ISAPnP read port. */
327                 memset ( &identifier, 0, sizeof ( identifier ) );
328                 seen55aa = 0;
329                 for ( i = 0 ; i < 9 ; i++ ) {
330                         byte = 0;
331                         for ( j = 0 ; j < 8 ; j++ ) {
332                                 data = isapnp_read_data ();
333                                 isapnp_delay();
334                                 data = ( data << 8 ) | isapnp_read_data ();
335                                 isapnp_delay();
336                                 if ( data == 0x55aa ) {
337                                         byte |= 1;
338                                 }
339                                 byte <<= 1;
340                         }
341                         ( (char *) &identifier )[i] = byte;
342                         if ( byte ) {
343                                 seen55aa = 1;
344                         }
345                 }
346                                 
347                 /* If we didn't see a valid ISAPnP device, stop here */
348                 if ( ( ! seen55aa ) ||
349                      ( identifier.checksum != isapnp_checksum (&identifier) ) )
350                         break;
351
352                 /* Give the device a CSN */
353                 isapnp_max_csn++;
354                 DBG ( "ISAPnP isolation found card %hhx ID %hx:%hx (\"%s\") "
355                       "serial %x checksum %hhx, assigning CSN %hhx\n",
356                       identifier.vendor_id, identifier.prod_id,
357                       isa_id_string ( identifier.vendor_id,
358                                       identifier.prod_id ),
359                       identifier.serial, identifier.checksum, isapnp_max_csn );
360                 
361                 isapnp_write_csn ( isapnp_max_csn );
362                 isapnp_delay();
363
364                 /* Send this card back to Sleep and force all cards
365                  * without a CSN into Isolation state
366                  */
367                 isapnp_wake ( 0x00 );
368                 isapnp_delay();
369         }
370
371         /* Place all cards in Wait for Key state */
372         isapnp_wait_for_key ();
373
374         /* Return number of cards found */
375         DBG ( "ISAPnP found %d cards at read port %hx\n",
376               isapnp_max_csn, isapnp_read_port );
377         return isapnp_max_csn;
378 }
379
380 /*
381  * Isolate all ISAPnP cards, locating a valid read port in the process.
382  *
383  */
384 static void isapnp_isolate ( void ) {
385         for ( isapnp_read_port = ISAPNP_READ_PORT_MIN ;
386               isapnp_read_port <= ISAPNP_READ_PORT_MAX ;
387               isapnp_read_port += ISAPNP_READ_PORT_STEP ) {
388                 /* Avoid problematic locations such as the NE2000
389                  * probe space
390                  */
391                 if ( ( isapnp_read_port >= 0x280 ) &&
392                      ( isapnp_read_port <= 0x380 ) )
393                         continue;
394                 
395                 /* If we detect any ISAPnP cards at this location, stop */
396                 if ( isapnp_try_isolate () )
397                         return;
398         }
399 }
400
401 /*
402  * Fill in parameters for an ISAPnP device based on CSN
403  *
404  * Return 1 if device present, 0 otherwise
405  *
406  */
407 static int fill_isapnp_device ( struct isapnp_device *isapnp ) {
408         unsigned int i;
409         struct isapnp_logdevid logdevid;
410         
411         /* Wake the card */
412         isapnp_wait_for_key ();
413         isapnp_send_key ();
414         isapnp_wake ( isapnp->csn );
415
416         /* Skip past the card identifier */
417         isapnp_peek ( NULL, sizeof ( struct isapnp_identifier ) );
418
419         /* Find the Logical Device ID tag corresponding to this device */
420         for ( i = 0 ; i <= isapnp->logdev ; i++ ) {
421                 if ( ! isapnp_find_tag ( ISAPNP_TAG_LOGDEVID,
422                                          ( char * ) &logdevid ) ) {
423                         /* No tag for this device */
424                         return 0;
425                 }
426         }
427
428         /* Read information from identifier structure */
429         isapnp->vendor_id = logdevid.vendor_id;
430         isapnp->prod_id = logdevid.prod_id;
431
432         /* Select the logical device */
433         isapnp_logicaldevice ( isapnp->logdev );
434
435         /* Read the current ioaddr and irqno */
436         isapnp->ioaddr = isapnp_read_iobase ( 0 );
437         isapnp->irqno = isapnp_read_irqno ( 0 );
438
439         /* Return all cards to Wait for Key state */
440         isapnp_wait_for_key ();
441
442         DBG ( "ISAPnP found device %hhx.%hhx ID %hx:%hx (\"%s\"), "
443               "base %hx irq %d\n",
444               isapnp->csn, isapnp->logdev, isapnp->vendor_id, isapnp->prod_id,
445               isa_id_string ( isapnp->vendor_id, isapnp->prod_id ),
446               isapnp->ioaddr, isapnp->irqno );
447
448         return 1;
449 }
450
451 /*
452  * Find an ISAPnP device matching the specified driver
453  *
454  */
455 int find_isapnp_device ( struct isapnp_device *isapnp,
456                          struct isapnp_driver *driver ) {
457         unsigned int i;
458
459         /* Initialise struct isapnp if it's the first time it's been used. */
460         if ( isapnp->magic != isapnp_magic ) {
461                 memset ( isapnp, 0, sizeof ( *isapnp ) );
462                 isapnp->magic = isapnp_magic;
463                 isapnp->csn = 1;
464         }
465
466         /* Ensure that all ISAPnP cards have CSNs allocated to them,
467          * if we haven't already done so.
468          */
469         if ( ! isapnp_read_port ) {
470                 isapnp_isolate();
471         }
472
473         /* Iterate through all possible ISAPNP CSNs, starting where we
474          * left off.
475          */
476         for ( ; isapnp->csn <= isapnp_max_csn ; isapnp->csn++ ) {
477                 for ( ; isapnp->logdev <= 0xff ; isapnp->logdev++ ) {
478                         /* If we've already used this device, skip it */
479                         if ( isapnp->already_tried ) {
480                                 isapnp->already_tried = 0;
481                                 continue;
482                         }
483                         
484                         /* Fill in device parameters */
485                         if ( ! fill_isapnp_device ( isapnp ) ) {
486                                 /* If fill_isapnp_device fails, assume
487                                  * that we've reached the last logical
488                                  * device on this card, and proceed to
489                                  * the next card.
490                                  */
491                                 isapnp->logdev = 0;
492                                 break;
493                         }
494
495                         /* Compare against driver's ID list */
496                         for ( i = 0 ; i < driver->id_count ; i++ ) {
497                                 struct isapnp_id *id = &driver->ids[i];
498                                 
499                                 if ( ( isapnp->vendor_id == id->vendor_id ) &&
500                                      ( ISA_PROD_ID ( isapnp->prod_id ) ==
501                                        ISA_PROD_ID ( id->prod_id ) ) ) {
502                                         DBG ( "Device %s (driver %s) "
503                                               "matches ID %s\n",
504                                               id->name, driver->name,
505                                               isa_id_string( isapnp->vendor_id,
506                                                            isapnp->prod_id ) );
507                                         isapnp->name = id->name;
508                                         isapnp->already_tried = 1;
509                                         return 1;
510                                 }
511                         }
512                 }
513         }
514
515         /* No device found */
516         isapnp->csn = 1;
517         return 0;
518 }
519
520 /*
521  * Find the next ISAPNP device that can be used to boot using the
522  * specified driver.
523  *
524  */
525 int find_isapnp_boot_device ( struct dev *dev, struct isapnp_driver *driver ) {
526         struct isapnp_device *isapnp = ( struct isapnp_device * ) dev->bus;
527
528         if ( ! find_isapnp_device ( isapnp, driver ) )
529                 return 0;
530
531         dev->name = isapnp->name;
532         dev->devid.bus_type = ISA_BUS_TYPE;
533         dev->devid.vendor_id = isapnp->vendor_id;
534         dev->devid.device_id = isapnp->prod_id;
535
536         return 1;
537 }
538
539 /*
540  * Activate or deactivate an ISAPnP device
541  *
542  * This routine simply activates the device in its current
543  * configuration.  It does not attempt any kind of resource
544  * arbitration.
545  *
546  */
547 void activate_isapnp_device ( struct isapnp_device *isapnp,
548                               int activate ) {
549         /* Wake the card and select the logical device */
550         isapnp_wait_for_key ();
551         isapnp_send_key ();
552         isapnp_wake ( isapnp->csn );
553         isapnp_logicaldevice ( isapnp->logdev );
554
555         /* Activate/deactivate the logical device */
556         isapnp_activate ( activate );
557         isapnp_delay();
558
559         /* Return all cards to Wait for Key state */
560         isapnp_wait_for_key ();
561
562         DBG ( "ISAPnP activated device %hhx.%hhx\n",
563               isapnp->csn, isapnp->logdev );
564 }