← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/ipxe/src/drivers/net/3c509.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/ipxe/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
FILE_LICENCE ( BSD2 );
 
8
 
 
9
#include <stdint.h>
 
10
#include <stdlib.h>
 
11
#include <string.h>
 
12
#include <errno.h>
 
13
#include <ipxe/io.h>
 
14
#include <unistd.h>
 
15
#include <ipxe/device.h>
 
16
#include <ipxe/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
 
 
34
static void t509bus_remove ( struct root_device *rootdev );
 
35
 
 
36
static unsigned int t509_id_port = 0;
 
37
static unsigned int t509_max_tag = 0;
 
38
 
 
39
/** A 3c509 device */
 
40
struct 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
 */
 
61
static 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
 */
 
71
static inline void * t509_get_drvdata ( struct t509_device *t509 ) {
 
72
        return t509->priv;
 
73
}
 
74
 
 
75
/*
 
76
 * t509 utility functions
 
77
 *
 
78
 */
 
79
 
 
80
static inline void t509_set_id_port ( void ) {
 
81
        outb ( 0x00, t509_id_port );
 
82
}
 
83
 
 
84
static inline void t509_wait_for_id_sequence ( void ) {
 
85
        outb ( 0x00, t509_id_port );
 
86
}
 
87
 
 
88
static inline void t509_global_reset ( void ) {
 
89
        outb ( 0xc0, t509_id_port );
 
90
}
 
91
 
 
92
static inline void t509_reset_tag ( void ) {
 
93
        outb ( 0xd0, t509_id_port );
 
94
}
 
95
 
 
96
static inline void t509_set_tag ( uint8_t tag ) {
 
97
        outb ( 0xd0 | tag, t509_id_port );
 
98
}
 
99
 
 
100
static inline void t509_select_tag ( uint8_t tag ) {
 
101
        outb ( 0xd8 | tag, t509_id_port );
 
102
}
 
103
 
 
104
static inline void t509_activate ( uint16_t ioaddr ) {
 
105
        outb ( 0xe0 | ( ioaddr >> 4 ), t509_id_port );
 
106
}
 
107
 
 
108
static inline void t509_deactivate_and_reset_tag ( uint16_t ioaddr ) {
 
109
        outb ( GLOBAL_RESET, ioaddr + EP_COMMAND );
 
110
}
 
111
 
 
112
static 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
 */
 
120
static 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
 */
 
143
static 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
 */
 
169
static 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
 */
 
186
static 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
 */
 
250
static 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
 */
 
265
static 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
 */
 
280
static 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
 
 
291
static 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
 
 
298
static inline void legacy_t509_set_drvdata ( void *hwdev, void *priv ) {
 
299
        t509_set_drvdata ( hwdev, priv );
 
300
}
 
301
 
 
302
static 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
 */
 
315
static 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
 */
 
327
static 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
 */
 
340
static 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
 */
 
408
static 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 */
 
421
static struct root_driver t509_root_driver = {
 
422
        .probe = t509bus_probe,
 
423
        .remove = t509bus_remove,
 
424
};
 
425
 
 
426
/** 3c509 bus root device */
 
427
struct root_device t509_root_device __root_device = {
 
428
        .dev = { .name = "3c509" },
 
429
        .driver = &t509_root_driver,
 
430
};
 
431
 
 
432
ISA_ROM ( "3c509", "3c509" );