1 files changed, 213 insertions, 103 deletions

diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index 607b92542df6..208127a5033a 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -1,6 +1,6 @@
 /*
  *
- * linux/drivers/s390/net/qeth_main.c ($Revision: 1.206 $)
+ * linux/drivers/s390/net/qeth_main.c ($Revision: 1.214 $)
  *
  * Linux on zSeries OSA Express and HiperSockets support
  *
@@ -12,7 +12,7 @@
  *                        Frank Pavlic (pavlic@de.ibm.com) and
  *                        Thomas Spatzier <tspat@de.ibm.com>
  *
- *    $Revision: 1.206 $         $Date: 2005/03/24 09:04:18 $
+ *    $Revision: 1.214 $         $Date: 2005/05/04 20:19:18 $
  *
  * 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
@@ -80,7 +80,7 @@ qeth_eyecatcher(void)
 #include "qeth_eddp.h"
 #include "qeth_tso.h"
 
-#define VERSION_QETH_C "$Revision: 1.206 $"
+#define VERSION_QETH_C "$Revision: 1.214 $"
 static const char *version = "qeth S/390 OSA-Express driver";
 
 /**
@@ -158,6 +158,9 @@ qeth_irq_tasklet(unsigned long);
 static int
 qeth_set_online(struct ccwgroup_device *);
 
+static int
+__qeth_set_online(struct ccwgroup_device *gdev, int recovery_mode);
+
 static struct qeth_ipaddr *
 qeth_get_addr_buffer(enum qeth_prot_versions);
 
@@ -510,10 +513,10 @@ qeth_irq_tasklet(unsigned long data)
         wake_up(&card->wait_q);
 }
 
-static int qeth_stop_card(struct qeth_card *);
+static int qeth_stop_card(struct qeth_card *, int);
 
 static int
-qeth_set_offline(struct ccwgroup_device *cgdev)
+__qeth_set_offline(struct ccwgroup_device *cgdev, int recovery_mode)
 {
         struct qeth_card *card = (struct qeth_card *) cgdev->dev.driver_data;
         int rc = 0;
@@ -523,7 +526,7 @@ qeth_set_offline(struct ccwgroup_device *cgdev)
         QETH_DBF_HEX(setup, 3, &card, sizeof(void *));
 
         recover_flag = card->state;
-        if (qeth_stop_card(card) == -ERESTARTSYS){
+        if (qeth_stop_card(card, recovery_mode) == -ERESTARTSYS){
                 PRINT_WARN("Stopping card %s interrupted by user!\n",
                            CARD_BUS_ID(card));
                 return -ERESTARTSYS;
@@ -540,6 +543,12 @@ qeth_set_offline(struct ccwgroup_device *cgdev)
 }
 
 static int
+qeth_set_offline(struct ccwgroup_device *cgdev)
+{
+        return  __qeth_set_offline(cgdev, 0);
+}
+
+static int
 qeth_wait_for_threads(struct qeth_card *card, unsigned long threads);
 
 
@@ -953,8 +962,8 @@ qeth_recover(void *ptr)
         PRINT_WARN("Recovery of device %s started ...\n",
                    CARD_BUS_ID(card));
         card->use_hard_stop = 1;
-        qeth_set_offline(card->gdev);
-        rc = qeth_set_online(card->gdev);
+        __qeth_set_offline(card->gdev,1);
+        rc = __qeth_set_online(card->gdev,1);
         if (!rc)
                 PRINT_INFO("Device %s successfully recovered!\n",
                            CARD_BUS_ID(card));
@@ -2152,9 +2161,15 @@ qeth_get_next_skb(struct qeth_card *card, struct qdio_buffer *buffer,
         if (!skb_len)
                 return NULL;
         if (card->options.fake_ll){
-                if (!(skb = qeth_get_skb(skb_len + QETH_FAKE_LL_LEN)))
-                        goto no_mem;
-                skb_pull(skb, QETH_FAKE_LL_LEN);
+                if(card->dev->type == ARPHRD_IEEE802_TR){
+                        if (!(skb = qeth_get_skb(skb_len+QETH_FAKE_LL_LEN_TR)))
+                                goto no_mem;
+                        skb_reserve(skb,QETH_FAKE_LL_LEN_TR);
+                } else {
+                        if (!(skb = qeth_get_skb(skb_len+QETH_FAKE_LL_LEN_ETH)))
+                                goto no_mem;
+                        skb_reserve(skb,QETH_FAKE_LL_LEN_ETH);
+                }
         } else if (!(skb = qeth_get_skb(skb_len)))
                 goto no_mem;
         data_ptr = element->addr + offset;
@@ -2229,14 +2244,68 @@ qeth_type_trans(struct sk_buff *skb, struct net_device *dev)
 }
 
 static inline void
-qeth_rebuild_skb_fake_ll(struct qeth_card *card, struct sk_buff *skb,
+qeth_rebuild_skb_fake_ll_tr(struct qeth_card *card, struct sk_buff *skb,
+                         struct qeth_hdr *hdr)
+{
+        struct trh_hdr *fake_hdr;
+        struct trllc *fake_llc;
+        struct iphdr *ip_hdr;
+
+        QETH_DBF_TEXT(trace,5,"skbfktr");
+        skb->mac.raw = skb->data - QETH_FAKE_LL_LEN_TR;
+        /* this is a fake ethernet header */
+        fake_hdr = (struct trh_hdr *) skb->mac.raw;
+
+        /* the destination MAC address */
+        switch (skb->pkt_type){
+        case PACKET_MULTICAST:
+                switch (skb->protocol){
+#ifdef CONFIG_QETH_IPV6
+                case __constant_htons(ETH_P_IPV6):
+                        ndisc_mc_map((struct in6_addr *)
+                                     skb->data + QETH_FAKE_LL_V6_ADDR_POS,
+                                     fake_hdr->daddr, card->dev, 0);
+                        break;
+#endif /* CONFIG_QETH_IPV6 */
+                case __constant_htons(ETH_P_IP):
+                        ip_hdr = (struct iphdr *)skb->data;
+                        ip_tr_mc_map(ip_hdr->daddr, fake_hdr->daddr);
+                        break;
+                default:
+                        memcpy(fake_hdr->daddr, card->dev->dev_addr, TR_ALEN);
+                }
+                break;
+        case PACKET_BROADCAST:
+                memset(fake_hdr->daddr, 0xff, TR_ALEN);
+                break;
+        default:
+                memcpy(fake_hdr->daddr, card->dev->dev_addr, TR_ALEN);
+        }
+        /* the source MAC address */
+        if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
+                memcpy(fake_hdr->saddr, &hdr->hdr.l3.dest_addr[2], TR_ALEN);
+        else
+                memset(fake_hdr->saddr, 0, TR_ALEN);
+        fake_hdr->rcf=0;
+        fake_llc = (struct trllc*)&(fake_hdr->rcf);
+        fake_llc->dsap = EXTENDED_SAP;
+        fake_llc->ssap = EXTENDED_SAP;
+        fake_llc->llc  = UI_CMD;
+        fake_llc->protid[0] = 0;
+        fake_llc->protid[1] = 0;
+        fake_llc->protid[2] = 0;
+        fake_llc->ethertype = ETH_P_IP;
+}
+
+static inline void
+qeth_rebuild_skb_fake_ll_eth(struct qeth_card *card, struct sk_buff *skb,
                          struct qeth_hdr *hdr)
 {
         struct ethhdr *fake_hdr;
         struct iphdr *ip_hdr;
 
-        QETH_DBF_TEXT(trace,5,"skbfake");
-        skb->mac.raw = skb->data - QETH_FAKE_LL_LEN;
+        QETH_DBF_TEXT(trace,5,"skbfketh");
+        skb->mac.raw = skb->data - QETH_FAKE_LL_LEN_ETH;
         /* this is a fake ethernet header */
         fake_hdr = (struct ethhdr *) skb->mac.raw;
 
@@ -2253,10 +2322,7 @@ qeth_rebuild_skb_fake_ll(struct qeth_card *card, struct sk_buff *skb,
 #endif /* CONFIG_QETH_IPV6 */
                 case __constant_htons(ETH_P_IP):
                         ip_hdr = (struct iphdr *)skb->data;
-                        if (card->dev->type == ARPHRD_IEEE802_TR)
-                                ip_tr_mc_map(ip_hdr->daddr, fake_hdr->h_dest);
-                        else
-                                ip_eth_mc_map(ip_hdr->daddr, fake_hdr->h_dest);
+                        ip_eth_mc_map(ip_hdr->daddr, fake_hdr->h_dest);
                         break;
                 default:
                         memcpy(fake_hdr->h_dest, card->dev->dev_addr, ETH_ALEN);
@@ -2278,6 +2344,16 @@ qeth_rebuild_skb_fake_ll(struct qeth_card *card, struct sk_buff *skb,
 }
 
 static inline void
+qeth_rebuild_skb_fake_ll(struct qeth_card *card, struct sk_buff *skb,
+                        struct qeth_hdr *hdr)
+{
+        if (card->dev->type == ARPHRD_IEEE802_TR)
+                qeth_rebuild_skb_fake_ll_tr(card, skb, hdr);
+        else
+                qeth_rebuild_skb_fake_ll_eth(card, skb, hdr);
+}
+
+static inline void
 qeth_rebuild_skb_vlan(struct qeth_card *card, struct sk_buff *skb,
                       struct qeth_hdr *hdr)
 {
@@ -3440,16 +3516,25 @@ qeth_fake_header(struct sk_buff *skb, struct net_device *dev,
                      unsigned short type, void *daddr, void *saddr,
                      unsigned len)
 {
-        struct ethhdr *hdr;
+        if(dev->type == ARPHRD_IEEE802_TR){
+                struct trh_hdr *hdr;
+                hdr = (struct trh_hdr *)skb_push(skb, QETH_FAKE_LL_LEN_TR);
+                memcpy(hdr->saddr, dev->dev_addr, TR_ALEN);
+                memcpy(hdr->daddr, "FAKELL", TR_ALEN);
+                return QETH_FAKE_LL_LEN_TR;
+
+        } else {
+                struct ethhdr *hdr;
+                hdr = (struct ethhdr *)skb_push(skb, QETH_FAKE_LL_LEN_ETH);
+                memcpy(hdr->h_source, dev->dev_addr, ETH_ALEN);
+                memcpy(hdr->h_dest, "FAKELL", ETH_ALEN);
+                if (type != ETH_P_802_3)
+                        hdr->h_proto = htons(type);
+                else
+                        hdr->h_proto = htons(len);
+                return QETH_FAKE_LL_LEN_ETH;
 
-        hdr = (struct ethhdr *)skb_push(skb, QETH_FAKE_LL_LEN);
-        memcpy(hdr->h_source, dev->dev_addr, ETH_ALEN);
-        memcpy(hdr->h_dest, "FAKELL", ETH_ALEN);
-        if (type != ETH_P_802_3)
-                hdr->h_proto = htons(type);
-        else
-                hdr->h_proto = htons(len);
-        return QETH_FAKE_LL_LEN;
+        }
 }
 
 static inline int
@@ -3710,16 +3795,12 @@ static inline int
 qeth_prepare_skb(struct qeth_card *card, struct sk_buff **skb,
                  struct qeth_hdr **hdr, int ipv)
 {
-        int rc = 0;
 #ifdef CONFIG_QETH_VLAN
         u16 *tag;
 #endif
 
         QETH_DBF_TEXT(trace, 6, "prepskb");
 
-        rc = qeth_realloc_headroom(card, skb, sizeof(struct qeth_hdr));
-        if (rc)
-                return rc;
 #ifdef CONFIG_QETH_VLAN
         if (card->vlangrp && vlan_tx_tag_present(*skb) &&
             ((ipv == 6) || card->options.layer2) ) {
@@ -3882,9 +3963,15 @@ qeth_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
                         memcpy(hdr->hdr.l3.dest_addr, &skb->nh.ipv6h->daddr, 16);
                 }
         } else { /* passthrough */
-                if (!memcmp(skb->data + sizeof(struct qeth_hdr),
+                if((skb->dev->type == ARPHRD_IEEE802_TR) &&
+                    !memcmp(skb->data + sizeof(struct qeth_hdr) + 
+                    sizeof(__u16), skb->dev->broadcast, 6)) {
+                        hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
+                                                QETH_HDR_PASSTHRU;
+                } else if (!memcmp(skb->data + sizeof(struct qeth_hdr),
                             skb->dev->broadcast, 6)) {   /* broadcast? */
-                        hdr->hdr.l3.flags = QETH_CAST_BROADCAST | QETH_HDR_PASSTHRU;
+                        hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
+                                                QETH_HDR_PASSTHRU;
                 } else {
                         hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
                                 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
@@ -3894,67 +3981,29 @@ qeth_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
 }
 
 static inline void
-__qeth_fill_buffer_frag(struct sk_buff *skb, struct qdio_buffer *buffer,
-                        int *next_element_to_fill)
-{
-        int length = skb->len;
-        struct skb_frag_struct *frag;
-        int fragno;
-        unsigned long addr;
-        int element;
-        int first_lap = 1;
-
-        fragno = skb_shinfo(skb)->nr_frags; /* start with last frag */
-        element = *next_element_to_fill + fragno;
-        while (length > 0) {
-                if (fragno > 0) {
-                        frag = &skb_shinfo(skb)->frags[fragno - 1];
-                        addr = (page_to_pfn(frag->page) << PAGE_SHIFT) +
-                                frag->page_offset;
-                        buffer->element[element].addr = (char *)addr;
-                        buffer->element[element].length = frag->size;
-                        length -= frag->size;
-                        if (first_lap)
-                                buffer->element[element].flags =
-                                    SBAL_FLAGS_LAST_FRAG;
-                        else
-                                buffer->element[element].flags =
-                                    SBAL_FLAGS_MIDDLE_FRAG;
-                } else {
-                        buffer->element[element].addr = skb->data;
-                        buffer->element[element].length = length;
-                        length = 0;
-                        buffer->element[element].flags =
-                                SBAL_FLAGS_FIRST_FRAG;
-                }
-                element--;
-                fragno--;
-                first_lap = 0;
-        }
-        *next_element_to_fill += skb_shinfo(skb)->nr_frags + 1;
-}
-
-static inline void
 __qeth_fill_buffer(struct sk_buff *skb, struct qdio_buffer *buffer,
-                   int *next_element_to_fill)
+                   int is_tso, int *next_element_to_fill)
 {
         int length = skb->len;
         int length_here;
         int element;
         char *data;
-        int first_lap = 1;
+        int first_lap ;
 
         element = *next_element_to_fill;
         data = skb->data;
+        first_lap = (is_tso == 0 ? 1 : 0);
+
         while (length > 0) {
                 /* length_here is the remaining amount of data in this page */
                 length_here = PAGE_SIZE - ((unsigned long) data % PAGE_SIZE);
                 if (length < length_here)
                         length_here = length;
+
                 buffer->element[element].addr = data;
                 buffer->element[element].length = length_here;
                 length -= length_here;
-                if (!length){
+                if (!length) {
                         if (first_lap)
                                 buffer->element[element].flags = 0;
                         else
@@ -3981,17 +4030,35 @@ qeth_fill_buffer(struct qeth_qdio_out_q *queue,
                  struct sk_buff *skb)
 {
         struct qdio_buffer *buffer;
-        int flush_cnt = 0;
+        struct qeth_hdr_tso *hdr;
+        int flush_cnt = 0, hdr_len, large_send = 0;
 
         QETH_DBF_TEXT(trace, 6, "qdfillbf");
+
         buffer = buf->buffer;
         atomic_inc(&skb->users);
         skb_queue_tail(&buf->skb_list, skb);
+
+        hdr  = (struct qeth_hdr_tso *) skb->data;
+        /*check first on TSO ....*/
+        if (hdr->hdr.hdr.l3.id == QETH_HEADER_TYPE_TSO) {
+                int element = buf->next_element_to_fill;
+
+                hdr_len = sizeof(struct qeth_hdr_tso) + hdr->ext.dg_hdr_len;
+                /*fill first buffer entry only with header information */
+                buffer->element[element].addr = skb->data;
+                buffer->element[element].length = hdr_len;
+                buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG;
+                buf->next_element_to_fill++;
+                skb->data += hdr_len;
+                skb->len  -= hdr_len;
+                large_send = 1;
+        }
         if (skb_shinfo(skb)->nr_frags == 0)
-                __qeth_fill_buffer(skb, buffer,
+                __qeth_fill_buffer(skb, buffer, large_send,
                                    (int *)&buf->next_element_to_fill);
         else
-                __qeth_fill_buffer_frag(skb, buffer,
+                __qeth_fill_buffer_frag(skb, buffer, large_send,
                                         (int *)&buf->next_element_to_fill);
 
         if (!queue->do_pack) {
@@ -4184,6 +4251,25 @@ out:
 }
 
 static inline int
+qeth_get_elements_no(struct qeth_card *card, void *hdr, struct sk_buff *skb)
+{
+        int elements_needed = 0;
+
+        if (skb_shinfo(skb)->nr_frags > 0) {
+                elements_needed = (skb_shinfo(skb)->nr_frags + 1);
+        }
+        if (elements_needed == 0 )
+                elements_needed = 1 + (((((unsigned long) hdr) % PAGE_SIZE)
+                                        + skb->len) >> PAGE_SHIFT);
+        if (elements_needed > QETH_MAX_BUFFER_ELEMENTS(card)){
+                PRINT_ERR("qeth_do_send_packet: invalid size of "
+                          "IP packet. Discarded.");
+                return 0;
+        }
+        return elements_needed;
+}
+
+static inline int
 qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
 {
         int ipv = 0;
@@ -4205,7 +4291,11 @@ qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
                                 dev_kfree_skb_irq(skb);
                                 return 0;
                         }
-                        skb_pull(skb, QETH_FAKE_LL_LEN);
+                        if(card->dev->type == ARPHRD_IEEE802_TR){
+                                skb_pull(skb, QETH_FAKE_LL_LEN_TR);
+                        } else {
+                                skb_pull(skb, QETH_FAKE_LL_LEN_ETH);
+                        }
                 }
         }
         cast_type = qeth_get_cast_type(card, skb);
@@ -4221,19 +4311,25 @@ qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
         if (skb_shinfo(skb)->tso_size)
                 large_send = card->options.large_send;
 
-        if ((rc = qeth_prepare_skb(card, &skb, &hdr, ipv))){
-                QETH_DBF_TEXT_(trace, 4, "pskbe%d", rc);
-                return rc;
-        }
         /*are we able to do TSO ? If so ,prepare and send it from here */
         if ((large_send == QETH_LARGE_SEND_TSO) &&
             (cast_type == RTN_UNSPEC)) {
-                rc = qeth_tso_send_packet(card, skb, queue,
-                                          ipv, cast_type);
-                goto do_statistics;
+                rc = qeth_tso_prepare_packet(card, skb, ipv, cast_type);
+                if (rc) {
+                        card->stats.tx_dropped++;
+                        card->stats.tx_errors++;
+                        dev_kfree_skb_any(skb);
+                        return NETDEV_TX_OK;
+                } 
+                elements_needed++;
+        } else {
+                if ((rc = qeth_prepare_skb(card, &skb, &hdr, ipv))) {
+                        QETH_DBF_TEXT_(trace, 4, "pskbe%d", rc);
+                        return rc;
+                }
+                qeth_fill_header(card, hdr, skb, ipv, cast_type);
         }
 
-        qeth_fill_header(card, hdr, skb, ipv, cast_type);
         if (large_send == QETH_LARGE_SEND_EDDP) {
                 ctx = qeth_eddp_create_context(card, skb, hdr);
                 if (ctx == NULL) {
@@ -4241,7 +4337,7 @@ qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
                         return -EINVAL;
                 }
         } else {
-                elements_needed = qeth_get_elements_no(card,(void*) hdr, skb);
+                elements_needed += qeth_get_elements_no(card,(void*) hdr, skb);
                 if (!elements_needed)
                         return -EINVAL;
         }
@@ -4252,12 +4348,12 @@ qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
         else
                 rc = qeth_do_send_packet_fast(card, queue, skb, hdr,
                                               elements_needed, ctx);
-do_statistics:
         if (!rc){
                 card->stats.tx_packets++;
                 card->stats.tx_bytes += skb->len;
 #ifdef CONFIG_QETH_PERF_STATS
-                if (skb_shinfo(skb)->tso_size) {
+                if (skb_shinfo(skb)->tso_size &&
+                   !(large_send == QETH_LARGE_SEND_NO)) {
                         card->perf_stats.large_send_bytes += skb->len;
                         card->perf_stats.large_send_cnt++;
                 }
@@ -7154,7 +7250,7 @@ qeth_wait_for_threads(struct qeth_card *card, unsigned long threads)
 }
 
 static int
-qeth_stop_card(struct qeth_card *card)
+qeth_stop_card(struct qeth_card *card, int recovery_mode)
 {
         int rc = 0;
 
@@ -7167,9 +7263,13 @@ qeth_stop_card(struct qeth_card *card)
         if (card->read.state == CH_STATE_UP &&
             card->write.state == CH_STATE_UP &&
             (card->state == CARD_STATE_UP)) {
-                rtnl_lock();
-                dev_close(card->dev);
-                rtnl_unlock();
+                if(recovery_mode) {
+                        qeth_stop(card->dev);
+                } else {
+                        rtnl_lock();
+                        dev_close(card->dev);
+                        rtnl_unlock();
+                }
                 if (!card->use_hard_stop) {
                         __u8 *mac = &card->dev->dev_addr[0];
                         rc = qeth_layer2_send_delmac(card, mac);
@@ -7341,13 +7441,17 @@ qeth_register_netdev(struct qeth_card *card)
 }
 
 static void
-qeth_start_again(struct qeth_card *card)
+qeth_start_again(struct qeth_card *card, int recovery_mode)
 {
         QETH_DBF_TEXT(setup ,2, "startag");
 
-        rtnl_lock();
-        dev_open(card->dev);
-        rtnl_unlock();
+        if(recovery_mode) {
+                qeth_open(card->dev);
+        } else {
+                rtnl_lock();
+                dev_open(card->dev);
+                rtnl_unlock();
+        }
         /* this also sets saved unicast addresses */
         qeth_set_multicast_list(card->dev);
 }
@@ -7404,7 +7508,7 @@ static void qeth_make_parameters_consistent(struct qeth_card *card)
 
 
 static int
-qeth_set_online(struct ccwgroup_device *gdev)
+__qeth_set_online(struct ccwgroup_device *gdev, int recovery_mode)
 {
         struct qeth_card *card = gdev->dev.driver_data;
         int rc = 0;
@@ -7464,12 +7568,12 @@ qeth_set_online(struct ccwgroup_device *gdev)
  * we can also use this state for recovery purposes*/
         qeth_set_allowed_threads(card, 0xffffffff, 0);
         if (recover_flag == CARD_STATE_RECOVER)
-                qeth_start_again(card);
+                qeth_start_again(card, recovery_mode);
         qeth_notify_processes();
         return 0;
 out_remove:
         card->use_hard_stop = 1;
-        qeth_stop_card(card);
+        qeth_stop_card(card, 0);
         ccw_device_set_offline(CARD_DDEV(card));
         ccw_device_set_offline(CARD_WDEV(card));
         ccw_device_set_offline(CARD_RDEV(card));
@@ -7480,6 +7584,12 @@ out_remove:
         return -ENODEV;
 }
 
+static int
+qeth_set_online(struct ccwgroup_device *gdev)
+{
+        return __qeth_set_online(gdev, 0);
+}
+
 static struct ccw_device_id qeth_ids[] = {
         {CCW_DEVICE(0x1731, 0x01), driver_info:QETH_CARD_TYPE_OSAE},
         {CCW_DEVICE(0x1731, 0x05), driver_info:QETH_CARD_TYPE_IQD},