/*
 *
 * linux/drivers/s390/net/qeth.c ($Revision: 1.337.4.24 $)
 *
 * Linux on zSeries OSA Express and HiperSockets support
 *
 * Copyright 2000,2003 IBM Corporation
 *
 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>
 *            Cornelia Huck <cohuck@de.ibm.com> (chandev stuff,
 *                                               numerous bugfixes)
 *            Frank Pavlic <pavlic@de.ibm.com>  (query/purge ARP, SNMP, fixes)
 *            Andreas Herrmann <aherrman@de.ibm.com> (bugfixes)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 * For all devices, three channels must be available to the driver. One
 * channel is the read channel, one is the write channel and the third
 * one is the channel used to control QDIO.
 *
 * There are several stages from the channel recognition to the running
 * network device:
 * - The channels are scanned and ordered due to the parameters (see
 *   MODULE_PARM_DESC)
 * - The card is hardsetup: this means, that the communication channels
 *   are prepared
 * - The card is softsetup: this means, that commands are issued
 *   to activate the network parameters
 * - After that, data can flow through the card (transported by QDIO)
 *
 *IPA Takeover:
 * /proc/qeth_ipa_takeover provides the possibility to add and remove
 * certain ranges of IP addresses to the driver. As soon as these
 * addresses have to be set by the driver, the driver uses the OSA
 * Address Takeover mechanism.
 * reading out of the proc-file displays the registered addresses;
 * writing into it changes the information. Only one command at one
 * time must be written into the file. Subsequent commands are ignored.
 * The following commands are available:
 * inv4
 * inv6
 * add4 <ADDR>/<mask bits>[:<interface>]
 * add6 <ADDR>/<mask bits>[:<interface>]
 * del4 <ADDR>/<mask bits>[:<interface>]
 * del6 <ADDR>/<mask bits>[:<interface>]
 * inv4 and inv6 toggle the IPA takeover behaviour for all interfaces:
 * when inv4 was input once, all addresses specified with add4 are not
 * set using the takeover mechanism, but all other IPv4 addresses are set so.
 *
 * add# adds an address range, del# deletes an address range. # corresponds
 * to the IP version (4 or 6).
 * <ADDR> is a 8 or 32byte hexadecimal view of the IP address.
 * <mask bits> specifies the number of bits which are set in the network mask.
 * <interface> is optional and specifies the interface name to which the
 * address range is bound.
 * E. g.
 *   add4 C0a80100/24
 * activates all addresses in the 192.168.10 subnet for address takeover.
 * Note, that the address is not taken over before an according ifconfig
 * is executed.
 *
 *VIPA:
 * add_vipa4 <ADDR>:<interface>
 * add_vipa6 <ADDR>:<interface>
 * del_vipa4 <ADDR>:<interface>
 * del_vipa6 <ADDR>:<interface>
 *
 * the specified address is set/unset as VIPA on the specified interface.
 * use the src_vipa package to exploit this out of arbitrary applications.
 *
 *Proxy ARP:
 *
 * add_rxip4 <ADDR>:<interface>
 * add_rxip6 <ADDR>:<interface>
 * del_rxip4 <ADDR>:<interface>
 * del_rxip6 <ADDR>:<interface>
 *
 * the specified address is set/unset as "do not fail a gratuitous ARP"
 * on the specified interface. this can be used to act as a proxy ARP.
 */

void volatile qeth_eyecatcher(void)
{
        return;
}

#include <linux/config.h>

#ifndef CONFIG_CHANDEV
#error "qeth can only be compiled with chandev support"
#endif /* CONFIG_CHANDEV */

#include <linux/module.h>

#include <linux/string.h>
#include <linux/errno.h>
#include <linux/mm.h>

#include <linux/version.h>

#include <asm/io.h>
#include <asm/ebcdic.h>
#include <linux/ctype.h>
#include <asm/semaphore.h>
#include <linux/if.h>
#include <linux/if_arp.h>
#include <linux/ip.h>
#include <linux/inetdevice.h>
#include <linux/netdevice.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/tcp.h>
#include <linux/icmp.h>
#include <linux/skbuff.h>
#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
#endif /* CONFIG_PROC_FS */
#include <net/route.h>
#include <net/arp.h>
#include <linux/in.h>
#include <linux/igmp.h>
#include <net/ip.h>
#include <asm/uaccess.h>
#include <linux/init.h>
#include <net/ipv6.h>
#include <linux/in6.h>
#include <net/if_inet6.h>
#include <net/addrconf.h>
#include <linux/if_tr.h>
#include <linux/trdevice.h>
#include <linux/etherdevice.h>
#include <linux/reboot.h>

#include <linux/if_vlan.h>
#include <asm/chandev.h>

#include <asm/irq.h>
#include <asm/s390dyn.h>
#include <asm/debug.h>
#include <asm/processor.h>

#include <asm/qdio.h>

#include "qeth_mpc.h"
#include "qeth.h"

/****************** MODULE PARAMETER VARIABLES ********************/
static int qeth_sparebufs=0;
MODULE_PARM(qeth_sparebufs,"i");
MODULE_PARM_DESC(qeth_sparebufs,"the number of pre-allocated spare buffers " \
                 "reserved for low memory situations");

static int global_stay_in_mem=0;

/****************** MODULE STUFF **********************************/
#define VERSION_QETH_C "$Revision: 1.337.4.24 $"
static const char *version="qeth S/390 OSA-Express driver (" \
        VERSION_QETH_C "/" VERSION_QETH_H "/" VERSION_QETH_MPC_H
        QETH_VERSION_IPV6 QETH_VERSION_VLAN ")";

MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>");
MODULE_DESCRIPTION("Linux on zSeries OSA Express and HiperSockets support\n" \
                   "Copyright 2000,2003 IBM Corporation\n");
MODULE_LICENSE("GPL");

/******************** HERE WE GO ***********************************/



static qeth_card_t *firstcard=NULL;

static sparebufs_t sparebufs[MAX_SPARE_BUFFERS];
static int sparebuffer_count;

static unsigned int known_devices[][10]=QETH_MODELLIST_ARRAY;

static spinlock_t setup_lock;
static rwlock_t list_lock=RW_LOCK_UNLOCKED;

static debug_info_t *qeth_dbf_setup=NULL;
static debug_info_t *qeth_dbf_data=NULL;
static debug_info_t *qeth_dbf_misc=NULL;
static debug_info_t *qeth_dbf_control=NULL;
static debug_info_t *qeth_dbf_trace=NULL;
static debug_info_t *qeth_dbf_sense=NULL;
static debug_info_t *qeth_dbf_qerr=NULL;

static int proc_file_registration;
#ifdef QETH_PERFORMANCE_STATS
static int proc_perf_file_registration;
#define NOW qeth_get_micros()
#endif /* QETH_PERFORMANCE_STATS */
static int proc_ipato_file_registration;

static int ipato_inv4=0,ipato_inv6=0;
static ipato_entry_t *ipato_entries=NULL;
static spinlock_t ipato_list_lock;

typedef struct {
        char *data;
        int len;
} tempinfo_t;

/* thought I could get along without forward declarations...
 * just lazyness here */
static int qeth_reinit_thread(void*);
static inline void qeth_schedule_recovery(qeth_card_t *card);
static int qeth_fake_header(struct sk_buff *skb, struct net_device *dev,
                            unsigned short type, void *daddr, void *saddr,
                            unsigned len);

static inline int QETH_IP_VERSION(struct sk_buff *skb)
{
        switch (skb->protocol) {
        case ETH_P_IPV6: return 6;
        case ETH_P_IP: return 4;
        default: return 0;
        }
}
/* not a macro, as one of the arguments is atomic_read */
static inline int qeth_min(int a,int b)
{
        if (a<b)
                return a;
        else
                return b;
}

/*
 * This is our local skb_unshare, only with pskb_copy instead of skb_copy.
 * We place our headers whare Ethernet MAC was, so we do not need
 * full skb_copy.
 */
static inline struct sk_buff *qeth_pskb_unshare(struct sk_buff *skb, int pri)
{
        struct sk_buff *nskb;
        if (!skb_cloned(skb))
                return skb;
        nskb = skb_copy(skb, pri);
        kfree_skb(skb); /* free our shared copy */
        return nskb;
}

static inline unsigned int qeth_get_millis(void)
{
        __u64 time;

        asm volatile ("STCK %0" : "=m" (time));
        return (int) (time>>22); /* time>>12 is microseconds, we divide it
                                    by 1024 */
}

#ifdef QETH_PERFORMANCE_STATS
static inline unsigned int qeth_get_micros(void)
{
        __u64 time;

        asm volatile ("STCK %0" : "=m" (time));
        return (int) (time>>12);
}
#endif /* QETH_PERFORMANCE_STATS */

static void qeth_delay_millis(unsigned long msecs)
{
        unsigned int start;

        start=qeth_get_millis();
        while (qeth_get_millis()-start<msecs)
                ;
}

static void qeth_wait_nonbusy(unsigned int timeout)
{
        unsigned int start;
        char dbf_text[15];

        sprintf(dbf_text,"wtnb%4x",timeout);
        QETH_DBF_TEXT3(0,trace,dbf_text);

        start=qeth_get_millis();
        for (;;) {
                set_task_state(current,TASK_INTERRUPTIBLE);
                if (qeth_get_millis()-start>timeout) {
                        goto out;
                }
                schedule_timeout(((start+timeout-qeth_get_millis())>>10)*HZ);
        }
 out:
        set_task_state(current,TASK_RUNNING);
}

static inline void qeth_get_mac_for_ipm(__u32 ipm,char *mac,
                                        struct net_device *dev) {
        if (dev->type==ARPHRD_IEEE802_TR)
                ip_tr_mc_map(ipm,mac);
        else
                ip_eth_mc_map(ipm,mac);
}

#define HEXDUMP16(importance,header,ptr) \
PRINT_##importance(header "%02x %02x %02x %02x  %02x %02x %02x %02x  " \
                   "%02x %02x %02x %02x  %02x %02x %02x %02x\n", \
                   *(((char*)ptr)),*(((char*)ptr)+1),*(((char*)ptr)+2), \
                   *(((char*)ptr)+3),*(((char*)ptr)+4),*(((char*)ptr)+5), \
                   *(((char*)ptr)+6),*(((char*)ptr)+7),*(((char*)ptr)+8), \
                   *(((char*)ptr)+9),*(((char*)ptr)+10),*(((char*)ptr)+11), \
                   *(((char*)ptr)+12),*(((char*)ptr)+13), \
                   *(((char*)ptr)+14),*(((char*)ptr)+15)); \
PRINT_##importance(header "%02x %02x %02x %02x  %02x %02x %02x %02x  " \
                   "%02x %02x %02x %02x  %02x %02x %02x %02x\n", \
                   *(((char*)ptr)+16),*(((char*)ptr)+17), \
                   *(((char*)ptr)+18),*(((char*)ptr)+19), \
                   *(((char*)ptr)+20),*(((char*)ptr)+21), \
                   *(((char*)ptr)+22),*(((char*)ptr)+23), \
                   *(((char*)ptr)+24),*(((char*)ptr)+25), \
                   *(((char*)ptr)+26),*(((char*)ptr)+27), \
                   *(((char*)ptr)+28),*(((char*)ptr)+29), \
                   *(((char*)ptr)+30),*(((char*)ptr)+31));

#define atomic_swap(a,b) xchg((int*)a.counter,b)

#ifdef QETH_DBF_LIKE_HELL

#define my_read_lock(x) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"rd_lck"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        read_lock(x); \
} while (0)
#define my_read_unlock(x) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"rd_unlck"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        read_unlock(x); \
} while (0)
#define my_write_lock(x) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"wr_lck"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        write_lock(x); \
} while (0)
#define my_write_unlock(x) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"wr_unlck"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        write_unlock(x); \
} while (0)

#define my_spin_lock(x) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"sp_lck"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        spin_lock(x); \
} while (0)
#define my_spin_unlock(x) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"sp_unlck"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        spin_unlock(x); \
} while (0)
#define my_spin_lock_irqsave(x,y) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"sp_lck_i"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        spin_lock_irqsave(x,y); \
} while (0)
#define my_spin_unlock_irqrestore(x,y) do { \
        void *ptr=x; \
        QETH_DBF_TEXT6(0,trace,"sp_nlk_i"); \
        QETH_DBF_HEX6(0,trace,&ptr,sizeof(void*)); \
        spin_unlock_irqrestore(x,y); \
} while (0)

#else /* QETH_DBF_LIKE_HELL */

#define my_read_lock(x) read_lock(x)
#define my_write_lock(x) write_lock(x)
#define my_read_unlock(x) read_unlock(x)
#define my_write_unlock(x) write_unlock(x)

#define my_spin_lock(x) spin_lock(x)
#define my_spin_unlock(x) spin_unlock(x)
#define my_spin_lock_irqsave(x,y) spin_lock_irqsave(x,y)
#define my_spin_unlock_irqrestore(x,y) spin_unlock_irqrestore(x,y)

#endif /* QETH_DBF_LIKE_HELL */

static int inline my_spin_lock_nonbusy(qeth_card_t *card,spinlock_t *lock)
{
        for (;;) {
                if (card) {
                        if (atomic_read(&card->shutdown_phase)) return -1;
                }
                if (spin_trylock(lock)) return 0;
                qeth_wait_nonbusy(QETH_IDLE_WAIT_TIME);
        }
}

#ifdef CONFIG_ARCH_S390X
#define QETH_GET_ADDR(x) ((__u32)(unsigned long)x)
#else /* CONFIG_ARCH_S390X */
#define QETH_GET_ADDR(x) ((__u32)x)
#endif /* CONFIG_ARCH_S390X */

static inline int qeth_does_card_exist(qeth_card_t *card)
{
        qeth_card_t *c=firstcard;
        int rc=0;

        my_read_lock(&list_lock);
        while (c) {
                if (c==card) {
                        rc=1;
                        break;
                }
                c=c->next;
        }
        my_read_unlock(&list_lock);
        return rc;
}

static inline qeth_card_t *qeth_get_card_by_irq(int irq)
{
        qeth_card_t *card;

        my_read_lock(&list_lock);
        card=firstcard;
        while (card) {
                if ((card->irq0==irq)&&
                    (atomic_read(&card->shutdown_phase)!=
                     QETH_REMOVE_CARD_QUICK)) break;
                if ((card->irq1==irq)&&
                    (atomic_read(&card->shutdown_phase)!=
                     QETH_REMOVE_CARD_QUICK)) break;
                if ((card->irq2==irq)&&
                    (atomic_read(&card->shutdown_phase)!=
                     QETH_REMOVE_CARD_QUICK)) break;
                card=card->next;
        }
        my_read_unlock(&list_lock);

        return card;
}

static int qeth_getxdigit(char c)
{
        if ((c>='0') && (c<='9')) return c-'0';
        if ((c>='a') && (c<='f')) return c+10-'a';
        if ((c>='A') && (c<='F')) return c+10-'A';
        return -1;
}

static qeth_card_t *qeth_get_card_by_name(char *name)
{
        qeth_card_t *card;

        my_read_lock(&list_lock);
        card=firstcard;
        while (card) {
                if (!strncmp(name,card->dev_name,DEV_NAME_LEN)) break;
                card=card->next;
        }
        my_read_unlock(&list_lock);

        return card;
}

static void qeth_convert_addr_to_text(int version,__u8 *addr,char *text)
{
        if (version==4) {
                sprintf(text,"%02x%02x%02x%02x",
                        addr[0],addr[1],addr[2],addr[3]);
        } else {
                sprintf(text,"%02x%02x%02x%02x%02x%02x%02x%02x" \
                        "%02x%02x%02x%02x%02x%02x%02x%02x",
                        addr[0],addr[1],addr[2],addr[3],
                        addr[4],addr[5],addr[6],addr[7],
                        addr[8],addr[9],addr[10],addr[11],
                        addr[12],addr[13],addr[14],addr[15]);
        }
}

static int qeth_convert_text_to_addr(int version,char *text,__u8 *addr)
{
        int olen=(version==4)?4:16;

        while (olen--) {
                if ( (!isxdigit(*text)) || (!isxdigit(*(text+1))) )
                        return -EINVAL;
                *addr=(qeth_getxdigit(*text)<<4)+qeth_getxdigit(*(text+1));
                addr++;
                text+=2;
        }
        return 0;
}

static void qeth_add_ipato_entry(int version,__u8 *addr,int mask_bits,
                                 char *dev_name)
{
        ipato_entry_t *entry,*e;
        int len=(version==4)?4:16;

        entry=(ipato_entry_t*)kmalloc(sizeof(ipato_entry_t),GFP_KERNEL);
        if (!entry) {
                PRINT_ERR("not enough memory for ipato allocation\n");
                return;
        }
        entry->version=version;
        memcpy(entry->addr,addr,len);
        if (dev_name) {
                strncpy(entry->dev_name,dev_name,DEV_NAME_LEN);
                if (qeth_get_card_by_name(dev_name)->options.ena_ipat!=
                    ENABLE_TAKEOVER)
                        PRINT_WARN("IP takeover is not enabled on %s! " \
                                   "Ignoring line\n",dev_name);
        } else
                memset(entry->dev_name,0,DEV_NAME_LEN);
        entry->mask_bits=mask_bits;
        entry->next=NULL;

        my_spin_lock(&ipato_list_lock);
        if (ipato_entries) {
                e=ipato_entries;
                while (e) {
                        if ( (e->version==version) &&
                             (e->mask_bits==mask_bits) &&
                             ( ((dev_name)&&!strncmp(e->dev_name,dev_name,
                                                     DEV_NAME_LEN)) ||
                               (!dev_name) ) &&
                             (!memcmp(e->addr,addr,len)) ) {
                                PRINT_INFO("ipato to be added does already " \
                                           "exist\n");
                                kfree(entry);
                                goto out;
                             }
                        if (e->next) e=e->next; else break;
                }
                e->next=entry;
        } else
                ipato_entries=entry;
out:
        my_spin_unlock(&ipato_list_lock);
}

static void qeth_del_ipato_entry(int version,__u8 *addr,int mask_bits,
                                 char *dev_name)
{
        ipato_entry_t *e,*e_before;
        int len=(version==4)?4:16;
        int found=0;
        
        my_spin_lock(&ipato_list_lock);
        e=ipato_entries;
        if ( (e->version==version) &&
             (e->mask_bits==mask_bits) &&
             (!memcmp(e->addr,addr,len)) ) {
                ipato_entries=e->next;
                kfree(e);
        } else while (e) {
                e_before=e;
                e=e->next;
                if (!e) break;
                if ( (e->version==version) &&
                     (e->mask_bits==mask_bits) &&
                     ( ((dev_name)&&!strncmp(e->dev_name,dev_name,
                                             DEV_NAME_LEN)) ||
                       (!dev_name) ) &&
                     (!memcmp(e->addr,addr,len)) ) {
                        e_before->next=e->next;
                        kfree(e);
                        found=1;
                        break;
                }
        }
        if (!found)
                PRINT_INFO("ipato to be deleted does not exist\n");
        my_spin_unlock(&ipato_list_lock);
}

static void qeth_convert_addr_to_bits(__u8 *addr,char *bits,int len)
{
        int i,j;
        __u8 octet;
        
        for (i=0;i<len;i++) {
                octet=addr[i];
                for (j=7;j>=0;j--) {
                        bits[i*8+j]=(octet&1)?1:0;
                        octet>>=1;
                }
        }
}

static int qeth_is_ipa_covered_by_ipato_entries(int version,__u8 *addr,
                                                qeth_card_t *card)
{
        char *memarea,*addr_bits,*entry_bits;
        int len=(version==4)?4:16;
        int invert=(version==4)?ipato_inv4:ipato_inv6;
        int result=0;
        ipato_entry_t *e;

        if (card->options.ena_ipat!=ENABLE_TAKEOVER) {
                return 0;
        }

        memarea=kmalloc(256,GFP_KERNEL);
        if (!memarea) {
                PRINT_ERR("not enough memory to check out whether to " \
                          "use ipato\n");
                return 0;
        }
        addr_bits=memarea;
        entry_bits=memarea+128;
        qeth_convert_addr_to_bits(addr,addr_bits,len);
        e=ipato_entries;
        while (e) {
                qeth_convert_addr_to_bits(e->addr,entry_bits,len);
                if ( (!memcmp(addr_bits,entry_bits,
                              __min(len*8,e->mask_bits))) &&
                     ( (e->dev_name[0]&&
                        (!strncmp(e->dev_name,card->dev_name,DEV_NAME_LEN))) ||
                       (!e->dev_name[0]) ) ) {
                        result=1;
                        break;
                }
                e=e->next;
        }

        kfree(memarea);
        if (invert)
                return !result;
        else
                return result;
}

static void qeth_set_dev_flag_running(qeth_card_t *card)
{
        if (card) {
                card->dev->flags|=IFF_RUNNING;
/*
                clear_bit(__LINK_STATE_DOWN,&dev->flags);
*/
        }
}

static void qeth_set_dev_flag_norunning(qeth_card_t *card)
{
        if (card) {
                card->dev->flags&=~IFF_RUNNING;
/*
                set_bit(__LINK_STATE_DOWN,&dev->flags);
*/
        }
}

static void qeth_restore_dev_flag_state(qeth_card_t *card)
{
        if (card) {
                if (card->saved_dev_flags&IFF_RUNNING)
                        card->dev->flags|=IFF_RUNNING;
                else
                        card->dev->flags&=~IFF_RUNNING;
/*
                if (card->saved_dev_flags&__LINK_STATE_DOWN)
                        set_bit(__LINK_STATE_DOWN,&card->dev->flags);
                else
                        clear_bit(__LINK_STATE_DOWN,&card->dev->flags);
*/
        }
}

static void qeth_save_dev_flag_state(qeth_card_t *card)
{
        if (card) {
                card->saved_dev_flags=card->dev->flags&IFF_RUNNING;
/*
                card->saved_dev_flags=card->dev->flags&__LINK_STATE_DOWN;
*/
        }
}

static inline int netif_is_busy(struct net_device *dev)
{
        return(test_bit(__LINK_STATE_XOFF,&dev->flags));
}

static int qeth_open(struct net_device *dev)
{
        char dbf_text[15];
        qeth_card_t *card;

        card=(qeth_card_t *)dev->priv;
        sprintf(dbf_text,"open%4x",card->irq0);
        QETH_DBF_TEXT2(0,trace,dbf_text);
        QETH_DBF_TEXT2(0,setup,dbf_text);

        qeth_save_dev_flag_state(card);

        netif_start_queue(dev);
        if (!atomic_swap(&((qeth_card_t*)dev->priv)->is_open,1)) {
                MOD_INC_USE_COUNT;
        }
        return 0;
}

static int qeth_set_config(struct net_device *dev,struct ifmap *map)
{
        qeth_card_t *card=(qeth_card_t*)dev->priv;
        char dbf_text[15];

        sprintf(dbf_text,"nscf%04x",card->irq0);
        QETH_DBF_TEXT3(0,trace,dbf_text);

        return -EOPNOTSUPP;
}

static int qeth_is_multicast_skb_at_all(struct sk_buff *skb,int version)
{
        int i=RTN_UNSPEC;
        qeth_card_t *card = (qeth_card_t *)skb->dev->priv;

        if (skb->dst && skb->dst->neighbour) {
                i=skb->dst->neighbour->type;
                return ((i==RTN_BROADCAST)||
                        (i==RTN_MULTICAST)||
                        (i==RTN_ANYCAST))?i:0;
        }
        /* ok, we've to try it somehow else */
        if (version==4) {
                return ((skb->nh.raw[16]&0xf0)==0xe0)?RTN_MULTICAST:0;
        } else if (version==6) {
                return (skb->nh.raw[24]==0xff)?RTN_MULTICAST:0;
        }
        if (!memcmp(skb->nh.raw,skb->dev->broadcast,6)) {
                i=RTN_BROADCAST;
        } else {
                __u16 hdr_mac;
                hdr_mac=*((__u16*)skb->nh.raw);
                /* tr multicast? */
                switch (card->link_type) {
                case QETH_MPC_LINK_TYPE_HSTR:
                case QETH_MPC_LINK_TYPE_LANE_TR:
                        if ( (hdr_mac==QETH_TR_MAC_NC) ||
                             (hdr_mac==QETH_TR_MAC_C) )
                                i = RTN_MULTICAST;
                        break;
                /* eth or so multicast? */
                default:
                        if ( (hdr_mac==QETH_ETH_MAC_V4) ||
                             (hdr_mac==QETH_ETH_MAC_V6) )
                                i = RTN_MULTICAST;
                }
        }
        return ((i==RTN_BROADCAST)||
                (i==RTN_MULTICAST)||
                (i==RTN_ANYCAST))?i:0;
}

static int qeth_get_prioqueue(qeth_card_t *card,struct sk_buff *skb,
                              int multicast,int version)
{
        if (!version &&
            (card->type==QETH_CARD_TYPE_OSAE))
                return QETH_DEFAULT_QUEUE;
        switch (card->no_queues) {
        case 1:
                return 0;
        case 4:
                if ( (card->can_do_async_iqd) &&
                     (card->options.async_iqd==ASYNC_IQD) ) {
                        return card->no_queues-1;
                }
                if (card->is_multicast_different) {
                        if (multicast) {
                            return card->is_multicast_different&
                                    (card->no_queues-1);
                        } else {
                                return 0;
                        }
                }
                if (card->options.do_prio_queueing) {
                        if (version==4) {
                                if (card->options.do_prio_queueing==
                                    PRIO_QUEUEING_TOS) {
                                        if (skb->nh.iph->tos&
                                            IP_TOS_NOTIMPORTANT) {
                                                return 3;
                                        }
                                        if (skb->nh.iph->tos&
                                            IP_TOS_LOWDELAY) {
                                                return 0;
                                        }
                                        if (skb->nh.iph->tos&
                                            IP_TOS_HIGHTHROUGHPUT) {
                                                return 1;
                                        }
                                        if (skb->nh.iph->tos&
                                            IP_TOS_HIGHRELIABILITY) {
                                                return 2;
                                        }
                                        return QETH_DEFAULT_QUEUE;
                                }
                                if (card->options.do_prio_queueing==
                                    PRIO_QUEUEING_PREC) {
                                        return 3-(skb->nh.iph->tos>>6);
                                }
                        } else if (version==6) {
/********************
 ********************
TODO: IPv6!!!
********************/
                        }
                        return card->options.default_queue;
                } else return card->options.default_queue;
        default:
                return 0;
        }
}

static void qeth_wakeup(qeth_card_t *card) {
        char dbf_text[15];

        sprintf(dbf_text,"wkup%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);

        atomic_set(&card->data_has_arrived,1);
        spin_lock(&card->wait_q_lock);
        if (atomic_read(&card->wait_q_active)) {
                wake_up(&card->wait_q);
        }
        spin_unlock(&card->wait_q_lock);
}

static int qeth_check_idx_response(unsigned char *buffer)
{
        if (!buffer)
                return 0;
        if ((buffer[2]&0xc0)==0xc0) {
                return -EIO;
        }
        return 0;
}

static int qeth_get_cards_problem(qeth_card_t *card,unsigned char *buffer,
                                  int irq,int dstat,int cstat,int rqparam,
                                  char *irb,char *sense)
{
        char dbf_text[15];
        int problem=0;

        if (atomic_read(&card->shutdown_phase)) return 0;
        if (dstat&DEV_STAT_UNIT_CHECK) {
                if (irq==card->irq2) {
                        sprintf(dbf_text,"ACHK%04x",card->irq0);
                        QETH_DBF_TEXT1(0,trace,dbf_text);
                        problem=PROBLEM_ACTIVATE_CHECK_CONDITION;
                        goto out;
                }
                if (sense[SENSE_RESETTING_EVENT_BYTE]&
                    SENSE_RESETTING_EVENT_FLAG) {
                        sprintf(dbf_text,"REVN%04x",card->irq0);
                        QETH_DBF_TEXT1(0,trace,dbf_text);
                        problem=PROBLEM_RESETTING_EVENT_INDICATOR;
                        goto out;
                }
                if (sense[SENSE_COMMAND_REJECT_BYTE]&
                    SENSE_COMMAND_REJECT_FLAG) {
                        sprintf(dbf_text,"CREJ%04x",card->irq0);
                        QETH_DBF_TEXT1(0,trace,dbf_text);
                        problem=PROBLEM_COMMAND_REJECT;
                        goto out;
                }
                if ( (sense[2]==0xaf)&&(sense[3]==0xfe) ) {
                        sprintf(dbf_text,"AFFE%04x",card->irq0);
                        QETH_DBF_TEXT1(0,trace,dbf_text);
                        problem=PROBLEM_AFFE;
                        goto out;
                }
                if ( (!sense[0]) && (!sense[1]) &&
                     (!sense[2]) && (!sense[3]) ) {
                        sprintf(dbf_text,"ZSNS%04x",card->irq0);
                        QETH_DBF_TEXT1(0,trace,dbf_text);
                        problem=PROBLEM_ZERO_SENSE_DATA;
                        goto out;
                }
                sprintf(dbf_text,"GCHK%04x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                problem=PROBLEM_GENERAL_CHECK;
                goto out;
        }
        if (cstat& (SCHN_STAT_CHN_CTRL_CHK|SCHN_STAT_INTF_CTRL_CHK|
                    SCHN_STAT_CHN_DATA_CHK|SCHN_STAT_CHAIN_CHECK|
                    SCHN_STAT_PROT_CHECK|SCHN_STAT_PROG_CHECK) ) {
                sprintf(dbf_text,"GCHK%04x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                QETH_DBF_HEX1(0,misc,irb,__max(QETH_DBF_MISC_LEN,64));
                PRINT_WARN("check on irq x%x, dstat=x%x, cstat=x%x, " \
                           "rqparam=x%x\n",irq,dstat,cstat,rqparam);
                HEXDUMP16(WARN,"irb: ",irb);
                HEXDUMP16(WARN,"irb: ",((char*)irb)+32);
                problem=PROBLEM_GENERAL_CHECK;
                goto out;
        }
        if (qeth_check_idx_response(buffer)) {
                PRINT_WARN("received an IDX TERMINATE on irq 0x%X/0x%X " \
                           "with cause code 0x%02x%s\n",
                           card->irq0,card->irq1,buffer[4],
                           (buffer[4]==0x22)?" -- try another portname":"");
                sprintf(dbf_text,"RTRM%04x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                problem=PROBLEM_RECEIVED_IDX_TERMINATE;
                goto out;
        }
        if (IS_IPA(buffer) && !IS_IPA_REPLY(buffer)) {
                if ( *(PDU_ENCAPSULATION(buffer))==IPA_CMD_STOPLAN ) {
                        atomic_set(&card->is_startlaned,0);
                        /* we don't do a  netif_stop_queue(card->dev);
                           we better discard all packets --
                           the outage could take longer */
                        PRINT_WARN("Link failure on %s (CHPID 0x%X) -- " \
                                   "there is a network problem or someone " \
                                   "pulled the cable or disabled the port."
                                   "Discarding outgoing packets.\n",
                                   card->dev_name,card->chpid);
                        sprintf(dbf_text,"CBOT%04x",card->irq0);
                        QETH_DBF_TEXT1(0,trace,dbf_text);
                        qeth_set_dev_flag_norunning(card);
                        problem=0;
                        goto out;
                }
                /* we checked for buffer!=0 in IS_IPA */
                if ( *(PDU_ENCAPSULATION(buffer))==IPA_CMD_STARTLAN ) {
                        if (!atomic_read(&card->is_startlaned)) {
                                atomic_set(&card->is_startlaned,1);
                                problem=PROBLEM_CARD_HAS_STARTLANED;
                        }
                        goto out;
                }
                if ( *(PDU_ENCAPSULATION(buffer))==
                     IPA_CMD_REGISTER_LOCAL_ADDR ) {
                        sprintf(dbf_text,"irla%04x",card->irq0);
                        QETH_DBF_TEXT3(0,trace,dbf_text);
                }
                if ( *(PDU_ENCAPSULATION(buffer))==
                     IPA_CMD_UNREGISTER_LOCAL_ADDR ) {
                        sprintf(dbf_text,"irla%04x",card->irq0);
                        QETH_DBF_TEXT3(0,trace,dbf_text);
                }
                PRINT_WARN("probably a problem on %s: received data is " \
                           "IPA, but not a reply: command=0x%x\n",
                           card->dev_name,*(PDU_ENCAPSULATION(buffer)+1));
                sprintf(dbf_text,"INRP%04x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                goto out;
        }
        /* no probs */
out:
        if (problem) {
                sprintf(dbf_text,"gcpr%4x",card->irq0);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                sprintf(dbf_text,"%2x%2x%4x",dstat,cstat,problem);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                sprintf(dbf_text,"%8x",rqparam);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                if (buffer)
                        QETH_DBF_HEX3(0,trace,&buffer,sizeof(void*));
                QETH_DBF_HEX3(0,trace,&irb,sizeof(void*));
                QETH_DBF_HEX3(0,trace,&sense,sizeof(void*));
        }
        atomic_set(&card->problem,problem);
        return problem;
}


static void qeth_issue_next_read(qeth_card_t *card)
{
        int result,result2;
        char dbf_text[15];

        sprintf(dbf_text,"isnr%04x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);

        /* set up next read ccw */

        memcpy(&card->dma_stuff->read_ccw,READ_CCW,sizeof(ccw1_t));
        card->dma_stuff->read_ccw.count=QETH_BUFSIZE;
        /* recbuf is not yet used by read channel program */
        card->dma_stuff->read_ccw.cda=QETH_GET_ADDR(card->dma_stuff->recbuf);

        /* we don't s390irq_spin_lock_irqsave(card->irq0,flags), as
           we are only called in the interrupt handler */
        result=do_IO(card->irq0,&card->dma_stuff->read_ccw,
                     MPC_SETUP_STATE,0,0);
        if (result) {
                qeth_delay_millis(QETH_WAIT_BEFORE_2ND_DOIO);
                result2=do_IO(card->irq0,&card->dma_stuff->read_ccw,
                              MPC_SETUP_STATE,0,0);
                PRINT_WARN("read handler on irq x%x, read: do_IO " \
                           "returned %i, next try returns %i\n",
                           card->irq0,result,result2);
                sprintf(dbf_text,"IsNR%04x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                sprintf(dbf_text,"%04x%04x",(__s16)result,(__s16)result2);
                QETH_DBF_TEXT1(0,trace,dbf_text);
        }
}

static int qeth_is_to_recover(qeth_card_t *card,int problem)
{
        switch (problem) {
        case PROBLEM_CARD_HAS_STARTLANED:
                return 1;
        case PROBLEM_RECEIVED_IDX_TERMINATE:
                if (atomic_read(&card->in_recovery)) {
                        return 1;
                } else {
                        qeth_set_dev_flag_norunning(card);
                        return 0;
                }
        case PROBLEM_ACTIVATE_CHECK_CONDITION:
                return 1;
        case PROBLEM_RESETTING_EVENT_INDICATOR:
                return 1;
        case PROBLEM_COMMAND_REJECT:
                return 0;
        case PROBLEM_ZERO_SENSE_DATA:
                return 0;
        case PROBLEM_GENERAL_CHECK:
                return 1;
        case PROBLEM_BAD_SIGA_RESULT:
                return 1;
        case PROBLEM_USER_TRIGGERED_RECOVERY:
                return 1;
        case PROBLEM_AFFE:
                return 1;
        case PROBLEM_MACHINE_CHECK:
                return 1;
        case PROBLEM_TX_TIMEOUT:
                return 1;
        }
        return 0;
}

static int qeth_wait_for_event(atomic_t *var,unsigned int timeout)
{
        unsigned int start;
        int retval;
        char dbf_text[15];

        QETH_DBF_TEXT5(0,trace,"wait4evn");
        sprintf(dbf_text,"%08x",timeout);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        QETH_DBF_HEX5(0,trace,&var,sizeof(void*));

        start=qeth_get_millis();
        for (;;) {
                set_task_state(current,TASK_INTERRUPTIBLE);
                if (atomic_read(var)) {
                        retval=0;
                        goto out;
                }
                if (qeth_get_millis()-start>timeout) {
                        retval=-ETIME;
                        goto out;
                }
                schedule_timeout(((start+timeout-qeth_get_millis())>>10)*HZ);
        }
 out:
        set_task_state(current,TASK_RUNNING);

        return retval;
}

static inline int qeth_get_spare_buf(void)
{
        int i=0;
        char dbf_text[15];

        while (i<sparebuffer_count) {
                if (!atomic_compare_and_swap(SPAREBUF_FREE,SPAREBUF_USED,
                                             &sparebufs[i].status)) {
                        sprintf(dbf_text,"gtspb%3x",i);
                        QETH_DBF_TEXT4(0,trace,dbf_text);
                        return i;
                }
                i++;
        }
        QETH_DBF_TEXT3(0,trace,"nospbuf");

        return -1;
}

static void qeth_put_spare_buf(int no)
{
        char dbf_text[15];
        
        sprintf(dbf_text,"ptspb%3x",no);
        QETH_DBF_TEXT4(0,trace,dbf_text);
        atomic_set(&sparebufs[no].status, SPAREBUF_FREE);
}

static inline void qeth_put_buffer_pool_entry(qeth_card_t *card,int entry_no)
{
        if (entry_no&SPAREBUF_MASK)
                qeth_put_spare_buf(entry_no&(~SPAREBUF_MASK));
        else
                card->inbound_buffer_pool_entry_used[entry_no]=BUFFER_UNUSED;
}

static inline int qeth_get_empty_buffer_pool_entry(qeth_card_t *card)
{
        int i;
        int max_buffers=card->options.inbound_buffer_count;
        
        for (i=0;i<max_buffers;i++) {
                if (xchg((int*)&card->inbound_buffer_pool_entry_used[i],
                         BUFFER_USED)==BUFFER_UNUSED) return i;
        }
        return -1;
}

static inline void qeth_clear_input_buffer(qeth_card_t *card,int bufno)
{
        qdio_buffer_t *buffer;
        int i;
        int elements,el_m_1;
        void *ptr;
#ifdef QETH_DBF_LIKE_HELL
        char dbf_text[15];

        sprintf(dbf_text,"clib%4x",card->irq0);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        sprintf(dbf_text,"bufno%3x",bufno);
        QETH_DBF_TEXT6(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */

        buffer=&card->inbound_qdio_buffers[bufno];
        elements=BUFFER_MAX_ELEMENTS;
        el_m_1=elements-1;

        for (i=0;i<elements;i++) {
                if (i==el_m_1)
                        buffer->element[i].flags=SBAL_FLAGS_LAST_ENTRY;
                else
                        buffer->element[i].flags=0;

                buffer->element[i].length=PAGE_SIZE;
                ptr=INBOUND_BUFFER_POS(card,bufno,i);
                if (card->do_pfix) {
                        /* we assume here, that ptr&(PAGE_SIZE-1)==0 */
                        buffer->element[i].addr=(void *)pfix_get_page_addr(ptr);
                        card->real_inb_buffer_addr[bufno][i]=ptr;
                } else {
                        buffer->element[i].addr=ptr;
                }
        }
}

static inline void qeth_queue_input_buffer(qeth_card_t *card,int bufno,
                                           unsigned int under_int)
{
        int count=0,start=0,stop=0,pos;
        int result;
        int cnt1,cnt2=0;
        int wrapped=0;
        int i;
        int requeue_counter;
        char dbf_text[15];
        int no;

#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"qibf%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        sprintf(dbf_text,"%4x%4x",under_int,bufno);
        QETH_DBF_TEXT5(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */
        atomic_inc(&card->requeue_counter);
        if (atomic_read(&card->requeue_counter) > QETH_REQUEUE_THRESHOLD) {
                if (!spin_trylock(&card->requeue_input_lock)) {
#ifndef QETH_DBF_LIKE_HELL
                        sprintf(dbf_text,"qibl%4x",card->irq0);
                        QETH_DBF_TEXT5(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */
                        return;
                }
                requeue_counter=atomic_read(&card->requeue_counter);
                pos=atomic_read(&card->requeue_position);

                start=pos;
                /* omit the situation with 128 simultaneously
                   enqueued buffers, as then we can't benefit from PCI
                   avoidance anymore -- therefore we let count not grow as
                   big as requeue_counter */
                while ( (!atomic_read(&card->inbound_buffer_refcnt[pos])) &&
                        (count<requeue_counter-1) ) {
                        no=qeth_get_empty_buffer_pool_entry(card);
                        if (no==-1) {
                                if (count) break;
                                no=qeth_get_spare_buf();
                                if (no==-1) {
                                        PRINT_ERR("%s: no more input "\
                                                  "buffers available! " \
                                                  "Inbound traffic could " \
                                                  "be lost! Try to spend " \
                                                  "more memory for qeth\n",
                                                  card->dev_name);
                                        sprintf(dbf_text,"QINB%4x",card->irq0);
                                        QETH_DBF_TEXT2(1,trace,dbf_text);
                                        goto out;
                                }
                                card->inbound_buffer_entry_no[pos]=
                                        no|SPAREBUF_MASK;
                        }
                        card->inbound_buffer_entry_no[pos]=no;
                        atomic_set(&card->inbound_buffer_refcnt[pos],1);
                        count++;
                        if (pos>=QDIO_MAX_BUFFERS_PER_Q-1) {
                                pos=0;
                                wrapped=1;
                        } else pos++;
                }
                /* stop points to the position after the last element */
                stop=pos;

#ifdef QETH_DBF_LIKE_HELL
                sprintf(dbf_text,"qibi%4x",card->irq0);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                sprintf(dbf_text,"%4x",requeue_counter);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                sprintf(dbf_text,"%4x%4x",start,stop);
                QETH_DBF_TEXT3(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */
                if (wrapped) {
                        cnt1=QDIO_MAX_BUFFERS_PER_Q-start;
                        cnt2=stop;
                } else {
                        cnt1=count;
                        /* cnt2 is already set to 0 */
                }

                atomic_sub(count,&card->requeue_counter);
                /* this is the only place where card->requeue_position is
                   written to, so that's ok (as it is in a lock) */
                atomic_set(&card->requeue_position,
                           (atomic_read(&card->requeue_position)+count)
                           &(QDIO_MAX_BUFFERS_PER_Q-1));

                if (cnt1) {
                        for (i=start;i<start+cnt1;i++) {
                                qeth_clear_input_buffer(card,i);
                        }
                        result=do_QDIO(card->irq2,
                                       QDIO_FLAG_SYNC_INPUT|under_int,
                                       0,start,cnt1,
                                       NULL);
                        if (result) {
                                PRINT_WARN("qeth_queue_input_buffer's " \
                                           "do_QDIO returnd %i " \
                                           "(irq 0x%x)\n",
                                           result,card->irq2);
                                sprintf(dbf_text,"QIDQ%4x",card->irq0);
                                QETH_DBF_TEXT1(0,trace,dbf_text);
                                sprintf(dbf_text,"%4x%4x",result,
                                        requeue_counter);
                                QETH_DBF_TEXT1(0,trace,dbf_text);
                                sprintf(dbf_text,"%4x%4x",start,cnt1);
                                QETH_DBF_TEXT1(1,trace,dbf_text);
                        }
                }
                if (cnt2) {
                        for (i=0;i<cnt2;i++) {
                                qeth_clear_input_buffer(card,i);
                        }
                        result=do_QDIO(card->irq2,
                                       QDIO_FLAG_SYNC_INPUT|under_int,0,
                                       0,cnt2,
                                       NULL);
                        if (result) {
                                PRINT_WARN("qeth_queue_input_buffer's " \
                                           "do_QDIO returnd %i " \
                                           "(irq 0x%x)\n",
                                           result,card->irq2);
                                sprintf(dbf_text,"QIDQ%4x",card->irq0);
                                QETH_DBF_TEXT1(0,trace,dbf_text);
                                sprintf(dbf_text,"%4x%4x",result,
                                        requeue_counter);
                                QETH_DBF_TEXT1(0,trace,dbf_text);
                                sprintf(dbf_text,"%4x%4x",0,cnt2);
                                QETH_DBF_TEXT1(1,trace,dbf_text);
                        }
                }
out:
                my_spin_unlock(&card->requeue_input_lock);
        }

}

static inline struct sk_buff *qeth_get_skb(unsigned int len)
{
        struct sk_buff *skb;

#ifdef QETH_VLAN
        skb=dev_alloc_skb(len+VLAN_HLEN);
        if (skb) skb_reserve(skb,VLAN_HLEN);
#else /* QETH_VLAN */
        skb=dev_alloc_skb(len);
#endif /* QETH_VLAN */
        return skb;
}

static inline struct sk_buff *qeth_get_next_skb(qeth_card_t *card,
                                                int *element_ptr,
                                                int *pos_in_el_ptr,
                                                void **hdr_ptr,
                                                qdio_buffer_t *buffer)
{
        int length;
        char *data_ptr;
        int step,len_togo,element,pos_in_el;
        int curr_len;
        int max_elements;
        struct sk_buff *skb;
        char dbf_text[15];

        max_elements=BUFFER_MAX_ELEMENTS;

#define SBALE_LEN(x) ((x>=max_elements)?0:(buffer->element[x].length))
#define SBALE_ADDR(x) (buffer->element[x].addr)

        element=*element_ptr;

        if (element>=max_elements) {
                PRINT_WARN("irq 0x%x: error in interpreting buffer (data " \
                           "too long), %i elements.\n",card->irq0,element);
                sprintf(dbf_text,"IEDL%4x",card->irq0);
                QETH_DBF_TEXT0(0,trace,dbf_text);
                sprintf(dbf_text,"%4x%4x",*element_ptr,*pos_in_el_ptr);
                QETH_DBF_TEXT0(1,trace,dbf_text);
                QETH_DBF_HEX0(0,misc,buffer,QETH_DBF_MISC_LEN);
                QETH_DBF_HEX0(0,misc,buffer+QETH_DBF_MISC_LEN,
                              QETH_DBF_MISC_LEN);
                return NULL;
        }

        pos_in_el=*pos_in_el_ptr;

        curr_len=SBALE_LEN(element);
        if (curr_len>PAGE_SIZE) {
                PRINT_WARN("irq 0x%x: bad element length in element %i: " \
                           "0x%x\n",card->irq0,element,curr_len);
                sprintf(dbf_text,"BELN%4x",card->irq0);
                QETH_DBF_TEXT0(0,trace,dbf_text);
                sprintf(dbf_text,"%4x",curr_len);
                QETH_DBF_TEXT0(0,trace,dbf_text);
                sprintf(dbf_text,"%4x%4x",*element_ptr,*pos_in_el_ptr);
                QETH_DBF_TEXT0(1,trace,dbf_text);
                QETH_DBF_HEX0(0,misc,buffer,QETH_DBF_MISC_LEN);
                QETH_DBF_HEX0(0,misc,buffer+QETH_DBF_MISC_LEN,
                              QETH_DBF_MISC_LEN);
                return NULL;
        }
        /* header fits in current element? */
        if (curr_len<pos_in_el+QETH_HEADER_SIZE) {
                if (!pos_in_el) {
#ifdef QETH_DBF_LIKE_HELL
                        sprintf(dbf_text,"gnmh%4x",card->irq0);
                        QETH_DBF_TEXT6(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */
                        return NULL; /* no more data in buffer */
                }
                /* set hdr to next element */
                element++;
                pos_in_el=0;
                curr_len=SBALE_LEN(element);
                /* does it fit in there? */
                if (curr_len<QETH_HEADER_SIZE) {
#ifdef QETH_DBF_LIKE_HELL
                        sprintf(dbf_text,"gdnf%4x",card->irq0);
                        QETH_DBF_TEXT6(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */
                        return NULL;
                }
        }

        *hdr_ptr=SBALE_ADDR(element)+pos_in_el;

        length=*(__u16*)((char*)(*hdr_ptr)+QETH_HEADER_LEN_POS);

#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"gnHd%4x",card->irq0);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        QETH_DBF_HEX6(0,trace,hdr_ptr,sizeof(void*));
#endif /* QETH_DBF_LIKE_HELL */

        pos_in_el+=QETH_HEADER_SIZE;
        if (curr_len<=pos_in_el) {
                /* switch to next element for data */
                pos_in_el=0;
                element++;
                curr_len=SBALE_LEN(element);
                if (!curr_len) {
                        PRINT_WARN("irq 0x%x: inb. buffer with more headers " \
                                   "than data areas (%i elements).\n",
                                   card->irq0,element);
                        sprintf(dbf_text,"IEMH%4x",card->irq0);
                        QETH_DBF_TEXT0(0,trace,dbf_text);
                        sprintf(dbf_text,"%2x%2x%4x",element,*element_ptr,
                                *pos_in_el_ptr);
                        QETH_DBF_TEXT0(1,trace,dbf_text);
                        QETH_DBF_HEX0(0,misc,buffer,QETH_DBF_MISC_LEN);
                        QETH_DBF_HEX0(0,misc,buffer+QETH_DBF_MISC_LEN,
                                      QETH_DBF_MISC_LEN);
                        return NULL;
                }
        }

        data_ptr=SBALE_ADDR(element)+pos_in_el;

        if (card->options.fake_ll==FAKE_LL) {
                skb=qeth_get_skb(length+QETH_FAKE_LL_LEN);
                if (!skb) goto nomem;
                skb_pull(skb,QETH_FAKE_LL_LEN);
        } else {
                skb=qeth_get_skb(length);
                if (!skb) goto nomem;
        }

        if (card->easy_copy_cap)
                memcpy(skb_put(skb,length),data_ptr,length);

#ifdef QETH_DBF_LIKE_HELL
        QETH_DBF_HEX6(0,trace,&data_ptr,sizeof(void*));
        QETH_DBF_HEX6(0,trace,&skb,sizeof(void*));
#endif /* QETH_DBF_LIKE_HELL */

        len_togo=length;
        while (1) {
                step=qeth_min(len_togo,curr_len-pos_in_el);
                if (!step) {
                        PRINT_WARN("irq 0x%x: unexpected end of buffer, " \
                                   "length of element %i is 0. Discarding " \
                                   "packet.\n",card->irq0,element);
                        sprintf(dbf_text,"IEUE%4x",card->irq0);
                        QETH_DBF_TEXT0(0,trace,dbf_text);
                        sprintf(dbf_text,"%2x%2x%4x",element,*element_ptr,
                                *pos_in_el_ptr);
                        QETH_DBF_TEXT0(0,trace,dbf_text);
                        sprintf(dbf_text,"%4x%4x",len_togo,step);
                        QETH_DBF_TEXT0(0,trace,dbf_text);
                        sprintf(dbf_text,"%4x%4x",curr_len,pos_in_el);
                        QETH_DBF_TEXT0(1,trace,dbf_text);
                        QETH_DBF_HEX0(0,misc,buffer,QETH_DBF_MISC_LEN);
                        QETH_DBF_HEX0(0,misc,buffer+QETH_DBF_MISC_LEN,
                                      QETH_DBF_MISC_LEN);
                        dev_kfree_skb_irq(skb);
                        return NULL;
                }
                if (!card->easy_copy_cap)
                        memcpy(skb_put(skb,step),data_ptr,step);
                len_togo-=step;
                if (len_togo) {
                        pos_in_el=0;
                        element++;
                        curr_len=SBALE_LEN(element);
                        data_ptr=SBALE_ADDR(element);
                } else {
#ifdef QETH_INBOUND_PACKING_1_PACKET_PER_SBALE
                        element++;
                        /* we don't need to calculate curr_len */
                        pos_in_el=0;
#else /* QETH_INBOUND_PACKING_1_PACKET_PER_SBALE */
                        pos_in_el+=step;
#endif /* QETH_INBOUND_PACKING_1_PACKET_PER_SBALE */
                        break;
                }
        }

#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"%4x%4x",element,pos_in_el);
        QETH_DBF_TEXT6(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */

        *element_ptr=element;
        *pos_in_el_ptr=pos_in_el;

        return skb;

nomem:
        if (net_ratelimit()) {
                PRINT_WARN("no memory for packet from %s\n",card->dev_name);
        }
        sprintf(dbf_text,"NOMM%4x",card->irq0);
        QETH_DBF_TEXT0(0,trace,dbf_text);
        return NULL;
}

static inline void qeth_transform_outbound_addrs(qeth_card_t *card,
                                                 qdio_buffer_t *buffer)
{
        int i;
        void *ptr;

        if (card->do_pfix) {
                for (i=0;i<QDIO_MAX_ELEMENTS_PER_BUFFER;i++) {
                        ptr=buffer->element[i].addr;
                        buffer->element[i].addr=(void *)pfix_get_addr(ptr);
                }
        }
}
static inline void qeth_get_linux_addrs_for_buffer(qeth_card_t *card,
                                                   int buffer_no)
{
        int i;
        void *ptr;

        if (card->do_pfix) {
                for (i=0;i<QDIO_MAX_ELEMENTS_PER_BUFFER;i++) {
                        ptr=card->inbound_qdio_buffers[buffer_no].
                                element[i].addr;
                        card->inbound_qdio_buffers[buffer_no].element[i].addr=
                                card->real_inb_buffer_addr[buffer_no][i]+
                                ((unsigned long)ptr&(PAGE_SIZE-1));
                }
        }
}

static inline void qeth_read_in_buffer(qeth_card_t *card,int buffer_no)
{
        struct sk_buff *skb;
        void *hdr_ptr;
        int element=0,pos_in_el=0;
        int version;
        qdio_buffer_t *buffer;
        unsigned short cast_type;
#ifdef QETH_VLAN
        __u16 *vlan_tag;
#endif
        int i;
        int max_elements;
        char dbf_text[15];
        struct net_device *dev;

        dev=card->dev;
        max_elements=BUFFER_MAX_ELEMENTS;

        buffer=&card->inbound_qdio_buffers[buffer_no];

        /* inform about errors */
        if (buffer->element[15].flags&0xff) {
                PRINT_WARN("on irq 0x%x: incoming SBALF 15 on buffer " \
                           "0x%x are 0x%x\n",card->irq0,buffer_no,
                           buffer->element[15].flags&0xff);
                sprintf(dbf_text,"SF##%2x%2x",buffer_no,
                        buffer->element[15].flags&0xff);
                *((__u16*)(&dbf_text[2]))=(__u16)card->irq0;
                QETH_DBF_HEX1(1,trace,dbf_text,QETH_DBF_TRACE_LEN);
        }

        for (i=0;i<max_elements-1;i++) {
                if (buffer->element[i].flags&SBAL_FLAGS_LAST_ENTRY) {
                        buffer->element[i+1].length=0;
                        break;
                }
        }
#ifdef QETH_PERFORMANCE_STATS
        card->perf_stats.bufs_rec++;
#endif /* QETH_PERFORMANCE_STATS */

#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"ribX%4x",card->irq0);
        dbf_text[3]=buffer_no;
        QETH_DBF_HEX6(0,trace,dbf_text,QETH_DBF_TRACE_LEN);
#endif /* QETH_DBF_LIKE_HELL */

        while ((skb=qeth_get_next_skb(card,&element,&pos_in_el,
                                      &hdr_ptr,buffer))) {

#ifdef QETH_PERFORMANCE_STATS
                card->perf_stats.skbs_rec++;
#endif /* QETH_PERFORMANCE_STATS */

                if (skb) {
                        skb->dev=dev;

#ifdef QETH_IPV6
                        if ( (*(__u16 *)(hdr_ptr))&(QETH_HEADER_PASSTHRU) ) {
                                skb->protocol=card->type_trans(skb,dev);
                        } else
#endif /* QETH_IPV6 */
                        {
                                version=((*(__u16 *)(hdr_ptr))&
                                         (QETH_HEADER_IPV6))?6:4;
                                skb->protocol=htons((version==4)?ETH_P_IP:
                                                    (version==6)?ETH_P_IPV6:
                                                    ETH_P_ALL);
                                cast_type=(*(__u16 *)(hdr_ptr))&
                                        (QETH_CAST_FLAGS);
                                if (cast_type==QETH_CAST_UNICAST) {
                                        skb->pkt_type=PACKET_HOST;
                                } else if (cast_type==QETH_CAST_MULTICAST) {
                                        skb->pkt_type=PACKET_MULTICAST;
                                } else if (cast_type==QETH_CAST_BROADCAST) {
                                        skb->pkt_type=PACKET_BROADCAST;
                                } else if ( (cast_type==QETH_CAST_ANYCAST) ||
                                            (cast_type==QETH_CAST_NOCAST) ) {
                                        sprintf(dbf_text,"ribf%4x",card->irq0);
                                        QETH_DBF_TEXT2(0,trace,dbf_text);
                                        sprintf(dbf_text,"castan%2x",cast_type);
                                        QETH_DBF_TEXT2(1,trace,dbf_text);
                                        skb->pkt_type=PACKET_HOST;
                                } else {
                                        PRINT_WARN("adapter is using an " \
                                                   "unknown casting value " \
                                                   "of 0x%x. Using " \
                                                   "unicasting instead.\n",
                                                   cast_type);
                                        skb->pkt_type=PACKET_HOST;
                                        sprintf(dbf_text,"ribf%4x",card->irq0);
                                        QETH_DBF_TEXT2(0,trace,dbf_text);
                                        sprintf(dbf_text,"castun%2x",cast_type);
                                        QETH_DBF_TEXT2(1,trace,dbf_text);
                                }

                if (card->options.fake_ll==FAKE_LL) {
                        skb->mac.raw=skb->data-QETH_FAKE_LL_LEN;
                        if (skb->pkt_type==PACKET_MULTICAST) {
                                switch (skb->protocol) {
#ifdef QETH_IPV6
                                case __constant_htons(ETH_P_IPV6):
                                        ndisc_mc_map((struct in6_addr *)
                                        skb->data+QETH_FAKE_LL_V6_ADDR_POS,
                                                skb->mac.raw+
                                                QETH_FAKE_LL_DEST_MAC_POS,
                                                card->dev,0);
                                        break;
#endif /* QETH_IPV6 */
                                case __constant_htons(ETH_P_IP):
                                        qeth_get_mac_for_ipm(*(__u32*)
                                        skb->data+QETH_FAKE_LL_V4_ADDR_POS,
                                                skb->mac.raw+
                                                QETH_FAKE_LL_DEST_MAC_POS,
                                                card->dev);
                                        break;
                                default:
                                        memcpy(skb->mac.raw+
                                               QETH_FAKE_LL_DEST_MAC_POS,
                                               card->dev->dev_addr,
                                               QETH_FAKE_LL_ADDR_LEN);
                                }
                        } else if (skb->pkt_type==PACKET_BROADCAST) {
                                memset(skb->mac.raw+
                                       QETH_FAKE_LL_DEST_MAC_POS,0xff,
                                       QETH_FAKE_LL_ADDR_LEN);
                        } else {
                                memcpy(skb->mac.raw+
                                       QETH_FAKE_LL_DEST_MAC_POS,
                                       card->dev->dev_addr,
                                       QETH_FAKE_LL_ADDR_LEN);
                        }
                        if (*(__u8*)(hdr_ptr+11)&
                            QETH_EXT_HEADER_SRC_MAC_ADDRESS) {
                                memcpy(skb->mac.raw+
                                       QETH_FAKE_LL_SRC_MAC_POS,
                               hdr_ptr+QETH_FAKE_LL_SRC_MAC_POS_IN_QDIO_HDR,
                                       QETH_FAKE_LL_ADDR_LEN);
                        } else {
                                /* clear source MAC for security reasons */
                                memset(skb->mac.raw+
                                       QETH_FAKE_LL_SRC_MAC_POS,0,
                                       QETH_FAKE_LL_ADDR_LEN);
                        }
                        memcpy(skb->mac.raw+
                               QETH_FAKE_LL_PROT_POS,
                               &skb->protocol,
                               QETH_FAKE_LL_PROT_LEN);
                } else {
                        skb->mac.raw=skb->data;
                }

                if (card->options.checksum_type==HW_CHECKSUMMING) {
                        /* do we have a checksummed packet? */

                        /* we only check for TCP/UDP checksums when the
                         * pseudo header was also checked sucessfully -- for
                         * the rest of the packets, it's not clear, whether
                         * the upper layer csum is alright. And they
                         * shouldn't occur too often anyway in real life */
                        if ( (*(__u8*)(hdr_ptr+11)&
                              (QETH_EXT_HEADER_CSUM_HDR_REQ|
                               QETH_EXT_HEADER_CSUM_TRANSP_REQ)) ==
                              (QETH_EXT_HEADER_CSUM_HDR_REQ|
                               QETH_EXT_HEADER_CSUM_TRANSP_REQ) ) {
                                /* csum does not need to be set
                                 * inbound anyway
                                 *
                                 * vlan is not an issue here, it's still in
                                 * the QDIO header, not pushed in the
                                 * skb yet *
                                int ip_len=(skb->data[0]&0x0f)<<2;

                                if (*(__u8*)(hdr_ptr+11)&
                                    QETH_EXT_HEADER_CSUM_TRANSP_FRAME_TYPE) {
                                        * get the UDP checksum *
                                        skb->csum=*(__u16*)
                                                (&skb->data[ip_len+
                                                 QETH_UDP_CSUM_OFFSET]);
                                } else {
                                        * get the TCP checksum *
                                        skb->csum=*(__u16*)
                                                (&skb->data[ip_len+
                                                 QETH_TCP_CSUM_OFFSET]);
                                }
                                 */
                                skb->ip_summed=CHECKSUM_UNNECESSARY;
                        } else {
                                /* make the stack check it */
                                skb->ip_summed=CHECKSUM_NONE;
                        }
                } else {
                        skb->ip_summed=card->options.checksum_type;
                }

#ifdef QETH_VLAN
                                if (*(__u8*)(hdr_ptr+11)&
                                    QETH_EXT_HEADER_VLAN_FRAME) {
                                        vlan_tag=(__u16 *)skb_push(skb,
                                                                   VLAN_HLEN);
                                        /*
                                         if (*(__u8*)(hdr_ptr+11) & 
                                             QETH_EXT_HEADER_INCLUDE_VLAN_TAG) {
                                           *vlan_tag = *(__u16*)(hdr_ptr+28);
                                           *(vlan_tag+1)= *(__u16*)(hdr_ptr+30);
                                         } else {
                                         */
                                        *vlan_tag = *(__u16*)(hdr_ptr+12);
                                        *(vlan_tag+1) = skb->protocol;
                                        /*
                                           }
                                         */
                                        skb->protocol=
                                                __constant_htons(ETH_P_8021Q);
                                }
#endif                          
                        }

#ifdef QETH_PERFORMANCE_STATS
                        card->perf_stats.inbound_time+=
                                NOW-card->perf_stats.inbound_start_time;
                        card->perf_stats.inbound_cnt++;
#endif /* QETH_PERFORMANCE_STATS */

#ifdef QETH_DBF_LIKE_HELL
                        sprintf(dbf_text,"rxpk%4x",card->irq0);
                        QETH_DBF_TEXT6(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */

                        netif_rx(skb);

                        card->stats->rx_packets++;
                        card->stats->rx_bytes+=skb->len;
                } else {
                        PRINT_WARN("%s: dropped packet, no buffers " \
                                   "available.\n",card->dev_name);
                        sprintf(dbf_text,"DROP%4x",card->irq0);
                        QETH_DBF_TEXT2(1,trace,dbf_text);
                        card->stats->rx_dropped++;
                }
        }
        atomic_set(&card->inbound_buffer_refcnt[buffer_no],0);
        qeth_put_buffer_pool_entry(card,card->inbound_buffer_entry_no[
                                   buffer_no]);
}

static inline void qeth_fill_header(qeth_hdr_t *hdr,struct sk_buff *skb,
                                    int version,int multicast)
{
#ifdef QETH_DBF_LIKE_HELL
        char dbf_text[15];
#endif /* QETH_DBF_LIKE_HELL */
#ifdef QETH_VLAN
        qeth_card_t *card;
#endif

        hdr->id=1;
        hdr->ext_flags=0;

#ifdef QETH_VLAN
        /* before we're going to overwrite 
         * this location with next hop ip.
         * v6 uses passthrough, v4 sets the tag in the QDIO header */
        card = (qeth_card_t *)skb->dev->priv;
        if ((card->vlangrp != NULL) && 
            vlan_tx_tag_present(skb)) 
        {
                if (version == 4) {
                        hdr->ext_flags = QETH_EXT_HEADER_VLAN_FRAME;
                } else {
                        hdr->ext_flags = QETH_EXT_HEADER_INCLUDE_VLAN_TAG;
                }
                hdr->vlan_id  = vlan_tx_tag_get(skb);
        }
#endif

        hdr->length=skb->len-QETH_HEADER_SIZE; /* as skb->len includes
                                                  the header now */

        /* yes, I know this is doubled code, but a small little bit
           faster maybe */
        if (version==4) { /* IPv4 */
                if (multicast==RTN_MULTICAST) {
                        hdr->flags=QETH_CAST_MULTICAST;
                } else if (multicast==RTN_BROADCAST) {
                        hdr->flags=QETH_CAST_BROADCAST;
                } else {
                        hdr->flags=QETH_CAST_UNICAST;
                }
                *((__u32*)(&hdr->dest_addr[0]))=0;
                *((__u32*)(&hdr->dest_addr[4]))=0;
                *((__u32*)(&hdr->dest_addr[8]))=0;
                if ((skb->dst) && (skb->dst->neighbour)) {
                *((__u32*)(&hdr->dest_addr[12]))=
                               *((__u32*)skb->dst->neighbour->primary_key);
                } else {
                        /* fill in destination address used
                         * in ip header */
                        *((__u32*)(&hdr->dest_addr[12]))=
                                skb->nh.iph->daddr;
                }
        } else if (version==6) { /* IPv6 or passthru */
                if (multicast==RTN_MULTICAST) {
                        hdr->flags=QETH_CAST_MULTICAST|
                                QETH_HEADER_PASSTHRU|
                                QETH_HEADER_IPV6;
                } else if (multicast==RTN_ANYCAST) {
                        hdr->flags=QETH_CAST_ANYCAST|
                                QETH_HEADER_PASSTHRU|
                                QETH_HEADER_IPV6;
                } else if (multicast==RTN_BROADCAST) {
                        hdr->flags=QETH_CAST_BROADCAST|
                                QETH_HEADER_PASSTHRU|
                                QETH_HEADER_IPV6;
                } else { /* default: RTN_UNICAST */
                        hdr->flags=QETH_CAST_UNICAST|
                                QETH_HEADER_PASSTHRU|
                                QETH_HEADER_IPV6;
                }

                if ((skb->dst) && (skb->dst->neighbour)) {
                        memcpy(hdr->dest_addr,
                               skb->dst->neighbour->primary_key,16);
                } else {
                        /* fill in destination address used
                         * in ip header */
                        memcpy(hdr->dest_addr,
                               &skb->nh.ipv6h->daddr,16);
                }
        } else { /* passthrough */
                if (!memcmp(skb->data+QETH_HEADER_SIZE,
                            skb->dev->broadcast,6)) { /* broadcast? */
                        hdr->flags=QETH_CAST_BROADCAST|QETH_HEADER_PASSTHRU;
                } else {
                        if (multicast==RTN_MULTICAST) {
                                hdr->flags=QETH_CAST_MULTICAST|
                                        QETH_HEADER_PASSTHRU;
                        } else {
                                hdr->flags=QETH_CAST_UNICAST|
                                        QETH_HEADER_PASSTHRU;
                        }
                }
        }
#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"filhdr%2x",version);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        sprintf(dbf_text,"%2x",multicast);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        QETH_DBF_HEX6(0,trace,&skb,sizeof(void*));
        QETH_DBF_HEX6(0,trace,&skb->data,sizeof(void*));
        QETH_DBF_HEX6(0,misc,hdr,__max(QETH_HEADER_SIZE,QETH_DBF_MISC_LEN));
        QETH_DBF_HEX6(0,data,skb->data,
                      __max(QETH_DBF_DATA_LEN,QETH_DBF_DATA_LEN));
#endif /* QETH_DBF_LIKE_HELL */
}

static inline int qeth_fill_buffer(qdio_buffer_t *buffer,char *dataptr,
                                   int length,int element)
{
        int length_here;
        int first_lap=1;
#ifdef QETH_DBF_LIKE_HELL
        char dbf_text[15];
#endif /* QETH_DBF_LIKE_HELL */
        int first_element=element;

        while (length>0) {
                /* length_here is the remaining amount of data in this page */
                length_here=PAGE_SIZE-((unsigned long)dataptr&(PAGE_SIZE-1));
                if (length<length_here) length_here=length;

                buffer->element[element].addr=dataptr;
                buffer->element[element].length=length_here;
                length-=length_here;
                if (!length) {
                        if (first_lap) {
                                buffer->element[element].flags=0;
                        } else {
                                buffer->element[element].flags=
                                        SBAL_FLAGS_LAST_FRAG;
                        }
                } else {
                        if (first_lap) {
                                buffer->element[element].flags=
                                        SBAL_FLAGS_FIRST_FRAG;
                        } else {
                                buffer->element[element].flags=
                                        SBAL_FLAGS_MIDDLE_FRAG;
                        }
                }
                dataptr=dataptr+length_here;
                element++;
                if (element>QDIO_MAX_ELEMENTS_PER_BUFFER) {
                        PRINT_ERR("qeth_fill_buffer: IP packet too big!\n");
                        QETH_DBF_TEXT1(0,trace,"IPpktobg");
                        QETH_DBF_HEX1(1,trace,&dataptr,sizeof(void*));
                        buffer->element[first_element].length=0;
                        break;
                }
                first_lap=0;
        }
#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"filbuf%2x",element);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        QETH_DBF_HEX3(0,misc,buffer,QETH_DBF_MISC_LEN);
        QETH_DBF_HEX3(0,misc,buffer+QETH_DBF_MISC_LEN,QETH_DBF_MISC_LEN);
#endif /* QETH_DBF_LIKE_HELL */

        return element;
}

static inline void qeth_flush_packed_packets(qeth_card_t *card,int queue,
                                             int under_int)
{
        qdio_buffer_t *buffer;
        int result;
        int position;
        int position_for_do_qdio;
        char dbf_text[15];
        int last_pci;

        position=card->outbound_first_free_buffer[queue];
        /* can happen, when in the time between deciding to pack and sending
           the next packet the lower mark was reached: */
        if (!card->outbound_ringbuffer[queue]->ringbuf_element[position].
            next_element_to_fill)
                return;

        buffer=&card->outbound_ringbuffer[queue]->buffer[position];
        buffer->element[card->outbound_ringbuffer[queue]->
                       ringbuf_element[position].
                       next_element_to_fill-1].flags|=SBAL_FLAGS_LAST_ENTRY;

        card->dev->trans_start=jiffies;
        
#ifdef QETH_PERFORMANCE_STATS
        if (card->outbound_buffer_send_state[queue][position]==
            SEND_STATE_DONT_PACK) {
                card->perf_stats.bufs_sent_dont_pack++;
        } else if (card->outbound_buffer_send_state[queue][position]==
                   SEND_STATE_PACK) {
                card->perf_stats.bufs_sent_pack++;
        }
        card->perf_stats.bufs_sent++;
#endif /* QETH_PERFORMANCE_STATS */

        position_for_do_qdio=position;

        position=(position+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
        card->outbound_first_free_buffer[queue]=position;

        card->outbound_bytes_in_buffer[queue]=0;
        /* we can override that, as we have at most 127 buffers enqueued */
        card->outbound_ringbuffer[queue]->ringbuf_element[position].
                next_element_to_fill=0;

        atomic_inc(&card->outbound_used_buffers[queue]);

#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"flsp%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        sprintf(dbf_text,"%4x%2x%2x",position_for_do_qdio,under_int,queue);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        QETH_DBF_HEX5(0,misc,buffer,QETH_DBF_MISC_LEN);
        QETH_DBF_HEX5(0,misc,buffer+QETH_DBF_MISC_LEN,QETH_DBF_MISC_LEN);
#endif /* QETH_DBF_LIKE_HELL */

        /* we always set the outbound pci flag, don't care, whether the
         * adapter honors it or not */
        switch (card->send_state[queue]) {
        case SEND_STATE_DONT_PACK:
                /* only request a PCI, if the fill level of the queue
                 * is close to the high watermark, so that we don't
                 * loose initiative during packing */
                if (atomic_read(&card->outbound_used_buffers[queue])
                    <HIGH_WATERMARK_PACK-WATERMARK_FUZZ) break;

                last_pci=atomic_read(&card->last_pci_pos[queue]);
                /* compensate queues that wrapped around */
                if (position_for_do_qdio<last_pci)
                        last_pci-=QDIO_MAX_BUFFERS_PER_Q;

                /* reduce the number of PCIs in cases where we are always
                 * a little below the high watermark for packing -- request
                 * PCIs less frequently */
                if (position_for_do_qdio-last_pci<
                    HIGH_WATERMARK_PACK-WATERMARK_FUZZ) break;

                /* set the PCI bit */
                card->outbound_ringbuffer[queue]->
                        buffer[position_for_do_qdio].element[0].flags|=0x40;
                atomic_set(&card->last_pci_pos[queue],position_for_do_qdio);
                break;
        case SEND_STATE_PACK:
                last_pci=atomic_read(&card->last_pci_pos[queue]);
                if (position_for_do_qdio<last_pci)
                        last_pci-=QDIO_MAX_BUFFERS_PER_Q;
                /* so:
                 * last_pci is the position of the last pci we've set
                 * position_for_do_qdio is the position we will send out now
                 * outbound_used_buffers is the number of buffers used (means
                 *   all buffers OSA has, inclusive position_for_do_qdio)
                 *
                 * we have to request a pci, if we have got the buffer of the
                 * last_pci position back.
                 *
                 * position_for_do_qdio-outbound_used_buffers is the newest
                 *   buffer that we got back from OSA
                 *
                 * if this is greater or equal than the last_pci position,
                 * we should request a pci, as no pci request is
                 * outstanding anymore
                 */
                if (position_for_do_qdio-
                    atomic_read(&card->outbound_used_buffers[queue])>=
                    last_pci) {
                        /* set the PCI bit */
                        card->outbound_ringbuffer[queue]->
                                buffer[position_for_do_qdio].
                                element[0].flags|=0x40;
                        atomic_set(&card->last_pci_pos[queue],
                                   position_for_do_qdio);
                }
        }

        qeth_transform_outbound_addrs(card,
                                      &card->outbound_ringbuffer[queue]->
                                      buffer[position_for_do_qdio]);
        /* this has to be at the end, otherwise a buffer could be flushed
           twice (see coment in qeth_do_send_packet) */
        result=do_QDIO(card->irq2,QDIO_FLAG_SYNC_OUTPUT|under_int,queue,
                       position_for_do_qdio,1,
                                       NULL);

        if (result) {
                PRINT_WARN("Outbound do_QDIO returned %i " \
                           "(irq 0x%x)\n",result,card->irq2);
                sprintf(dbf_text,"FLSP%4x",card->irq0);
                QETH_DBF_TEXT5(0,trace,dbf_text);
                sprintf(dbf_text,"odoQ%4x",result);
                QETH_DBF_TEXT5(0,trace,dbf_text);
                sprintf(dbf_text,"%4x%2x%2x",position_for_do_qdio,
                        under_int,queue);
                QETH_DBF_TEXT5(0,trace,dbf_text);
                QETH_DBF_HEX5(0,misc,buffer,QETH_DBF_MISC_LEN);
                QETH_DBF_HEX5(0,misc,buffer+QETH_DBF_MISC_LEN,
                              QETH_DBF_MISC_LEN);
        }
}

#define ERROR_NONE 0
#define ERROR_RETRY 1
#define ERROR_LINK_FAILURE 2
#define ERROR_KICK_THAT_PUPPY 3
static inline int qeth_determine_send_error(int cc,int qdio_error,int sbalf15)
{
        char dbf_text[15];

        switch (cc&3) {
        case 0:
                if (qdio_error)
                        return ERROR_LINK_FAILURE;
                return ERROR_NONE;
        case 2:
                if (cc&QDIO_SIGA_ERROR_B_BIT_SET) {
                        QETH_DBF_TEXT3(0,trace,"sigacc2b");
                        return ERROR_KICK_THAT_PUPPY;
                }
                if (qeth_sbalf15_in_retrieable_range(sbalf15))
                        return ERROR_RETRY;
                return ERROR_LINK_FAILURE;
                /* look at qdio_error and sbalf 15 */
        case 1:
                PRINT_WARN("siga returned cc 1! cc=0x%x, " \
                           "qdio_error=0x%x, sbalf15=0x%x\n",
                           cc,qdio_error,sbalf15);

                QETH_DBF_TEXT3(0,trace,"siga-cc1");
                QETH_DBF_TEXT2(0,qerr,"siga-cc1");
                sprintf(dbf_text,"%1x%2x%2x",cc,qdio_error,sbalf15);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                QETH_DBF_TEXT2(0,qerr,dbf_text);
                return ERROR_LINK_FAILURE;
        case 3:
                QETH_DBF_TEXT3(0,trace,"siga-cc3");
                return ERROR_KICK_THAT_PUPPY;
        }
        return ERROR_LINK_FAILURE; /* should never happen */
}

static inline void qeth_free_buffer(qeth_card_t *card,int queue,int bufno,
                                    int qdio_error,int siga_error)
{
        struct sk_buff *skb;
        int error;
        int retries;
        int sbalf15;
        char dbf_text[15];
        qdio_buffer_t *buffer;

        switch (card->outbound_buffer_send_state[queue][bufno]) {
        case SEND_STATE_DONT_PACK: /* fallthrough */
        case SEND_STATE_PACK:
#ifdef QETH_DBF_LIKE_HELL
                sprintf(dbf_text,"frbf%4x",card->irq0);
                QETH_DBF_TEXT5(0,trace,dbf_text);
                sprintf(dbf_text,"%2x%2x%4x",queue,bufno,
                        card->outbound_buffer_send_state[queue][bufno]);
                QETH_DBF_TEXT5(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */

                buffer=&card->outbound_ringbuffer[queue]->buffer[bufno];
                sbalf15=buffer->element[15].flags&0xff;
                error=qeth_determine_send_error(siga_error,qdio_error,sbalf15);
                if (error==ERROR_KICK_THAT_PUPPY) {
                        sprintf(dbf_text,"KP%4x%2x",card->irq0,queue);
                        QETH_DBF_TEXT2(0,trace,dbf_text);
                        QETH_DBF_TEXT2(0,qerr,dbf_text);
                        QETH_DBF_TEXT2(1,setup,dbf_text);
                        sprintf(dbf_text,"%2x%2x%2x%2x",bufno,
                                siga_error,qdio_error,sbalf15);
                        QETH_DBF_TEXT2(1,trace,dbf_text);
                        QETH_DBF_TEXT2(1,qerr,dbf_text);
                        PRINT_ERR("Outbound queue x%x on irq x%x (%s); " \
                                  "errs: siga: x%x, qdio: x%x, flags15: " \
                                  "x%x. The device will be taken down.\n",
                                  queue,card->irq0,card->dev_name,
                                  siga_error,qdio_error,sbalf15);
                        netif_stop_queue(card->dev);
                        qeth_set_dev_flag_norunning(card);
                        atomic_set(&card->problem,PROBLEM_BAD_SIGA_RESULT);
                        qeth_schedule_recovery(card);
                } else if (error==ERROR_RETRY) {
                        /* analyze, how many retries we did so far */
                        retries=card->send_retries[queue][bufno];

                        sprintf(dbf_text,"Rt%4x%2x",card->irq0,queue);
                        QETH_DBF_TEXT4(0,trace,dbf_text);
                        sprintf(dbf_text,"b%2x:%2x%2x",bufno,
                                sbalf15,retries);
                        QETH_DBF_TEXT4(0,trace,dbf_text);

                        if (++retries>SEND_RETRIES_ALLOWED) {
                                error=ERROR_LINK_FAILURE;
                                QETH_DBF_TEXT4(1,trace,"ndegelnd");
                        }
                        /* else error stays RETRY for the switch statemnet */
                } else if (error==ERROR_LINK_FAILURE) {
                        /* we don't want to log failures resulting from
                         * too many retries */
                        sprintf(dbf_text,"Fail%4x",card->irq0);
                        QETH_DBF_TEXT3(1,trace,dbf_text);
                        QETH_DBF_HEX3(0,misc,buffer,QETH_DBF_MISC_LEN);
                        QETH_DBF_HEX3(0,misc,buffer+QETH_DBF_MISC_LEN,
                                      QETH_DBF_MISC_LEN);
                }

                while ((skb=skb_dequeue(&card->outbound_ringbuffer[queue]->
                                        ringbuf_element[bufno].skb_list))) {
                        switch (error) {
                        case ERROR_NONE:
                                atomic_dec(&skb->users);
                                dev_kfree_skb_irq(skb);
                                break;
                        case ERROR_RETRY:
                                QETH_DBF_TEXT3(0,qerr,"RETRY!!!");
                                QETH_DBF_TEXT4(0,trace,"RETRY!!!");
                                /* retry packet async (quickly) ... */
                                atomic_dec(&skb->users);
                                dev_kfree_skb_irq(skb);
                                break;
                        case ERROR_LINK_FAILURE:
                        case ERROR_KICK_THAT_PUPPY:
                                QETH_DBF_TEXT4(0,trace,"endeglnd");
                                card->stats->tx_dropped++;
                                card->stats->tx_errors++;
                                atomic_dec(&skb->users);
                                dev_kfree_skb_irq(skb);
                                break;
                        }
                }
                break;
        default:
                PRINT_WARN("oops... wrong send_state on %s. " \
                           "shouldn't happen " \
                           "(line %i). q=%i, bufno=x%x, state=%i\n",
                           card->dev_name,__LINE__,queue,bufno,
                           card->outbound_buffer_send_state[queue][bufno]);
                sprintf(dbf_text,"UPSf%4x",card->irq0);
                QETH_DBF_TEXT0(1,trace,dbf_text);
                QETH_DBF_TEXT0(1,qerr,dbf_text);
                sprintf(dbf_text,"%2x%2x%4x",queue,bufno,
                        card->outbound_buffer_send_state[queue][bufno]);
                QETH_DBF_TEXT0(1,trace,dbf_text);
                QETH_DBF_TEXT0(1,qerr,dbf_text);
        }
        card->outbound_buffer_send_state[queue][bufno]=SEND_STATE_INACTIVE;
        card->send_retries[queue][bufno]=0;
}

static inline void qeth_free_all_skbs(qeth_card_t *card)
{
        int q,b;

        for (q=0;q<card->no_queues;q++)
                for (b=0;b<QDIO_MAX_BUFFERS_PER_Q;b++)
                        if (card->outbound_buffer_send_state[q][b]!=
                            SEND_STATE_INACTIVE)
                                qeth_free_buffer(card,q,b,0,0);
}

static inline void qeth_flush_buffer(qeth_card_t *card,int queue,
                                     int under_int)
{
#ifdef QETH_DBF_LIKE_HELL
        char dbf_text[15];
        sprintf(dbf_text,"flsb%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        sprintf(dbf_text,"%2x%2x%2x",queue,under_int,
                card->outbound_buffer_send_state[queue][
                card->outbound_first_free_buffer[queue] ]);
        QETH_DBF_TEXT5(0,trace,dbf_text);
#endif /* QETH_DBF_LIKE_HELL */

        switch (card->outbound_buffer_send_state[queue][
                card->outbound_first_free_buffer[queue] ]) {
        case SEND_STATE_DONT_PACK: break;
        case SEND_STATE_PACK:
                qeth_flush_packed_packets(card,queue,under_int);
                break;
        default:break;
        }
}
#ifdef QETH_VLAN

static inline void qeth_insert_ipv6_vlan_tag(struct sk_buff *__skb)
{

        /* Move the mac addresses to the beginning of the new header.
         * We are using three memcpys instead of one memmove to save
         * cycles.
         */
#define TMP_CPYSIZE 4
        __u16 *tag;
        tag = (__u16*)skb_push(__skb, VLAN_HLEN);
        memcpy(__skb->data,
               __skb->data+TMP_CPYSIZE,TMP_CPYSIZE);
        memcpy(__skb->data+TMP_CPYSIZE,
               __skb->data+(2*TMP_CPYSIZE),TMP_CPYSIZE);
        memcpy(__skb->data+(2*TMP_CPYSIZE),
               __skb->data+(3*TMP_CPYSIZE),TMP_CPYSIZE);
        tag = (__u16*)(__skb->data+(3*TMP_CPYSIZE));

        /*first two bytes  = ETH_P_8021Q (0x8100)
         *second two bytes = VLANID
         */

        *tag =  __constant_htons(ETH_P_8021Q);
        *(tag+1) = vlan_tx_tag_get(__skb);
        *(tag+1)=htons(*(tag+1));
#undef TMP_CPYSIZE
}
#endif



static inline void qeth_send_packet_fast(qeth_card_t *card,struct sk_buff *skb,
                                         struct net_device *dev,
                                         int queue,int version,int multicast)
{
        qeth_ringbuffer_element_t *mybuffer;
        int position;
        qeth_hdr_t *hdr;
        char *dataptr;
        char dbf_text[15];
        struct sk_buff *nskb;

        position=card->outbound_first_free_buffer[queue];

        card->outbound_buffer_send_state[queue][position]=SEND_STATE_DONT_PACK;

        mybuffer=&card->outbound_ringbuffer[queue]->ringbuf_element[position];
        if (skb_headroom(skb)<QETH_HEADER_SIZE) {
                if ((version)&&(!card->realloc_message)) {
                        card->realloc_message=1;
                        PRINT_WARN("%s: not enough headroom in skb. " \
                                   "Increasing the " \
                                   "add_hhlen parameter by %i may help.\n",
                                   card->dev_name,
                                   QETH_HEADER_SIZE-skb_headroom(skb));
                }
                PRINT_STUPID("%s: not enough headroom in skb (missing: %i)\n",
                             card->dev_name,QETH_HEADER_SIZE-skb_headroom(skb));
                sprintf(dbf_text,"NHRf%4x",card->irq0);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                sprintf(dbf_text,"%2x%2x%2x%2x",skb_headroom(skb),
                        version,multicast,queue);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                QETH_DBF_HEX3(0,trace,&skb->head,sizeof(void*));
                QETH_DBF_HEX3(0,trace,&skb->data,sizeof(void*));
                nskb=skb_realloc_headroom(skb,QETH_HEADER_SIZE);
                if (!nskb) {
                        PRINT_WARN("%s: could not realloc headroom\n",
                                   card->dev_name);
                        sprintf(dbf_text,"CNRf%4x",card->irq0);
                        QETH_DBF_TEXT2(0,trace,dbf_text);
                        dev_kfree_skb_irq(skb);
                        return;
                }
                dev_kfree_skb_irq(skb);
                skb=nskb;
        }
#ifdef QETH_VLAN
        if ( (card->vlangrp != NULL) &&
             vlan_tx_tag_present(skb) &&
             (version==6)) {
                qeth_insert_ipv6_vlan_tag(skb);
        }
#endif
                hdr=(qeth_hdr_t*)(skb_push(skb,QETH_HEADER_SIZE));
        /* sanity check, the Linux memory allocation scheme should
           never present us cases like this one (the 32bytes header plus
           the first 40 bytes of the paket cross a 4k boundary) */
        dataptr=(char*)hdr;
        if ( (((unsigned long)dataptr)&(~(PAGE_SIZE-1))) !=
             ( ((unsigned long)dataptr+QETH_HEADER_SIZE+QETH_IP_HEADER_SIZE)&
               (~(PAGE_SIZE-1)) ) ) {
                PRINT_ERR("%s: packet misaligned -- the first %i bytes " \
                          "are not in the same page. Discarding packet!\n",
                          card->dev_name,
                          QETH_HEADER_SIZE+QETH_IP_HEADER_SIZE);
                PRINT_ERR("head=%p, data=%p\n",skb->head,skb->data);
                sprintf(dbf_text,"PMAf%4x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                sprintf(dbf_text,"%2x%2x%2x%2x",skb_headroom(skb),
                        version,multicast,queue);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                QETH_DBF_HEX1(0,trace,&skb->head,sizeof(void*));
                QETH_DBF_HEX1(1,trace,&skb->data,sizeof(void*));
                dev_kfree_skb_irq(skb);
                return;
        }

        atomic_inc(&skb->users);
        skb_queue_tail(&mybuffer->skb_list,skb);
        qeth_fill_header(hdr,skb,version,multicast);
        /* we need to write to next_element_to_fill as
           qeth_flush_packed_packets checks it */
        card->outbound_ringbuffer[queue]->ringbuf_element[position].
                next_element_to_fill=
                qeth_fill_buffer(&card->outbound_ringbuffer[queue]->
                                 buffer[position],(char *)hdr,
                                 skb->len,0);

#ifdef QETH_PERFORMANCE_STATS
        card->perf_stats.skbs_sent_dont_pack++;
#endif /* QETH_PERFORMANCE_STATS */

        qeth_flush_packed_packets(card,queue,0);
}

/* no checks, if all elements are used, as then we would not be here (at most
   127 buffers are enqueued) */
static inline void qeth_send_packet_packed(qeth_card_t *card,
                                           struct sk_buff *skb,
                                           struct net_device *dev,
                                           int queue,int version,
                                           int multicast)
{
        qeth_ringbuffer_element_t *mybuffer;
        int elements_needed;
        int element_to_fill;
        int buffer_no;
        int length;
        char *dataptr;
        qeth_hdr_t *hdr;
        char dbf_text[15];
        struct sk_buff *nskb;

        /* sanity check, dev->hard_header_len should prevent this */
        if (skb_headroom(skb)<QETH_HEADER_SIZE) {
                if ((version)&&(!card->realloc_message)) {
                        card->realloc_message=1;
                        PRINT_WARN("%s: not enough headroom in skb. " \
                                   "Try increasing the " \
                                   "add_hhlen parameter by %i.\n",
                                   card->dev_name,
                                   QETH_HEADER_SIZE-skb_headroom(skb));
                }
                PRINT_STUPID("%s: not enough headroom in skb (missing: %i)\n",
                             card->dev_name,QETH_HEADER_SIZE-skb_headroom(skb));
                sprintf(dbf_text,"NHRp%4x",card->irq0);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                sprintf(dbf_text,"%2x%2x%2x%2x",skb_headroom(skb),
                        version,multicast,queue);
                QETH_DBF_TEXT3(0,trace,dbf_text);
                QETH_DBF_HEX3(0,trace,&skb->head,sizeof(void*));
                QETH_DBF_HEX3(0,trace,&skb->data,sizeof(void*));
                nskb=skb_realloc_headroom(skb,QETH_HEADER_SIZE);
                if (!nskb) {
                        PRINT_WARN("%s: could not realloc headroom\n",
                                   card->dev_name);
                        sprintf(dbf_text,"CNRp%4x",card->irq0);
                        QETH_DBF_TEXT2(0,trace,dbf_text);
                        dev_kfree_skb_irq(skb);
                        return;
                }
                dev_kfree_skb_irq(skb);
                skb=nskb;
        }
#ifdef QETH_VLAN
        if ( (card->vlangrp != NULL) &&
             vlan_tx_tag_present(skb) &&
             (version==6)) {
                qeth_insert_ipv6_vlan_tag(skb);
        }

#endif
        hdr=(qeth_hdr_t*)(skb_push(skb,QETH_HEADER_SIZE));

        length=skb->len;

        /* sanity check, the Linux memory allocation scheme should
           never present us cases like this one (the 32bytes header plus
           the first 40 bytes of the paket cross a 4k boundary) */
        dataptr=(char*)hdr;
        if ( (((unsigned long)dataptr)&(~(PAGE_SIZE-1))) !=
             ( ((unsigned long)dataptr+QETH_HEADER_SIZE+QETH_IP_HEADER_SIZE)&
               (~(PAGE_SIZE-1)) ) ) {
                PRINT_ERR("%s: packet misaligned -- the first %i bytes " \
                          "are not in the same page. Discarding packet!\n",
                          card->dev_name,
                          QETH_HEADER_SIZE+QETH_IP_HEADER_SIZE);
                sprintf(dbf_text,"PMAp%4x",card->irq0);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                sprintf(dbf_text,"%2x%2x%2x%2x",skb_headroom(skb),
                        version,multicast,queue);
                QETH_DBF_TEXT1(0,trace,dbf_text);
                QETH_DBF_HEX1(0,trace,&skb->head,sizeof(void*));
                QETH_DBF_HEX1(1,trace,&skb->data,sizeof(void*));
                dev_kfree_skb_irq(skb);
                return;
        }

        buffer_no=card->outbound_first_free_buffer[queue];

        element_to_fill=card->outbound_ringbuffer[queue]->
                ringbuf_element[buffer_no].
                next_element_to_fill;

        elements_needed=1+( ( (((unsigned long)dataptr)&(PAGE_SIZE-1))+
                              length ) >>PAGE_SHIFT);
        if ( (elements_needed>(QDIO_MAX_ELEMENTS_PER_BUFFER-element_to_fill)) ||
             ( (elements_needed==
                (QDIO_MAX_ELEMENTS_PER_BUFFER-element_to_fill)) &&
                ((element_to_fill>>PAGE_SHIFT)==
                 card->outbound_bytes_in_buffer[queue]) ) ) {
                qeth_flush_packed_packets(card,queue,0);
                element_to_fill=0;
                card->outbound_bytes_in_buffer[queue]=0;
                buffer_no=(buffer_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
        }

        if (!element_to_fill)
                card->outbound_buffer_send_state[queue][buffer_no]
                        =SEND_STATE_PACK;

#ifdef QETH_PERFORMANCE_STATS
        card->perf_stats.skbs_sent_pack++;
#endif /* QETH_PERFORMANCE_STATS */

        mybuffer=&card->outbound_ringbuffer[queue]->ringbuf_element[buffer_no];
        atomic_inc(&skb->users);
        skb_queue_tail(&mybuffer->skb_list,skb);
        qeth_fill_header(hdr,skb,version,multicast);
        card->outbound_bytes_in_buffer[queue]+=length+QETH_HEADER_SIZE;
        card->outbound_ringbuffer[queue]->ringbuf_element[buffer_no].
                next_element_to_fill=
                qeth_fill_buffer(&card->outbound_ringbuffer[queue]->
                                 buffer[buffer_no],
                                 dataptr,length,element_to_fill);
}

static void qeth_alloc_spare_bufs(void)
{
        int i;
        int dont_alloc_more=0;
        char dbf_text[15];

        sparebuffer_count=0;
        for (i=0;i<qeth_sparebufs;i++) {
                if (!dont_alloc_more) {
                        sparebufs[i].buf=(char*)
                                kmalloc(DEFAULT_BUFFER_SIZE,GFP_KERNEL);
                        if (sparebufs[i].buf)
                                sparebuffer_count++;
                        else
                                dont_alloc_more=1;
                }
                atomic_set(&sparebufs[i].status,(dont_alloc_more)?
                           SPAREBUF_UNAVAIL:SPAREBUF_FREE);
        }
        sprintf(dbf_text,"alspb%3x",sparebuffer_count);
        QETH_DBF_TEXT2(0,trace,dbf_text);

        PRINT_INFO("allocated %i spare buffers\n",sparebuffer_count);
}

static void qeth_free_all_spare_bufs(void)
{
        int i;

        QETH_DBF_TEXT2(0,trace,"frealspb");

        for (i=0;i<qeth_sparebufs;i++)
                if (atomic_read(&sparebufs[i].status)!=SPAREBUF_UNAVAIL) {
                        kfree(sparebufs[i].buf);
                        atomic_set(&sparebufs[i].status,SPAREBUF_UNAVAIL);
                }
}

static __inline__ int atomic_return_sub(int i, atomic_t *v)
{
        int old_val, new_val;
        __CS_LOOP(old_val, new_val, v, i, "sr");
        return old_val;
}

static inline int qeth_do_send_packet(qeth_card_t *card,struct sk_buff *skb,
                                      struct net_device *dev)
{
        int queue,result=0;
        int multicast,version;
        char dbf_text[15];
        char dbf_text2[15]="stchupXX";

        version=QETH_IP_VERSION(skb);
        multicast=qeth_is_multicast_skb_at_all(skb,version);
        queue=qeth_get_prioqueue(card,skb,multicast,version);

#ifdef QETH_DBF_LIKE_HELL
        sprintf(dbf_text,"dsp:%4x",card->irq0);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        sprintf(dbf_text,"%c %c%4x",(version==4)?'4':((version==6)?'6':'0'),
                (multicast)?'m':'_',queue);
        QETH_DBF_TEXT6(0,trace,dbf_text);
        sprintf(dbf_text,"%4x%4x",
                card->outbound_first_free_buffer[queue],
                atomic_read(&card->outbound_used_buffers[queue]));
        QETH_DBF_TEXT6(0,trace,dbf_text);
        if (qeth_sbal_packing_on_card(card->type)) {
                switch (card->send_state[queue]) {
                case SEND_STATE_DONT_PACK:
                        QETH_DBF_TEXT6(0,trace,"usngfast");
                        break;
                case SEND_STATE_PACK:
                        QETH_DBF_TEXT6(0,trace,"usngpack");
                        break;
                }
        } else {
                QETH_DBF_TEXT6(0,trace,"usngfast");
        }
#endif /* QETH_DBF_LIKE_HELL */

        if (atomic_read(&card->outbound_used_buffers[queue])
            >=QDIO_MAX_BUFFERS_PER_Q-1) {
                sprintf(dbf_text,"cdbs%4x",card->irq0);
                QETH_DBF_TEXT2(1,trace,dbf_text);
                netif_stop_queue(dev);
                return -EBUSY;
        }
        
        /* we are not called under int, so we just spin */
        /* happens around once a second under heavy traffic. takes a little
         * bit less than 10usec in avg. on a z900 */
        if (atomic_compare_and_swap(QETH_LOCK_UNLOCKED,QETH_LOCK_NORMAL,
                                    &card->outbound_ringbuffer_lock[queue])) {
                sprintf(dbf_text,"SPIN%4x",card->irq0);
                QETH_DBF_TEXT2(0,trace,dbf_text);
                while (atomic_compare_and_swap
                       (QETH_LOCK_UNLOCKED,QETH_LOCK_NORMAL,
                        &card->outbound_ringbuffer_lock[queue]))
                        ;
                sprintf(dbf_text,"spin%4x",card->irq0);
                QETH_DBF_TEXT2(0,trace,dbf_text);
        }

#ifdef QETH_PERFORMANCE_STATS
        card->perf_stats.skbs_sent++;
#endif /* QETH_PERFORMANCE_STATS */
        
        if (qeth_sbal_packing_on_card(card->type)) {
                switch (card->send_state[queue]) {
                case SEND_STATE_DONT_PACK:
                        qeth_send_packet_fast(card,skb,dev,queue,
                                              version,multicast);
                        if (atomic_read(&card->outbound_used_buffers[queue])
                            >=HIGH_WATERMARK_PACK) {
                                card->send_state[queue]=SEND_STATE_PACK;
                                *((__u16*)(&dbf_text2[6]))=card->irq0;
                                QETH_DBF_HEX3(0,trace,dbf_text2,
                                              QETH_DBF_TRACE_LEN);
#ifdef QETH_PERFORMANCE_STATS
                                card->perf_stats.sc_dp_p++;
#endif /* QETH_PERFORMANCE_STATS */
                        }
                        break;
                case SEND_STATE_PACK:
                        qeth_send_packet_packed(card,skb,dev,queue,
                                                version,multicast);
                        break;
                default:
                        result=-EBUSY;
                        sprintf(dbf_text,"UPSs%4x",card->irq0);
                        QETH_DBF_TEXT0(1,trace,dbf_text);
                        PRINT_ALL("oops... shouldn't happen (line %i:%i).\n",
                                  __LINE__,card->send_state[queue]);
                }
        } else {
                qeth_send_packet_fast(card,skb,dev,queue,
                                      version,multicast);
        }

again:
        /* ATOMIC: (NORMAL->UNLOCKED, FLUSH->NORMAL) */
        if (atomic_dec_return(&card->outbound_ringbuffer_lock[queue])) {
                qeth_flush_buffer(card,queue,0);
                card->send_state[queue]=SEND_STATE_DONT_PACK;
                goto again;
        }

#ifdef QETH_PERFORMANCE_STATS
        card->perf_stats.outbound_time+=
                NOW-card->perf_stats.outbound_start_time;
        card->perf_stats.outbound_cnt++;
#endif /* QETH_PERFORMANCE_STATS */

        card->stats->tx_packets++;
        card->stats->tx_bytes+=skb->len;

        return result;
}

static int qeth_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
{
        qeth_card_t *card;
        char dbf_text[15];
        int result;
        unsigned long stackptr;

        card=(qeth_card_t*)(dev->priv);

        if (skb==NULL)
                return 0;

#ifdef CONFIG_ARCH_S390X
        asm volatile ("lgr %0,15" : "=d" (stackptr));
#else /* CONFIG_ARCH_S390X */
        asm volatile ("lr %0,15" : "=d" (stackptr));
#endif /* CONFIG_ARCH_S390X */
        /* prevent stack overflows */
        /* normal and async stack is both 8k on s390 and 16k on s390x,
         * so it doesn't matter whether we're in an interrupt */
        if ( (stackptr & STACK_PTR_MASK)<
             (sizeof(struct task_struct) + WORST_CASE_STACK_USAGE) ) {
                PRINT_ERR("delaying packet transmission " \
                          "due to potential stack overflow\n");
                sprintf(dbf_text,"STOF%4x",card->irq0);
                QETH_DBF_TEXT1(1,trace,dbf_text);
                PRINT_ERR("Backtrace follows:\n");
                show_trace((unsigned long *)stackptr);
                return -EBUSY;
        }

#ifdef QETH_DBF_LIKE_HELL
        QETH_DBF_HEX4(0,data,skb->data,__max(QETH_DBF_DATA_LEN,skb->len));
#endif /* QETH_DBF_LIKE_HELL */

        netif_stop_queue(dev);

        if (!card) {
                QETH_DBF_TEXT2(0,trace,"XMNSNOCD");
                card->stats->tx_dropped++;
                card->stats->tx_errors++;
                dev_kfree_skb_irq(skb);
                return 0;
        }

#ifdef QETH_PERFORMANCE_STATS
        card->perf_stats.outbound_start_time=NOW;
#endif /* QETH_PERFORMANCE_STATS */

        if (!atomic_read(&card->is_startlaned)) {
                card->stats->tx_carrier_errors++;
                sprintf(dbf_text,"XMNS%4x",card->irq0);
                QETH_DBF_TEXT2(0,trace,dbf_text);
                card->stats->tx_dropped++;
                card->stats->tx_errors++;
                dev_kfree_skb_irq(skb);
                return 0;
        }

        if (dev->hard_header == qeth_fake_header) {
                /*
                 * in theory, if we run in undef-ed QETH_IPV6, we should
                 * always unshare, because we do skb_push, then overwrite
                 * that place with OSA header in qeth_send_packet_fast().
                 * But it is only visible to one application - tcpdump.
                 * Nobody else cares if (fake) MAC header gets smashed.
                 * So, we only do it if fake_ll is in effect.
                 */
                if ((skb = qeth_pskb_unshare(skb, GFP_ATOMIC)) == NULL) {
                        card->stats->tx_dropped++;
                        dev_kfree_skb_irq(skb);
                        return 0;
                }
                skb_pull(skb, QETH_FAKE_LL_LEN);
        }

        result=qeth_do_send_packet(card,skb,dev);

        if (!result)
                netif_wake_queue(card->dev);

        return result;
}

/*
 * This function is needed to tell af_packet.c to process headers.
 * It is not called from there, but only from the transmit path,
 * when we do not need any actual header.
 *
 * N.B. Why do we insist on kludging here instead of fixing tcpdump?
 * Because tcpdump is shared among gazillions of platforms, and
 * there is a) no reliable way to identify qeth or its packets
 * in pcap-linux.c (sll->sll_halen is the only hope); b) no easy
 * way to pass this information from libpcap to tcpdump proper.
 *
 * XXX This fails with TR: traffic flows ok, but tcpdump remains confused.
 */
int qeth_fake_header(struct sk_buff *skb, struct net_device *dev,
                     unsigned short type, void *daddr, void *saddr,
                     unsigned len)
{
        unsigned char *hdr;

        hdr = skb_push(skb, QETH_FAKE_LL_LEN);
        memcpy(hdr, "FAKELLFAKELL", ETH_ALEN*2);
        if (type != ETH_P_802_3)
                *(u16 *)(hdr + ETH_ALEN*2) = htons(type);
        else
                *(u16 *)(hdr + ETH_ALEN*2) = htons(len);

        /* XXX Maybe dev->hard_header_len here? Then skb_pull by same size. */
        return QETH_FAKE_LL_LEN;
}

static struct net_device_stats* qeth_get_stats(struct net_device *dev)
{
        qeth_card_t *card;
        char dbf_text[15];

        card=(qeth_card_t*)(dev->priv);

        sprintf(dbf_text,"gtst%4x",card->irq0);
        QETH_DBF_TEXT3(0,trace,dbf_text);

        return card->stats;
}

static int qeth_change_mtu(struct net_device *dev,int new_mtu)
{
        qeth_card_t *card;
        char dbf_text[15];

        card=(qeth_card_t*)(dev->priv);

        sprintf(dbf_text,"mtu %4x",card->irq0);
        QETH_DBF_TEXT2(0,trace,dbf_text);
        sprintf(dbf_text,"%8x",new_mtu);
        QETH_DBF_TEXT2(0,trace,dbf_text);

        if (new_mtu<64) return -EINVAL;
        if (new_mtu>65535) return -EINVAL;
        if ((!qeth_is_supported(IPA_IP_FRAGMENTATION)) &&
            (!qeth_mtu_is_valid(card,new_mtu)))
            return -EINVAL;
        dev->mtu=new_mtu;
        return 0;
}

static void qeth_start_softsetup_thread(qeth_card_t *card)
{
        char dbf_text[15];
        if (!atomic_read(&card->shutdown_phase)) {
                sprintf(dbf_text,"stss%4x",card->irq0);
                QETH_DBF_TEXT2(0,trace,dbf_text);
                up(&card->softsetup_thread_sem);
        }
}

static int qeth_sleepon(qeth_card_t *card,int timeout)
{
        unsigned long flags;
        unsigned long start;
        int retval;
        char dbf_text[15];

        DECLARE_WAITQUEUE (current_wait_q,current);

        sprintf(dbf_text,"slpn%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        sprintf(dbf_text,"%08x",timeout);
        QETH_DBF_TEXT5(0,trace,dbf_text);

        add_wait_queue(&card->wait_q,&current_wait_q);
        atomic_set(&card->wait_q_active,1);
        start=qeth_get_millis();
        for (;;) {
                set_task_state(current,TASK_INTERRUPTIBLE);
                if (atomic_read(&card->data_has_arrived)) {
                        atomic_set(&card->data_has_arrived,0);
                        retval=0;
                        goto out;
                }
                if (qeth_get_millis()-start>timeout) {
                        retval=-ETIME;
                        goto out;
                }
                schedule_timeout(((start+timeout-qeth_get_millis())>>10)*HZ);
        }
 out:
        spin_lock_irqsave(&card->wait_q_lock,flags);
        atomic_set(&card->wait_q_active,0);
        spin_unlock_irqrestore(&card->wait_q_lock,flags);

        /* we've got to check once again to close the window */
        if (atomic_read(&card->data_has_arrived)) {
                atomic_set(&card->data_has_arrived,0);
                retval=0;
        }

        set_task_state(current,TASK_RUNNING);
        remove_wait_queue(&card->wait_q,&current_wait_q);
        
        return retval;
}

static void qeth_wakeup_ioctl(qeth_card_t *card) {
        char dbf_text[15];

        sprintf(dbf_text,"wkup%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);

        atomic_set(&card->ioctl_data_has_arrived,1);
        spin_lock(&card->ioctl_wait_q_lock);
        if (atomic_read(&card->ioctl_wait_q_active)) {
                wake_up(&card->ioctl_wait_q);
        }
        spin_unlock(&card->ioctl_wait_q_lock);
}

static int qeth_sleepon_ioctl(qeth_card_t *card,int timeout)
{
        unsigned long flags;
        unsigned long start;
        int retval;
        char dbf_text[15];

        DECLARE_WAITQUEUE (current_wait_q,current);

        sprintf(dbf_text,"ioctlslpn%4x",card->irq0);
        QETH_DBF_TEXT5(0,trace,dbf_text);
        sprintf(dbf_text,"%08x",timeout);
        QETH_DBF_TEXT5(0,trace,dbf_text);

        save_flags(flags); 
        add_wait_queue(&card->ioctl_wait_q,&current_wait_q);
        atomic_set(&card->ioctl_wait_q_active,1);
        start=qeth_get_millis();
        for (;;) {
                set_task_state(current,TASK_INTERRUPTIBLE);
                if (atomic_read(&card->ioctl_data_has_arrived)) {
                        atomic_set(&card->ioctl_data_has_arrived,0);
                        retval=0;
                        goto out;
                }
                if (qeth_get_millis()-start>timeout) {
                        retval=-ETIME;
                        goto out;
                }
                schedule_timeout(((start+timeout-qeth_get_millis())>>10)*HZ);
        }
 out:
        spin_lock_irqsave(&card->ioctl_wait_q_lock,flags);
        atomic_set(&card->ioctl_wait_q_active,0);
        spin_unlock_irqrestore(&card->ioctl_wait_q_lock,flags);

        /* we've got to check once again to close the window */
        if (atomic_read(&card->ioctl_data_has_arrived)) {
                atomic_set(&card->ioctl_data_has_arrived,0);
                retval=0;
        }

        set_task_state(current,TASK_RUNNING);
        remove_wait_queue(&card->ioctl_wait_q,&current_wait_q);
        
        return retval;
}

static void qeth_snmp_notify(void)
{
        /*notify all  registered processes */
        struct list_head *l;
        struct qeth_notify_list *n_entry;

        QETH_DBF_TEXT5(0,trace,"snmpnoti");
        spin_lock(&notify_lock);
        list_for_each(l, &notify_list) {
                n_entry = list_entry(l, struct qeth_notify_list, list);
                send_sig(n_entry->signum, n_entry->task, 1);
        }
        spin_unlock(&notify_lock);
}

static char* qeth_send_control_data(qeth_card_t *card,unsigned char *buffer,
                                    int len,unsigned long intparam)
{
        unsigned long flags;
        int result,result2;
        char dbf_text[15];
        unsigned char *rec_buf;
        int setip=(intparam&IPA_SETIP_FLAG)?1:0;

again:
        if (atomic_read(&card->shutdown_phase)==
            QETH_REMOVE_CARD_QUICK) return NULL;
        if (atomic_read(&card->escape_softsetup))
                return NULL;

        /* we lock very early to synchronize access to seqnos */
        if (atomic_swap(&card->write_busy,1)) {
                qeth_wait_nonbusy(QETH_IDLE_WAIT_TIME);
                sprintf(dbf_text,"LSCD%4x",card->irq0);
                QETH_DBF_TEXT2(0,trace,dbf_text);
                goto again;
        }
        memcpy(card->dma_stuff->sendbuf,card->send_buf,QETH_BUFSIZE);

        memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(buffer),
               &card->seqno.trans_hdr,QETH_SEQ_NO_LENGTH);
        card->seqno.trans_hdr++;

        memcpy(QETH_PDU_HEADER_SEQ_NO(buffer),
               &card->seqno.pdu_hdr,QETH_SEQ_NO_LENGTH);
        card->seqno.pdu_hdr++;
        memcpy(QETH_PDU_HEADER_ACK_SEQ_NO(buffer),