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