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" ); 433