source: grub-pc/trunk/fuentes/debian/grub-extras/disabled/gpxe/src/drivers/net/3c509.c @ 22

Last change on this file since 22 was 22, checked in by mabarracus, 4 years ago

updated version and apply net.ifnames=0 into debian/rules

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