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