gcc is rather over-aggressive about optimising out static data structures
[people/asdlkf/gpxe.git] / src / drivers / net / 3c509.c
1 /*
2  * Split out into 3c509.c and 3c5x9.c, to make it possible to build a
3  * 3c529 module without including ISA, ISAPnP and EISA code.
4  *
5  */
6
7 #include "isa.h"
8 #include "io.h"
9 #include "timer.h"
10 #include "string.h"
11 #include "console.h"
12 #include "3c509.h"
13
14 /*
15  * 3c509 cards have their own method of contention resolution; this
16  * effectively defines another bus type similar to ISAPnP.  Even the
17  * original ISA cards can be programatically mapped to any I/O address
18  * in the range 0x200-0x3e0.
19  * 
20  * However, there is a small problem: once you've activated a card,
21  * the only ways to deactivate it will also wipe its tag, meaning that
22  * you won't be able to subsequently reactivate it without going
23  * through the whole ID sequence again.  The solution we adopt is to
24  * isolate and tag all cards at the start, and to immediately
25  * re-isolate and re-tag a card after disabling it.
26  *
27  */
28
29 static uint16_t t509_id_port = 0;
30 static uint8_t t509_max_tag = 0;
31
32 /*
33  * A location on a t509 bus
34  *
35  */
36 struct t509_loc {
37         uint8_t tag;
38 };
39
40 /*
41  * A physical t509 device
42  *
43  */
44 struct t509_device {
45         uint16_t ioaddr;
46         uint8_t tag;
47 };
48
49 /*
50  * t509 utility functions
51  *
52  */
53
54 static inline void t509_set_id_port ( void ) {
55         outb ( 0x00, t509_id_port );
56 }
57
58 static inline void t509_wait_for_id_sequence ( void ) {
59         outb ( 0x00, t509_id_port );
60 }
61
62 static inline void t509_global_reset ( void ) {
63         outb ( 0xc0, t509_id_port );
64 }
65
66 static inline void t509_reset_tag ( void ) {
67         outb ( 0xd0, t509_id_port );
68 }
69
70 static inline void t509_set_tag ( uint8_t tag ) {
71         outb ( 0xd0 | tag, t509_id_port );
72 }
73
74 static inline void t509_select_tag ( uint8_t tag ) {
75         outb ( 0xd8 | tag, t509_id_port );
76 }
77
78 static inline void t509_activate ( uint16_t ioaddr ) {
79         outb ( 0xe0 | ( ioaddr >> 4 ), t509_id_port );
80 }
81
82 static inline void t509_deactivate_and_reset_tag ( uint16_t ioaddr ) {
83         outb ( GLOBAL_RESET, ioaddr + EP_COMMAND );
84 }
85
86 static inline void t509_load_eeprom_word ( uint8_t offset ) {
87         outb ( 0x80 | offset, t509_id_port );
88 }
89
90 /*
91  * Find a suitable ID port
92  *
93  */
94 static inline int t509_find_id_port ( void ) {
95
96         for ( t509_id_port = EP_ID_PORT_START ;
97               t509_id_port < EP_ID_PORT_END ;
98               t509_id_port += EP_ID_PORT_INC ) {
99                 t509_set_id_port ();
100                 /* See if anything's listening */
101                 outb ( 0xff, t509_id_port );
102                 if ( inb ( t509_id_port ) & 0x01 ) {
103                         /* Found a suitable port */
104                         DBG ( "T509 using ID port at %hx\n", t509_id_port );
105                         return 1;
106                 }
107         }
108         /* No id port available */
109         DBG ( "T509 found no available ID port\n" );
110         return 0;
111 }
112
113 /*
114  * Send ID sequence to the ID port
115  *
116  */
117 static void t509_send_id_sequence ( void ) {
118         unsigned short lrs_state, i;
119
120         t509_set_id_port ();
121         /* Reset IDS on cards */
122         t509_wait_for_id_sequence ();
123         lrs_state = 0xff;
124         for ( i = 0; i < 255; i++ ) {
125                 outb ( lrs_state, t509_id_port );
126                 lrs_state <<= 1;
127                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
128         }
129 }
130
131 /*
132  * We get eeprom data from the id_port given an offset into the eeprom.
133  * Basically; after the ID_sequence is sent to all of the cards; they enter
134  * the ID_CMD state where they will accept command requests. 0x80-0xbf loads
135  * the eeprom data.  We then read the port 16 times and with every read; the
136  * cards check for contention (ie: if one card writes a 0 bit and another
137  * writes a 1 bit then the host sees a 0. At the end of the cycle; each card
138  * compares the data on the bus; if there is a difference then that card goes
139  * into ID_WAIT state again). In the meantime; one bit of data is returned in
140  * the AX register which is conveniently returned to us by inb().  Hence; we
141  * read 16 times getting one bit of data with each read.
142  */
143 static uint16_t t509_id_read_eeprom ( int offset ) {
144         int i, data = 0;
145
146         t509_load_eeprom_word ( offset );
147         /* Do we really need this wait? Won't be noticeable anyway */
148         udelay(10000);
149
150         for ( i = 0; i < 16; i++ ) {
151                 data = ( data << 1 ) | ( inw ( t509_id_port ) & 1 );
152         }
153         return data;
154 }
155
156 /*
157  * Isolate and tag all t509 cards
158  *
159  */
160 static void t509_isolate ( void ) {
161         unsigned int i;
162         uint16_t contend[3];
163
164         /* Find a suitable ID port */
165         if ( ! t509_find_id_port () )
166                 return;
167
168         while ( 1 ) {
169
170                 /* All cards are in ID_WAIT state each time we go
171                  * through this loop.
172                  */
173
174                 /* Send the ID sequence */
175                 t509_send_id_sequence ();
176
177                 /* First time through, reset all tags.  On subsequent
178                  * iterations, kill off any already-tagged cards
179                  */
180                 if ( t509_max_tag == 0 ) {
181                         t509_reset_tag();
182                 } else {
183                         t509_select_tag(0);
184                 }
185         
186                 /* Read the manufacturer ID, to see if there are any
187                  * more cards
188                  */
189                 if ( t509_id_read_eeprom ( EEPROM_MFG_ID ) != MFG_ID ) {
190                         DBG ( "T509 saw %s signs of life\n",
191                               t509_max_tag ? "no further" : "no" );
192                         break;
193                 }
194
195                 /* Perform contention selection on the MAC address */
196                 for ( i = 0 ; i < 3 ; i++ ) {
197                         contend[i] = t509_id_read_eeprom ( i );
198                 }
199
200                 /* Only one device will still be left alive.  Tag it. */
201                 ++t509_max_tag;
202                 DBG ( "T509 found card %hx%hx%hx, assigning tag %hhx\n",
203                       contend[0], contend[1], contend[2], t509_max_tag );
204                 t509_set_tag ( t509_max_tag );
205
206                 /* Return all cards back to ID_WAIT state */
207                 t509_wait_for_id_sequence();
208         }
209
210         DBG ( "T509 found %d cards using ID port %hx\n",
211               t509_max_tag, t509_id_port );
212         return;
213 }
214
215 /*
216  * Increment a bus_loc structure to the next possible T509 location.
217  * Leave the structure zeroed and return 0 if there are no more valid
218  * locations.
219  *
220  */
221 static int t509_next_location ( struct bus_loc *bus_loc ) {
222         struct t509_loc *t509_loc = ( struct t509_loc * ) bus_loc;
223         
224         /*
225          * Ensure that there is sufficient space in the shared bus
226          * structures for a struct t509_loc and a struct t509_dev,
227          * as mandated by bus.h.
228          *
229          */
230         BUS_LOC_CHECK ( struct t509_loc );
231         BUS_DEV_CHECK ( struct t509_device );
232
233         return ( t509_loc->tag = ( ++t509_loc->tag & EP_TAG_MAX ) );
234 }
235
236 /*
237  * Fill in parameters for a T509 device based on tag
238  *
239  * Return 1 if device present, 0 otherwise
240  *
241  */
242 static int t509_fill_device ( struct bus_dev *bus_dev,
243                               struct bus_loc *bus_loc ) {
244         struct t509_device *t509 = ( struct t509_device * ) bus_dev;
245         struct t509_loc *t509_loc = ( struct t509_loc * ) bus_loc;
246         uint16_t iobase;
247
248         /* Copy tag to struct t509 */
249         t509->tag = t509_loc->tag;
250
251         /* Tag 0 is never valid, but may be passed in */
252         if ( ! t509->tag )
253                 return 0;
254
255         /* Perform isolation if it hasn't yet been done */
256         if ( ! t509_id_port )
257                 t509_isolate();
258
259         /* Check tag is in range */
260         if ( t509->tag > t509_max_tag )
261                 return 0;
262
263         /* Send the ID sequence */
264         t509_send_id_sequence ();
265
266         /* Select the specified tag */
267         t509_select_tag ( t509->tag );
268
269         /* Read the default I/O address */
270         iobase = t509_id_read_eeprom ( EEPROM_ADDR_CFG );
271         t509->ioaddr = 0x200 + ( ( iobase & 0x1f ) << 4 );
272
273         /* Send card back to ID_WAIT */
274         t509_wait_for_id_sequence();
275
276         DBG ( "T509 found device %hhx, base %hx\n", t509->tag, t509->ioaddr );
277         return 1;
278 }
279
280 /*
281  * Test whether or not a driver is capable of driving the device.
282  * This is a no-op for T509.
283  *
284  */
285 static int t509_check_driver ( struct bus_dev *bus_dev __unused,
286                                struct device_driver *device_driver __unused ) {
287         return 1;
288 }
289
290 /*
291  * Describe a T509 device
292  *
293  */
294 static char * t509_describe_device ( struct bus_dev *bus_dev ) {
295         struct t509_device *t509 = ( struct t509_device * ) bus_dev;
296         static char t509_description[] = "T509 00";
297
298         sprintf ( t509_description + 4, "%hhx", t509->tag );
299         return t509_description;
300 }
301
302 /*
303  * Name a T509 device
304  *
305  */
306 static const char * t509_name_device ( struct bus_dev *bus_dev __unused ) {
307         return "T509";
308 }
309
310 /*
311  * T509 bus operations table
312  *
313  */
314 struct bus_driver t509_driver __bus_driver = {
315         .name                   = "T509",
316         .next_location          = t509_next_location,
317         .fill_device            = t509_fill_device,
318         .check_driver           = t509_check_driver,
319         .describe_device        = t509_describe_device,
320         .name_device            = t509_name_device,
321 };
322
323 /*
324  * Activate a T509 device
325  *
326  * The device will be enabled at whatever ioaddr is specified in the
327  * struct t509_device; there is no need to stick with the default
328  * ioaddr read from the EEPROM.
329  *
330  */
331 static inline void activate_t509_device ( struct t509_device *t509 ) {
332         t509_send_id_sequence ();
333         t509_select_tag ( t509->tag );
334         t509_activate ( t509->ioaddr );
335         DBG ( "T509 activated device %hhx at ioaddr %hx\n",
336               t509->tag, t509->ioaddr );
337 }
338
339 /*
340  * Deactivate a T509 device
341  *
342  * Disabling also clears the tag, so we immediately isolate and re-tag
343  * this card.
344  *
345  */
346 static inline void deactivate_t509_device ( struct t509_device *t509 ) {
347         t509_deactivate_and_reset_tag ( t509->ioaddr );
348         udelay ( 1000 );
349         t509_send_id_sequence ();
350         t509_select_tag ( 0 );
351         t509_set_tag ( t509->tag );
352         t509_wait_for_id_sequence ();
353         DBG ( "T509 deactivated device at %hx and re-tagged as %hhx\n",
354               t509->ioaddr, t509->tag );
355 }
356
357 /*
358  * Fill in a nic structure
359  *
360  * Called only once, so inlined for efficiency
361  *
362  */
363 static inline void t509_fill_nic ( struct nic *nic,
364                                    struct t509_device *t509 ) {
365
366         /* Fill in ioaddr and irqno */
367         nic->ioaddr = t509->ioaddr;
368         nic->irqno = 0;
369
370         /* Fill in DHCP device ID structure */
371         nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
372         nic->dhcp_dev_id.vendor_id = htons ( MFG_ID );
373         nic->dhcp_dev_id.device_id = htons ( PROD_ID );
374 }
375
376 /*
377  * The ISA probe function
378  *
379  */
380 static int el3_t509_probe ( struct nic *nic, struct t509_device *t509 ) {
381         
382         /* We could change t509->ioaddr if we wanted to */
383         activate_t509_device ( t509 );
384         t509_fill_nic ( nic, t509 );
385
386         /* Hand off to generic t5x9 probe routine */
387         return t5x9_probe ( nic, ISA_PROD_ID ( PROD_ID ), ISA_PROD_ID_MASK );
388 }
389
390 static void el3_t509_disable ( struct nic *nic, struct t509_device *t509 ) {
391         t5x9_disable ( nic );
392         deactivate_t509_device ( t509 );
393 }
394
395 struct {} el3_t509_driver;
396
397 DRIVER ( "3c509", nic_driver, t509_driver, el3_t509_driver,
398          el3_t509_probe, el3_t509_disable );
399
400 ISA_ROM ( "3c509", "3c509" );