t5x9 code relies on nic->ioaddr being set
[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 <stdint.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <io.h>
11 #include <timer.h>
12 #include <gpxe/device.h>
13 #include <gpxe/isa.h>
14 #include "3c509.h"
15
16 /*
17  * 3c509 cards have their own method of contention resolution; this
18  * effectively defines another bus type similar to ISAPnP.  Even the
19  * original ISA cards can be programatically mapped to any I/O address
20  * in the range 0x200-0x3e0.
21  * 
22  * However, there is a small problem: once you've activated a card,
23  * the only ways to deactivate it will also wipe its tag, meaning that
24  * you won't be able to subsequently reactivate it without going
25  * through the whole ID sequence again.  The solution we adopt is to
26  * isolate and tag all cards at the start, and to immediately
27  * re-isolate and re-tag a card after disabling it.
28  *
29  */
30
31 static void t509bus_remove ( struct root_device *rootdev );
32
33 static unsigned int t509_id_port = 0;
34 static unsigned int t509_max_tag = 0;
35
36 /** A 3c509 device */
37 struct t509_device {
38         /** Generic device */
39         struct device dev;
40         /** Tag */
41         unsigned int tag;
42         /** I/O address */
43         uint16_t ioaddr;
44         /** Driver-private data
45          *
46          * Use t509_set_drvdata() and t509_get_drvdata() to access
47          * this field.
48          */
49         void *priv;
50 };
51
52 /**
53  * Set 3c509 driver-private data
54  *
55  * @v t509              3c509 device
56  * @v priv              Private data
57  */
58 static inline void t509_set_drvdata ( struct t509_device *t509, void *priv ) {
59         t509->priv = priv;
60 }
61
62 /**
63  * Get 3c509 driver-private data
64  *
65  * @v t509              3c509 device
66  * @ret priv            Private data
67  */
68 static inline void * t509_get_drvdata ( struct t509_device *t509 ) {
69         return t509->priv;
70 }
71
72 /*
73  * t509 utility functions
74  *
75  */
76
77 static inline void t509_set_id_port ( void ) {
78         outb ( 0x00, t509_id_port );
79 }
80
81 static inline void t509_wait_for_id_sequence ( void ) {
82         outb ( 0x00, t509_id_port );
83 }
84
85 static inline void t509_global_reset ( void ) {
86         outb ( 0xc0, t509_id_port );
87 }
88
89 static inline void t509_reset_tag ( void ) {
90         outb ( 0xd0, t509_id_port );
91 }
92
93 static inline void t509_set_tag ( uint8_t tag ) {
94         outb ( 0xd0 | tag, t509_id_port );
95 }
96
97 static inline void t509_select_tag ( uint8_t tag ) {
98         outb ( 0xd8 | tag, t509_id_port );
99 }
100
101 static inline void t509_activate ( uint16_t ioaddr ) {
102         outb ( 0xe0 | ( ioaddr >> 4 ), t509_id_port );
103 }
104
105 static inline void t509_deactivate_and_reset_tag ( uint16_t ioaddr ) {
106         outb ( GLOBAL_RESET, ioaddr + EP_COMMAND );
107 }
108
109 static inline void t509_load_eeprom_word ( uint8_t offset ) {
110         outb ( 0x80 | offset, t509_id_port );
111 }
112
113 /*
114  * Find a suitable ID port
115  *
116  */
117 static inline int t509_find_id_port ( void ) {
118
119         for ( t509_id_port = EP_ID_PORT_START ;
120               t509_id_port < EP_ID_PORT_END ;
121               t509_id_port += EP_ID_PORT_INC ) {
122                 t509_set_id_port ();
123                 /* See if anything's listening */
124                 outb ( 0xff, t509_id_port );
125                 if ( inb ( t509_id_port ) & 0x01 ) {
126                         /* Found a suitable port */
127                         DBG ( "T509 using ID port at %04x\n", t509_id_port );
128                         return 0;
129                 }
130         }
131         /* No id port available */
132         DBG ( "T509 found no available ID port\n" );
133         return -ENOENT;
134 }
135
136 /*
137  * Send ID sequence to the ID port
138  *
139  */
140 static void t509_send_id_sequence ( void ) {
141         unsigned short lrs_state, i;
142
143         t509_set_id_port ();
144         /* Reset IDS on cards */
145         t509_wait_for_id_sequence ();
146         lrs_state = 0xff;
147         for ( i = 0; i < 255; i++ ) {
148                 outb ( lrs_state, t509_id_port );
149                 lrs_state <<= 1;
150                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
151         }
152 }
153
154 /*
155  * We get eeprom data from the id_port given an offset into the eeprom.
156  * Basically; after the ID_sequence is sent to all of the cards; they enter
157  * the ID_CMD state where they will accept command requests. 0x80-0xbf loads
158  * the eeprom data.  We then read the port 16 times and with every read; the
159  * cards check for contention (ie: if one card writes a 0 bit and another
160  * writes a 1 bit then the host sees a 0. At the end of the cycle; each card
161  * compares the data on the bus; if there is a difference then that card goes
162  * into ID_WAIT state again). In the meantime; one bit of data is returned in
163  * the AX register which is conveniently returned to us by inb().  Hence; we
164  * read 16 times getting one bit of data with each read.
165  */
166 static uint16_t t509_id_read_eeprom ( int offset ) {
167         int i, data = 0;
168
169         t509_load_eeprom_word ( offset );
170         /* Do we really need this wait? Won't be noticeable anyway */
171         udelay(10000);
172
173         for ( i = 0; i < 16; i++ ) {
174                 data = ( data << 1 ) | ( inw ( t509_id_port ) & 1 );
175         }
176         return data;
177 }
178
179 /*
180  * Isolate and tag all t509 cards
181  *
182  */
183 static int t509_isolate ( void ) {
184         unsigned int i;
185         uint16_t contend[3];
186         int rc;
187
188         /* Find a suitable ID port */
189         if ( ( rc = t509_find_id_port() ) != 0 )
190                 return rc;
191
192         while ( 1 ) {
193
194                 /* All cards are in ID_WAIT state each time we go
195                  * through this loop.
196                  */
197
198                 /* Send the ID sequence */
199                 t509_send_id_sequence();
200
201                 /* First time through, reset all tags.  On subsequent
202                  * iterations, kill off any already-tagged cards
203                  */
204                 if ( t509_max_tag == 0 ) {
205                         t509_reset_tag();
206                 } else {
207                         t509_select_tag ( 0 );
208                 }
209         
210                 /* Read the manufacturer ID, to see if there are any
211                  * more cards
212                  */
213                 if ( t509_id_read_eeprom ( EEPROM_MFG_ID ) != MFG_ID ) {
214                         DBG ( "T509 saw %s signs of life\n",
215                               t509_max_tag ? "no further" : "no" );
216                         break;
217                 }
218
219                 /* Perform contention selection on the MAC address */
220                 for ( i = 0 ; i < 3 ; i++ ) {
221                         contend[i] = t509_id_read_eeprom ( i );
222                 }
223
224                 /* Only one device will still be left alive.  Tag it. */
225                 ++t509_max_tag;
226                 DBG ( "T509 found card %04x%04x%04x, assigning tag %02x\n",
227                       contend[0], contend[1], contend[2], t509_max_tag );
228                 t509_set_tag ( t509_max_tag );
229
230                 /* Return all cards back to ID_WAIT state */
231                 t509_wait_for_id_sequence();
232         }
233
234         DBG ( "T509 found %d cards using ID port %04x\n",
235               t509_max_tag, t509_id_port );
236         return 0;
237 }
238
239 /*
240  * Activate a T509 device
241  *
242  * The device will be enabled at whatever ioaddr is specified in the
243  * struct t509_device; there is no need to stick with the default
244  * ioaddr read from the EEPROM.
245  *
246  */
247 static inline void activate_t509_device ( struct t509_device *t509 ) {
248         t509_send_id_sequence ();
249         t509_select_tag ( t509->tag );
250         t509_activate ( t509->ioaddr );
251         DBG ( "T509 activated device %02x at ioaddr %04x\n",
252               t509->tag, t509->ioaddr );
253 }
254
255 /*
256  * Deactivate a T509 device
257  *
258  * Disabling also clears the tag, so we immediately isolate and re-tag
259  * this card.
260  *
261  */
262 static inline void deactivate_t509_device ( struct t509_device *t509 ) {
263         t509_deactivate_and_reset_tag ( t509->ioaddr );
264         udelay ( 1000 );
265         t509_send_id_sequence ();
266         t509_select_tag ( 0 );
267         t509_set_tag ( t509->tag );
268         t509_wait_for_id_sequence ();
269         DBG ( "T509 deactivated device at %04x and re-tagged as %02x\n",
270               t509->ioaddr, t509->tag );
271 }
272
273 /*
274  * The ISA probe function
275  *
276  */
277 static int legacy_t509_probe ( struct nic *nic, void *hwdev ) {
278         struct t509_device *t509 = hwdev;
279
280         /* We could change t509->ioaddr if we wanted to */
281         activate_t509_device ( t509 );
282         nic->ioaddr = t509->ioaddr;
283
284         /* Hand off to generic t5x9 probe routine */
285         return t5x9_probe ( nic, ISA_PROD_ID ( PROD_ID ), ISA_PROD_ID_MASK );
286 }
287
288 static void legacy_t509_disable ( struct nic *nic, void *hwdev ) {
289         struct t509_device *t509 = hwdev;
290
291         t5x9_disable ( nic );
292         deactivate_t509_device ( t509 );
293 }
294
295 static inline void legacy_t509_set_drvdata ( void *hwdev, void *priv ) {
296         t509_set_drvdata ( hwdev, priv );
297 }
298
299 static inline void * legacy_t509_get_drvdata ( void *hwdev ) {
300         return t509_get_drvdata ( hwdev );
301 }
302
303 /**
304  * Probe a 3c509 device
305  *
306  * @v t509              3c509 device
307  * @ret rc              Return status code
308  *
309  * Searches for a driver for the 3c509 device.  If a driver is found,
310  * its probe() routine is called.
311  */
312 static int t509_probe ( struct t509_device *t509 ) {
313         DBG ( "Adding 3c509 device %02x (I/O %04x)\n",
314               t509->tag, t509->ioaddr );
315         return legacy_probe ( t509, legacy_t509_set_drvdata, &t509->dev,
316                               legacy_t509_probe, legacy_t509_disable );
317 }
318
319 /**
320  * Remove a 3c509 device
321  *
322  * @v t509              3c509 device
323  */
324 static void t509_remove ( struct t509_device *t509 ) {
325         legacy_remove ( t509, legacy_t509_get_drvdata, legacy_t509_disable );
326         DBG ( "Removed 3c509 device %02x\n", t509->tag );
327 }
328
329 /**
330  * Probe 3c509 root bus
331  *
332  * @v rootdev           3c509 bus root device
333  *
334  * Scans the 3c509 bus for devices and registers all devices it can
335  * find.
336  */
337 static int t509bus_probe ( struct root_device *rootdev ) {
338         struct t509_device *t509 = NULL;
339         unsigned int tag;
340         unsigned int iobase;
341         int rc;
342
343         /* Perform isolation and tagging */
344         if ( ( rc = t509_isolate() ) != 0 )
345                 return rc;
346
347         for ( tag = 1 ; tag <= t509_max_tag ; tag++ ) {
348                 /* Allocate struct t509_device */
349                 if ( ! t509 )
350                         t509 = malloc ( sizeof ( *t509 ) );
351                 if ( ! t509 ) {
352                         rc = -ENOMEM;
353                         goto err;
354                 }
355                 memset ( t509, 0, sizeof ( *t509 ) );
356                 t509->tag = tag;
357
358                 /* Send the ID sequence */
359                 t509_send_id_sequence ();
360
361                 /* Select the specified tag */
362                 t509_select_tag ( t509->tag );
363
364                 /* Read the default I/O address */
365                 iobase = t509_id_read_eeprom ( EEPROM_ADDR_CFG );
366                 t509->ioaddr = 0x200 + ( ( iobase & 0x1f ) << 4 );
367
368                 /* Send card back to ID_WAIT */
369                 t509_wait_for_id_sequence();
370
371                 /* Add to device hierarchy */
372                 snprintf ( t509->dev.name, sizeof ( t509->dev.name ),
373                            "t509%02x", tag );
374                 t509->dev.desc.bus_type = BUS_TYPE_ISA;
375                 t509->dev.desc.vendor = MFG_ID;
376                 t509->dev.desc.device = PROD_ID;
377                 t509->dev.parent = &rootdev->dev;
378                 list_add ( &t509->dev.siblings, &rootdev->dev.children );
379                 INIT_LIST_HEAD ( &t509->dev.children );
380                         
381                 /* Look for a driver */
382                 if ( t509_probe ( t509 ) == 0 ) {
383                         /* t509dev registered, we can drop our ref */
384                         t509 = NULL;
385                 } else {
386                         /* Not registered; re-use struct */
387                         list_del ( &t509->dev.siblings );
388                 }
389         }
390
391         free ( t509 );
392         return 0;
393
394  err:
395         free ( t509 );
396         t509bus_remove ( rootdev );
397         return rc;
398 }
399
400 /**
401  * Remove 3c509 root bus
402  *
403  * @v rootdev           3c509 bus root device
404  */
405 static void t509bus_remove ( struct root_device *rootdev ) {
406         struct t509_device *t509;
407         struct t509_device *tmp;
408
409         list_for_each_entry_safe ( t509, tmp, &rootdev->dev.children,
410                                    dev.siblings ) {
411                 t509_remove ( t509 );
412                 list_del ( &t509->dev.siblings );
413                 free ( t509 );
414         }
415 }
416
417 /** 3c509 bus root device driver */
418 static struct root_driver t509_root_driver = {
419         .probe = t509bus_probe,
420         .remove = t509bus_remove,
421 };
422
423 /** 3c509 bus root device */
424 struct root_device t509_root_device __root_device = {
425         .dev = { .name = "3c509" },
426         .driver = &t509_root_driver,
427 };
428
429 ISA_ROM ( "3c509", "3c509" );