1static const char version[] = 2 "de600.c: $Revision: 1.1.1.1 $, Bjorn Ekwall (bj0rn@blox.se)\n"; 3/* 4 * de600.c 5 * 6 * Linux driver for the D-Link DE-600 Ethernet pocket adapter. 7 * 8 * Portions (C) Copyright 1993, 1994 by Bjorn Ekwall 9 * The Author may be reached as bj0rn@blox.se 10 * 11 * Based on adapter information gathered from DE600.ASM by D-Link Inc., 12 * as included on disk C in the v.2.11 of PC/TCP from FTP Software. 13 * For DE600.asm: 14 * Portions (C) Copyright 1990 D-Link, Inc. 15 * Copyright, 1988-1992, Russell Nelson, Crynwr Software 16 * 17 * Adapted to the sample network driver core for linux, 18 * written by: Donald Becker <becker@super.org> 19 * (Now at <becker@scyld.com>) 20 * 21 * compile-command: 22 * "gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer \ 23 * -m486 -c de600.c 24 * 25 **************************************************************/ 26/* 27 * This program is free software; you can redistribute it and/or modify 28 * it under the terms of the GNU General Public License as published by 29 * the Free Software Foundation; either version 2, or (at your option) 30 * any later version. 31 * 32 * This program is distributed in the hope that it will be useful, 33 * but WITHOUT ANY WARRANTY; without even the implied warranty of 34 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 35 * GNU General Public License for more details. 36 * 37 * You should have received a copy of the GNU General Public License 38 * along with this program; if not, write to the Free Software 39 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 40 * 41 **************************************************************/ 42/* Add more time here if your adapter won't work OK: */ 43#define DE600_SLOW_DOWN udelay(delay_time) 44 45 /* 46 * If you still have trouble reading/writing to the adapter, 47 * modify the following "#define": (see <asm/io.h> for more info) 48#define REALLY_SLOW_IO 49 */ 50#define SLOW_IO_BY_JUMPING /* Looks "better" than dummy write to port 0x80 :-) */ 51 52/* 53 * If you want to enable automatic continuous checking for the DE600, 54 * keep this #define enabled. 55 * It doesn't cost much per packet, so I think it is worth it! 56 * If you disagree, comment away the #define, and live with it... 57 * 58 */ 59#define CHECK_LOST_DE600 60 61/* 62 * Enable this #define if you want the adapter to do a "ifconfig down" on 63 * itself when we have detected that something is possibly wrong with it. 64 * The default behaviour is to retry with "adapter_init()" until success. 65 * This should be used for debugging purposes only. 66 * (Depends on the CHECK_LOST_DE600 above) 67 * 68 */ 69#define SHUTDOWN_WHEN_LOST 70 71/* 72 * See comment at "de600_rspace()"! 73 * This is an *ugly* hack, but for now it achieves its goal of 74 * faking a TCP flow-control that will not flood the poor DE600. 75 * 76 * Tricks TCP to announce a small max window (max 2 fast packets please :-) 77 * 78 * Comment away at your own risk! 79 * 80 * Update: Use the more general per-device maxwindow parameter instead. 81 */ 82#undef FAKE_SMALL_MAX 83 84/* use 0 for production, 1 for verification, >2 for debug */ 85#ifdef DE600_DEBUG 86#define PRINTK(x) if (de600_debug >= 2) printk x 87#else 88#define DE600_DEBUG 0 89#define PRINTK(x) /**/ 90#endif 91 92#include <linux/module.h> 93 94#include <linux/kernel.h> 95#include <linux/sched.h> 96#include <linux/types.h> 97#include <linux/fcntl.h> 98#include <linux/string.h> 99#include <linux/interrupt.h> 100#include <linux/ioport.h> 101#include <asm/io.h> 102#include <linux/in.h> 103#include <linux/ptrace.h> 104#include <asm/system.h> 105#include <linux/errno.h> 106#include <linux/init.h> 107#include <linux/delay.h> 108 109#include <linux/inet.h> 110#include <linux/netdevice.h> 111#include <linux/etherdevice.h> 112#include <linux/skbuff.h> 113 114static unsigned int de600_debug = DE600_DEBUG; 115MODULE_PARM(de600_debug, "i"); 116MODULE_PARM_DESC(de600_debug, "DE-600 debug level (0-2)"); 117 118static unsigned int delay_time = 10; 119MODULE_PARM(delay_time, "i"); 120MODULE_PARM_DESC(delay_time, "DE-600 deley on I/O in microseconds"); 121 122#ifdef FAKE_SMALL_MAX 123static unsigned long de600_rspace(struct sock *sk); 124#include <net/sock.h> 125#endif 126 127typedef unsigned char byte; 128 129/************************************************** 130 * * 131 * Definition of D-Link Ethernet Pocket adapter * 132 * * 133 **************************************************/ 134/* 135 * D-Link Ethernet pocket adapter ports 136 */ 137/* 138 * OK, so I'm cheating, but there are an awful lot of 139 * reads and writes in order to get anything in and out 140 * of the DE-600 with 4 bits at a time in the parallel port, 141 * so every saved instruction really helps :-) 142 * 143 * That is, I don't care what the device struct says 144 * but hope that Space.c will keep the rest of the drivers happy. 145 */ 146#ifndef DE600_IO 147#define DE600_IO 0x378 148#endif 149 150#define DATA_PORT (DE600_IO) 151#define STATUS_PORT (DE600_IO + 1) 152#define COMMAND_PORT (DE600_IO + 2) 153 154#ifndef DE600_IRQ 155#define DE600_IRQ 7 156#endif 157/* 158 * It really should look like this, and autoprobing as well... 159 * 160#define DATA_PORT (dev->base_addr + 0) 161#define STATUS_PORT (dev->base_addr + 1) 162#define COMMAND_PORT (dev->base_addr + 2) 163#define DE600_IRQ dev->irq 164 */ 165 166/* 167 * D-Link COMMAND_PORT commands 168 */ 169#define SELECT_NIC 0x04 /* select Network Interface Card */ 170#define SELECT_PRN 0x1c /* select Printer */ 171#define NML_PRN 0xec /* normal Printer situation */ 172#define IRQEN 0x10 /* enable IRQ line */ 173 174/* 175 * D-Link STATUS_PORT 176 */ 177#define RX_BUSY 0x80 178#define RX_GOOD 0x40 179#define TX_FAILED16 0x10 180#define TX_BUSY 0x08 181 182/* 183 * D-Link DATA_PORT commands 184 * command in low 4 bits 185 * data in high 4 bits 186 * select current data nibble with HI_NIBBLE bit 187 */ 188#define WRITE_DATA 0x00 /* write memory */ 189#define READ_DATA 0x01 /* read memory */ 190#define STATUS 0x02 /* read status register */ 191#define COMMAND 0x03 /* write command register (see COMMAND below) */ 192#define NULL_COMMAND 0x04 /* null command */ 193#define RX_LEN 0x05 /* read received packet length */ 194#define TX_ADDR 0x06 /* set adapter transmit memory address */ 195#define RW_ADDR 0x07 /* set adapter read/write memory address */ 196#define HI_NIBBLE 0x08 /* read/write the high nibble of data, 197 or-ed with rest of command */ 198 199/* 200 * command register, accessed through DATA_PORT with low bits = COMMAND 201 */ 202#define RX_ALL 0x01 /* PROMISCUOUS */ 203#define RX_BP 0x02 /* default: BROADCAST & PHYSICAL ADDRESS */ 204#define RX_MBP 0x03 /* MULTICAST, BROADCAST & PHYSICAL ADDRESS */ 205 206#define TX_ENABLE 0x04 /* bit 2 */ 207#define RX_ENABLE 0x08 /* bit 3 */ 208 209#define RESET 0x80 /* set bit 7 high */ 210#define STOP_RESET 0x00 /* set bit 7 low */ 211 212/* 213 * data to command register 214 * (high 4 bits in write to DATA_PORT) 215 */ 216#define RX_PAGE2_SELECT 0x10 /* bit 4, only 2 pages to select */ 217#define RX_BASE_PAGE 0x20 /* bit 5, always set when specifying RX_ADDR */ 218#define FLIP_IRQ 0x40 /* bit 6 */ 219 220/* 221 * D-Link adapter internal memory: 222 * 223 * 0-2K 1:st transmit page (send from pointer up to 2K) 224 * 2-4K 2:nd transmit page (send from pointer up to 4K) 225 * 226 * 4-6K 1:st receive page (data from 4K upwards) 227 * 6-8K 2:nd receive page (data from 6K upwards) 228 * 229 * 8K+ Adapter ROM (contains magic code and last 3 bytes of Ethernet address) 230 */ 231#define MEM_2K 0x0800 /* 2048 */ 232#define MEM_4K 0x1000 /* 4096 */ 233#define MEM_6K 0x1800 /* 6144 */ 234#define NODE_ADDRESS 0x2000 /* 8192 */ 235 236#define RUNT 60 /* Too small Ethernet packet */ 237 238/************************************************** 239 * * 240 * End of definition * 241 * * 242 **************************************************/ 243 244/* 245 * Index to functions, as function prototypes. 246 */ 247/* Routines used internally. (See "convenience macros") */ 248static byte de600_read_status(struct net_device *dev); 249static byte de600_read_byte(unsigned char type, struct net_device *dev); 250 251/* Put in the device structure. */ 252static int de600_open(struct net_device *dev); 253static int de600_close(struct net_device *dev); 254static struct net_device_stats *get_stats(struct net_device *dev); 255static int de600_start_xmit(struct sk_buff *skb, struct net_device *dev); 256 257/* Dispatch from interrupts. */ 258static void de600_interrupt(int irq, void *dev_id, struct pt_regs *regs); 259static int de600_tx_intr(struct net_device *dev, int irq_status); 260static void de600_rx_intr(struct net_device *dev); 261 262/* Initialization */ 263static void trigger_interrupt(struct net_device *dev); 264int de600_probe(struct net_device *dev); 265static int adapter_init(struct net_device *dev); 266 267/* 268 * D-Link driver variables: 269 */ 270static volatile int rx_page; 271 272#define TX_PAGES 2 273static volatile int tx_fifo[TX_PAGES]; 274static volatile int tx_fifo_in; 275static volatile int tx_fifo_out; 276static volatile int free_tx_pages = TX_PAGES; 277static int was_down; 278 279/* 280 * Convenience macros/functions for D-Link adapter 281 */ 282 283#define select_prn() outb_p(SELECT_PRN, COMMAND_PORT); DE600_SLOW_DOWN 284#define select_nic() outb_p(SELECT_NIC, COMMAND_PORT); DE600_SLOW_DOWN 285 286/* Thanks for hints from Mark Burton <markb@ordern.demon.co.uk> */ 287#define de600_put_byte(data) ( \ 288 outb_p(((data) << 4) | WRITE_DATA , DATA_PORT), \ 289 outb_p(((data) & 0xf0) | WRITE_DATA | HI_NIBBLE, DATA_PORT)) 290 291/* 292 * The first two outb_p()'s below could perhaps be deleted if there 293 * would be more delay in the last two. Not certain about it yet... 294 */ 295#define de600_put_command(cmd) ( \ 296 outb_p(( rx_page << 4) | COMMAND , DATA_PORT), \ 297 outb_p(( rx_page & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT), \ 298 outb_p(((rx_page | cmd) << 4) | COMMAND , DATA_PORT), \ 299 outb_p(((rx_page | cmd) & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT)) 300 301#define de600_setup_address(addr,type) ( \ 302 outb_p((((addr) << 4) & 0xf0) | type , DATA_PORT), \ 303 outb_p(( (addr) & 0xf0) | type | HI_NIBBLE, DATA_PORT), \ 304 outb_p((((addr) >> 4) & 0xf0) | type , DATA_PORT), \ 305 outb_p((((addr) >> 8) & 0xf0) | type | HI_NIBBLE, DATA_PORT)) 306 307#define rx_page_adr() ((rx_page & RX_PAGE2_SELECT)?(MEM_6K):(MEM_4K)) 308 309/* Flip bit, only 2 pages */ 310#define next_rx_page() (rx_page ^= RX_PAGE2_SELECT) 311 312#define tx_page_adr(a) (((a) + 1) * MEM_2K) 313 314static inline byte 315de600_read_status(struct net_device *dev) 316{ 317 byte status; 318 319 outb_p(STATUS, DATA_PORT); 320 status = inb(STATUS_PORT); 321 outb_p(NULL_COMMAND | HI_NIBBLE, DATA_PORT); 322 323 return status; 324} 325 326static inline byte 327de600_read_byte(unsigned char type, struct net_device *dev) { /* dev used by macros */ 328 byte lo; 329 330 (void)outb_p((type), DATA_PORT); 331 lo = ((unsigned char)inb(STATUS_PORT)) >> 4; 332 (void)outb_p((type) | HI_NIBBLE, DATA_PORT); 333 return ((unsigned char)inb(STATUS_PORT) & (unsigned char)0xf0) | lo; 334} 335 336/* 337 * Open/initialize the board. This is called (in the current kernel) 338 * after booting when 'ifconfig <dev->name> $IP_ADDR' is run (in rc.inet1). 339 * 340 * This routine should set everything up anew at each open, even 341 * registers that "should" only need to be set once at boot, so that 342 * there is a non-reboot way to recover if something goes wrong. 343 */ 344static int 345de600_open(struct net_device *dev) 346{ 347 int ret = request_irq(DE600_IRQ, de600_interrupt, 0, dev->name, dev); 348 if (ret) { 349 printk ("%s: unable to get IRQ %d\n", dev->name, DE600_IRQ); 350 return ret; 351 } 352 353 if (adapter_init(dev)) 354 return -EIO; 355 356 return 0; 357} 358 359/* 360 * The inverse routine to de600_open(). 361 */ 362static int 363de600_close(struct net_device *dev) 364{ 365 select_nic(); 366 rx_page = 0; 367 de600_put_command(RESET); 368 de600_put_command(STOP_RESET); 369 de600_put_command(0); 370 select_prn(); 371 372 if (netif_running(dev)) { /* perhaps not needed? */ 373 free_irq(DE600_IRQ, dev); 374 } 375 return 0; 376} 377 378static struct net_device_stats * 379get_stats(struct net_device *dev) 380{ 381 return (struct net_device_stats *)(dev->priv); 382} 383 384static inline void 385trigger_interrupt(struct net_device *dev) 386{ 387 de600_put_command(FLIP_IRQ); 388 select_prn(); 389 DE600_SLOW_DOWN; 390 select_nic(); 391 de600_put_command(0); 392} 393 394/* 395 * Copy a buffer to the adapter transmit page memory. 396 * Start sending. 397 */ 398static int 399de600_start_xmit(struct sk_buff *skb, struct net_device *dev) 400{ 401 unsigned long flags; 402 int transmit_from; 403 int len; 404 int tickssofar; 405 byte *buffer = skb->data; 406 407 if (free_tx_pages <= 0) { /* Do timeouts, to avoid hangs. */ 408 tickssofar = jiffies - dev->trans_start; 409 410 if (tickssofar < 5) 411 return 1; 412 413 /* else */ 414 printk("%s: transmit timed out (%d), %s?\n", 415 dev->name, 416 tickssofar, 417 "network cable problem" 418 ); 419 /* Restart the adapter. */ 420 if (adapter_init(dev)) { 421 return 1; 422 } 423 } 424 425 /* Start real output */ 426 PRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages)); 427 428 if ((len = skb->len) < RUNT) 429 len = RUNT; 430 431 save_flags(flags); 432 cli(); 433 select_nic(); 434 tx_fifo[tx_fifo_in] = transmit_from = tx_page_adr(tx_fifo_in) - len; 435 tx_fifo_in = (tx_fifo_in + 1) % TX_PAGES; /* Next free tx page */ 436 437#ifdef CHECK_LOST_DE600 438 /* This costs about 40 instructions per packet... */ 439 de600_setup_address(NODE_ADDRESS, RW_ADDR); 440 de600_read_byte(READ_DATA, dev); 441 if (was_down || (de600_read_byte(READ_DATA, dev) != 0xde)) { 442 if (adapter_init(dev)) { 443 restore_flags(flags); 444 return 1; 445 } 446 } 447#endif 448 449 de600_setup_address(transmit_from, RW_ADDR); 450 for ( ; len > 0; --len, ++buffer) 451 de600_put_byte(*buffer); 452 453 if (free_tx_pages-- == TX_PAGES) { /* No transmission going on */ 454 dev->trans_start = jiffies; 455 netif_start_queue(dev); /* allow more packets into adapter */ 456 /* Send page and generate a faked interrupt */ 457 de600_setup_address(transmit_from, TX_ADDR); 458 de600_put_command(TX_ENABLE); 459 } 460 else { 461 if (free_tx_pages) 462 netif_start_queue(dev); 463 else 464 netif_stop_queue(dev); 465 select_prn(); 466 } 467 468 restore_flags(flags); 469 470#ifdef FAKE_SMALL_MAX 471 /* This will "patch" the socket TCP proto at an early moment */ 472 if (skb->sk && (skb->sk->protocol == IPPROTO_TCP) && 473 (skb->sk->prot->rspace != &de600_rspace)) 474 skb->sk->prot->rspace = de600_rspace; /* Ugh! */ 475#endif 476 477 dev_kfree_skb (skb); 478 479 return 0; 480} 481 482/* 483 * The typical workload of the driver: 484 * Handle the network interface interrupts. 485 */ 486static void 487de600_interrupt(int irq, void *dev_id, struct pt_regs * regs) 488{ 489 struct net_device *dev = dev_id; 490 byte irq_status; 491 int retrig = 0; 492 int boguscount = 0; 493 494 /* This might just as well be deleted now, no crummy drivers present :-) */ 495 if ((dev == NULL) || (DE600_IRQ != irq)) { 496 printk("%s: bogus interrupt %d\n", dev?dev->name:"DE-600", irq); 497 return; 498 } 499 500 select_nic(); 501 irq_status = de600_read_status(dev); 502 503 do { 504 PRINTK(("de600_interrupt (%02X)\n", irq_status)); 505 506 if (irq_status & RX_GOOD) 507 de600_rx_intr(dev); 508 else if (!(irq_status & RX_BUSY)) 509 de600_put_command(RX_ENABLE); 510 511 /* Any transmission in progress? */ 512 if (free_tx_pages < TX_PAGES) 513 retrig = de600_tx_intr(dev, irq_status); 514 else 515 retrig = 0; 516 517 irq_status = de600_read_status(dev); 518 } while ( (irq_status & RX_GOOD) || ((++boguscount < 100) && retrig) ); 519 /* 520 * Yeah, it _looks_ like busy waiting, smells like busy waiting 521 * and I know it's not PC, but please, it will only occur once 522 * in a while and then only for a loop or so (< 1ms for sure!) 523 */ 524 525 /* Enable adapter interrupts */ 526 select_prn(); 527 528 if (retrig) 529 trigger_interrupt(dev); 530 531 return; 532} 533 534static int 535de600_tx_intr(struct net_device *dev, int irq_status) 536{ 537 /* 538 * Returns 1 if tx still not done 539 */ 540 541 /* Check if current transmission is done yet */ 542 if (irq_status & TX_BUSY) 543 return 1; /* tx not done, try again */ 544 545 /* else */ 546 /* If last transmission OK then bump fifo index */ 547 if (!(irq_status & TX_FAILED16)) { 548 tx_fifo_out = (tx_fifo_out + 1) % TX_PAGES; 549 ++free_tx_pages; 550 ((struct net_device_stats *)(dev->priv))->tx_packets++; 551 netif_wake_queue(dev); 552 } 553 554 /* More to send, or resend last packet? */ 555 if ((free_tx_pages < TX_PAGES) || (irq_status & TX_FAILED16)) { 556 dev->trans_start = jiffies; 557 de600_setup_address(tx_fifo[tx_fifo_out], TX_ADDR); 558 de600_put_command(TX_ENABLE); 559 return 1; 560 } 561 /* else */ 562 563 return 0; 564} 565 566/* 567 * We have a good packet, get it out of the adapter. 568 */ 569static void 570de600_rx_intr(struct net_device *dev) 571{ 572 struct sk_buff *skb; 573 unsigned long flags; 574 int i; 575 int read_from; 576 int size; 577 register unsigned char *buffer; 578 579 save_flags(flags); 580 cli(); 581 582 /* Get size of received packet */ 583 size = de600_read_byte(RX_LEN, dev); /* low byte */ 584 size += (de600_read_byte(RX_LEN, dev) << 8); /* high byte */ 585 size -= 4; /* Ignore trailing 4 CRC-bytes */ 586 587 /* Tell adapter where to store next incoming packet, enable receiver */ 588 read_from = rx_page_adr(); 589 next_rx_page(); 590 de600_put_command(RX_ENABLE); 591 592 restore_flags(flags); 593 594 if ((size < 32) || (size > 1535)) { 595 printk("%s: Bogus packet size %d.\n", dev->name, size); 596 if (size > 10000) 597 adapter_init(dev); 598 return; 599 } 600 601 skb = dev_alloc_skb(size+2); 602 if (skb == NULL) { 603 printk("%s: Couldn't allocate a sk_buff of size %d.\n", 604 dev->name, size); 605 return; 606 } 607 /* else */ 608 609 skb->dev = dev; 610 skb_reserve(skb,2); /* Align */ 611 612 /* 'skb->data' points to the start of sk_buff data area. */ 613 buffer = skb_put(skb,size); 614 615 /* copy the packet into the buffer */ 616 de600_setup_address(read_from, RW_ADDR); 617 for (i = size; i > 0; --i, ++buffer) 618 *buffer = de600_read_byte(READ_DATA, dev); 619 620 skb->protocol=eth_type_trans(skb,dev); 621 622 netif_rx(skb); 623 624 /* update stats */ 625 dev->last_rx = jiffies; 626 ((struct net_device_stats *)(dev->priv))->rx_packets++; /* count all receives */ 627 ((struct net_device_stats *)(dev->priv))->rx_bytes += size; /* count all received bytes */ 628 629 /* 630 * If any worth-while packets have been received, netif_rx() 631 * has done a mark_bh(INET_BH) for us and will work on them 632 * when we get to the bottom-half routine. 633 */ 634} 635 636int __init 637de600_probe(struct net_device *dev) 638{ 639 int i; 640 static struct net_device_stats de600_netstats; 641 /*dev->priv = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);*/ 642 643 SET_MODULE_OWNER(dev); 644 645 printk("%s: D-Link DE-600 pocket adapter", dev->name); 646 /* Alpha testers must have the version number to report bugs. */ 647 if (de600_debug > 1) 648 printk(version); 649 650 /* probe for adapter */ 651 rx_page = 0; 652 select_nic(); 653 (void)de600_read_status(dev); 654 de600_put_command(RESET); 655 de600_put_command(STOP_RESET); 656 if (de600_read_status(dev) & 0xf0) { 657 printk(": not at I/O %#3x.\n", DATA_PORT); 658 return -ENODEV; 659 } 660 661 /* 662 * Maybe we found one, 663 * have to check if it is a D-Link DE-600 adapter... 664 */ 665 666 /* Get the adapter ethernet address from the ROM */ 667 de600_setup_address(NODE_ADDRESS, RW_ADDR); 668 for (i = 0; i < ETH_ALEN; i++) { 669 dev->dev_addr[i] = de600_read_byte(READ_DATA, dev); 670 dev->broadcast[i] = 0xff; 671 } 672 673 /* Check magic code */ 674 if ((dev->dev_addr[1] == 0xde) && (dev->dev_addr[2] == 0x15)) { 675 /* OK, install real address */ 676 dev->dev_addr[0] = 0x00; 677 dev->dev_addr[1] = 0x80; 678 dev->dev_addr[2] = 0xc8; 679 dev->dev_addr[3] &= 0x0f; 680 dev->dev_addr[3] |= 0x70; 681 } else { 682 printk(" not identified in the printer port\n"); 683 return -ENODEV; 684 } 685 686 request_region(DE600_IO, 3, "de600"); 687 688 printk(", Ethernet Address: %02X", dev->dev_addr[0]); 689 for (i = 1; i < ETH_ALEN; i++) 690 printk(":%02X",dev->dev_addr[i]); 691 printk("\n"); 692 693 /* Initialize the device structure. */ 694 dev->priv = &de600_netstats; 695 696 memset(dev->priv, 0, sizeof(struct net_device_stats)); 697 dev->get_stats = get_stats; 698 699 dev->open = de600_open; 700 dev->stop = de600_close; 701 dev->hard_start_xmit = &de600_start_xmit; 702 703 ether_setup(dev); 704 705 dev->flags&=~IFF_MULTICAST; 706 707 select_prn(); 708 return 0; 709} 710 711static int 712adapter_init(struct net_device *dev) 713{ 714 int i; 715 unsigned long flags; 716 717 save_flags(flags); 718 cli(); 719 720 select_nic(); 721 rx_page = 0; /* used by RESET */ 722 de600_put_command(RESET); 723 de600_put_command(STOP_RESET); 724#ifdef CHECK_LOST_DE600 725 /* Check if it is still there... */ 726 /* Get the some bytes of the adapter ethernet address from the ROM */ 727 de600_setup_address(NODE_ADDRESS, RW_ADDR); 728 de600_read_byte(READ_DATA, dev); 729 if ((de600_read_byte(READ_DATA, dev) != 0xde) || 730 (de600_read_byte(READ_DATA, dev) != 0x15)) { 731 /* was: if (de600_read_status(dev) & 0xf0) { */ 732 printk("Something has happened to the DE-600! Please check it" 733#ifdef SHUTDOWN_WHEN_LOST 734 " and do a new ifconfig" 735#endif /* SHUTDOWN_WHEN_LOST */ 736 "!\n"); 737#ifdef SHUTDOWN_WHEN_LOST 738 /* Goodbye, cruel world... */ 739 dev->flags &= ~IFF_UP; 740 de600_close(dev); 741#endif /* SHUTDOWN_WHEN_LOST */ 742 was_down = 1; 743 netif_stop_queue(dev); /* Transmit busy... */ 744 restore_flags(flags); 745 return 1; /* failed */ 746 } 747#endif /* CHECK_LOST_DE600 */ 748 if (was_down) { 749 printk("Thanks, I feel much better now!\n"); 750 was_down = 0; 751 } 752 753 netif_start_queue(dev); 754 tx_fifo_in = 0; 755 tx_fifo_out = 0; 756 free_tx_pages = TX_PAGES; 757 758 /* set the ether address. */ 759 de600_setup_address(NODE_ADDRESS, RW_ADDR); 760 for (i = 0; i < ETH_ALEN; i++) 761 de600_put_byte(dev->dev_addr[i]); 762 763 /* where to start saving incoming packets */ 764 rx_page = RX_BP | RX_BASE_PAGE; 765 de600_setup_address(MEM_4K, RW_ADDR); 766 /* Enable receiver */ 767 de600_put_command(RX_ENABLE); 768 select_prn(); 769 restore_flags(flags); 770 771 return 0; /* OK */ 772} 773 774#ifdef FAKE_SMALL_MAX 775/* 776 * The new router code (coming soon 8-) ) will fix this properly. 777 */ 778#define DE600_MIN_WINDOW 1024 779#define DE600_MAX_WINDOW 2048 780#define DE600_TCP_WINDOW_DIFF 1024 781/* 782 * Copied from "net/inet/sock.c" 783 * 784 * Sets a lower max receive window in order to achieve <= 2 785 * packets arriving at the adapter in fast succession. 786 * (No way that a DE-600 can keep up with a net saturated 787 * with packets homing in on it :-( ) 788 * 789 * Since there are only 2 receive buffers in the DE-600 790 * and it takes some time to copy from the adapter, 791 * this is absolutely necessary for any TCP performance whatsoever! 792 * 793 * Note that the returned window info will never be smaller than 794 * DE600_MIN_WINDOW, i.e. 1024 795 * This differs from the standard function, that can return an 796 * arbitrarily small window! 797 */ 798static unsigned long 799de600_rspace(struct sock *sk) 800{ 801 int amt; 802 803 if (sk != NULL) { 804/* 805 * Hack! You might want to play with commenting away the following line, 806 * if you know what you do! 807 sk->max_unacked = DE600_MAX_WINDOW - DE600_TCP_WINDOW_DIFF; 808 */ 809 810 if (atomic_read(&sk->rmem_alloc) >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0); 811 amt = min_t(int, (sk->rcvbuf-atomic_read(&sk->rmem_alloc))/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW); 812 if (amt < 0) return(0); 813 return(amt); 814 } 815 return(0); 816} 817#endif 818 819#ifdef MODULE 820static struct net_device de600_dev; 821 822int 823init_module(void) 824{ 825 de600_dev.init = de600_probe; 826 if (register_netdev(&de600_dev) != 0) 827 return -EIO; 828 return 0; 829} 830 831void 832cleanup_module(void) 833{ 834 unregister_netdev(&de600_dev); 835 release_region(DE600_IO, 3); 836} 837#endif /* MODULE */ 838 839MODULE_LICENSE("GPL"); 840 841/* 842 * Local variables: 843 * kernel-compile-command: "gcc -D__KERNEL__ -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de600.c" 844 * module-compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de600.c" 845 * compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de600.c" 846 * End: 847 */ 848