1 /* 2 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200 3 * 4 * (C) Copyright 1997 Alain Malek 5 * (Alain.Malek@cryogen.com) 6 * 7 * ---------------------------------------------------------------------------- 8 * 9 * This program is based on 10 * 11 * ne.c: A general non-shared-memory NS8390 ethernet driver for linux 12 * Written 1992-94 by Donald Becker. 13 * 14 * 8390.c: A general NS8390 ethernet driver core for linux. 15 * Written 1992-94 by Donald Becker. 16 * 17 * cnetdevice: A Sana-II ethernet driver for AmigaOS 18 * Written by Bruce Abbott (bhabbott@inhb.co.nz) 19 * 20 * ---------------------------------------------------------------------------- 21 * 22 * This file is subject to the terms and conditions of the GNU General Public 23 * License. See the file COPYING in the main directory of the Linux 24 * distribution for more details. 25 * 26 * ---------------------------------------------------------------------------- 27 * 28 */ 29 30 31 #include <linux/module.h> 32 #include <linux/kernel.h> 33 #include <linux/errno.h> 34 #include <linux/pci.h> 35 #include <linux/init.h> 36 #include <linux/delay.h> 37 #include <linux/netdevice.h> 38 #include <linux/etherdevice.h> 39 #include <linux/interrupt.h> 40 #include <linux/jiffies.h> 41 42 #include <asm/io.h> 43 #include <asm/setup.h> 44 #include <asm/amigaints.h> 45 #include <asm/amigahw.h> 46 #include <asm/amigayle.h> 47 #include <asm/amipcmcia.h> 48 49 #include "8390.h" 50 51 /* ---- No user-serviceable parts below ---- */ 52 53 #define DRV_NAME "apne" 54 55 #define NE_BASE (dev->base_addr) 56 #define NE_CMD 0x00 57 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */ 58 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */ 59 #define NE_IO_EXTENT 0x20 60 61 #define NE_EN0_ISR 0x07 62 #define NE_EN0_DCFG 0x0e 63 64 #define NE_EN0_RSARLO 0x08 65 #define NE_EN0_RSARHI 0x09 66 #define NE_EN0_RCNTLO 0x0a 67 #define NE_EN0_RXCR 0x0c 68 #define NE_EN0_TXCR 0x0d 69 #define NE_EN0_RCNTHI 0x0b 70 #define NE_EN0_IMR 0x0f 71 72 #define NE1SM_START_PG 0x20 /* First page of TX buffer */ 73 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */ 74 #define NESM_START_PG 0x40 /* First page of TX buffer */ 75 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */ 76 77 78 struct net_device * __init apne_probe(int unit); 79 static int apne_probe1(struct net_device *dev, int ioaddr); 80 81 static void apne_reset_8390(struct net_device *dev); 82 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, 83 int ring_page); 84 static void apne_block_input(struct net_device *dev, int count, 85 struct sk_buff *skb, int ring_offset); 86 static void apne_block_output(struct net_device *dev, const int count, 87 const unsigned char *buf, const int start_page); 88 static irqreturn_t apne_interrupt(int irq, void *dev_id); 89 90 static int init_pcmcia(void); 91 92 /* IO base address used for nic */ 93 94 #define IOBASE 0x300 95 96 /* 97 use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand 98 you can find the values to use by looking at the cnet.device 99 config file example (the default values are for the CNET40BC card) 100 */ 101 102 /* 103 #define MANUAL_CONFIG 0x20 104 #define MANUAL_OFFSET 0x3f8 105 106 #define MANUAL_HWADDR0 0x00 107 #define MANUAL_HWADDR1 0x12 108 #define MANUAL_HWADDR2 0x34 109 #define MANUAL_HWADDR3 0x56 110 #define MANUAL_HWADDR4 0x78 111 #define MANUAL_HWADDR5 0x9a 112 */ 113 114 static const char version[] = 115 "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n"; 116 117 static int apne_owned; /* signal if card already owned */ 118 119 static u32 apne_msg_enable; 120 module_param_named(msg_enable, apne_msg_enable, uint, 0444); 121 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)"); 122 123 struct net_device * __init apne_probe(int unit) 124 { 125 struct net_device *dev; 126 struct ei_device *ei_local; 127 128 #ifndef MANUAL_CONFIG 129 char tuple[8]; 130 #endif 131 int err; 132 133 if (!MACH_IS_AMIGA) 134 return ERR_PTR(-ENODEV); 135 136 if (apne_owned) 137 return ERR_PTR(-ENODEV); 138 139 if ( !(AMIGAHW_PRESENT(PCMCIA)) ) 140 return ERR_PTR(-ENODEV); 141 142 pr_info("Looking for PCMCIA ethernet card : "); 143 144 /* check if a card is inserted */ 145 if (!(PCMCIA_INSERTED)) { 146 pr_cont("NO PCMCIA card inserted\n"); 147 return ERR_PTR(-ENODEV); 148 } 149 150 dev = alloc_ei_netdev(); 151 if (!dev) 152 return ERR_PTR(-ENOMEM); 153 if (unit >= 0) { 154 sprintf(dev->name, "eth%d", unit); 155 netdev_boot_setup_check(dev); 156 } 157 ei_local = netdev_priv(dev); 158 ei_local->msg_enable = apne_msg_enable; 159 160 /* disable pcmcia irq for readtuple */ 161 pcmcia_disable_irq(); 162 163 #ifndef MANUAL_CONFIG 164 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) || 165 (tuple[2] != CISTPL_FUNCID_NETWORK)) { 166 pr_cont("not an ethernet card\n"); 167 /* XXX: shouldn't we re-enable irq here? */ 168 free_netdev(dev); 169 return ERR_PTR(-ENODEV); 170 } 171 #endif 172 173 pr_cont("ethernet PCMCIA card inserted\n"); 174 175 if (!init_pcmcia()) { 176 /* XXX: shouldn't we re-enable irq here? */ 177 free_netdev(dev); 178 return ERR_PTR(-ENODEV); 179 } 180 181 if (!request_region(IOBASE, 0x20, DRV_NAME)) { 182 free_netdev(dev); 183 return ERR_PTR(-EBUSY); 184 } 185 186 err = apne_probe1(dev, IOBASE); 187 if (err) { 188 release_region(IOBASE, 0x20); 189 free_netdev(dev); 190 return ERR_PTR(err); 191 } 192 err = register_netdev(dev); 193 if (!err) 194 return dev; 195 196 pcmcia_disable_irq(); 197 free_irq(IRQ_AMIGA_PORTS, dev); 198 pcmcia_reset(); 199 release_region(IOBASE, 0x20); 200 free_netdev(dev); 201 return ERR_PTR(err); 202 } 203 204 static int __init apne_probe1(struct net_device *dev, int ioaddr) 205 { 206 int i; 207 unsigned char SA_prom[32]; 208 int wordlength = 2; 209 const char *name = NULL; 210 int start_page, stop_page; 211 #ifndef MANUAL_HWADDR0 212 int neX000, ctron; 213 #endif 214 static unsigned version_printed; 215 216 if ((apne_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0)) 217 netdev_info(dev, version); 218 219 netdev_info(dev, "PCMCIA NE*000 ethercard probe"); 220 221 /* Reset card. Who knows what dain-bramaged state it was left in. */ 222 { unsigned long reset_start_time = jiffies; 223 224 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET); 225 226 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0) 227 if (time_after(jiffies, reset_start_time + 2*HZ/100)) { 228 pr_cont(" not found (no reset ack).\n"); 229 return -ENODEV; 230 } 231 232 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */ 233 } 234 235 #ifndef MANUAL_HWADDR0 236 237 /* Read the 16 bytes of station address PROM. 238 We must first initialize registers, similar to NS8390_init(eifdev, 0). 239 We can't reliably read the SAPROM address without this. 240 (I learned the hard way!). */ 241 { 242 struct {unsigned long value, offset; } program_seq[] = { 243 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/ 244 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */ 245 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */ 246 {0x00, NE_EN0_RCNTHI}, 247 {0x00, NE_EN0_IMR}, /* Mask completion irq. */ 248 {0xFF, NE_EN0_ISR}, 249 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */ 250 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */ 251 {32, NE_EN0_RCNTLO}, 252 {0x00, NE_EN0_RCNTHI}, 253 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */ 254 {0x00, NE_EN0_RSARHI}, 255 {E8390_RREAD+E8390_START, NE_CMD}, 256 }; 257 for (i = 0; i < ARRAY_SIZE(program_seq); i++) { 258 outb(program_seq[i].value, ioaddr + program_seq[i].offset); 259 } 260 261 } 262 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) { 263 SA_prom[i] = inb(ioaddr + NE_DATAPORT); 264 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT); 265 if (SA_prom[i] != SA_prom[i+1]) 266 wordlength = 1; 267 } 268 269 /* At this point, wordlength *only* tells us if the SA_prom is doubled 270 up or not because some broken PCI cards don't respect the byte-wide 271 request in program_seq above, and hence don't have doubled up values. 272 These broken cards would otherwise be detected as an ne1000. */ 273 274 if (wordlength == 2) 275 for (i = 0; i < 16; i++) 276 SA_prom[i] = SA_prom[i+i]; 277 278 if (wordlength == 2) { 279 /* We must set the 8390 for word mode. */ 280 outb(0x49, ioaddr + NE_EN0_DCFG); 281 start_page = NESM_START_PG; 282 stop_page = NESM_STOP_PG; 283 } else { 284 start_page = NE1SM_START_PG; 285 stop_page = NE1SM_STOP_PG; 286 } 287 288 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57); 289 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d); 290 291 /* Set up the rest of the parameters. */ 292 if (neX000) { 293 name = (wordlength == 2) ? "NE2000" : "NE1000"; 294 } else if (ctron) { 295 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16"; 296 start_page = 0x01; 297 stop_page = (wordlength == 2) ? 0x40 : 0x20; 298 } else { 299 pr_cont(" not found.\n"); 300 return -ENXIO; 301 302 } 303 304 #else 305 wordlength = 2; 306 /* We must set the 8390 for word mode. */ 307 outb(0x49, ioaddr + NE_EN0_DCFG); 308 start_page = NESM_START_PG; 309 stop_page = NESM_STOP_PG; 310 311 SA_prom[0] = MANUAL_HWADDR0; 312 SA_prom[1] = MANUAL_HWADDR1; 313 SA_prom[2] = MANUAL_HWADDR2; 314 SA_prom[3] = MANUAL_HWADDR3; 315 SA_prom[4] = MANUAL_HWADDR4; 316 SA_prom[5] = MANUAL_HWADDR5; 317 name = "NE2000"; 318 #endif 319 320 dev->base_addr = ioaddr; 321 dev->irq = IRQ_AMIGA_PORTS; 322 dev->netdev_ops = &ei_netdev_ops; 323 324 /* Install the Interrupt handler */ 325 i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev); 326 if (i) return i; 327 328 for (i = 0; i < ETH_ALEN; i++) 329 dev->dev_addr[i] = SA_prom[i]; 330 331 pr_cont(" %pM\n", dev->dev_addr); 332 333 netdev_info(dev, "%s found.\n", name); 334 335 ei_status.name = name; 336 ei_status.tx_start_page = start_page; 337 ei_status.stop_page = stop_page; 338 ei_status.word16 = (wordlength == 2); 339 340 ei_status.rx_start_page = start_page + TX_PAGES; 341 342 ei_status.reset_8390 = &apne_reset_8390; 343 ei_status.block_input = &apne_block_input; 344 ei_status.block_output = &apne_block_output; 345 ei_status.get_8390_hdr = &apne_get_8390_hdr; 346 347 NS8390_init(dev, 0); 348 349 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */ 350 pcmcia_enable_irq(); 351 352 apne_owned = 1; 353 354 return 0; 355 } 356 357 /* Hard reset the card. This used to pause for the same period that a 358 8390 reset command required, but that shouldn't be necessary. */ 359 static void 360 apne_reset_8390(struct net_device *dev) 361 { 362 unsigned long reset_start_time = jiffies; 363 struct ei_device *ei_local = netdev_priv(dev); 364 365 init_pcmcia(); 366 367 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n", jiffies); 368 369 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET); 370 371 ei_status.txing = 0; 372 ei_status.dmaing = 0; 373 374 /* This check _should_not_ be necessary, omit eventually. */ 375 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0) 376 if (time_after(jiffies, reset_start_time + 2*HZ/100)) { 377 netdev_err(dev, "ne_reset_8390() did not complete.\n"); 378 break; 379 } 380 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */ 381 } 382 383 /* Grab the 8390 specific header. Similar to the block_input routine, but 384 we don't need to be concerned with ring wrap as the header will be at 385 the start of a page, so we optimize accordingly. */ 386 387 static void 388 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) 389 { 390 391 int nic_base = dev->base_addr; 392 int cnt; 393 char *ptrc; 394 short *ptrs; 395 396 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 397 if (ei_status.dmaing) { 398 netdev_err(dev, "DMAing conflict in ne_get_8390_hdr " 399 "[DMAstat:%d][irqlock:%d][intr:%d].\n", 400 ei_status.dmaing, ei_status.irqlock, dev->irq); 401 return; 402 } 403 404 ei_status.dmaing |= 0x01; 405 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); 406 outb(ENISR_RDC, nic_base + NE_EN0_ISR); 407 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO); 408 outb(0, nic_base + NE_EN0_RCNTHI); 409 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */ 410 outb(ring_page, nic_base + NE_EN0_RSARHI); 411 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD); 412 413 if (ei_status.word16) { 414 ptrs = (short*)hdr; 415 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++) 416 *ptrs++ = inw(NE_BASE + NE_DATAPORT); 417 } else { 418 ptrc = (char*)hdr; 419 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++) 420 *ptrc++ = inb(NE_BASE + NE_DATAPORT); 421 } 422 423 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */ 424 ei_status.dmaing &= ~0x01; 425 426 le16_to_cpus(&hdr->count); 427 } 428 429 /* Block input and output, similar to the Crynwr packet driver. If you 430 are porting to a new ethercard, look at the packet driver source for hints. 431 The NEx000 doesn't share the on-board packet memory -- you have to put 432 the packet out through the "remote DMA" dataport using outb. */ 433 434 static void 435 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset) 436 { 437 int nic_base = dev->base_addr; 438 char *buf = skb->data; 439 char *ptrc; 440 short *ptrs; 441 int cnt; 442 443 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 444 if (ei_status.dmaing) { 445 netdev_err(dev, "DMAing conflict in ne_block_input " 446 "[DMAstat:%d][irqlock:%d][intr:%d].\n", 447 ei_status.dmaing, ei_status.irqlock, dev->irq); 448 return; 449 } 450 ei_status.dmaing |= 0x01; 451 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD); 452 outb(ENISR_RDC, nic_base + NE_EN0_ISR); 453 outb(count & 0xff, nic_base + NE_EN0_RCNTLO); 454 outb(count >> 8, nic_base + NE_EN0_RCNTHI); 455 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO); 456 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI); 457 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD); 458 if (ei_status.word16) { 459 ptrs = (short*)buf; 460 for (cnt = 0; cnt < (count>>1); cnt++) 461 *ptrs++ = inw(NE_BASE + NE_DATAPORT); 462 if (count & 0x01) { 463 buf[count-1] = inb(NE_BASE + NE_DATAPORT); 464 } 465 } else { 466 ptrc = buf; 467 for (cnt = 0; cnt < count; cnt++) 468 *ptrc++ = inb(NE_BASE + NE_DATAPORT); 469 } 470 471 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */ 472 ei_status.dmaing &= ~0x01; 473 } 474 475 static void 476 apne_block_output(struct net_device *dev, int count, 477 const unsigned char *buf, const int start_page) 478 { 479 int nic_base = NE_BASE; 480 unsigned long dma_start; 481 char *ptrc; 482 short *ptrs; 483 int cnt; 484 485 /* Round the count up for word writes. Do we need to do this? 486 What effect will an odd byte count have on the 8390? 487 I should check someday. */ 488 if (ei_status.word16 && (count & 0x01)) 489 count++; 490 491 /* This *shouldn't* happen. If it does, it's the last thing you'll see */ 492 if (ei_status.dmaing) { 493 netdev_err(dev, "DMAing conflict in ne_block_output." 494 "[DMAstat:%d][irqlock:%d][intr:%d]\n", 495 ei_status.dmaing, ei_status.irqlock, dev->irq); 496 return; 497 } 498 ei_status.dmaing |= 0x01; 499 /* We should already be in page 0, but to be safe... */ 500 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD); 501 502 outb(ENISR_RDC, nic_base + NE_EN0_ISR); 503 504 /* Now the normal output. */ 505 outb(count & 0xff, nic_base + NE_EN0_RCNTLO); 506 outb(count >> 8, nic_base + NE_EN0_RCNTHI); 507 outb(0x00, nic_base + NE_EN0_RSARLO); 508 outb(start_page, nic_base + NE_EN0_RSARHI); 509 510 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD); 511 if (ei_status.word16) { 512 ptrs = (short*)buf; 513 for (cnt = 0; cnt < count>>1; cnt++) 514 outw(*ptrs++, NE_BASE+NE_DATAPORT); 515 } else { 516 ptrc = (char*)buf; 517 for (cnt = 0; cnt < count; cnt++) 518 outb(*ptrc++, NE_BASE + NE_DATAPORT); 519 } 520 521 dma_start = jiffies; 522 523 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0) 524 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */ 525 netdev_warn(dev, "timeout waiting for Tx RDC.\n"); 526 apne_reset_8390(dev); 527 NS8390_init(dev,1); 528 break; 529 } 530 531 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */ 532 ei_status.dmaing &= ~0x01; 533 } 534 535 static irqreturn_t apne_interrupt(int irq, void *dev_id) 536 { 537 unsigned char pcmcia_intreq; 538 539 if (!(gayle.inten & GAYLE_IRQ_IRQ)) 540 return IRQ_NONE; 541 542 pcmcia_intreq = pcmcia_get_intreq(); 543 544 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) { 545 pcmcia_ack_int(pcmcia_intreq); 546 return IRQ_NONE; 547 } 548 if (apne_msg_enable & NETIF_MSG_INTR) 549 pr_debug("pcmcia intreq = %x\n", pcmcia_intreq); 550 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */ 551 ei_interrupt(irq, dev_id); 552 pcmcia_ack_int(pcmcia_get_intreq()); 553 pcmcia_enable_irq(); 554 return IRQ_HANDLED; 555 } 556 557 #ifdef MODULE 558 static struct net_device *apne_dev; 559 560 static int __init apne_module_init(void) 561 { 562 apne_dev = apne_probe(-1); 563 return PTR_ERR_OR_ZERO(apne_dev); 564 } 565 566 static void __exit apne_module_exit(void) 567 { 568 unregister_netdev(apne_dev); 569 570 pcmcia_disable_irq(); 571 572 free_irq(IRQ_AMIGA_PORTS, apne_dev); 573 574 pcmcia_reset(); 575 576 release_region(IOBASE, 0x20); 577 578 free_netdev(apne_dev); 579 } 580 module_init(apne_module_init); 581 module_exit(apne_module_exit); 582 #endif 583 584 static int init_pcmcia(void) 585 { 586 u_char config; 587 #ifndef MANUAL_CONFIG 588 u_char tuple[32]; 589 int offset_len; 590 #endif 591 u_long offset; 592 593 pcmcia_reset(); 594 pcmcia_program_voltage(PCMCIA_0V); 595 pcmcia_access_speed(PCMCIA_SPEED_250NS); 596 pcmcia_write_enable(); 597 598 #ifdef MANUAL_CONFIG 599 config = MANUAL_CONFIG; 600 #else 601 /* get and write config byte to enable IO port */ 602 603 if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3) 604 return 0; 605 606 config = tuple[2] & 0x3f; 607 #endif 608 #ifdef MANUAL_OFFSET 609 offset = MANUAL_OFFSET; 610 #else 611 if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6) 612 return 0; 613 614 offset_len = (tuple[2] & 0x3) + 1; 615 offset = 0; 616 while(offset_len--) { 617 offset = (offset << 8) | tuple[4+offset_len]; 618 } 619 #endif 620 621 out_8(GAYLE_ATTRIBUTE+offset, config); 622 623 return 1; 624 } 625 626 MODULE_LICENSE("GPL"); 627