← 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_core_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_core_main.c
24
24
 
25
25
#include <asm/ebcdic.h>
26
26
#include <asm/io.h>
 
27
#include <asm/sysinfo.h>
27
28
 
28
29
#include "qeth_core.h"
29
30
 
302
303
        int com = cmd->hdr.command;
303
304
        ipa_name = qeth_get_ipa_cmd_name(com);
304
305
        if (rc)
305
 
                QETH_DBF_MESSAGE(2, "IPA: %s(x%X) for %s returned x%X \"%s\"\n",
306
 
                                ipa_name, com, QETH_CARD_IFNAME(card),
307
 
                                        rc, qeth_get_ipa_msg(rc));
 
306
                QETH_DBF_MESSAGE(2, "IPA: %s(x%X) for %s/%s returned "
 
307
                                "x%X \"%s\"\n",
 
308
                                ipa_name, com, dev_name(&card->gdev->dev),
 
309
                                QETH_CARD_IFNAME(card), rc,
 
310
                                qeth_get_ipa_msg(rc));
308
311
        else
309
 
                QETH_DBF_MESSAGE(5, "IPA: %s(x%X) for %s succeeded\n",
310
 
                                ipa_name, com, QETH_CARD_IFNAME(card));
 
312
                QETH_DBF_MESSAGE(5, "IPA: %s(x%X) for %s/%s succeeded\n",
 
313
                                ipa_name, com, dev_name(&card->gdev->dev),
 
314
                                QETH_CARD_IFNAME(card));
311
315
}
312
316
 
313
317
static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card,
346
350
                                           card->info.chpid);
347
351
                                netif_carrier_on(card->dev);
348
352
                                card->lan_online = 1;
 
353
                                if (card->info.hwtrap)
 
354
                                        card->info.hwtrap = 2;
349
355
                                qeth_schedule_recovery(card);
350
356
                                return NULL;
351
357
                        case IPA_CMD_MODCCID:
884
890
        struct sk_buff *skb;
885
891
 
886
892
        /* is PCI flag set on buffer? */
887
 
        if (buf->buffer->element[0].flags & 0x40)
 
893
        if (buf->buffer->element[0].sflags & SBAL_SFLAGS0_PCI_REQ)
888
894
                atomic_dec(&queue->set_pci_flags_count);
889
895
 
890
896
        skb = skb_dequeue(&buf->skb_list);
900
906
                buf->is_header[i] = 0;
901
907
                buf->buffer->element[i].length = 0;
902
908
                buf->buffer->element[i].addr = NULL;
903
 
                buf->buffer->element[i].flags = 0;
 
909
                buf->buffer->element[i].eflags = 0;
 
910
                buf->buffer->element[i].sflags = 0;
904
911
        }
905
 
        buf->buffer->element[15].flags = 0;
 
912
        buf->buffer->element[15].eflags = 0;
 
913
        buf->buffer->element[15].sflags = 0;
906
914
        buf->next_element_to_fill = 0;
907
915
        atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY);
908
916
}
1023
1031
        atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED);
1024
1032
        /* inbound */
1025
1033
        card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT;
1026
 
        card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT;
 
1034
        if (card->info.type == QETH_CARD_TYPE_IQD)
 
1035
                card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_HSDEFAULT;
 
1036
        else
 
1037
                card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT;
1027
1038
        card->qdio.in_buf_pool.buf_count = card->qdio.init_pool.buf_count;
1028
1039
        INIT_LIST_HEAD(&card->qdio.in_buf_pool.entry_list);
1029
1040
        INIT_LIST_HEAD(&card->qdio.init_pool.entry_list);
1033
1044
{
1034
1045
        card->options.route4.type = NO_ROUTER;
1035
1046
        card->options.route6.type = NO_ROUTER;
1036
 
        card->options.checksum_type = QETH_CHECKSUM_DEFAULT;
1037
1047
        card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS;
1038
1048
        card->options.macaddr_mode = QETH_TR_MACADDR_NONCANONICAL;
1039
1049
        card->options.fake_broadcast = 0;
1083
1093
        card->data.state  = CH_STATE_DOWN;
1084
1094
        card->state = CARD_STATE_DOWN;
1085
1095
        card->lan_online = 0;
1086
 
        card->use_hard_stop = 0;
1087
1096
        card->read_or_write_problem = 0;
1088
1097
        card->dev = NULL;
1089
1098
        spin_lock_init(&card->vlanlock);
1102
1111
        INIT_LIST_HEAD(card->ip_tbd_list);
1103
1112
        INIT_LIST_HEAD(&card->cmd_waiter_list);
1104
1113
        init_waitqueue_head(&card->wait_q);
1105
 
        /* intial options */
 
1114
        /* initial options */
1106
1115
        qeth_set_intial_options(card);
1107
1116
        /* IP address takeover */
1108
1117
        INIT_LIST_HEAD(&card->ipato.entries);
1732
1741
                };
1733
1742
        }
1734
1743
 
 
1744
        if (reply->rc == -EIO)
 
1745
                goto error;
1735
1746
        rc = reply->rc;
1736
1747
        qeth_put_reply(reply);
1737
1748
        return rc;
1738
1749
 
1739
1750
time_err:
 
1751
        reply->rc = -ETIME;
1740
1752
        spin_lock_irqsave(&reply->card->lock, flags);
1741
1753
        list_del_init(&reply->list);
1742
1754
        spin_unlock_irqrestore(&reply->card->lock, flags);
1743
 
        reply->rc = -ETIME;
1744
1755
        atomic_inc(&reply->received);
 
1756
error:
1745
1757
        atomic_set(&card->write.irq_pending, 0);
1746
1758
        qeth_release_buffer(iob->channel, iob);
1747
1759
        card->write.buf_no = (card->write.buf_no + 1) % QETH_CMD_BUFFER_NO;
1748
 
        wake_up(&reply->wait_q);
1749
1760
        rc = reply->rc;
1750
1761
        qeth_put_reply(reply);
1751
1762
        return rc;
2359
2370
                buf->buffer->element[i].length = PAGE_SIZE;
2360
2371
                buf->buffer->element[i].addr =  pool_entry->elements[i];
2361
2372
                if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1)
2362
 
                        buf->buffer->element[i].flags = SBAL_FLAGS_LAST_ENTRY;
 
2373
                        buf->buffer->element[i].eflags = SBAL_EFLAGS_LAST_ENTRY;
2363
2374
                else
2364
 
                        buf->buffer->element[i].flags = 0;
 
2375
                        buf->buffer->element[i].eflags = 0;
 
2376
                buf->buffer->element[i].sflags = 0;
2365
2377
        }
2366
2378
        return 0;
2367
2379
}
2490
2502
}
2491
2503
EXPORT_SYMBOL_GPL(qeth_send_ipa_cmd);
2492
2504
 
2493
 
static int qeth_send_startstoplan(struct qeth_card *card,
2494
 
                enum qeth_ipa_cmds ipacmd, enum qeth_prot_versions prot)
2495
 
{
2496
 
        int rc;
2497
 
        struct qeth_cmd_buffer *iob;
2498
 
 
2499
 
        iob = qeth_get_ipacmd_buffer(card, ipacmd, prot);
2500
 
        rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
2501
 
 
2502
 
        return rc;
2503
 
}
2504
 
 
2505
2505
int qeth_send_startlan(struct qeth_card *card)
2506
2506
{
2507
2507
        int rc;
 
2508
        struct qeth_cmd_buffer *iob;
2508
2509
 
2509
2510
        QETH_DBF_TEXT(SETUP, 2, "strtlan");
2510
2511
 
2511
 
        rc = qeth_send_startstoplan(card, IPA_CMD_STARTLAN, 0);
 
2512
        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_STARTLAN, 0);
 
2513
        rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
2512
2514
        return rc;
2513
2515
}
2514
2516
EXPORT_SYMBOL_GPL(qeth_send_startlan);
2515
2517
 
2516
 
int qeth_send_stoplan(struct qeth_card *card)
2517
 
{
2518
 
        int rc = 0;
2519
 
 
2520
 
        /*
2521
 
         * TODO: according to the IPA format document page 14,
2522
 
         * TCP/IP (we!) never issue a STOPLAN
2523
 
         * is this right ?!?
2524
 
         */
2525
 
        QETH_DBF_TEXT(SETUP, 2, "stoplan");
2526
 
 
2527
 
        rc = qeth_send_startstoplan(card, IPA_CMD_STOPLAN, 0);
2528
 
        return rc;
2529
 
}
2530
 
EXPORT_SYMBOL_GPL(qeth_send_stoplan);
2531
 
 
2532
2518
int qeth_default_setadapterparms_cb(struct qeth_card *card,
2533
2519
                struct qeth_reply *reply, unsigned long data)
2534
2520
{
2593
2579
}
2594
2580
EXPORT_SYMBOL_GPL(qeth_query_setadapterparms);
2595
2581
 
 
2582
static int qeth_query_ipassists_cb(struct qeth_card *card,
 
2583
                struct qeth_reply *reply, unsigned long data)
 
2584
{
 
2585
        struct qeth_ipa_cmd *cmd;
 
2586
 
 
2587
        QETH_DBF_TEXT(SETUP, 2, "qipasscb");
 
2588
 
 
2589
        cmd = (struct qeth_ipa_cmd *) data;
 
2590
        if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
 
2591
                card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
 
2592
                card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
 
2593
        } else {
 
2594
                card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
 
2595
                card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
 
2596
        }
 
2597
        QETH_DBF_TEXT(SETUP, 2, "suppenbl");
 
2598
        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
 
2599
        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
 
2600
        return 0;
 
2601
}
 
2602
 
 
2603
int qeth_query_ipassists(struct qeth_card *card, enum qeth_prot_versions prot)
 
2604
{
 
2605
        int rc;
 
2606
        struct qeth_cmd_buffer *iob;
 
2607
 
 
2608
        QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
 
2609
        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
 
2610
        rc = qeth_send_ipa_cmd(card, iob, qeth_query_ipassists_cb, NULL);
 
2611
        return rc;
 
2612
}
 
2613
EXPORT_SYMBOL_GPL(qeth_query_ipassists);
 
2614
 
 
2615
static int qeth_query_setdiagass_cb(struct qeth_card *card,
 
2616
                struct qeth_reply *reply, unsigned long data)
 
2617
{
 
2618
        struct qeth_ipa_cmd *cmd;
 
2619
        __u16 rc;
 
2620
 
 
2621
        cmd = (struct qeth_ipa_cmd *)data;
 
2622
        rc = cmd->hdr.return_code;
 
2623
        if (rc)
 
2624
                QETH_CARD_TEXT_(card, 2, "diagq:%x", rc);
 
2625
        else
 
2626
                card->info.diagass_support = cmd->data.diagass.ext;
 
2627
        return 0;
 
2628
}
 
2629
 
 
2630
static int qeth_query_setdiagass(struct qeth_card *card)
 
2631
{
 
2632
        struct qeth_cmd_buffer *iob;
 
2633
        struct qeth_ipa_cmd    *cmd;
 
2634
 
 
2635
        QETH_DBF_TEXT(SETUP, 2, "qdiagass");
 
2636
        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
 
2637
        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
 
2638
        cmd->data.diagass.subcmd_len = 16;
 
2639
        cmd->data.diagass.subcmd = QETH_DIAGS_CMD_QUERY;
 
2640
        return qeth_send_ipa_cmd(card, iob, qeth_query_setdiagass_cb, NULL);
 
2641
}
 
2642
 
 
2643
static void qeth_get_trap_id(struct qeth_card *card, struct qeth_trap_id *tid)
 
2644
{
 
2645
        unsigned long info = get_zeroed_page(GFP_KERNEL);
 
2646
        struct sysinfo_2_2_2 *info222 = (struct sysinfo_2_2_2 *)info;
 
2647
        struct sysinfo_3_2_2 *info322 = (struct sysinfo_3_2_2 *)info;
 
2648
        struct ccw_dev_id ccwid;
 
2649
        int level, rc;
 
2650
 
 
2651
        tid->chpid = card->info.chpid;
 
2652
        ccw_device_get_id(CARD_RDEV(card), &ccwid);
 
2653
        tid->ssid = ccwid.ssid;
 
2654
        tid->devno = ccwid.devno;
 
2655
        if (!info)
 
2656
                return;
 
2657
 
 
2658
        rc = stsi(NULL, 0, 0, 0);
 
2659
        if (rc == -ENOSYS)
 
2660
                level = rc;
 
2661
        else
 
2662
                level = (((unsigned int) rc) >> 28);
 
2663
 
 
2664
        if ((level >= 2) && (stsi(info222, 2, 2, 2) != -ENOSYS))
 
2665
                tid->lparnr = info222->lpar_number;
 
2666
 
 
2667
        if ((level >= 3) && (stsi(info322, 3, 2, 2) != -ENOSYS)) {
 
2668
                EBCASC(info322->vm[0].name, sizeof(info322->vm[0].name));
 
2669
                memcpy(tid->vmname, info322->vm[0].name, sizeof(tid->vmname));
 
2670
        }
 
2671
        free_page(info);
 
2672
        return;
 
2673
}
 
2674
 
 
2675
static int qeth_hw_trap_cb(struct qeth_card *card,
 
2676
                struct qeth_reply *reply, unsigned long data)
 
2677
{
 
2678
        struct qeth_ipa_cmd *cmd;
 
2679
        __u16 rc;
 
2680
 
 
2681
        cmd = (struct qeth_ipa_cmd *)data;
 
2682
        rc = cmd->hdr.return_code;
 
2683
        if (rc)
 
2684
                QETH_CARD_TEXT_(card, 2, "trapc:%x", rc);
 
2685
        return 0;
 
2686
}
 
2687
 
 
2688
int qeth_hw_trap(struct qeth_card *card, enum qeth_diags_trap_action action)
 
2689
{
 
2690
        struct qeth_cmd_buffer *iob;
 
2691
        struct qeth_ipa_cmd *cmd;
 
2692
 
 
2693
        QETH_DBF_TEXT(SETUP, 2, "diagtrap");
 
2694
        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
 
2695
        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
 
2696
        cmd->data.diagass.subcmd_len = 80;
 
2697
        cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRAP;
 
2698
        cmd->data.diagass.type = 1;
 
2699
        cmd->data.diagass.action = action;
 
2700
        switch (action) {
 
2701
        case QETH_DIAGS_TRAP_ARM:
 
2702
                cmd->data.diagass.options = 0x0003;
 
2703
                cmd->data.diagass.ext = 0x00010000 +
 
2704
                        sizeof(struct qeth_trap_id);
 
2705
                qeth_get_trap_id(card,
 
2706
                        (struct qeth_trap_id *)cmd->data.diagass.cdata);
 
2707
                break;
 
2708
        case QETH_DIAGS_TRAP_DISARM:
 
2709
                cmd->data.diagass.options = 0x0001;
 
2710
                break;
 
2711
        case QETH_DIAGS_TRAP_CAPTURE:
 
2712
                break;
 
2713
        }
 
2714
        return qeth_send_ipa_cmd(card, iob, qeth_hw_trap_cb, NULL);
 
2715
}
 
2716
EXPORT_SYMBOL_GPL(qeth_hw_trap);
 
2717
 
2596
2718
int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf,
2597
2719
                unsigned int qdio_error, const char *dbftext)
2598
2720
{
2599
2721
        if (qdio_error) {
2600
2722
                QETH_CARD_TEXT(card, 2, dbftext);
2601
2723
                QETH_CARD_TEXT_(card, 2, " F15=%02X",
2602
 
                               buf->element[15].flags & 0xff);
 
2724
                               buf->element[15].sflags);
2603
2725
                QETH_CARD_TEXT_(card, 2, " F14=%02X",
2604
 
                               buf->element[14].flags & 0xff);
 
2726
                               buf->element[14].sflags);
2605
2727
                QETH_CARD_TEXT_(card, 2, " qerr=%X", qdio_error);
2606
 
                if ((buf->element[15].flags & 0xff) == 0x12) {
 
2728
                if ((buf->element[15].sflags) == 0x12) {
2607
2729
                        card->stats.rx_dropped++;
2608
2730
                        return 0;
2609
2731
                } else
2679
2801
static int qeth_handle_send_error(struct qeth_card *card,
2680
2802
                struct qeth_qdio_out_buffer *buffer, unsigned int qdio_err)
2681
2803
{
2682
 
        int sbalf15 = buffer->buffer->element[15].flags & 0xff;
 
2804
        int sbalf15 = buffer->buffer->element[15].sflags;
2683
2805
 
2684
2806
        QETH_CARD_TEXT(card, 6, "hdsnderr");
2685
2807
        if (card->info.type == QETH_CARD_TYPE_IQD) {
2788
2910
 
2789
2911
        for (i = index; i < index + count; ++i) {
2790
2912
                buf = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q];
2791
 
                buf->buffer->element[buf->next_element_to_fill - 1].flags |=
2792
 
                                SBAL_FLAGS_LAST_ENTRY;
 
2913
                buf->buffer->element[buf->next_element_to_fill - 1].eflags |=
 
2914
                                SBAL_EFLAGS_LAST_ENTRY;
2793
2915
 
2794
2916
                if (queue->card->info.type == QETH_CARD_TYPE_IQD)
2795
2917
                        continue;
2802
2924
                                /* it's likely that we'll go to packing
2803
2925
                                 * mode soon */
2804
2926
                                atomic_inc(&queue->set_pci_flags_count);
2805
 
                                buf->buffer->element[0].flags |= 0x40;
 
2927
                                buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ;
2806
2928
                        }
2807
2929
                } else {
2808
2930
                        if (!atomic_read(&queue->set_pci_flags_count)) {
2815
2937
                                 * further send was requested by the stack
2816
2938
                                 */
2817
2939
                                atomic_inc(&queue->set_pci_flags_count);
2818
 
                                buf->buffer->element[0].flags |= 0x40;
 
2940
                                buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ;
2819
2941
                        }
2820
2942
                }
2821
2943
        }
3061
3183
                if (!length) {
3062
3184
                        if (first_lap)
3063
3185
                                if (skb_shinfo(skb)->nr_frags)
3064
 
                                        buffer->element[element].flags =
3065
 
                                                SBAL_FLAGS_FIRST_FRAG;
 
3186
                                        buffer->element[element].eflags =
 
3187
                                                SBAL_EFLAGS_FIRST_FRAG;
3066
3188
                                else
3067
 
                                        buffer->element[element].flags = 0;
 
3189
                                        buffer->element[element].eflags = 0;
3068
3190
                        else
3069
 
                                buffer->element[element].flags =
3070
 
                                    SBAL_FLAGS_MIDDLE_FRAG;
 
3191
                                buffer->element[element].eflags =
 
3192
                                    SBAL_EFLAGS_MIDDLE_FRAG;
3071
3193
                } else {
3072
3194
                        if (first_lap)
3073
 
                                buffer->element[element].flags =
3074
 
                                    SBAL_FLAGS_FIRST_FRAG;
 
3195
                                buffer->element[element].eflags =
 
3196
                                    SBAL_EFLAGS_FIRST_FRAG;
3075
3197
                        else
3076
 
                                buffer->element[element].flags =
3077
 
                                    SBAL_FLAGS_MIDDLE_FRAG;
 
3198
                                buffer->element[element].eflags =
 
3199
                                    SBAL_EFLAGS_MIDDLE_FRAG;
3078
3200
                }
3079
3201
                data += length_here;
3080
3202
                element++;
3086
3208
                buffer->element[element].addr = (char *)page_to_phys(frag->page)
3087
3209
                        + frag->page_offset;
3088
3210
                buffer->element[element].length = frag->size;
3089
 
                buffer->element[element].flags = SBAL_FLAGS_MIDDLE_FRAG;
 
3211
                buffer->element[element].eflags = SBAL_EFLAGS_MIDDLE_FRAG;
3090
3212
                element++;
3091
3213
        }
3092
3214
 
3093
 
        if (buffer->element[element - 1].flags)
3094
 
                buffer->element[element - 1].flags = SBAL_FLAGS_LAST_FRAG;
 
3215
        if (buffer->element[element - 1].eflags)
 
3216
                buffer->element[element - 1].eflags = SBAL_EFLAGS_LAST_FRAG;
3095
3217
        *next_element_to_fill = element;
3096
3218
}
3097
3219
 
3115
3237
                /*fill first buffer entry only with header information */
3116
3238
                buffer->element[element].addr = skb->data;
3117
3239
                buffer->element[element].length = hdr_len;
3118
 
                buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG;
 
3240
                buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG;
3119
3241
                buf->next_element_to_fill++;
3120
3242
                skb->data += hdr_len;
3121
3243
                skb->len  -= hdr_len;
3127
3249
                buffer->element[element].addr = hdr;
3128
3250
                buffer->element[element].length = sizeof(struct qeth_hdr) +
3129
3251
                                                        hd_len;
3130
 
                buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG;
 
3252
                buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG;
3131
3253
                buf->is_header[element] = 1;
3132
3254
                buf->next_element_to_fill++;
3133
3255
        }
3921
4043
MODULE_DEVICE_TABLE(ccw, qeth_ids);
3922
4044
 
3923
4045
static struct ccw_driver qeth_ccw_driver = {
3924
 
        .name = "qeth",
 
4046
        .driver = {
 
4047
                .owner = THIS_MODULE,
 
4048
                .name = "qeth",
 
4049
        },
3925
4050
        .ids = qeth_ids,
3926
4051
        .probe = ccwgroup_probe_ccwdev,
3927
4052
        .remove = ccwgroup_remove_ccwdev,
4001
4126
                QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
4002
4127
                goto out;
4003
4128
        }
 
4129
 
 
4130
        card->options.ipa4.supported_funcs = 0;
 
4131
        card->options.adp.supported_funcs = 0;
 
4132
        card->info.diagass_support = 0;
 
4133
        qeth_query_ipassists(card, QETH_PROT_IPV4);
 
4134
        if (qeth_is_supported(card, IPA_SETADAPTERPARMS))
 
4135
                qeth_query_setadapterparms(card);
 
4136
        if (qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST))
 
4137
                qeth_query_setdiagass(card);
4004
4138
        return 0;
4005
4139
out:
4006
4140
        dev_warn(&card->gdev->dev, "The qeth device driver failed to recover "
4447
4581
}
4448
4582
 
4449
4583
static struct ccwgroup_driver qeth_core_ccwgroup_driver = {
4450
 
        .owner = THIS_MODULE,
4451
 
        .name = "qeth",
 
4584
        .driver = {
 
4585
                .owner = THIS_MODULE,
 
4586
                .name = "qeth",
 
4587
        },
4452
4588
        .driver_id = 0xD8C5E3C8,
4453
4589
        .probe = qeth_core_probe_device,
4454
4590
        .remove = qeth_core_remove_device,