← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/s390/net/qeth_l3_main.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/s390/net/qeth_l3_main.c
43
43
static int __qeth_l3_set_online(struct ccwgroup_device *, int);
44
44
static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
45
45
 
46
 
int qeth_l3_set_large_send(struct qeth_card *card,
47
 
                enum qeth_large_send_types type)
48
 
{
49
 
        int rc = 0;
50
 
 
51
 
        card->options.large_send = type;
52
 
        if (card->dev == NULL)
53
 
                return 0;
54
 
 
55
 
        if (card->options.large_send == QETH_LARGE_SEND_TSO) {
56
 
                if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
57
 
                        card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
58
 
                                        NETIF_F_IP_CSUM;
59
 
                } else {
60
 
                        card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
61
 
                                        NETIF_F_IP_CSUM);
62
 
                        card->options.large_send = QETH_LARGE_SEND_NO;
63
 
                        rc = -EOPNOTSUPP;
64
 
                }
65
 
        } else {
66
 
                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
67
 
                                        NETIF_F_IP_CSUM);
68
 
                card->options.large_send = QETH_LARGE_SEND_NO;
69
 
        }
70
 
        return rc;
71
 
}
72
 
 
73
46
static int qeth_l3_isxdigit(char *buf)
74
47
{
75
48
        while (*buf) {
510
483
        kfree(tbd_list);
511
484
}
512
485
 
513
 
static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
514
 
                                        int recover)
 
486
static void qeth_l3_clear_ip_list(struct qeth_card *card, int recover)
515
487
{
516
488
        struct qeth_ipaddr *addr, *tmp;
517
489
        unsigned long flags;
530
502
                addr = list_entry(card->ip_list.next,
531
503
                                  struct qeth_ipaddr, entry);
532
504
                list_del_init(&addr->entry);
533
 
                if (clean) {
534
 
                        spin_unlock_irqrestore(&card->ip_lock, flags);
535
 
                        qeth_l3_deregister_addr_entry(card, addr);
536
 
                        spin_lock_irqsave(&card->ip_lock, flags);
537
 
                }
538
505
                if (!recover || addr->is_multicast) {
539
506
                        kfree(addr);
540
507
                        continue;
1310
1277
        return rc;
1311
1278
}
1312
1279
 
1313
 
static int qeth_l3_query_ipassists_cb(struct qeth_card *card,
1314
 
                struct qeth_reply *reply, unsigned long data)
1315
 
{
1316
 
        struct qeth_ipa_cmd *cmd;
1317
 
 
1318
 
        QETH_DBF_TEXT(SETUP, 2, "qipasscb");
1319
 
 
1320
 
        cmd = (struct qeth_ipa_cmd *) data;
1321
 
        if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
1322
 
                card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
1323
 
                card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1324
 
        } else {
1325
 
                card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
1326
 
                card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1327
 
        }
1328
 
        QETH_DBF_TEXT(SETUP, 2, "suppenbl");
1329
 
        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
1330
 
        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
1331
 
        return 0;
1332
 
}
1333
 
 
1334
 
static int qeth_l3_query_ipassists(struct qeth_card *card,
1335
 
                                enum qeth_prot_versions prot)
1336
 
{
1337
 
        int rc;
1338
 
        struct qeth_cmd_buffer *iob;
1339
 
 
1340
 
        QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
1341
 
        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
1342
 
        rc = qeth_send_ipa_cmd(card, iob, qeth_l3_query_ipassists_cb, NULL);
1343
 
        return rc;
1344
 
}
1345
 
 
1346
1280
#ifdef CONFIG_QETH_IPV6
1347
1281
static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1348
1282
{
1353
1287
        if (card->info.type == QETH_CARD_TYPE_IQD)
1354
1288
                goto out;
1355
1289
 
1356
 
        rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
 
1290
        rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
1357
1291
        if (rc) {
1358
1292
                dev_err(&card->gdev->dev,
1359
1293
                        "Activating IPv6 support for %s failed\n",
1478
1412
        return 0;
1479
1413
}
1480
1414
 
1481
 
int qeth_l3_set_rx_csum(struct qeth_card *card,
1482
 
        enum qeth_checksum_types csum_type)
 
1415
int qeth_l3_set_rx_csum(struct qeth_card *card, int on)
1483
1416
{
1484
1417
        int rc = 0;
1485
1418
 
1486
 
        if (card->options.checksum_type == HW_CHECKSUMMING) {
1487
 
                if ((csum_type != HW_CHECKSUMMING) &&
1488
 
                        (card->state != CARD_STATE_DOWN)) {
1489
 
                        rc = qeth_l3_send_simple_setassparms(card,
1490
 
                                IPA_INBOUND_CHECKSUM, IPA_CMD_ASS_STOP, 0);
1491
 
                        if (rc)
1492
 
                                return -EIO;
1493
 
                }
 
1419
        if (on) {
 
1420
                rc = qeth_l3_send_checksum_command(card);
 
1421
                if (rc)
 
1422
                        return -EIO;
 
1423
                dev_info(&card->gdev->dev,
 
1424
                        "HW Checksumming (inbound) enabled\n");
1494
1425
        } else {
1495
 
                if (csum_type == HW_CHECKSUMMING) {
1496
 
                        if (card->state != CARD_STATE_DOWN) {
1497
 
                                if (!qeth_is_supported(card,
1498
 
                                    IPA_INBOUND_CHECKSUM))
1499
 
                                        return -EPERM;
1500
 
                                rc = qeth_l3_send_checksum_command(card);
1501
 
                                if (rc)
1502
 
                                        return -EIO;
1503
 
                        }
1504
 
                }
 
1426
                rc = qeth_l3_send_simple_setassparms(card,
 
1427
                        IPA_INBOUND_CHECKSUM, IPA_CMD_ASS_STOP, 0);
 
1428
                if (rc)
 
1429
                        return -EIO;
1505
1430
        }
1506
 
        card->options.checksum_type = csum_type;
1507
 
        return rc;
 
1431
 
 
1432
        return 0;
1508
1433
}
1509
1434
 
1510
1435
static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
1511
1436
{
1512
 
        int rc = 0;
1513
 
 
1514
1437
        QETH_CARD_TEXT(card, 3, "strtcsum");
1515
1438
 
1516
 
        if (card->options.checksum_type == NO_CHECKSUMMING) {
1517
 
                dev_info(&card->gdev->dev,
1518
 
                        "Using no checksumming on %s.\n",
1519
 
                        QETH_CARD_IFNAME(card));
1520
 
                return 0;
1521
 
        }
1522
 
        if (card->options.checksum_type == SW_CHECKSUMMING) {
1523
 
                dev_info(&card->gdev->dev,
1524
 
                        "Using SW checksumming on %s.\n",
1525
 
                        QETH_CARD_IFNAME(card));
1526
 
                return 0;
1527
 
        }
1528
 
        if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
1529
 
                dev_info(&card->gdev->dev,
1530
 
                        "Inbound HW Checksumming not "
1531
 
                        "supported on %s,\ncontinuing "
1532
 
                        "using Inbound SW Checksumming\n",
1533
 
                        QETH_CARD_IFNAME(card));
1534
 
                card->options.checksum_type = SW_CHECKSUMMING;
1535
 
                return 0;
1536
 
        }
1537
 
        rc = qeth_l3_send_checksum_command(card);
1538
 
        if (!rc)
1539
 
                dev_info(&card->gdev->dev,
1540
 
                        "HW Checksumming (inbound) enabled\n");
1541
 
 
1542
 
        return rc;
 
1439
        if (card->dev->features & NETIF_F_RXCSUM) {
 
1440
                rtnl_lock();
 
1441
                /* force set_features call */
 
1442
                card->dev->features &= ~NETIF_F_RXCSUM;
 
1443
                netdev_update_features(card->dev);
 
1444
                rtnl_unlock();
 
1445
        }
 
1446
        return 0;
1543
1447
}
1544
1448
 
1545
1449
static int qeth_l3_start_ipa_tx_checksum(struct qeth_card *card)
1586
1490
                        dev_info(&card->gdev->dev,
1587
1491
                                "Outbound TSO enabled\n");
1588
1492
        }
1589
 
        if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
1590
 
                card->options.large_send = QETH_LARGE_SEND_NO;
1591
 
                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
1592
 
        }
 
1493
        if (rc)
 
1494
                card->dev->features &= ~NETIF_F_TSO;
1593
1495
        return rc;
1594
1496
}
1595
1497
 
1611
1513
        return 0;
1612
1514
}
1613
1515
 
1614
 
static int qeth_l3_put_unique_id(struct qeth_card *card)
1615
 
{
1616
 
 
1617
 
        int rc = 0;
1618
 
        struct qeth_cmd_buffer *iob;
1619
 
        struct qeth_ipa_cmd *cmd;
1620
 
 
1621
 
        QETH_CARD_TEXT(card, 2, "puniqeid");
1622
 
 
1623
 
        if ((card->info.unique_id & UNIQUE_ID_NOT_BY_CARD) ==
1624
 
                UNIQUE_ID_NOT_BY_CARD)
1625
 
                return -1;
1626
 
        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_DESTROY_ADDR,
1627
 
                                     QETH_PROT_IPV6);
1628
 
        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1629
 
        *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1630
 
                                card->info.unique_id;
1631
 
        memcpy(&cmd->data.create_destroy_addr.unique_id[0],
1632
 
               card->dev->dev_addr, OSA_ADDR_LEN);
1633
 
        rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
1634
 
        return rc;
1635
 
}
1636
 
 
1637
1516
static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1638
1517
                struct qeth_reply *reply, unsigned long data)
1639
1518
{
2093
1972
                is_vlan = 1;
2094
1973
        }
2095
1974
 
2096
 
        switch (card->options.checksum_type) {
2097
 
        case SW_CHECKSUMMING:
2098
 
                skb->ip_summed = CHECKSUM_NONE;
2099
 
                break;
2100
 
        case NO_CHECKSUMMING:
2101
 
                skb->ip_summed = CHECKSUM_UNNECESSARY;
2102
 
                break;
2103
 
        case HW_CHECKSUMMING:
 
1975
        if (card->dev->features & NETIF_F_RXCSUM) {
2104
1976
                if ((hdr->hdr.l3.ext_flags &
2105
1977
                    (QETH_HDR_EXT_CSUM_HDR_REQ |
2106
1978
                     QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
2109
1981
                        skb->ip_summed = CHECKSUM_UNNECESSARY;
2110
1982
                else
2111
1983
                        skb->ip_summed = CHECKSUM_NONE;
2112
 
        }
 
1984
        } else
 
1985
                skb->ip_summed = CHECKSUM_NONE;
2113
1986
 
2114
1987
        return is_vlan;
2115
1988
}
2324
2197
                        dev_close(card->dev);
2325
2198
                        rtnl_unlock();
2326
2199
                }
2327
 
                if (!card->use_hard_stop) {
2328
 
                        rc = qeth_send_stoplan(card);
2329
 
                        if (rc)
2330
 
                                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
2331
 
                }
2332
2200
                card->state = CARD_STATE_SOFTSETUP;
2333
2201
        }
2334
2202
        if (card->state == CARD_STATE_SOFTSETUP) {
2335
 
                qeth_l3_clear_ip_list(card, !card->use_hard_stop, 1);
 
2203
                qeth_l3_clear_ip_list(card, 1);
2336
2204
                qeth_clear_ipacmd_list(card);
2337
2205
                card->state = CARD_STATE_HARDSETUP;
2338
2206
        }
2339
2207
        if (card->state == CARD_STATE_HARDSETUP) {
2340
 
                if (!card->use_hard_stop &&
2341
 
                    (card->info.type != QETH_CARD_TYPE_IQD)) {
2342
 
                        rc = qeth_l3_put_unique_id(card);
2343
 
                        if (rc)
2344
 
                                QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
2345
 
                }
2346
2208
                qeth_qdio_clear_card(card, 0);
2347
2209
                qeth_clear_qdio_buffers(card);
2348
2210
                qeth_clear_working_pool_list(card);
2352
2214
                qeth_clear_cmd_buffers(&card->read);
2353
2215
                qeth_clear_cmd_buffers(&card->write);
2354
2216
        }
2355
 
        card->use_hard_stop = 0;
2356
2217
        return rc;
2357
2218
}
2358
2219
 
3065
2926
        struct qeth_qdio_out_q *queue = card->qdio.out_qs
3066
2927
                [qeth_get_priority_queue(card, skb, ipv, cast_type)];
3067
2928
        int tx_bytes = skb->len;
3068
 
        enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
 
2929
        bool large_send;
3069
2930
        int data_offset = -1;
3070
2931
        int nr_frags;
3071
2932
 
3087
2948
                card->perf_stats.outbound_start_time = qeth_get_micros();
3088
2949
        }
3089
2950
 
3090
 
        if (skb_is_gso(skb))
3091
 
                large_send = card->options.large_send;
 
2951
        large_send = skb_is_gso(skb);
3092
2952
 
3093
2953
        if ((card->info.type == QETH_CARD_TYPE_IQD) && (!large_send) &&
3094
2954
            (skb_shinfo(skb)->nr_frags == 0)) {
3137
2997
        /* fix hardware limitation: as long as we do not have sbal
3138
2998
         * chaining we can not send long frag lists
3139
2999
         */
3140
 
        if (large_send == QETH_LARGE_SEND_TSO) {
 
3000
        if (large_send) {
3141
3001
                if (qeth_l3_tso_elements(new_skb) + 1 > 16) {
3142
3002
                        if (skb_linearize(new_skb))
3143
3003
                                goto tx_drop;
3146
3006
                }
3147
3007
        }
3148
3008
 
3149
 
        if ((large_send == QETH_LARGE_SEND_TSO) &&
3150
 
            (cast_type == RTN_UNSPEC)) {
 
3009
        if (large_send && (cast_type == RTN_UNSPEC)) {
3151
3010
                hdr = (struct qeth_hdr *)skb_push(new_skb,
3152
3011
                                                sizeof(struct qeth_hdr_tso));
3153
3012
                memset(hdr, 0, sizeof(struct qeth_hdr_tso));
3182
3041
 
3183
3042
        if (card->info.type != QETH_CARD_TYPE_IQD) {
3184
3043
                int len;
3185
 
                if (large_send == QETH_LARGE_SEND_TSO)
 
3044
                if (large_send)
3186
3045
                        len = ((unsigned long)tcp_hdr(new_skb) +
3187
3046
                                tcp_hdr(new_skb)->doff * 4) -
3188
3047
                                (unsigned long)new_skb->data;
3203
3062
                if (new_skb != skb)
3204
3063
                        dev_kfree_skb_any(skb);
3205
3064
                if (card->options.performance_stats) {
3206
 
                        if (large_send != QETH_LARGE_SEND_NO) {
 
3065
                        if (large_send) {
3207
3066
                                card->perf_stats.large_send_bytes += tx_bytes;
3208
3067
                                card->perf_stats.large_send_cnt++;
3209
3068
                        }
3289
3148
        return 0;
3290
3149
}
3291
3150
 
3292
 
static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
3293
 
{
3294
 
        struct qeth_card *card = dev->ml_priv;
3295
 
 
3296
 
        return (card->options.checksum_type == HW_CHECKSUMMING);
3297
 
}
3298
 
 
3299
 
static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
3300
 
{
3301
 
        struct qeth_card *card = dev->ml_priv;
3302
 
        enum qeth_checksum_types csum_type;
3303
 
 
3304
 
        if (data)
3305
 
                csum_type = HW_CHECKSUMMING;
3306
 
        else
3307
 
                csum_type = SW_CHECKSUMMING;
3308
 
 
3309
 
        return qeth_l3_set_rx_csum(card, csum_type);
3310
 
}
3311
 
 
3312
 
static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
3313
 
{
3314
 
        struct qeth_card *card = dev->ml_priv;
3315
 
        int rc = 0;
3316
 
 
3317
 
        if (data) {
3318
 
                rc = qeth_l3_set_large_send(card, QETH_LARGE_SEND_TSO);
3319
 
        } else {
3320
 
                dev->features &= ~NETIF_F_TSO;
3321
 
                card->options.large_send = QETH_LARGE_SEND_NO;
3322
 
        }
3323
 
        return rc;
3324
 
}
3325
 
 
3326
 
static int qeth_l3_ethtool_set_tx_csum(struct net_device *dev, u32 data)
3327
 
{
3328
 
        struct qeth_card *card = dev->ml_priv;
3329
 
 
3330
 
        if (data) {
3331
 
                if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
3332
 
                        dev->features |= NETIF_F_IP_CSUM;
3333
 
                else
3334
 
                        return -EPERM;
3335
 
        } else
3336
 
                dev->features &= ~NETIF_F_IP_CSUM;
3337
 
 
3338
 
        return 0;
 
3151
static u32 qeth_l3_fix_features(struct net_device *dev, u32 features)
 
3152
{
 
3153
        struct qeth_card *card = dev->ml_priv;
 
3154
 
 
3155
        if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
 
3156
                features &= ~NETIF_F_IP_CSUM;
 
3157
        if (!qeth_is_supported(card, IPA_OUTBOUND_TSO))
 
3158
                features &= ~NETIF_F_TSO;
 
3159
        if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM))
 
3160
                features &= ~NETIF_F_RXCSUM;
 
3161
 
 
3162
        return features;
 
3163
}
 
3164
 
 
3165
static int qeth_l3_set_features(struct net_device *dev, u32 features)
 
3166
{
 
3167
        struct qeth_card *card = dev->ml_priv;
 
3168
        u32 changed = dev->features ^ features;
 
3169
        int err;
 
3170
 
 
3171
        if (!(changed & NETIF_F_RXCSUM))
 
3172
                return 0;
 
3173
 
 
3174
        if (card->state == CARD_STATE_DOWN ||
 
3175
            card->state == CARD_STATE_RECOVER)
 
3176
                return 0;
 
3177
 
 
3178
        err = qeth_l3_set_rx_csum(card, features & NETIF_F_RXCSUM);
 
3179
        if (err)
 
3180
                dev->features = features ^ NETIF_F_RXCSUM;
 
3181
 
 
3182
        return err;
3339
3183
}
3340
3184
 
3341
3185
static const struct ethtool_ops qeth_l3_ethtool_ops = {
3342
3186
        .get_link = ethtool_op_get_link,
3343
 
        .get_tx_csum = ethtool_op_get_tx_csum,
3344
 
        .set_tx_csum = qeth_l3_ethtool_set_tx_csum,
3345
 
        .get_rx_csum = qeth_l3_ethtool_get_rx_csum,
3346
 
        .set_rx_csum = qeth_l3_ethtool_set_rx_csum,
3347
 
        .get_sg      = ethtool_op_get_sg,
3348
 
        .set_sg      = ethtool_op_set_sg,
3349
 
        .get_tso     = ethtool_op_get_tso,
3350
 
        .set_tso     = qeth_l3_ethtool_set_tso,
3351
3187
        .get_strings = qeth_core_get_strings,
3352
3188
        .get_ethtool_stats = qeth_core_get_ethtool_stats,
3353
3189
        .get_sset_count = qeth_core_get_sset_count,
3388
3224
        .ndo_set_multicast_list = qeth_l3_set_multicast_list,
3389
3225
        .ndo_do_ioctl           = qeth_l3_do_ioctl,
3390
3226
        .ndo_change_mtu         = qeth_change_mtu,
 
3227
        .ndo_fix_features       = qeth_l3_fix_features,
 
3228
        .ndo_set_features       = qeth_l3_set_features,
3391
3229
        .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
3392
3230
        .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
3393
3231
        .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
3403
3241
        .ndo_set_multicast_list = qeth_l3_set_multicast_list,
3404
3242
        .ndo_do_ioctl           = qeth_l3_do_ioctl,
3405
3243
        .ndo_change_mtu         = qeth_change_mtu,
 
3244
        .ndo_fix_features       = qeth_l3_fix_features,
 
3245
        .ndo_set_features       = qeth_l3_set_features,
3406
3246
        .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
3407
3247
        .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
3408
3248
        .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
3433
3273
                        if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
3434
3274
                                card->dev->dev_id = card->info.unique_id &
3435
3275
                                                         0xffff;
 
3276
                        if (!card->info.guestlan) {
 
3277
                                card->dev->hw_features = NETIF_F_SG |
 
3278
                                        NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
 
3279
                                        NETIF_F_TSO;
 
3280
                                card->dev->features = NETIF_F_RXCSUM;
 
3281
                        }
3436
3282
                }
3437
3283
        } else if (card->info.type == QETH_CARD_TYPE_IQD) {
3438
3284
                card->dev = alloc_netdev(0, "hsi%d", ether_setup);
3465
3311
 
3466
3312
        qeth_l3_create_device_attributes(&gdev->dev);
3467
3313
        card->options.layer2 = 0;
 
3314
        card->info.hwtrap = 0;
3468
3315
        card->discipline.start_poll = qeth_qdio_start_poll;
3469
3316
        card->discipline.input_handler = (qdio_handler_t *)
3470
3317
                qeth_qdio_input_handler;
3483
3330
        qeth_set_allowed_threads(card, 0, 1);
3484
3331
        wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3485
3332
 
3486
 
        if (cgdev->state == CCWGROUP_ONLINE) {
3487
 
                card->use_hard_stop = 1;
 
3333
        if (cgdev->state == CCWGROUP_ONLINE)
3488
3334
                qeth_l3_set_offline(cgdev);
3489
 
        }
3490
3335
 
3491
3336
        if (card->dev) {
3492
3337
                unregister_netdev(card->dev);
3493
3338
                card->dev = NULL;
3494
3339
        }
3495
3340
 
3496
 
        qeth_l3_clear_ip_list(card, 0, 0);
 
3341
        qeth_l3_clear_ip_list(card, 0);
3497
3342
        qeth_l3_clear_ipato_list(card);
3498
3343
        return;
3499
3344
}
3518
3363
                goto out_remove;
3519
3364
        }
3520
3365
 
3521
 
        qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
3522
 
 
3523
3366
        if (!card->dev && qeth_l3_setup_netdev(card)) {
3524
3367
                rc = -ENODEV;
3525
3368
                goto out_remove;
3526
3369
        }
3527
3370
 
 
3371
        if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
 
3372
                if (card->info.hwtrap &&
 
3373
                    qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
 
3374
                        card->info.hwtrap = 0;
 
3375
        } else
 
3376
                card->info.hwtrap = 0;
 
3377
 
3528
3378
        card->state = CARD_STATE_HARDSETUP;
3529
3379
        memset(&card->rx, 0, sizeof(struct qeth_rx));
3530
3380
        qeth_print_status_message(card);
3554
3404
                rc = qeth_l3_start_ipassists(card);
3555
3405
                if (rc)
3556
3406
                        QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
3557
 
                qeth_l3_set_large_send(card, card->options.large_send);
3558
3407
                rc = qeth_l3_setrouting_v4(card);
3559
3408
                if (rc)
3560
3409
                        QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
3594
3443
        mutex_unlock(&card->discipline_mutex);
3595
3444
        return 0;
3596
3445
out_remove:
3597
 
        card->use_hard_stop = 1;
3598
3446
        qeth_l3_stop_card(card, 0);
3599
3447
        ccw_device_set_offline(CARD_DDEV(card));
3600
3448
        ccw_device_set_offline(CARD_WDEV(card));
3628
3476
        if (card->dev && netif_carrier_ok(card->dev))
3629
3477
                netif_carrier_off(card->dev);
3630
3478
        recover_flag = card->state;
 
3479
        if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
 
3480
                qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
 
3481
                card->info.hwtrap = 1;
 
3482
        }
3631
3483
        qeth_l3_stop_card(card, recovery_mode);
3632
3484
        rc  = ccw_device_set_offline(CARD_DDEV(card));
3633
3485
        rc2 = ccw_device_set_offline(CARD_WDEV(card));
3663
3515
        QETH_CARD_TEXT(card, 2, "recover2");
3664
3516
        dev_warn(&card->gdev->dev,
3665
3517
                "A recovery process has been started for the device\n");
3666
 
        card->use_hard_stop = 1;
3667
3518
        __qeth_l3_set_offline(card->gdev, 1);
3668
3519
        rc = __qeth_l3_set_online(card->gdev, 1);
3669
3520
        if (!rc)
3684
3535
static void qeth_l3_shutdown(struct ccwgroup_device *gdev)
3685
3536
{
3686
3537
        struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3687
 
        qeth_l3_clear_ip_list(card, 0, 0);
 
3538
        if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap)
 
3539
                qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3688
3540
        qeth_qdio_clear_card(card, 0);
3689
3541
        qeth_clear_qdio_buffers(card);
3690
3542
}
3700
3552
        if (gdev->state == CCWGROUP_OFFLINE)
3701
3553
                return 0;
3702
3554
        if (card->state == CARD_STATE_UP) {
3703
 
                card->use_hard_stop = 1;
 
3555
                if (card->info.hwtrap)
 
3556
                        qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3704
3557
                __qeth_l3_set_offline(card->gdev, 1);
3705
3558
        } else
3706
3559
                __qeth_l3_set_offline(card->gdev, 0);