61ee6843cacfa843fa273474f1afeb30611d4bb9
[people/xl0/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 "string.h"
37 #include "timer.h"
38 #include "io.h"
39 #include "console.h"
40 #include "isapnp.h"
41
42 /*
43  * We can have only one ISAPnP bus in a system.  Once the read port is
44  * known and all cards have been allocated CSNs, there's nothing to be
45  * gained by re-scanning for cards.
46  *
47  * However, we shouldn't make scanning the ISAPnP bus an INIT_FN(),
48  * because even ISAPnP probing can still screw up other devices on the
49  * ISA bus.  We therefore probe only when we are first asked to find
50  * an ISAPnP device.
51  *
52  * External code (e.g. the ISAPnP ROM prefix) may already know the
53  * read port address, in which case it can initialise this value.
54  * Note that setting the read port address will prevent further
55  * isolation from taking place; you should set the read port address
56  * only if you know that devices have already been allocated CSNs.
57  *
58  */
59 uint16_t isapnp_read_port;
60
61 /*
62  * ISAPnP utility functions
63  *
64  */
65
66 #define ISAPNP_CARD_ID_FMT "ID %hx:%hx (\"%s\") serial %x"
67 #define ISAPNP_CARD_ID_DATA(identifier)                                   \
68         (identifier)->vendor_id, (identifier)->prod_id,                   \
69         isa_id_string ( (identifier)->vendor_id, (identifier)->prod_id ), \
70         (identifier)->serial
71 #define ISAPNP_DEV_ID_FMT "ID %hx:%hx (\"%s\")"
72 #define ISAPNP_DEV_ID_DATA(isapnp)                                        \
73         (isapnp)->vendor_id, (isapnp)->prod_id,                           \
74         isa_id_string ( (isapnp)->vendor_id, (isapnp)->prod_id )
75
76 static inline void isapnp_write_address ( uint8_t address ) {
77         outb ( address, ISAPNP_ADDRESS );
78 }
79
80 static inline void isapnp_write_data ( uint8_t data ) {
81         outb ( data, ISAPNP_WRITE_DATA );
82 }
83
84 static inline uint8_t isapnp_read_data ( void ) {
85         return inb ( isapnp_read_port );
86 }
87
88 static inline void isapnp_write_byte ( uint8_t address, uint8_t value ) {
89         isapnp_write_address ( address );
90         isapnp_write_data ( value );
91 }
92
93 static inline uint8_t isapnp_read_byte ( uint8_t address ) {
94         isapnp_write_address ( address );
95         return isapnp_read_data ();
96 }
97
98 static inline uint16_t isapnp_read_word ( uint8_t address ) {
99         /* Yes, they're in big-endian order */
100         return ( ( isapnp_read_byte ( address ) << 8 )
101                  + isapnp_read_byte ( address + 1 ) );
102 }
103
104 static inline void isapnp_set_read_port ( void ) {
105         isapnp_write_byte ( ISAPNP_READPORT, isapnp_read_port >> 2 );
106 }
107
108 static inline void isapnp_serialisolation ( void ) {
109         isapnp_write_address ( ISAPNP_SERIALISOLATION );
110 }
111
112 static inline void isapnp_wait_for_key ( void ) {
113         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_WAIT_FOR_KEY );
114 }
115
116 static inline void isapnp_reset_csn ( void ) {
117         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_RESET_CSN );
118 }
119
120 static inline void isapnp_wake ( uint8_t csn ) {
121         isapnp_write_byte ( ISAPNP_WAKE, csn );
122 }
123
124 static inline uint8_t isapnp_read_resourcedata ( void ) {
125         return isapnp_read_byte ( ISAPNP_RESOURCEDATA );
126 }
127
128 static inline uint8_t isapnp_read_status ( void ) {
129         return isapnp_read_byte ( ISAPNP_STATUS );
130 }
131
132 static inline void isapnp_write_csn ( uint8_t csn ) {
133         isapnp_write_byte ( ISAPNP_CARDSELECTNUMBER, csn );
134 }
135
136 static inline void isapnp_logicaldevice ( uint8_t logdev ) {
137         isapnp_write_byte ( ISAPNP_LOGICALDEVICENUMBER, logdev );
138 }
139
140 static inline void isapnp_activate ( uint8_t logdev ) {
141         isapnp_logicaldevice ( logdev );
142         isapnp_write_byte ( ISAPNP_ACTIVATE, 1 );
143 }
144
145 static inline void isapnp_deactivate ( uint8_t logdev ) {
146         isapnp_logicaldevice ( logdev );
147         isapnp_write_byte ( ISAPNP_ACTIVATE, 0 );
148 }
149
150 static inline uint16_t isapnp_read_iobase ( unsigned int index ) {
151         return isapnp_read_word ( ISAPNP_IOBASE ( index ) );
152 }
153
154 static inline uint8_t isapnp_read_irqno ( unsigned int index ) {
155         return isapnp_read_byte ( ISAPNP_IRQNO ( index ) );
156 }
157
158 static void isapnp_delay ( void ) {
159         udelay ( 1000 );
160 }
161
162 /*
163  * The linear feedback shift register as described in Appendix B of
164  * the PnP ISA spec.  The hardware implementation uses eight D-type
165  * latches and two XOR gates.  I think this is probably the smallest
166  * possible implementation in software.  Six instructions when input_bit
167  * is a constant 0 (for isapnp_send_key).  :)
168  *
169  */
170 static inline uint8_t isapnp_lfsr_next ( uint8_t lfsr, int input_bit ) {
171         register uint8_t lfsr_next;
172
173         lfsr_next = lfsr >> 1;
174         lfsr_next |= ( ( ( lfsr ^ lfsr_next ) ^ input_bit ) ) << 7;
175         return lfsr_next;
176 }
177
178 /*
179  * Send the ISAPnP initiation key
180  *
181  */
182 static void isapnp_send_key ( void ) {
183         unsigned int i;
184         uint8_t lfsr;
185
186         isapnp_delay();
187         isapnp_write_address ( 0x00 );
188         isapnp_write_address ( 0x00 );
189
190         lfsr = ISAPNP_LFSR_SEED;
191         for ( i = 0 ; i < 32 ; i++ ) {
192                 isapnp_write_address ( lfsr );
193                 lfsr = isapnp_lfsr_next ( lfsr, 0 );
194         }
195 }
196
197 /*
198  *  Compute ISAPnP identifier checksum
199  *
200  */
201 static uint8_t isapnp_checksum ( struct isapnp_identifier *identifier ) {
202         int i, j;
203         uint8_t lfsr;
204         uint8_t byte;
205
206         lfsr = ISAPNP_LFSR_SEED;
207         for ( i = 0 ; i < 8 ; i++ ) {
208                 byte = ( (char *) identifier )[i];
209                 for ( j = 0 ; j < 8 ; j++ ) {
210                         lfsr = isapnp_lfsr_next ( lfsr, byte );
211                         byte >>= 1;
212                 }
213         }
214         return lfsr;
215 }
216
217 /*
218  * Read a byte of resource data from the current location
219  *
220  */
221 static inline uint8_t isapnp_peek_byte ( void ) {
222         int i;
223
224         /* Wait for data to be ready */
225         for ( i = 0 ; i < 20 ; i ++ ) {
226                 if ( isapnp_read_status() & 0x01 ) {
227                         /* Byte ready - read it */
228                         return isapnp_read_resourcedata();
229                 }
230                 isapnp_delay ();
231         }
232         /* Data never became ready - return 0xff */
233         return 0xff;
234 }
235
236 /*
237  * Read n bytes of resource data from the current location.  If buf is
238  * NULL, discard data.
239  *
240  */
241 static void isapnp_peek ( uint8_t *buf, size_t bytes ) {
242         unsigned int i;
243         uint8_t byte;
244
245         for ( i = 0 ; i < bytes ; i++) {
246                 byte = isapnp_peek_byte();
247                 if ( buf ) {
248                         buf[i] = byte;
249                 }
250         }
251 }
252
253 /*
254  * Scan through the resource data until we find a particular tag, and
255  * read its contents into a buffer.
256  *
257  * It is the caller's responsibility to ensure that buf is large
258  * enough to contain a tag of the requested size.
259  *
260  */
261 static int isapnp_find_tag ( uint8_t wanted_tag, uint8_t *buf ) {
262         uint8_t tag;
263         uint16_t len;
264
265         DBG ( "ISAPnP read tag" );
266         do {
267                 tag = isapnp_peek_byte();
268                 if ( ISAPNP_IS_SMALL_TAG ( tag ) ) {
269                         len = ISAPNP_SMALL_TAG_LEN ( tag );
270                         tag = ISAPNP_SMALL_TAG_NAME ( tag );
271                 } else {
272                         len = isapnp_peek_byte() + ( isapnp_peek_byte() << 8 );
273                         tag = ISAPNP_LARGE_TAG_NAME ( tag );
274                 }
275                 DBG ( " %hhx (%hhx)", tag, len );
276                 if ( tag == wanted_tag ) {
277                         isapnp_peek ( buf, len );
278                         DBG ( "\n" );
279                         return 1;
280                 } else {
281                         isapnp_peek ( NULL, len );
282                 }
283         } while ( tag != ISAPNP_TAG_END );
284         DBG ( "\n" );
285         return 0;
286 }
287
288 /*
289  * Try isolating ISAPnP cards at the current read port.  Return the
290  * number of ISAPnP cards found.
291  *
292  * The state diagram on page 18 (PDF page 24) of the PnP ISA spec
293  * gives the best overview of what happens here.
294  *
295  */
296 static int isapnp_try_isolate ( void ) {
297         struct isapnp_identifier identifier;
298         unsigned int i, j, seen55aa;
299         unsigned int csn = 0;
300         uint16_t data;
301         uint8_t byte;
302
303         DBG ( "ISAPnP attempting isolation at read port %hx\n",
304               isapnp_read_port );
305
306         /* Place all cards into the Sleep state, whatever state
307          * they're currently in.
308          */
309         isapnp_wait_for_key ();
310         isapnp_send_key ();
311
312         /* Reset all assigned CSNs */
313         isapnp_reset_csn ();
314         isapnp_delay();
315         isapnp_delay();
316         
317         /* Place all cards into the Isolation state */
318         isapnp_wait_for_key ();
319         isapnp_send_key ();
320         isapnp_wake ( 0x00 );
321         
322         /* Set the read port */
323         isapnp_set_read_port ();
324         isapnp_delay();
325
326         while ( 1 ) {
327
328                 /* All cards that do not have assigned CSNs are
329                  * currently in the Isolation state, each time we go
330                  * through this loop.
331                  */
332
333                 /* Initiate serial isolation */
334                 isapnp_serialisolation ();
335                 isapnp_delay();
336
337                 /* Read identifier serially via the ISAPnP read port. */
338                 memset ( &identifier, 0, sizeof ( identifier ) );
339                 seen55aa = 0;
340                 for ( i = 0 ; i < 9 ; i++ ) {
341                         byte = 0;
342                         for ( j = 0 ; j < 8 ; j++ ) {
343                                 data = isapnp_read_data ();
344                                 isapnp_delay();
345                                 data = ( data << 8 ) | isapnp_read_data ();
346                                 isapnp_delay();
347                                 byte >>= 1;
348                                 if ( data == 0x55aa ) {
349                                         byte |= 0x80;
350                                         seen55aa = 1;
351                                 }
352                         }
353                         ( (char *) &identifier )[i] = byte;
354                 }
355                                 
356                 /* If we didn't see any 55aa patterns, stop here */
357                 if ( ! seen55aa ) {
358                         DBG ( "ISAPnP saw %s signs of life\n",
359                               csn ? "no futher" : "no" );
360                         break;
361                 }
362
363                 /* If the checksum was invalid stop here */
364                 if ( identifier.checksum != isapnp_checksum ( &identifier) ) {
365                         DBG ( "ISAPnP found malformed card "
366                               ISAPNP_CARD_ID_FMT "\n  with checksum %hhx "
367                               "(should be %hhx), abandoning isolation\n",
368                               ISAPNP_CARD_ID_DATA ( &identifier ),
369                               identifier.checksum,
370                               isapnp_checksum ( &identifier) );
371                         /* break; */
372                 }
373
374                 /* Give the device a CSN */
375                 csn++;
376                 DBG ( "ISAPnP found card " ISAPNP_CARD_ID_FMT
377                       ", assigning CSN %hhx\n",
378                       ISAPNP_CARD_ID_DATA ( &identifier ), csn );
379                 
380                 isapnp_write_csn ( csn );
381                 isapnp_delay();
382
383                 /* Send this card back to Sleep and force all cards
384                  * without a CSN into Isolation state
385                  */
386                 isapnp_wake ( 0x00 );
387                 isapnp_delay();
388         }
389
390         /* Place all cards in Wait for Key state */
391         isapnp_wait_for_key ();
392
393         /* Return number of cards found */
394         DBG ( "ISAPnP found %d cards at read port %hx\n",
395               csn, isapnp_read_port );
396         return csn;
397 }
398
399 /*
400  * Isolate all ISAPnP cards, locating a valid read port in the process.
401  *
402  */
403 static void isapnp_isolate ( void ) {
404         for ( isapnp_read_port = ISAPNP_READ_PORT_MIN ;
405               isapnp_read_port <= ISAPNP_READ_PORT_MAX ;
406               isapnp_read_port += ISAPNP_READ_PORT_STEP ) {
407                 /* Avoid problematic locations such as the NE2000
408                  * probe space
409                  */
410                 if ( ( isapnp_read_port >= 0x280 ) &&
411                      ( isapnp_read_port <= 0x380 ) )
412                         continue;
413                 
414                 /* If we detect any ISAPnP cards at this location, stop */
415                 if ( isapnp_try_isolate () )
416                         return;
417         }
418 }
419
420 /*
421  * Increment a bus_loc structure to the next possible ISAPnP location.
422  * Leave the structure zeroed and return 0 if there are no more valid
423  * locations.
424  *
425  */
426 static int isapnp_next_location ( struct bus_loc *bus_loc ) {
427         struct isapnp_loc *isapnp_loc = ( struct isapnp_loc * ) bus_loc;
428         
429         /*
430          * Ensure that there is sufficient space in the shared bus
431          * structures for a struct isapnp_loc and a struct isapnp_dev,
432          * as mandated by bus.h.
433          *
434          */
435         BUS_LOC_CHECK ( struct isapnp_loc );
436         BUS_DEV_CHECK ( struct isapnp_device );
437
438         return ( ++isapnp_loc->logdev ? 1 : ++isapnp_loc->csn );
439 }
440
441 /*
442  * Fill in parameters for an ISAPnP device based on CSN
443  *
444  * Return 1 if device present, 0 otherwise
445  *
446  */
447 static int isapnp_fill_device ( struct bus_dev *bus_dev,
448                                 struct bus_loc *bus_loc ) {
449         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
450         struct isapnp_loc *isapnp_loc = ( struct isapnp_loc * ) bus_loc;
451         unsigned int i;
452         struct isapnp_identifier identifier;
453         struct isapnp_logdevid logdevid;
454         static struct {
455                 uint8_t csn;
456                 uint8_t first_nonexistent_logdev;
457         } cache = { 0, 0 };
458
459         /* Copy CSN and logdev to isapnp_device, set default values */
460         isapnp->csn = isapnp_loc->csn;
461         isapnp->logdev = isapnp_loc->logdev;
462         isapnp->name = "?";
463
464         /* CSN 0 is never valid, but may be passed in */
465         if ( ! isapnp->csn )
466                 return 0;
467
468         /* Check cache to see if we are already past the highest
469          * logical device of this CSN
470          */
471         if ( ( isapnp->csn == cache.csn ) &&
472              ( isapnp->logdev >= cache.first_nonexistent_logdev ) )
473                 return 0;
474
475         /* Perform isolation if it hasn't yet been done */
476         if ( ! isapnp_read_port )
477                 isapnp_isolate();
478
479         /* Wake the card */
480         isapnp_wait_for_key ();
481         isapnp_send_key ();
482         isapnp_wake ( isapnp->csn );
483
484         /* Read the card identifier */
485         isapnp_peek ( ( char * ) &identifier, sizeof ( identifier ) );
486
487         /* Need to return 0 if no device exists at this CSN */
488         if ( identifier.vendor_id & 0x80 ) {
489                 DBG ( "ISAPnP found no card %hhx\n", isapnp->csn );
490                 cache.csn = isapnp->csn;
491                 cache.first_nonexistent_logdev = 0;
492                 return 0;
493         }
494
495         /* Find the Logical Device ID tag corresponding to this device */
496         for ( i = 0 ; i <= isapnp->logdev ; i++ ) {
497                 if ( ! isapnp_find_tag ( ISAPNP_TAG_LOGDEVID,
498                                          ( char * ) &logdevid ) ) {
499                         /* No tag for this device */
500                         DBG ( "ISAPnP found no device %hhx.%hhx on "
501                               "card " ISAPNP_CARD_ID_FMT "\n",
502                               isapnp->csn, isapnp->logdev,
503                               ISAPNP_CARD_ID_DATA ( &identifier ) );
504                         cache.csn = isapnp->csn;
505                         cache.first_nonexistent_logdev = isapnp->logdev;
506                         return 0;
507                 }
508         }
509
510         /* Read information from logdevid structure */
511         isapnp->vendor_id = logdevid.vendor_id;
512         isapnp->prod_id = logdevid.prod_id;
513
514         /* Select the logical device */
515         isapnp_logicaldevice ( isapnp->logdev );
516
517         /* Read the current ioaddr and irqno */
518         isapnp->ioaddr = isapnp_read_iobase ( 0 );
519         isapnp->irqno = isapnp_read_irqno ( 0 );
520
521         /* Return all cards to Wait for Key state */
522         isapnp_wait_for_key ();
523
524         DBG ( "ISAPnP found device %hhx.%hhx " ISAPNP_DEV_ID_FMT
525               ", base %hx irq %d\n", isapnp->csn, isapnp->logdev,
526               ISAPNP_DEV_ID_DATA ( isapnp ), isapnp->ioaddr, isapnp->irqno );
527         DBG ( "  on card " ISAPNP_CARD_ID_FMT "\n",
528               ISAPNP_CARD_ID_DATA ( &identifier ) );
529
530         return 1;
531 }
532
533 /*
534  * Test whether or not a driver is capable of driving the device.
535  *
536  */
537 static int isapnp_check_driver ( struct bus_dev *bus_dev,
538                                  struct device_driver *device_driver ) {
539         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
540         struct isapnp_driver *driver
541                 = ( struct isapnp_driver * ) device_driver->bus_driver_info;
542         unsigned int i;
543
544         /* Compare against driver's ID list */
545         for ( i = 0 ; i < driver->id_count ; i++ ) {
546                 struct isapnp_id *id = &driver->ids[i];
547                 
548                 if ( ( isapnp->vendor_id == id->vendor_id ) &&
549                      ( ISA_PROD_ID ( isapnp->prod_id ) ==
550                        ISA_PROD_ID ( id->prod_id ) ) ) {
551                         DBG ( "ISAPnP found ID %hx:%hx "
552                               "(\"%s\") (device %s) "
553                               "matching driver %s\n",
554                               isapnp->vendor_id,
555                               isapnp->prod_id,
556                               isa_id_string( isapnp->vendor_id,
557                                              isapnp->prod_id ),
558                               id->name, driver->name );
559                         isapnp->name = id->name;
560                         return 1;
561                 }
562         }
563
564         return 0;
565 }
566
567 /*
568  * Describe an ISAPnP device
569  *
570  */
571 static char * isapnp_describe ( struct bus_dev *bus_dev ) {
572         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
573         static char isapnp_description[] = "ISAPnP 00:00";
574
575         sprintf ( isapnp_description + 7, "%hhx:%hhx",
576                   isapnp->csn, isapnp->logdev );
577         return isapnp_description;
578 }
579
580 /*
581  * Name an ISAPnP device
582  *
583  */
584 static const char * isapnp_name ( struct bus_dev *bus_dev ) {
585         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
586         
587         return isapnp->name;
588 }
589
590 /*
591  * ISAPnP bus operations table
592  *
593  */
594 struct bus_driver isapnp_driver __bus_driver = {
595         .next_location  = isapnp_next_location,
596         .fill_device    = isapnp_fill_device,
597         .check_driver   = isapnp_check_driver,
598         .describe       = isapnp_describe,
599         .name           = isapnp_name,
600 };
601
602 /*
603  * Activate or deactivate an ISAPnP device
604  *
605  * This routine simply activates the device in its current
606  * configuration.  It does not attempt any kind of resource
607  * arbitration.
608  *
609  */
610 void isapnp_device_activation ( struct isapnp_device *isapnp,
611                                 int activation ) {
612         /* Wake the card and select the logical device */
613         isapnp_wait_for_key ();
614         isapnp_send_key ();
615         isapnp_wake ( isapnp->csn );
616         isapnp_logicaldevice ( isapnp->logdev );
617
618         /* Activate/deactivate the logical device */
619         isapnp_activate ( activation );
620         isapnp_delay();
621
622         /* Return all cards to Wait for Key state */
623         isapnp_wait_for_key ();
624
625         DBG ( "ISAPnP activated device %hhx.%hhx\n",
626               isapnp->csn, isapnp->logdev );
627 }
628
629 /*
630  * Fill in a nic structure
631  *
632  */
633 void isapnp_fill_nic ( struct nic *nic, struct isapnp_device *isapnp ) {
634
635         /* Fill in ioaddr and irqno */
636         nic->ioaddr = isapnp->ioaddr;
637         nic->irqno = isapnp->irqno;
638
639         /* Fill in DHCP device ID structure */
640         nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
641         nic->dhcp_dev_id.vendor_id = htons ( isapnp->vendor_id );
642         nic->dhcp_dev_id.device_id = htons ( isapnp->prod_id );
643 }
644