PageRenderTime 104ms CodeModel.GetById 23ms app.highlight 67ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/ethernet/hp/hp100.c

http://github.com/mirrors/linux
C | 3051 lines | 2052 code | 449 blank | 550 comment | 438 complexity | b901a00119206b4fadfbd29636fa37ae MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2** hp100.c
   3** HP CASCADE Architecture Driver for 100VG-AnyLan Network Adapters
   4**
   5** $Id: hp100.c,v 1.58 2001/09/24 18:03:01 perex Exp perex $
   6**
   7** Based on the HP100 driver written by Jaroslav Kysela <perex@jcu.cz>
   8** Extended for new busmaster capable chipsets by
   9** Siegfried "Frieder" Loeffler (dg1sek) <floeff@mathematik.uni-stuttgart.de>
  10**
  11** Maintained by: Jaroslav Kysela <perex@perex.cz>
  12**
  13** This driver has only been tested with
  14** -- HP J2585B 10/100 Mbit/s PCI Busmaster
  15** -- HP J2585A 10/100 Mbit/s PCI
  16** -- HP J2970A 10 Mbit/s PCI Combo 10base-T/BNC
  17** -- HP J2973A 10 Mbit/s PCI 10base-T
  18** -- HP J2573  10/100 ISA
  19** -- Compex ReadyLink ENET100-VG4  10/100 Mbit/s PCI / EISA
  20** -- Compex FreedomLine 100/VG  10/100 Mbit/s ISA / EISA / PCI
  21**
  22** but it should also work with the other CASCADE based adapters.
  23**
  24** TODO:
  25**       -  J2573 seems to hang sometimes when in shared memory mode.
  26**       -  Mode for Priority TX
  27**       -  Check PCI registers, performance might be improved?
  28**       -  To reduce interrupt load in busmaster, one could switch off
  29**          the interrupts that are used to refill the queues whenever the
  30**          queues are filled up to more than a certain threshold.
  31**       -  some updates for EISA version of card
  32**
  33**
  34**   This code is free software; you can redistribute it and/or modify
  35**   it under the terms of the GNU General Public License as published by
  36**   the Free Software Foundation; either version 2 of the License, or
  37**   (at your option) any later version.
  38**
  39**   This code is distributed in the hope that it will be useful,
  40**   but WITHOUT ANY WARRANTY; without even the implied warranty of
  41**   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  42**   GNU General Public License for more details.
  43**
  44**   You should have received a copy of the GNU General Public License
  45**   along with this program; if not, write to the Free Software
  46**   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  47**
  48** 1.57c -> 1.58
  49**   - used indent to change coding-style
  50**   - added KTI DP-200 EISA ID
  51**   - ioremap is also used for low (<1MB) memory (multi-architecture support)
  52**
  53** 1.57b -> 1.57c - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  54**   - release resources on failure in init_module
  55**
  56** 1.57 -> 1.57b - Jean II
  57**   - fix spinlocks, SMP is now working !
  58**
  59** 1.56 -> 1.57
  60**   - updates for new PCI interface for 2.1 kernels
  61**
  62** 1.55 -> 1.56
  63**   - removed printk in misc. interrupt and update statistics to allow
  64**     monitoring of card status
  65**   - timing changes in xmit routines, relogin to 100VG hub added when
  66**     driver does reset
  67**   - included fix for Compex FreedomLine PCI adapter
  68**
  69** 1.54 -> 1.55
  70**   - fixed bad initialization in init_module
  71**   - added Compex FreedomLine adapter
  72**   - some fixes in card initialization
  73**
  74** 1.53 -> 1.54
  75**   - added hardware multicast filter support (doesn't work)
  76**   - little changes in hp100_sense_lan routine
  77**     - added support for Coax and AUI (J2970)
  78**   - fix for multiple cards and hp100_mode parameter (insmod)
  79**   - fix for shared IRQ
  80**
  81** 1.52 -> 1.53
  82**   - fixed bug in multicast support
  83**
  84*/
  85
  86#define HP100_DEFAULT_PRIORITY_TX 0
  87
  88#undef HP100_DEBUG
  89#undef HP100_DEBUG_B		/* Trace  */
  90#undef HP100_DEBUG_BM		/* Debug busmaster code (PDL stuff) */
  91
  92#undef HP100_DEBUG_TRAINING	/* Debug login-to-hub procedure */
  93#undef HP100_DEBUG_TX
  94#undef HP100_DEBUG_IRQ
  95#undef HP100_DEBUG_RX
  96
  97#undef HP100_MULTICAST_FILTER	/* Need to be debugged... */
  98
  99#include <linux/module.h>
 100#include <linux/kernel.h>
 101#include <linux/sched.h>
 102#include <linux/string.h>
 103#include <linux/errno.h>
 104#include <linux/ioport.h>
 105#include <linux/interrupt.h>
 106#include <linux/eisa.h>
 107#include <linux/pci.h>
 108#include <linux/dma-mapping.h>
 109#include <linux/spinlock.h>
 110#include <linux/netdevice.h>
 111#include <linux/etherdevice.h>
 112#include <linux/skbuff.h>
 113#include <linux/types.h>
 114#include <linux/delay.h>
 115#include <linux/init.h>
 116#include <linux/bitops.h>
 117#include <linux/jiffies.h>
 118
 119#include <asm/io.h>
 120
 121#include "hp100.h"
 122
 123/*
 124 *  defines
 125 */
 126
 127#define HP100_BUS_ISA     0
 128#define HP100_BUS_EISA    1
 129#define HP100_BUS_PCI     2
 130
 131#define HP100_REGION_SIZE	0x20	/* for ioports */
 132#define HP100_SIG_LEN		8	/* same as EISA_SIG_LEN */
 133
 134#define HP100_MAX_PACKET_SIZE	(1536+4)
 135#define HP100_MIN_PACKET_SIZE	60
 136
 137#ifndef HP100_DEFAULT_RX_RATIO
 138/* default - 75% onboard memory on the card are used for RX packets */
 139#define HP100_DEFAULT_RX_RATIO	75
 140#endif
 141
 142#ifndef HP100_DEFAULT_PRIORITY_TX
 143/* default - don't enable transmit outgoing packets as priority */
 144#define HP100_DEFAULT_PRIORITY_TX 0
 145#endif
 146
 147/*
 148 *  structures
 149 */
 150
 151struct hp100_private {
 152	spinlock_t lock;
 153	char id[HP100_SIG_LEN];
 154	u_short chip;
 155	u_short soft_model;
 156	u_int memory_size;
 157	u_int virt_memory_size;
 158	u_short rx_ratio;	/* 1 - 99 */
 159	u_short priority_tx;	/* != 0 - priority tx */
 160	u_short mode;		/* PIO, Shared Mem or Busmaster */
 161	u_char bus;
 162	struct pci_dev *pci_dev;
 163	short mem_mapped;	/* memory mapped access */
 164	void __iomem *mem_ptr_virt;	/* virtual memory mapped area, maybe NULL */
 165	unsigned long mem_ptr_phys;	/* physical memory mapped area */
 166	short lan_type;		/* 10Mb/s, 100Mb/s or -1 (error) */
 167	int hub_status;		/* was login to hub successful? */
 168	u_char mac1_mode;
 169	u_char mac2_mode;
 170	u_char hash_bytes[8];
 171
 172	/* Rings for busmaster mode: */
 173	hp100_ring_t *rxrhead;	/* Head (oldest) index into rxring */
 174	hp100_ring_t *rxrtail;	/* Tail (newest) index into rxring */
 175	hp100_ring_t *txrhead;	/* Head (oldest) index into txring */
 176	hp100_ring_t *txrtail;	/* Tail (newest) index into txring */
 177
 178	hp100_ring_t rxring[MAX_RX_PDL];
 179	hp100_ring_t txring[MAX_TX_PDL];
 180
 181	u_int *page_vaddr_algn;	/* Aligned virtual address of allocated page */
 182	u_long whatever_offset;	/* Offset to bus/phys/dma address */
 183	int rxrcommit;		/* # Rx PDLs committed to adapter */
 184	int txrcommit;		/* # Tx PDLs committed to adapter */
 185};
 186
 187/*
 188 *  variables
 189 */
 190#ifdef CONFIG_ISA
 191static const char *hp100_isa_tbl[] = {
 192	"HWPF150", /* HP J2573 rev A */
 193	"HWP1950", /* HP J2573 */
 194};
 195#endif
 196
 197static struct eisa_device_id hp100_eisa_tbl[] = {
 198	{ "HWPF180" }, /* HP J2577 rev A */
 199	{ "HWP1920" }, /* HP 27248B */
 200	{ "HWP1940" }, /* HP J2577 */
 201	{ "HWP1990" }, /* HP J2577 */
 202	{ "CPX0301" }, /* ReadyLink ENET100-VG4 */
 203	{ "CPX0401" }, /* FreedomLine 100/VG */
 204	{ "" }	       /* Mandatory final entry ! */
 205};
 206MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
 207
 208static const struct pci_device_id hp100_pci_tbl[] = {
 209	{PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
 210	{PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
 211	{PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,},
 212	{PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2973A, PCI_ANY_ID, PCI_ANY_ID,},
 213	{PCI_VENDOR_ID_COMPEX, PCI_DEVICE_ID_COMPEX_ENET100VG4, PCI_ANY_ID, PCI_ANY_ID,},
 214	{PCI_VENDOR_ID_COMPEX2, PCI_DEVICE_ID_COMPEX2_100VG, PCI_ANY_ID, PCI_ANY_ID,},
 215/*	{PCI_VENDOR_ID_KTI, PCI_DEVICE_ID_KTI_DP200, PCI_ANY_ID, PCI_ANY_ID }, */
 216	{}			/* Terminating entry */
 217};
 218MODULE_DEVICE_TABLE(pci, hp100_pci_tbl);
 219
 220static int hp100_rx_ratio = HP100_DEFAULT_RX_RATIO;
 221static int hp100_priority_tx = HP100_DEFAULT_PRIORITY_TX;
 222static int hp100_mode = 1;
 223
 224module_param(hp100_rx_ratio, int, 0);
 225module_param(hp100_priority_tx, int, 0);
 226module_param(hp100_mode, int, 0);
 227
 228/*
 229 *  prototypes
 230 */
 231
 232static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
 233			struct pci_dev *pci_dev);
 234
 235
 236static int hp100_open(struct net_device *dev);
 237static int hp100_close(struct net_device *dev);
 238static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
 239				    struct net_device *dev);
 240static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
 241				       struct net_device *dev);
 242static void hp100_rx(struct net_device *dev);
 243static struct net_device_stats *hp100_get_stats(struct net_device *dev);
 244static void hp100_misc_interrupt(struct net_device *dev);
 245static void hp100_update_stats(struct net_device *dev);
 246static void hp100_clear_stats(struct hp100_private *lp, int ioaddr);
 247static void hp100_set_multicast_list(struct net_device *dev);
 248static irqreturn_t hp100_interrupt(int irq, void *dev_id);
 249static void hp100_start_interface(struct net_device *dev);
 250static void hp100_stop_interface(struct net_device *dev);
 251static void hp100_load_eeprom(struct net_device *dev, u_short ioaddr);
 252static int hp100_sense_lan(struct net_device *dev);
 253static int hp100_login_to_vg_hub(struct net_device *dev,
 254				 u_short force_relogin);
 255static int hp100_down_vg_link(struct net_device *dev);
 256static void hp100_cascade_reset(struct net_device *dev, u_short enable);
 257static void hp100_BM_shutdown(struct net_device *dev);
 258static void hp100_mmuinit(struct net_device *dev);
 259static void hp100_init_pdls(struct net_device *dev);
 260static int hp100_init_rxpdl(struct net_device *dev,
 261			    register hp100_ring_t * ringptr,
 262			    register u_int * pdlptr);
 263static int hp100_init_txpdl(struct net_device *dev,
 264			    register hp100_ring_t * ringptr,
 265			    register u_int * pdlptr);
 266static void hp100_rxfill(struct net_device *dev);
 267static void hp100_hwinit(struct net_device *dev);
 268static void hp100_clean_txring(struct net_device *dev);
 269#ifdef HP100_DEBUG
 270static void hp100_RegisterDump(struct net_device *dev);
 271#endif
 272
 273/* Conversion to new PCI API :
 274 * Convert an address in a kernel buffer to a bus/phys/dma address.
 275 * This work *only* for memory fragments part of lp->page_vaddr,
 276 * because it was properly DMA allocated via pci_alloc_consistent(),
 277 * so we just need to "retrieve" the original mapping to bus/phys/dma
 278 * address - Jean II */
 279static inline dma_addr_t virt_to_whatever(struct net_device *dev, u32 * ptr)
 280{
 281	struct hp100_private *lp = netdev_priv(dev);
 282	return ((u_long) ptr) + lp->whatever_offset;
 283}
 284
 285static inline u_int pdl_map_data(struct hp100_private *lp, void *data)
 286{
 287	return pci_map_single(lp->pci_dev, data,
 288			      MAX_ETHER_SIZE, PCI_DMA_FROMDEVICE);
 289}
 290
 291/* TODO: This function should not really be needed in a good design... */
 292static void wait(void)
 293{
 294	mdelay(1);
 295}
 296
 297/*
 298 *  probe functions
 299 *  These functions should - if possible - avoid doing write operations
 300 *  since this could cause problems when the card is not installed.
 301 */
 302
 303/*
 304 * Read board id and convert to string.
 305 * Effectively same code as decode_eisa_sig
 306 */
 307static const char *hp100_read_id(int ioaddr)
 308{
 309	int i;
 310	static char str[HP100_SIG_LEN];
 311	unsigned char sig[4], sum;
 312        unsigned short rev;
 313
 314	hp100_page(ID_MAC_ADDR);
 315	sum = 0;
 316	for (i = 0; i < 4; i++) {
 317		sig[i] = hp100_inb(BOARD_ID + i);
 318		sum += sig[i];
 319	}
 320
 321	sum += hp100_inb(BOARD_ID + i);
 322	if (sum != 0xff)
 323		return NULL;	/* bad checksum */
 324
 325        str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
 326        str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
 327        str[2] = (sig[1] & 0x1f) + ('A' - 1);
 328        rev = (sig[2] << 8) | sig[3];
 329        sprintf(str + 3, "%04X", rev);
 330
 331	return str;
 332}
 333
 334#ifdef CONFIG_ISA
 335static __init int hp100_isa_probe1(struct net_device *dev, int ioaddr)
 336{
 337	const char *sig;
 338	int i;
 339
 340	if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
 341		goto err;
 342
 343	if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE) {
 344		release_region(ioaddr, HP100_REGION_SIZE);
 345		goto err;
 346	}
 347
 348	sig = hp100_read_id(ioaddr);
 349	release_region(ioaddr, HP100_REGION_SIZE);
 350
 351	if (sig == NULL)
 352		goto err;
 353
 354	for (i = 0; i < ARRAY_SIZE(hp100_isa_tbl); i++) {
 355		if (!strcmp(hp100_isa_tbl[i], sig))
 356			break;
 357
 358	}
 359
 360	if (i < ARRAY_SIZE(hp100_isa_tbl))
 361		return hp100_probe1(dev, ioaddr, HP100_BUS_ISA, NULL);
 362 err:
 363	return -ENODEV;
 364
 365}
 366/*
 367 * Probe for ISA board.
 368 * EISA and PCI are handled by device infrastructure.
 369 */
 370
 371static int  __init hp100_isa_probe(struct net_device *dev, int addr)
 372{
 373	int err = -ENODEV;
 374
 375	/* Probe for a specific ISA address */
 376	if (addr > 0xff && addr < 0x400)
 377		err = hp100_isa_probe1(dev, addr);
 378
 379	else if (addr != 0)
 380		err = -ENXIO;
 381
 382	else {
 383		/* Probe all ISA possible port regions */
 384		for (addr = 0x100; addr < 0x400; addr += 0x20) {
 385			err = hp100_isa_probe1(dev, addr);
 386			if (!err)
 387				break;
 388		}
 389	}
 390	return err;
 391}
 392#endif /* CONFIG_ISA */
 393
 394#if !defined(MODULE) && defined(CONFIG_ISA)
 395struct net_device * __init hp100_probe(int unit)
 396{
 397	struct net_device *dev = alloc_etherdev(sizeof(struct hp100_private));
 398	int err;
 399
 400	if (!dev)
 401		return ERR_PTR(-ENODEV);
 402
 403#ifdef HP100_DEBUG_B
 404	hp100_outw(0x4200, TRACE);
 405	printk("hp100: %s: probe\n", dev->name);
 406#endif
 407
 408	if (unit >= 0) {
 409		sprintf(dev->name, "eth%d", unit);
 410		netdev_boot_setup_check(dev);
 411	}
 412
 413	err = hp100_isa_probe(dev, dev->base_addr);
 414	if (err)
 415		goto out;
 416
 417	return dev;
 418 out:
 419	free_netdev(dev);
 420	return ERR_PTR(err);
 421}
 422#endif /* !MODULE && CONFIG_ISA */
 423
 424static const struct net_device_ops hp100_bm_netdev_ops = {
 425	.ndo_open		= hp100_open,
 426	.ndo_stop		= hp100_close,
 427	.ndo_start_xmit		= hp100_start_xmit_bm,
 428	.ndo_get_stats 		= hp100_get_stats,
 429	.ndo_set_rx_mode	= hp100_set_multicast_list,
 430	.ndo_change_mtu		= eth_change_mtu,
 431	.ndo_set_mac_address 	= eth_mac_addr,
 432	.ndo_validate_addr	= eth_validate_addr,
 433};
 434
 435static const struct net_device_ops hp100_netdev_ops = {
 436	.ndo_open		= hp100_open,
 437	.ndo_stop		= hp100_close,
 438	.ndo_start_xmit		= hp100_start_xmit,
 439	.ndo_get_stats 		= hp100_get_stats,
 440	.ndo_set_rx_mode	= hp100_set_multicast_list,
 441	.ndo_change_mtu		= eth_change_mtu,
 442	.ndo_set_mac_address 	= eth_mac_addr,
 443	.ndo_validate_addr	= eth_validate_addr,
 444};
 445
 446static int hp100_probe1(struct net_device *dev, int ioaddr, u_char bus,
 447			struct pci_dev *pci_dev)
 448{
 449	int i;
 450	int err = -ENODEV;
 451	const char *eid;
 452	u_int chip;
 453	u_char uc;
 454	u_int memory_size = 0, virt_memory_size = 0;
 455	u_short local_mode, lsw;
 456	short mem_mapped;
 457	unsigned long mem_ptr_phys;
 458	void __iomem *mem_ptr_virt;
 459	struct hp100_private *lp;
 460
 461#ifdef HP100_DEBUG_B
 462	hp100_outw(0x4201, TRACE);
 463	printk("hp100: %s: probe1\n", dev->name);
 464#endif
 465
 466	/* memory region for programmed i/o */
 467	if (!request_region(ioaddr, HP100_REGION_SIZE, "hp100"))
 468		goto out1;
 469
 470	if (hp100_inw(HW_ID) != HP100_HW_ID_CASCADE)
 471		goto out2;
 472
 473	chip = hp100_inw(PAGING) & HP100_CHIPID_MASK;
 474#ifdef HP100_DEBUG
 475	if (chip == HP100_CHIPID_SHASTA)
 476		printk("hp100: %s: Shasta Chip detected. (This is a pre 802.12 chip)\n", dev->name);
 477	else if (chip == HP100_CHIPID_RAINIER)
 478		printk("hp100: %s: Rainier Chip detected. (This is a pre 802.12 chip)\n", dev->name);
 479	else if (chip == HP100_CHIPID_LASSEN)
 480		printk("hp100: %s: Lassen Chip detected.\n", dev->name);
 481	else
 482		printk("hp100: %s: Warning: Unknown CASCADE chip (id=0x%.4x).\n", dev->name, chip);
 483#endif
 484
 485	dev->base_addr = ioaddr;
 486
 487	eid = hp100_read_id(ioaddr);
 488	if (eid == NULL) {	/* bad checksum? */
 489		printk(KERN_WARNING "%s: bad ID checksum at base port 0x%x\n",
 490		       __func__, ioaddr);
 491		goto out2;
 492	}
 493
 494	hp100_page(ID_MAC_ADDR);
 495	for (i = uc = 0; i < 7; i++)
 496		uc += hp100_inb(LAN_ADDR + i);
 497	if (uc != 0xff) {
 498		printk(KERN_WARNING
 499		       "%s: bad lan address checksum at port 0x%x)\n",
 500		       __func__, ioaddr);
 501		err = -EIO;
 502		goto out2;
 503	}
 504
 505	/* Make sure, that all registers are correctly updated... */
 506
 507	hp100_load_eeprom(dev, ioaddr);
 508	wait();
 509
 510	/*
 511	 * Determine driver operation mode
 512	 *
 513	 * Use the variable "hp100_mode" upon insmod or as kernel parameter to
 514	 * force driver modes:
 515	 * hp100_mode=1 -> default, use busmaster mode if configured.
 516	 * hp100_mode=2 -> enable shared memory mode
 517	 * hp100_mode=3 -> force use of i/o mapped mode.
 518	 * hp100_mode=4 -> same as 1, but re-set the enable bit on the card.
 519	 */
 520
 521	/*
 522	 * LSW values:
 523	 *   0x2278 -> J2585B, PnP shared memory mode
 524	 *   0x2270 -> J2585B, shared memory mode, 0xdc000
 525	 *   0xa23c -> J2585B, I/O mapped mode
 526	 *   0x2240 -> EISA COMPEX, BusMaster (Shasta Chip)
 527	 *   0x2220 -> EISA HP, I/O (Shasta Chip)
 528	 *   0x2260 -> EISA HP, BusMaster (Shasta Chip)
 529	 */
 530
 531#if 0
 532	local_mode = 0x2270;
 533	hp100_outw(0xfefe, OPTION_LSW);
 534	hp100_outw(local_mode | HP100_SET_LB | HP100_SET_HB, OPTION_LSW);
 535#endif
 536
 537	/* hp100_mode value maybe used in future by another card */
 538	local_mode = hp100_mode;
 539	if (local_mode < 1 || local_mode > 4)
 540		local_mode = 1;	/* default */
 541#ifdef HP100_DEBUG
 542	printk("hp100: %s: original LSW = 0x%x\n", dev->name,
 543	       hp100_inw(OPTION_LSW));
 544#endif
 545
 546	if (local_mode == 3) {
 547		hp100_outw(HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
 548		hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
 549		hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
 550		printk("hp100: IO mapped mode forced.\n");
 551	} else if (local_mode == 2) {
 552		hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
 553		hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
 554		hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
 555		printk("hp100: Shared memory mode requested.\n");
 556	} else if (local_mode == 4) {
 557		if (chip == HP100_CHIPID_LASSEN) {
 558			hp100_outw(HP100_BM_WRITE | HP100_BM_READ | HP100_SET_HB, OPTION_LSW);
 559			hp100_outw(HP100_IO_EN | HP100_MEM_EN | HP100_RESET_LB, OPTION_LSW);
 560			printk("hp100: Busmaster mode requested.\n");
 561		}
 562		local_mode = 1;
 563	}
 564
 565	if (local_mode == 1) {	/* default behaviour */
 566		lsw = hp100_inw(OPTION_LSW);
 567
 568		if ((lsw & HP100_IO_EN) && (~lsw & HP100_MEM_EN) &&
 569		    (~lsw & (HP100_BM_WRITE | HP100_BM_READ))) {
 570#ifdef HP100_DEBUG
 571			printk("hp100: %s: IO_EN bit is set on card.\n", dev->name);
 572#endif
 573			local_mode = 3;
 574		} else if (chip == HP100_CHIPID_LASSEN &&
 575			   (lsw & (HP100_BM_WRITE | HP100_BM_READ)) == (HP100_BM_WRITE | HP100_BM_READ)) {
 576			/* Conversion to new PCI API :
 577			 * I don't have the doc, but I assume that the card
 578			 * can map the full 32bit address space.
 579			 * Also, we can have EISA Busmaster cards (not tested),
 580			 * so beware !!! - Jean II */
 581			if((bus == HP100_BUS_PCI) &&
 582			   (pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32)))) {
 583				/* Gracefully fallback to shared memory */
 584				goto busmasterfail;
 585			}
 586			printk("hp100: Busmaster mode enabled.\n");
 587			hp100_outw(HP100_MEM_EN | HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
 588		} else {
 589		busmasterfail:
 590#ifdef HP100_DEBUG
 591			printk("hp100: %s: Card not configured for BM or BM not supported with this card.\n", dev->name);
 592			printk("hp100: %s: Trying shared memory mode.\n", dev->name);
 593#endif
 594			/* In this case, try shared memory mode */
 595			local_mode = 2;
 596			hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
 597			/* hp100_outw(HP100_IO_EN|HP100_RESET_LB, OPTION_LSW); */
 598		}
 599	}
 600#ifdef HP100_DEBUG
 601	printk("hp100: %s: new LSW = 0x%x\n", dev->name, hp100_inw(OPTION_LSW));
 602#endif
 603
 604	/* Check for shared memory on the card, eventually remap it */
 605	hp100_page(HW_MAP);
 606	mem_mapped = ((hp100_inw(OPTION_LSW) & (HP100_MEM_EN)) != 0);
 607	mem_ptr_phys = 0UL;
 608	mem_ptr_virt = NULL;
 609	memory_size = (8192 << ((hp100_inb(SRAM) >> 5) & 0x07));
 610	virt_memory_size = 0;
 611
 612	/* For memory mapped or busmaster mode, we want the memory address */
 613	if (mem_mapped || (local_mode == 1)) {
 614		mem_ptr_phys = (hp100_inw(MEM_MAP_LSW) | (hp100_inw(MEM_MAP_MSW) << 16));
 615		mem_ptr_phys &= ~0x1fff;	/* 8k alignment */
 616
 617		if (bus == HP100_BUS_ISA && (mem_ptr_phys & ~0xfffff) != 0) {
 618			printk("hp100: Can only use programmed i/o mode.\n");
 619			mem_ptr_phys = 0;
 620			mem_mapped = 0;
 621			local_mode = 3;	/* Use programmed i/o */
 622		}
 623
 624		/* We do not need access to shared memory in busmaster mode */
 625		/* However in slave mode we need to remap high (>1GB) card memory  */
 626		if (local_mode != 1) {	/* = not busmaster */
 627			/* We try with smaller memory sizes, if ioremap fails */
 628			for (virt_memory_size = memory_size; virt_memory_size > 16383; virt_memory_size >>= 1) {
 629				if ((mem_ptr_virt = ioremap((u_long) mem_ptr_phys, virt_memory_size)) == NULL) {
 630#ifdef HP100_DEBUG
 631					printk("hp100: %s: ioremap for 0x%x bytes high PCI memory at 0x%lx failed\n", dev->name, virt_memory_size, mem_ptr_phys);
 632#endif
 633				} else {
 634#ifdef HP100_DEBUG
 635					printk("hp100: %s: remapped 0x%x bytes high PCI memory at 0x%lx to %p.\n", dev->name, virt_memory_size, mem_ptr_phys, mem_ptr_virt);
 636#endif
 637					break;
 638				}
 639			}
 640
 641			if (mem_ptr_virt == NULL) {	/* all ioremap tries failed */
 642				printk("hp100: Failed to ioremap the PCI card memory. Will have to use i/o mapped mode.\n");
 643				local_mode = 3;
 644				virt_memory_size = 0;
 645			}
 646		}
 647	}
 648
 649	if (local_mode == 3) {	/* io mapped forced */
 650		mem_mapped = 0;
 651		mem_ptr_phys = 0;
 652		mem_ptr_virt = NULL;
 653		printk("hp100: Using (slow) programmed i/o mode.\n");
 654	}
 655
 656	/* Initialise the "private" data structure for this card. */
 657	lp = netdev_priv(dev);
 658
 659	spin_lock_init(&lp->lock);
 660	strlcpy(lp->id, eid, HP100_SIG_LEN);
 661	lp->chip = chip;
 662	lp->mode = local_mode;
 663	lp->bus = bus;
 664	lp->pci_dev = pci_dev;
 665	lp->priority_tx = hp100_priority_tx;
 666	lp->rx_ratio = hp100_rx_ratio;
 667	lp->mem_ptr_phys = mem_ptr_phys;
 668	lp->mem_ptr_virt = mem_ptr_virt;
 669	hp100_page(ID_MAC_ADDR);
 670	lp->soft_model = hp100_inb(SOFT_MODEL);
 671	lp->mac1_mode = HP100_MAC1MODE3;
 672	lp->mac2_mode = HP100_MAC2MODE3;
 673	memset(&lp->hash_bytes, 0x00, 8);
 674
 675	dev->base_addr = ioaddr;
 676
 677	lp->memory_size = memory_size;
 678	lp->virt_memory_size = virt_memory_size;
 679	lp->rx_ratio = hp100_rx_ratio;	/* can be conf'd with insmod */
 680
 681	if (lp->mode == 1)	/* busmaster */
 682		dev->netdev_ops = &hp100_bm_netdev_ops;
 683	else
 684		dev->netdev_ops = &hp100_netdev_ops;
 685
 686	/* Ask the card for which IRQ line it is configured */
 687	if (bus == HP100_BUS_PCI) {
 688		dev->irq = pci_dev->irq;
 689	} else {
 690		hp100_page(HW_MAP);
 691		dev->irq = hp100_inb(IRQ_CHANNEL) & HP100_IRQMASK;
 692		if (dev->irq == 2)
 693			dev->irq = 9;
 694	}
 695
 696	if (lp->mode == 1)	/* busmaster */
 697		dev->dma = 4;
 698
 699	/* Ask the card for its MAC address and store it for later use. */
 700	hp100_page(ID_MAC_ADDR);
 701	for (i = uc = 0; i < 6; i++)
 702		dev->dev_addr[i] = hp100_inb(LAN_ADDR + i);
 703
 704	/* Reset statistics (counters) */
 705	hp100_clear_stats(lp, ioaddr);
 706
 707	/* If busmaster mode is wanted, a dma-capable memory area is needed for
 708	 * the rx and tx PDLs
 709	 * PCI cards can access the whole PC memory. Therefore GFP_DMA is not
 710	 * needed for the allocation of the memory area.
 711	 */
 712
 713	/* TODO: We do not need this with old cards, where PDLs are stored
 714	 * in the cards shared memory area. But currently, busmaster has been
 715	 * implemented/tested only with the lassen chip anyway... */
 716	if (lp->mode == 1) {	/* busmaster */
 717		dma_addr_t page_baddr;
 718		/* Get physically continuous memory for TX & RX PDLs    */
 719		/* Conversion to new PCI API :
 720		 * Pages are always aligned and zeroed, no need to it ourself.
 721		 * Doc says should be OK for EISA bus as well - Jean II */
 722		lp->page_vaddr_algn = pci_alloc_consistent(lp->pci_dev, MAX_RINGSIZE, &page_baddr);
 723		if (!lp->page_vaddr_algn) {
 724			err = -ENOMEM;
 725			goto out_mem_ptr;
 726		}
 727		lp->whatever_offset = ((u_long) page_baddr) - ((u_long) lp->page_vaddr_algn);
 728
 729#ifdef HP100_DEBUG_BM
 730		printk("hp100: %s: Reserved DMA memory from 0x%x to 0x%x\n", dev->name, (u_int) lp->page_vaddr_algn, (u_int) lp->page_vaddr_algn + MAX_RINGSIZE);
 731#endif
 732		lp->rxrcommit = lp->txrcommit = 0;
 733		lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
 734		lp->txrhead = lp->txrtail = &(lp->txring[0]);
 735	}
 736
 737	/* Initialise the card. */
 738	/* (I'm not really sure if it's a good idea to do this during probing, but
 739	 * like this it's assured that the lan connection type can be sensed
 740	 * correctly)
 741	 */
 742	hp100_hwinit(dev);
 743
 744	/* Try to find out which kind of LAN the card is connected to. */
 745	lp->lan_type = hp100_sense_lan(dev);
 746
 747	/* Print out a message what about what we think we have probed. */
 748	printk("hp100: at 0x%x, IRQ %d, ", ioaddr, dev->irq);
 749	switch (bus) {
 750	case HP100_BUS_EISA:
 751		printk("EISA");
 752		break;
 753	case HP100_BUS_PCI:
 754		printk("PCI");
 755		break;
 756	default:
 757		printk("ISA");
 758		break;
 759	}
 760	printk(" bus, %dk SRAM (rx/tx %d%%).\n", lp->memory_size >> 10, lp->rx_ratio);
 761
 762	if (lp->mode == 2) {	/* memory mapped */
 763		printk("hp100: Memory area at 0x%lx-0x%lx", mem_ptr_phys,
 764				(mem_ptr_phys + (mem_ptr_phys > 0x100000 ? (u_long) lp->memory_size : 16 * 1024)) - 1);
 765		if (mem_ptr_virt)
 766			printk(" (virtual base %p)", mem_ptr_virt);
 767		printk(".\n");
 768
 769		/* Set for info when doing ifconfig */
 770		dev->mem_start = mem_ptr_phys;
 771		dev->mem_end = mem_ptr_phys + lp->memory_size;
 772	}
 773
 774	printk("hp100: ");
 775	if (lp->lan_type != HP100_LAN_ERR)
 776		printk("Adapter is attached to ");
 777	switch (lp->lan_type) {
 778	case HP100_LAN_100:
 779		printk("100Mb/s Voice Grade AnyLAN network.\n");
 780		break;
 781	case HP100_LAN_10:
 782		printk("10Mb/s network (10baseT).\n");
 783		break;
 784	case HP100_LAN_COAX:
 785		printk("10Mb/s network (coax).\n");
 786		break;
 787	default:
 788		printk("Warning! Link down.\n");
 789	}
 790
 791	err = register_netdev(dev);
 792	if (err)
 793		goto out3;
 794
 795	return 0;
 796out3:
 797	if (local_mode == 1)
 798		pci_free_consistent(lp->pci_dev, MAX_RINGSIZE + 0x0f,
 799				    lp->page_vaddr_algn,
 800				    virt_to_whatever(dev, lp->page_vaddr_algn));
 801out_mem_ptr:
 802	if (mem_ptr_virt)
 803		iounmap(mem_ptr_virt);
 804out2:
 805	release_region(ioaddr, HP100_REGION_SIZE);
 806out1:
 807	return err;
 808}
 809
 810/* This procedure puts the card into a stable init state */
 811static void hp100_hwinit(struct net_device *dev)
 812{
 813	int ioaddr = dev->base_addr;
 814	struct hp100_private *lp = netdev_priv(dev);
 815
 816#ifdef HP100_DEBUG_B
 817	hp100_outw(0x4202, TRACE);
 818	printk("hp100: %s: hwinit\n", dev->name);
 819#endif
 820
 821	/* Initialise the card. -------------------------------------------- */
 822
 823	/* Clear all pending Ints and disable Ints */
 824	hp100_page(PERFORMANCE);
 825	hp100_outw(0xfefe, IRQ_MASK);	/* mask off all ints */
 826	hp100_outw(0xffff, IRQ_STATUS);	/* clear all pending ints */
 827
 828	hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
 829	hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
 830
 831	if (lp->mode == 1) {
 832		hp100_BM_shutdown(dev);	/* disables BM, puts cascade in reset */
 833		wait();
 834	} else {
 835		hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
 836		hp100_cascade_reset(dev, 1);
 837		hp100_page(MAC_CTRL);
 838		hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);
 839	}
 840
 841	/* Initiate EEPROM reload */
 842	hp100_load_eeprom(dev, 0);
 843
 844	wait();
 845
 846	/* Go into reset again. */
 847	hp100_cascade_reset(dev, 1);
 848
 849	/* Set Option Registers to a safe state  */
 850	hp100_outw(HP100_DEBUG_EN |
 851		   HP100_RX_HDR |
 852		   HP100_EE_EN |
 853		   HP100_BM_WRITE |
 854		   HP100_BM_READ | HP100_RESET_HB |
 855		   HP100_FAKE_INT |
 856		   HP100_INT_EN |
 857		   HP100_MEM_EN |
 858		   HP100_IO_EN | HP100_RESET_LB, OPTION_LSW);
 859
 860	hp100_outw(HP100_TRI_INT |
 861		   HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
 862
 863	hp100_outb(HP100_PRIORITY_TX |
 864		   HP100_ADV_NXT_PKT |
 865		   HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
 866
 867	/* TODO: Configure MMU for Ram Test. */
 868	/* TODO: Ram Test. */
 869
 870	/* Re-check if adapter is still at same i/o location      */
 871	/* (If the base i/o in eeprom has been changed but the    */
 872	/* registers had not been changed, a reload of the eeprom */
 873	/* would move the adapter to the address stored in eeprom */
 874
 875	/* TODO: Code to implement. */
 876
 877	/* Until here it was code from HWdiscover procedure. */
 878	/* Next comes code from mmuinit procedure of SCO BM driver which is
 879	 * called from HWconfigure in the SCO driver.  */
 880
 881	/* Initialise MMU, eventually switch on Busmaster Mode, initialise
 882	 * multicast filter...
 883	 */
 884	hp100_mmuinit(dev);
 885
 886	/* We don't turn the interrupts on here - this is done by start_interface. */
 887	wait();			/* TODO: Do we really need this? */
 888
 889	/* Enable Hardware (e.g. unreset) */
 890	hp100_cascade_reset(dev, 0);
 891
 892	/* ------- initialisation complete ----------- */
 893
 894	/* Finally try to log in the Hub if there may be a VG connection. */
 895	if ((lp->lan_type == HP100_LAN_100) || (lp->lan_type == HP100_LAN_ERR))
 896		hp100_login_to_vg_hub(dev, 0);	/* relogin */
 897
 898}
 899
 900
 901/*
 902 * mmuinit - Reinitialise Cascade MMU and MAC settings.
 903 * Note: Must already be in reset and leaves card in reset.
 904 */
 905static void hp100_mmuinit(struct net_device *dev)
 906{
 907	int ioaddr = dev->base_addr;
 908	struct hp100_private *lp = netdev_priv(dev);
 909	int i;
 910
 911#ifdef HP100_DEBUG_B
 912	hp100_outw(0x4203, TRACE);
 913	printk("hp100: %s: mmuinit\n", dev->name);
 914#endif
 915
 916#ifdef HP100_DEBUG
 917	if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
 918		printk("hp100: %s: Not in reset when entering mmuinit. Fix me.\n", dev->name);
 919		return;
 920	}
 921#endif
 922
 923	/* Make sure IRQs are masked off and ack'ed. */
 924	hp100_page(PERFORMANCE);
 925	hp100_outw(0xfefe, IRQ_MASK);	/* mask off all ints */
 926	hp100_outw(0xffff, IRQ_STATUS);	/* ack IRQ */
 927
 928	/*
 929	 * Enable Hardware
 930	 * - Clear Debug En, Rx Hdr Pipe, EE En, I/O En, Fake Int and Intr En
 931	 * - Set Tri-State Int, Bus Master Rd/Wr, and Mem Map Disable
 932	 * - Clear Priority, Advance Pkt and Xmit Cmd
 933	 */
 934
 935	hp100_outw(HP100_DEBUG_EN |
 936		   HP100_RX_HDR |
 937		   HP100_EE_EN | HP100_RESET_HB |
 938		   HP100_IO_EN |
 939		   HP100_FAKE_INT |
 940		   HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
 941
 942	hp100_outw(HP100_TRI_INT | HP100_SET_HB, OPTION_LSW);
 943
 944	if (lp->mode == 1) {	/* busmaster */
 945		hp100_outw(HP100_BM_WRITE |
 946			   HP100_BM_READ |
 947			   HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW);
 948	} else if (lp->mode == 2) {	/* memory mapped */
 949		hp100_outw(HP100_BM_WRITE |
 950			   HP100_BM_READ | HP100_RESET_HB, OPTION_LSW);
 951		hp100_outw(HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW);
 952		hp100_outw(HP100_MEM_EN | HP100_SET_LB, OPTION_LSW);
 953		hp100_outw(HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
 954	} else if (lp->mode == 3) {	/* i/o mapped mode */
 955		hp100_outw(HP100_MMAP_DIS | HP100_SET_HB |
 956			   HP100_IO_EN | HP100_SET_LB, OPTION_LSW);
 957	}
 958
 959	hp100_page(HW_MAP);
 960	hp100_outb(0, EARLYRXCFG);
 961	hp100_outw(0, EARLYTXCFG);
 962
 963	/*
 964	 * Enable Bus Master mode
 965	 */
 966	if (lp->mode == 1) {	/* busmaster */
 967		/* Experimental: Set some PCI configuration bits */
 968		hp100_page(HW_MAP);
 969		hp100_andb(~HP100_PDL_USE3, MODECTRL1);	/* BM engine read maximum */
 970		hp100_andb(~HP100_TX_DUALQ, MODECTRL1);	/* No Queue for Priority TX */
 971
 972		/* PCI Bus failures should result in a Misc. Interrupt */
 973		hp100_orb(HP100_EN_BUS_FAIL, MODECTRL2);
 974
 975		hp100_outw(HP100_BM_READ | HP100_BM_WRITE | HP100_SET_HB, OPTION_LSW);
 976		hp100_page(HW_MAP);
 977		/* Use Burst Mode and switch on PAGE_CK */
 978		hp100_orb(HP100_BM_BURST_RD | HP100_BM_BURST_WR, BM);
 979		if ((lp->chip == HP100_CHIPID_RAINIER) || (lp->chip == HP100_CHIPID_SHASTA))
 980			hp100_orb(HP100_BM_PAGE_CK, BM);
 981		hp100_orb(HP100_BM_MASTER, BM);
 982	} else {		/* not busmaster */
 983
 984		hp100_page(HW_MAP);
 985		hp100_andb(~HP100_BM_MASTER, BM);
 986	}
 987
 988	/*
 989	 * Divide card memory into regions for Rx, Tx and, if non-ETR chip, PDLs
 990	 */
 991	hp100_page(MMU_CFG);
 992	if (lp->mode == 1) {	/* only needed for Busmaster */
 993		int xmit_stop, recv_stop;
 994
 995		if ((lp->chip == HP100_CHIPID_RAINIER) ||
 996		    (lp->chip == HP100_CHIPID_SHASTA)) {
 997			int pdl_stop;
 998
 999			/*
1000			 * Each pdl is 508 bytes long. (63 frags * 4 bytes for address and
1001			 * 4 bytes for header). We will leave NUM_RXPDLS * 508 (rounded
1002			 * to the next higher 1k boundary) bytes for the rx-pdl's
1003			 * Note: For non-etr chips the transmit stop register must be
1004			 * programmed on a 1k boundary, i.e. bits 9:0 must be zero.
1005			 */
1006			pdl_stop = lp->memory_size;
1007			xmit_stop = (pdl_stop - 508 * (MAX_RX_PDL) - 16) & ~(0x03ff);
1008			recv_stop = (xmit_stop * (lp->rx_ratio) / 100) & ~(0x03ff);
1009			hp100_outw((pdl_stop >> 4) - 1, PDL_MEM_STOP);
1010#ifdef HP100_DEBUG_BM
1011			printk("hp100: %s: PDL_STOP = 0x%x\n", dev->name, pdl_stop);
1012#endif
1013		} else {
1014			/* ETR chip (Lassen) in busmaster mode */
1015			xmit_stop = (lp->memory_size) - 1;
1016			recv_stop = ((lp->memory_size * lp->rx_ratio) / 100) & ~(0x03ff);
1017		}
1018
1019		hp100_outw(xmit_stop >> 4, TX_MEM_STOP);
1020		hp100_outw(recv_stop >> 4, RX_MEM_STOP);
1021#ifdef HP100_DEBUG_BM
1022		printk("hp100: %s: TX_STOP  = 0x%x\n", dev->name, xmit_stop >> 4);
1023		printk("hp100: %s: RX_STOP  = 0x%x\n", dev->name, recv_stop >> 4);
1024#endif
1025	} else {
1026		/* Slave modes (memory mapped and programmed io)  */
1027		hp100_outw((((lp->memory_size * lp->rx_ratio) / 100) >> 4), RX_MEM_STOP);
1028		hp100_outw(((lp->memory_size - 1) >> 4), TX_MEM_STOP);
1029#ifdef HP100_DEBUG
1030		printk("hp100: %s: TX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(TX_MEM_STOP));
1031		printk("hp100: %s: RX_MEM_STOP: 0x%x\n", dev->name, hp100_inw(RX_MEM_STOP));
1032#endif
1033	}
1034
1035	/* Write MAC address into page 1 */
1036	hp100_page(MAC_ADDRESS);
1037	for (i = 0; i < 6; i++)
1038		hp100_outb(dev->dev_addr[i], MAC_ADDR + i);
1039
1040	/* Zero the multicast hash registers */
1041	for (i = 0; i < 8; i++)
1042		hp100_outb(0x0, HASH_BYTE0 + i);
1043
1044	/* Set up MAC defaults */
1045	hp100_page(MAC_CTRL);
1046
1047	/* Go to LAN Page and zero all filter bits */
1048	/* Zero accept error, accept multicast, accept broadcast and accept */
1049	/* all directed packet bits */
1050	hp100_andb(~(HP100_RX_EN |
1051		     HP100_TX_EN |
1052		     HP100_ACC_ERRORED |
1053		     HP100_ACC_MC |
1054		     HP100_ACC_BC | HP100_ACC_PHY), MAC_CFG_1);
1055
1056	hp100_outb(0x00, MAC_CFG_2);
1057
1058	/* Zero the frame format bit. This works around a training bug in the */
1059	/* new hubs. */
1060	hp100_outb(0x00, VG_LAN_CFG_2);	/* (use 802.3) */
1061
1062	if (lp->priority_tx)
1063		hp100_outb(HP100_PRIORITY_TX | HP100_SET_LB, OPTION_MSW);
1064	else
1065		hp100_outb(HP100_PRIORITY_TX | HP100_RESET_LB, OPTION_MSW);
1066
1067	hp100_outb(HP100_ADV_NXT_PKT |
1068		   HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW);
1069
1070	/* If busmaster, initialize the PDLs */
1071	if (lp->mode == 1)
1072		hp100_init_pdls(dev);
1073
1074	/* Go to performance page and initialize isr and imr registers */
1075	hp100_page(PERFORMANCE);
1076	hp100_outw(0xfefe, IRQ_MASK);	/* mask off all ints */
1077	hp100_outw(0xffff, IRQ_STATUS);	/* ack IRQ */
1078}
1079
1080/*
1081 *  open/close functions
1082 */
1083
1084static int hp100_open(struct net_device *dev)
1085{
1086	struct hp100_private *lp = netdev_priv(dev);
1087#ifdef HP100_DEBUG_B
1088	int ioaddr = dev->base_addr;
1089#endif
1090
1091#ifdef HP100_DEBUG_B
1092	hp100_outw(0x4204, TRACE);
1093	printk("hp100: %s: open\n", dev->name);
1094#endif
1095
1096	/* New: if bus is PCI or EISA, interrupts might be shared interrupts */
1097	if (request_irq(dev->irq, hp100_interrupt,
1098			lp->bus == HP100_BUS_PCI || lp->bus ==
1099			HP100_BUS_EISA ? IRQF_SHARED : 0,
1100			dev->name, dev)) {
1101		printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
1102		return -EAGAIN;
1103	}
1104
1105	netif_trans_update(dev); /* prevent tx timeout */
1106	netif_start_queue(dev);
1107
1108	lp->lan_type = hp100_sense_lan(dev);
1109	lp->mac1_mode = HP100_MAC1MODE3;
1110	lp->mac2_mode = HP100_MAC2MODE3;
1111	memset(&lp->hash_bytes, 0x00, 8);
1112
1113	hp100_stop_interface(dev);
1114
1115	hp100_hwinit(dev);
1116
1117	hp100_start_interface(dev);	/* sets mac modes, enables interrupts */
1118
1119	return 0;
1120}
1121
1122/* The close function is called when the interface is to be brought down */
1123static int hp100_close(struct net_device *dev)
1124{
1125	int ioaddr = dev->base_addr;
1126	struct hp100_private *lp = netdev_priv(dev);
1127
1128#ifdef HP100_DEBUG_B
1129	hp100_outw(0x4205, TRACE);
1130	printk("hp100: %s: close\n", dev->name);
1131#endif
1132
1133	hp100_page(PERFORMANCE);
1134	hp100_outw(0xfefe, IRQ_MASK);	/* mask off all IRQs */
1135
1136	hp100_stop_interface(dev);
1137
1138	if (lp->lan_type == HP100_LAN_100)
1139		lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1140
1141	netif_stop_queue(dev);
1142
1143	free_irq(dev->irq, dev);
1144
1145#ifdef HP100_DEBUG
1146	printk("hp100: %s: close LSW = 0x%x\n", dev->name,
1147	       hp100_inw(OPTION_LSW));
1148#endif
1149
1150	return 0;
1151}
1152
1153
1154/*
1155 * Configure the PDL Rx rings and LAN
1156 */
1157static void hp100_init_pdls(struct net_device *dev)
1158{
1159	struct hp100_private *lp = netdev_priv(dev);
1160	hp100_ring_t *ringptr;
1161	u_int *pageptr;		/* Warning : increment by 4 - Jean II */
1162	int i;
1163
1164#ifdef HP100_DEBUG_B
1165	int ioaddr = dev->base_addr;
1166#endif
1167
1168#ifdef HP100_DEBUG_B
1169	hp100_outw(0x4206, TRACE);
1170	printk("hp100: %s: init pdls\n", dev->name);
1171#endif
1172
1173	if (!lp->page_vaddr_algn)
1174		printk("hp100: %s: Warning: lp->page_vaddr_algn not initialised!\n", dev->name);
1175	else {
1176		/* pageptr shall point into the DMA accessible memory region  */
1177		/* we use this pointer to status the upper limit of allocated */
1178		/* memory in the allocated page. */
1179		/* note: align the pointers to the pci cache line size */
1180		memset(lp->page_vaddr_algn, 0, MAX_RINGSIZE);	/* Zero  Rx/Tx ring page */
1181		pageptr = lp->page_vaddr_algn;
1182
1183		lp->rxrcommit = 0;
1184		ringptr = lp->rxrhead = lp->rxrtail = &(lp->rxring[0]);
1185
1186		/* Initialise Rx Ring */
1187		for (i = MAX_RX_PDL - 1; i >= 0; i--) {
1188			lp->rxring[i].next = ringptr;
1189			ringptr = &(lp->rxring[i]);
1190			pageptr += hp100_init_rxpdl(dev, ringptr, pageptr);
1191		}
1192
1193		/* Initialise Tx Ring */
1194		lp->txrcommit = 0;
1195		ringptr = lp->txrhead = lp->txrtail = &(lp->txring[0]);
1196		for (i = MAX_TX_PDL - 1; i >= 0; i--) {
1197			lp->txring[i].next = ringptr;
1198			ringptr = &(lp->txring[i]);
1199			pageptr += hp100_init_txpdl(dev, ringptr, pageptr);
1200		}
1201	}
1202}
1203
1204
1205/* These functions "format" the entries in the pdl structure   */
1206/* They return how much memory the fragments need.            */
1207static int hp100_init_rxpdl(struct net_device *dev,
1208			    register hp100_ring_t * ringptr,
1209			    register u32 * pdlptr)
1210{
1211	/* pdlptr is starting address for this pdl */
1212
1213	if (0 != (((unsigned long) pdlptr) & 0xf))
1214		printk("hp100: %s: Init rxpdl: Unaligned pdlptr 0x%lx.\n",
1215		       dev->name, (unsigned long) pdlptr);
1216
1217	ringptr->pdl = pdlptr + 1;
1218	ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr + 1);
1219	ringptr->skb = NULL;
1220
1221	/*
1222	 * Write address and length of first PDL Fragment (which is used for
1223	 * storing the RX-Header
1224	 * We use the 4 bytes _before_ the PDH in the pdl memory area to
1225	 * store this information. (PDH is at offset 0x04)
1226	 */
1227	/* Note that pdlptr+1 and not pdlptr is the pointer to the PDH */
1228
1229	*(pdlptr + 2) = (u_int) virt_to_whatever(dev, pdlptr);	/* Address Frag 1 */
1230	*(pdlptr + 3) = 4;	/* Length  Frag 1 */
1231
1232	return roundup(MAX_RX_FRAG * 2 + 2, 4);
1233}
1234
1235
1236static int hp100_init_txpdl(struct net_device *dev,
1237			    register hp100_ring_t * ringptr,
1238			    register u32 * pdlptr)
1239{
1240	if (0 != (((unsigned long) pdlptr) & 0xf))
1241		printk("hp100: %s: Init txpdl: Unaligned pdlptr 0x%lx.\n", dev->name, (unsigned long) pdlptr);
1242
1243	ringptr->pdl = pdlptr;	/* +1; */
1244	ringptr->pdl_paddr = virt_to_whatever(dev, pdlptr);	/* +1 */
1245	ringptr->skb = NULL;
1246
1247	return roundup(MAX_TX_FRAG * 2 + 2, 4);
1248}
1249
1250/*
1251 * hp100_build_rx_pdl allocates an skb_buff of maximum size plus two bytes
1252 * for possible odd word alignment rounding up to next dword and set PDL
1253 * address for fragment#2
1254 * Returns: 0 if unable to allocate skb_buff
1255 *          1 if successful
1256 */
1257static int hp100_build_rx_pdl(hp100_ring_t * ringptr,
1258			      struct net_device *dev)
1259{
1260#ifdef HP100_DEBUG_B
1261	int ioaddr = dev->base_addr;
1262#endif
1263#ifdef HP100_DEBUG_BM
1264	u_int *p;
1265#endif
1266
1267#ifdef HP100_DEBUG_B
1268	hp100_outw(0x4207, TRACE);
1269	printk("hp100: %s: build rx pdl\n", dev->name);
1270#endif
1271
1272	/* Allocate skb buffer of maximum size */
1273	/* Note: This depends on the alloc_skb functions allocating more
1274	 * space than requested, i.e. aligning to 16bytes */
1275
1276	ringptr->skb = netdev_alloc_skb(dev, roundup(MAX_ETHER_SIZE + 2, 4));
1277
1278	if (NULL != ringptr->skb) {
1279		/*
1280		 * Reserve 2 bytes at the head of the buffer to land the IP header
1281		 * on a long word boundary (According to the Network Driver section
1282		 * in the Linux KHG, this should help to increase performance.)
1283		 */
1284		skb_reserve(ringptr->skb, 2);
1285
1286		ringptr->skb->data = (u_char *) skb_put(ringptr->skb, MAX_ETHER_SIZE);
1287
1288		/* ringptr->pdl points to the beginning of the PDL, i.e. the PDH */
1289		/* Note: 1st Fragment is used for the 4 byte packet status
1290		 * (receive header). Its PDL entries are set up by init_rxpdl. So
1291		 * here we only have to set up the PDL fragment entries for the data
1292		 * part. Those 4 bytes will be stored in the DMA memory region
1293		 * directly before the PDL.
1294		 */
1295#ifdef HP100_DEBUG_BM
1296		printk("hp100: %s: build_rx_pdl: PDH@0x%x, skb->data (len %d) at 0x%x\n",
1297				     dev->name, (u_int) ringptr->pdl,
1298				     roundup(MAX_ETHER_SIZE + 2, 4),
1299				     (unsigned int) ringptr->skb->data);
1300#endif
1301
1302		/* Conversion to new PCI API : map skbuf data to PCI bus.
1303		 * Doc says it's OK for EISA as well - Jean II */
1304		ringptr->pdl[0] = 0x00020000;	/* Write PDH */
1305		ringptr->pdl[3] = pdl_map_data(netdev_priv(dev),
1306					       ringptr->skb->data);
1307		ringptr->pdl[4] = MAX_ETHER_SIZE;	/* Length of Data */
1308
1309#ifdef HP100_DEBUG_BM
1310		for (p = (ringptr->pdl); p < (ringptr->pdl + 5); p++)
1311			printk("hp100: %s: Adr 0x%.8x = 0x%.8x\n", dev->name, (u_int) p, (u_int) * p);
1312#endif
1313		return 1;
1314	}
1315	/* else: */
1316	/* alloc_skb failed (no memory) -> still can receive the header
1317	 * fragment into PDL memory. make PDL safe by clearing msgptr and
1318	 * making the PDL only 1 fragment (i.e. the 4 byte packet status)
1319	 */
1320#ifdef HP100_DEBUG_BM
1321	printk("hp100: %s: build_rx_pdl: PDH@0x%x, No space for skb.\n", dev->name, (u_int) ringptr->pdl);
1322#endif
1323
1324	ringptr->pdl[0] = 0x00010000;	/* PDH: Count=1 Fragment */
1325
1326	return 0;
1327}
1328
1329/*
1330 *  hp100_rxfill - attempt to fill the Rx Ring will empty skb's
1331 *
1332 * Makes assumption that skb's are always contiguous memory areas and
1333 * therefore PDLs contain only 2 physical fragments.
1334 * -  While the number of Rx PDLs with buffers is less than maximum
1335 *      a.  Get a maximum packet size skb
1336 *      b.  Put the physical address of the buffer into the PDL.
1337 *      c.  Output physical address of PDL to adapter.
1338 */
1339static void hp100_rxfill(struct net_device *dev)
1340{
1341	int ioaddr = dev->base_addr;
1342
1343	struct hp100_private *lp = netdev_priv(dev);
1344	hp100_ring_t *ringptr;
1345
1346#ifdef HP100_DEBUG_B
1347	hp100_outw(0x4208, TRACE);
1348	printk("hp100: %s: rxfill\n", dev->name);
1349#endif
1350
1351	hp100_page(PERFORMANCE);
1352
1353	while (lp->rxrcommit < MAX_RX_PDL) {
1354		/*
1355		   ** Attempt to get a buffer and build a Rx PDL.
1356		 */
1357		ringptr = lp->rxrtail;
1358		if (0 == hp100_build_rx_pdl(ringptr, dev)) {
1359			return;	/* None available, return */
1360		}
1361
1362		/* Hand this PDL over to the card */
1363		/* Note: This needs performance page selected! */
1364#ifdef HP100_DEBUG_BM
1365		printk("hp100: %s: rxfill: Hand to card: pdl #%d @0x%x phys:0x%x, buffer: 0x%x\n",
1366				     dev->name, lp->rxrcommit, (u_int) ringptr->pdl,
1367				     (u_int) ringptr->pdl_paddr, (u_int) ringptr->pdl[3]);
1368#endif
1369
1370		hp100_outl((u32) ringptr->pdl_paddr, RX_PDA);
1371
1372		lp->rxrcommit += 1;
1373		lp->rxrtail = ringptr->next;
1374	}
1375}
1376
1377/*
1378 * BM_shutdown - shutdown bus mastering and leave chip in reset state
1379 */
1380
1381static void hp100_BM_shutdown(struct net_device *dev)
1382{
1383	int ioaddr = dev->base_addr;
1384	struct hp100_private *lp = netdev_priv(dev);
1385	unsigned long time;
1386
1387#ifdef HP100_DEBUG_B
1388	hp100_outw(0x4209, TRACE);
1389	printk("hp100: %s: bm shutdown\n", dev->name);
1390#endif
1391
1392	hp100_page(PERFORMANCE);
1393	hp100_outw(0xfefe, IRQ_MASK);	/* mask off all ints */
1394	hp100_outw(0xffff, IRQ_STATUS);	/* Ack all ints */
1395
1396	/* Ensure Interrupts are off */
1397	hp100_outw(HP100_INT_EN | HP100_RESET_LB, OPTION_LSW);
1398
1399	/* Disable all MAC activity */
1400	hp100_page(MAC_CTRL);
1401	hp100_andb(~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1);	/* stop rx/tx */
1402
1403	/* If cascade MMU is not already in reset */
1404	if (0 != (hp100_inw(OPTION_LSW) & HP100_HW_RST)) {
1405		/* Wait 1.3ms (10Mb max packet time) to ensure MAC is idle so
1406		 * MMU pointers will not be reset out from underneath
1407		 */
1408		hp100_page(MAC_CTRL);
1409		for (time = 0; time < 5000; time++) {
1410			if ((hp100_inb(MAC_CFG_1) & (HP100_TX_IDLE | HP100_RX_IDLE)) == (HP100_TX_IDLE | HP100_RX_IDLE))
1411				break;
1412		}
1413
1414		/* Shutdown algorithm depends on the generation of Cascade */
1415		if (lp->chip == HP100_CHIPID_LASSEN) {	/* ETR shutdown/reset */
1416			/* Disable Busmaster mode and wait for bit to go to zero. */
1417			hp100_page(HW_MAP);
1418			hp100_andb(~HP100_BM_MASTER, BM);
1419			/* 100 ms timeout */
1420			for (time = 0; time < 32000; time++) {
1421				if (0 == (hp100_inb(BM) & HP100_BM_MASTER))
1422					break;
1423			}
1424		} else {	/* Shasta or Rainier Shutdown/Reset */
1425			/* To ensure all bus master inloading activity has ceased,
1426			 * wait for no Rx PDAs or no Rx packets on card.
1427			 */
1428			hp100_page(PERFORMANCE);
1429			/* 100 ms timeout */
1430			for (time = 0; time < 10000; time++) {
1431				/* RX_PDL: PDLs not executed. */
1432				/* RX_PKT_CNT: RX'd packets on card. */
1433				if ((hp100_inb(RX_PDL) == 0) && (hp100_inb(RX_PKT_CNT) == 0))
1434					break;
1435			}
1436
1437			if (time >= 10000)
1438				printk("hp100: %s: BM shutdown error.\n", dev->name);
1439
1440			/* To ensure all bus master outloading activity has ceased,
1441			 * wait until the Tx PDA count goes to zero or no more Tx space
1442			 * available in the Tx region of the card.
1443			 */
1444			/* 100 ms timeout */
1445			for (time = 0; time < 10000; time++) {
1446				if ((0 == hp100_inb(TX_PKT_CNT)) &&
1447				    (0 != (hp100_inb(TX_MEM_FREE) & HP100_AUTO_COMPARE)))
1448					break;
1449			}
1450
1451			/* Disable Busmaster mode */
1452			hp100_page(HW_MAP);
1453			hp100_andb(~HP100_BM_MASTER, BM);
1454		}	/* end of shutdown procedure for non-etr parts */
1455
1456		hp100_cascade_reset(dev, 1);
1457	}
1458	hp100_page(PERFORMANCE);
1459	/* hp100_outw( HP100_BM_READ | HP100_BM_WRITE | HP100_RESET_HB, OPTION_LSW ); */
1460	/* Busmaster mode should be shut down now. */
1461}
1462
1463static int hp100_check_lan(struct net_device *dev)
1464{
1465	struct hp100_private *lp = netdev_priv(dev);
1466
1467	if (lp->lan_type < 0) {	/* no LAN type detected yet? */
1468		hp100_stop_interface(dev);
1469		if ((lp->lan_type = hp100_sense_lan(dev)) < 0) {
1470			printk("hp100: %s: no connection found - check wire\n", dev->name);
1471			hp100_start_interface(dev);	/* 10Mb/s RX packets maybe handled */
1472			return -EIO;
1473		}
1474		if (lp->lan_type == HP100_LAN_100)
1475			lp->hub_status = hp100_login_to_vg_hub(dev, 0);	/* relogin */
1476		hp100_start_interface(dev);
1477	}
1478	return 0;
1479}
1480
1481/*
1482 *  transmit functions
1483 */
1484
1485/* tx function for busmaster mode */
1486static netdev_tx_t hp100_start_xmit_bm(struct sk_buff *skb,
1487				       struct net_device *dev)
1488{
1489	unsigned long flags;
1490	int i, ok_flag;
1491	int ioaddr = dev->base_addr;
1492	struct hp100_private *lp = netdev_priv(dev);
1493	hp100_ring_t *ringptr;
1494
1495#ifdef HP100_DEBUG_B
1496	hp100_outw(0x4210, TRACE);
1497	printk("hp100: %s: start_xmit_bm\n", dev->name);
1498#endif
1499	if (skb->len <= 0)
1500		goto drop;
1501
1502	if (lp->chip == HP100_CHIPID_SHASTA && skb_padto(skb, ETH_ZLEN))
1503		return NETDEV_TX_OK;
1504
1505	/* Get Tx ring tail pointer */
1506	if (lp->txrtail->next == lp->txrhead) {
1507		/* No memory. */
1508#ifdef HP100_DEBUG
1509		printk("hp100: %s: start_xmit_bm: No TX PDL available.\n", dev->name);
1510#endif
1511		/* not waited long enough since last tx? */
1512		if (time_before(jiffies, dev_trans_start(dev) + HZ))
1513			goto drop;
1514
1515		if (hp100_check_lan(dev))
1516			goto drop;
1517
1518		if (lp->lan_type == HP100_LAN_100 && lp->hub_status < 0) {
1519			/* we have a 100Mb/s adapter but it isn't connected to hub */
1520			printk("hp100: %s: login to 100Mb/s hub retry\n", dev->name);
1521			hp100_stop_interface(dev);
1522			lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1523			hp100_start_interface(dev);
1524		} else {
1525			spin_lock_irqsave(&lp->lock, flags);
1526			hp100_ints_off();	/* Useful ? Jean II */
1527			i = hp100_sense_lan(dev);
1528			hp100_ints_on();
1529			spin_unlock_irqrestore(&lp->lock, flags);
1530			if (i == HP100_LAN_ERR)
1531				printk("hp100: %s: link down detected\n", dev->name);
1532			else if (lp->lan_type != i) {	/* cable change! */
1533				/* it's very hard - all network settings must be changed!!! */
1534				printk("hp100: %s: cable change 10Mb/s <-> 100Mb/s detected\n", dev->name);
1535				lp->lan_type = i;
1536				hp100_stop_interface(dev);
1537				if (lp->lan_type == HP100_LAN_100)
1538					lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1539				hp100_start_interface(dev);
1540			} else {
1541				printk("hp100: %s: interface reset\n", dev->name);
1542				hp100_stop_interface(dev);
1543				if (lp->lan_type == HP100_LAN_100)
1544					lp->hub_status = hp100_login_to_vg_hub(dev, 0);
1545				hp100_start_interface(dev);
1546			}
1547		}
1548
1549		goto drop;
1550	}
1551
1552	/*
1553	 * we have to turn int's off before modifying this, otherwise
1554	 * a tx_pdl_cleanup could occur at the same time
1555	 */
1556	spin_lock_irqsave(&lp->lock, flags);
1557	ringptr = lp->txrtail;
1558	lp->txrtail = ringptr->next;
1559
1560	/* Check whether packet has minimal packet size */
1561	ok_flag = skb->len >= HP100_MIN_PACKET_SIZE;
1562	i = ok_flag ? skb->len : HP100_MIN_PACKET_SIZE;
1563
1564	ringptr->skb = skb;
1565	ringptr->pdl[0] = ((1 << 16) | i);	/* PDH: 1 Fragment & length */
1566	if (lp->chip == HP100_CHIPID_SHASTA) {
1567		/* TODO:Could someone who has the EISA card please check if this works? */
1568		ringptr->pdl[2] = i;
1569	} else {		/* Lassen */
1570		/* In the PDL, don't use the padded size but the real packet size: */
1571		ringptr->pdl[2] = skb->len;	/* 1st Frag: Length of frag */
1572	}
1573	/* Conversion to new PCI API : map skbuf data to PCI bus.
1574	 * Doc says it's OK for EISA as well - Jean II */
1575	ringptr->pdl[1] = ((u32) pci_map_single(lp->pci_dev, skb->data, ringptr->pdl[2], PCI_DMA_TODEVICE));	/* 1st Frag: Adr. of data */
1576
1577	/* Hand this PDL to the card. */
1578	hp100_outl(ringptr->pdl_paddr, TX_PDA_L);	/* Low Prio. Queue */
1579
1580	lp->txrcommit++;
1581
1582	dev->stats.tx_packets++;
1583	dev->stats.tx_bytes += skb->len;
1584
1585	spin_unlock_irqrestore(&lp->lock, flags);
1586
1587	return NETDEV_TX_OK;
1588
1589drop:
1590	dev_kfree_skb(skb);
1591	return NETDEV_TX_OK;
1592}
1593
1594
1595/* clean_txring checks if packets have been sent by the card by reading
1596 * the TX_PDL register from the performance page and comparing it to the
1597 * number of committed packets. It then frees the skb's of the packets that
1598 * obviously have been sent to the network.
1599 *
1600 * Needs the PERFORMANCE page selected.
1601 */
1602static void hp100_clean_txring(struct net_device *dev)
1603{
1604	struct hp100_private *lp = netdev_priv(dev);
1605	int ioaddr = dev->base_addr;
1606	int donecount;
1607
1608#ifdef HP100_DEBUG_B
1609	hp100_outw(0x4211, TRACE);
1610	printk("hp100: %s: clean txring\n", dev->name);
1611#endif
1612
1613	/* How many PDLs have been transmitted? */
1614	donecount = (lp->txrcommit) - hp100_inb(TX_PDL);
1615
1616#ifdef HP100_DEBUG
1617	if (donecount > MAX_TX_PDL)
1618		printk("hp100: %s: Warning: More PDLs transmitted than committed to card???\n", dev->name);
1619#endif
1620
1621	for (; 0 != donecount; donecount--) {
1622#ifdef HP100_DEBUG_BM
1623		printk("hp100: %s: Free skb: data @0x%.8x txrcommit=0x%x TXPDL=0x%x, done=0x%x\n",
1624				dev->name, (u_int) lp->txrhead->skb->data,
1625				lp->txrcommit, hp100_inb(TX_PDL), donecount);
1626#endif
1627		/* Conversion to new PCI API : NOP */
1628		pci_unmap_single(lp->pci_dev, (dma_addr_t) lp->txrhead->pdl[1], lp->txrhead->pdl[2], PCI_DMA_TODEVICE);
1629		dev_consume_skb_any(lp->txrhead->skb);
1630		lp->txrhead->skb = NULL;
1631		lp->txrhead = lp->txrhead->next;
1632		lp->txrcommit--;
1633	}
1634}
1635
1636/* tx function for slave modes */
1637static netdev_tx_t hp100_start_xmit(struct sk_buff *skb,
1638				    struct net_device *dev)
1639{
1640	unsigned long flags;
1641	int i, ok_flag;
1642	int ioaddr = dev->base_addr;
1643	u_short val;
1644	struct hp100_private *lp = netdev_priv(dev);
1645
1646#ifdef HP100_DEBUG_B
1647	hp100_outw(0x4212, TRACE);
1648	printk("hp100: %s: start_xmit\n", dev->name);
1649#endif
1650	if (skb->len <= 0)
1651		goto drop;
1652
1653	if (hp100_check_lan(dev))
1654		goto drop;
1655
1656	/* If there is not enough free memory on the card... */
1657	i = hp100_i

Large files files are truncated, but you can click here to view the full file