Lines Matching refs:card
45 int qeth_l3_set_large_send(struct qeth_card *card,
50 card->options.large_send = type;
51 if (card->dev == NULL)
54 if (card->options.large_send == QETH_LARGE_SEND_TSO) {
55 if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
56 card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
59 card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
61 card->options.large_send = QETH_LARGE_SEND_NO;
65 card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
67 card->options.large_send = QETH_LARGE_SEND_NO;
198 int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
206 if (!card->ipato.enabled)
211 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
227 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
229 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
240 static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
246 if (card->options.sniffer)
248 list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
284 list_add(&addr->entry, card->ip_tbd_list);
289 qeth_l3_is_addr_covered_by_ipato(card, addr)) {
290 QETH_CARD_TEXT(card, 2, "tkovaddr");
293 list_add_tail(&addr->entry, card->ip_tbd_list);
299 static int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
304 QETH_CARD_TEXT(card, 4, "delip");
307 QETH_CARD_HEX(card, 4, &addr->u.a4.addr, 4);
309 QETH_CARD_HEX(card, 4, &addr->u.a6.addr, 8);
310 QETH_CARD_HEX(card, 4, ((char *)&addr->u.a6.addr) + 8, 8);
312 spin_lock_irqsave(&card->ip_lock, flags);
313 rc = __qeth_l3_insert_ip_todo(card, addr, 0);
314 spin_unlock_irqrestore(&card->ip_lock, flags);
318 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
323 QETH_CARD_TEXT(card, 4, "addip");
325 QETH_CARD_HEX(card, 4, &addr->u.a4.addr, 4);
327 QETH_CARD_HEX(card, 4, &addr->u.a6.addr, 8);
328 QETH_CARD_HEX(card, 4, ((char *)&addr->u.a6.addr) + 8, 8);
330 spin_lock_irqsave(&card->ip_lock, flags);
331 rc = __qeth_l3_insert_ip_todo(card, addr, 1);
332 spin_unlock_irqrestore(&card->ip_lock, flags);
351 static void qeth_l3_delete_mc_addresses(struct qeth_card *card)
356 QETH_CARD_TEXT(card, 4, "delmc");
359 QETH_CARD_TEXT(card, 2, "dmcnomem");
363 spin_lock_irqsave(&card->ip_lock, flags);
364 if (!__qeth_l3_insert_ip_todo(card, iptodo, 0))
366 spin_unlock_irqrestore(&card->ip_lock, flags);
370 * Add/remove address to/from card's ip list, i.e. try to add or remove
371 * reference to/from an IP address that is already registered on the card.
373 * 0 address was on card and its reference count has been adjusted,
375 * also returns 0 if card was not on card and the todo was to delete
377 * 1 address was not on card and the todo is to add it to the card's ip
379 * -1 address was on card and its reference count has been decremented
380 * to <= 0 by the todo -> address must be removed from card
382 static int __qeth_l3_ref_ip_on_card(struct qeth_card *card,
388 list_for_each_entry(addr, &card->ip_list, entry) {
428 static void __qeth_l3_delete_all_mc(struct qeth_card *card,
437 list_for_each_entry_safe(addr, tmp, &card->ip_list, entry) {
440 spin_unlock_irqrestore(&card->ip_lock, *flags);
441 rc = qeth_l3_deregister_addr_entry(card, addr);
442 spin_lock_irqsave(&card->ip_lock, *flags);
450 list_splice(&fail_list, &card->ip_list);
453 static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
460 QETH_CARD_TEXT(card, 2, "sdiplist");
461 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
463 if (card->options.sniffer)
465 spin_lock_irqsave(&card->ip_lock, flags);
466 tbd_list = card->ip_tbd_list;
467 card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
468 if (!card->ip_tbd_list) {
469 QETH_CARD_TEXT(card, 0, "silnomem");
470 card->ip_tbd_list = tbd_list;
471 spin_unlock_irqrestore(&card->ip_lock, flags);
474 INIT_LIST_HEAD(card->ip_tbd_list);
480 __qeth_l3_delete_all_mc(card, &flags);
484 rc = __qeth_l3_ref_ip_on_card(card, todo, &addr);
489 /* new entry to be added to on-card list */
490 spin_unlock_irqrestore(&card->ip_lock, flags);
491 rc = qeth_l3_register_addr_entry(card, todo);
492 spin_lock_irqsave(&card->ip_lock, flags);
494 list_add_tail(&todo->entry, &card->ip_list);
498 /* on-card entry to be removed */
500 spin_unlock_irqrestore(&card->ip_lock, flags);
501 rc = qeth_l3_deregister_addr_entry(card, addr);
502 spin_lock_irqsave(&card->ip_lock, flags);
506 list_add_tail(&addr->entry, &card->ip_list);
510 spin_unlock_irqrestore(&card->ip_lock, flags);
514 static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
520 QETH_CARD_TEXT(card, 4, "clearip");
521 if (recover && card->options.sniffer)
523 spin_lock_irqsave(&card->ip_lock, flags);
525 list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
530 while (!list_empty(&card->ip_list)) {
531 addr = list_entry(card->ip_list.next,
535 spin_unlock_irqrestore(&card->ip_lock, flags);
536 qeth_l3_deregister_addr_entry(card, addr);
537 spin_lock_irqsave(&card->ip_lock, flags);
543 list_add_tail(&addr->entry, card->ip_tbd_list);
545 spin_unlock_irqrestore(&card->ip_lock, flags);
573 static int qeth_l3_send_setdelmc(struct qeth_card *card,
580 QETH_CARD_TEXT(card, 4, "setdelmc");
582 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
591 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
610 static int qeth_l3_send_setdelip(struct qeth_card *card,
618 QETH_CARD_TEXT(card, 4, "setdelip");
619 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
621 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
636 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
641 static int qeth_l3_send_setrouting(struct qeth_card *card,
648 QETH_CARD_TEXT(card, 4, "setroutg");
649 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
652 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
657 static void qeth_l3_correct_routing_type(struct qeth_card *card,
660 if (card->info.type == QETH_CARD_TYPE_IQD) {
677 if (qeth_is_ipafunc_supported(card, prot,
688 int qeth_l3_setrouting_v4(struct qeth_card *card)
692 QETH_CARD_TEXT(card, 3, "setrtg4");
694 qeth_l3_correct_routing_type(card, &card->options.route4.type,
697 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
700 card->options.route4.type = NO_ROUTER;
703 QETH_CARD_IFNAME(card));
708 int qeth_l3_setrouting_v6(struct qeth_card *card)
712 QETH_CARD_TEXT(card, 3, "setrtg6");
715 if (!qeth_is_supported(card, IPA_IPV6))
717 qeth_l3_correct_routing_type(card, &card->options.route6.type,
720 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
723 card->options.route6.type = NO_ROUTER;
726 QETH_CARD_IFNAME(card));
735 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
741 spin_lock_irqsave(&card->ip_lock, flags);
742 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
746 spin_unlock_irqrestore(&card->ip_lock, flags);
749 int qeth_l3_add_ipato_entry(struct qeth_card *card,
756 QETH_CARD_TEXT(card, 2, "addipato");
757 spin_lock_irqsave(&card->ip_lock, flags);
758 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
769 list_add_tail(&new->entry, &card->ipato.entries);
771 spin_unlock_irqrestore(&card->ip_lock, flags);
775 void qeth_l3_del_ipato_entry(struct qeth_card *card,
781 QETH_CARD_TEXT(card, 2, "delipato");
782 spin_lock_irqsave(&card->ip_lock, flags);
783 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
793 spin_unlock_irqrestore(&card->ip_lock, flags);
799 int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
809 QETH_CARD_TEXT(card, 2, "addvipa4");
813 QETH_CARD_TEXT(card, 2, "addvipa6");
822 spin_lock_irqsave(&card->ip_lock, flags);
823 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
824 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
826 spin_unlock_irqrestore(&card->ip_lock, flags);
830 if (!qeth_l3_add_ip(card, ipaddr))
832 qeth_l3_set_ip_addr_list(card);
836 void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
844 QETH_CARD_TEXT(card, 2, "delvipa4");
848 QETH_CARD_TEXT(card, 2, "delvipa6");
855 if (!qeth_l3_delete_ip(card, ipaddr))
857 qeth_l3_set_ip_addr_list(card);
863 int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
873 QETH_CARD_TEXT(card, 2, "addrxip4");
877 QETH_CARD_TEXT(card, 2, "addrxip6");
886 spin_lock_irqsave(&card->ip_lock, flags);
887 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
888 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
890 spin_unlock_irqrestore(&card->ip_lock, flags);
894 if (!qeth_l3_add_ip(card, ipaddr))
896 qeth_l3_set_ip_addr_list(card);
900 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
908 QETH_CARD_TEXT(card, 2, "addrxip4");
912 QETH_CARD_TEXT(card, 2, "addrxip6");
919 if (!qeth_l3_delete_ip(card, ipaddr))
921 qeth_l3_set_ip_addr_list(card);
924 static int qeth_l3_register_addr_entry(struct qeth_card *card,
932 QETH_CARD_TEXT(card, 2, "setaddr4");
933 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
935 QETH_CARD_TEXT(card, 2, "setaddr6");
936 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
937 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
939 QETH_CARD_TEXT(card, 2, "setaddr?");
940 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
944 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
946 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
949 QETH_CARD_TEXT(card, 2, "failed");
952 QETH_CARD_TEXT(card, 2, "FAILED");
954 dev_warn(&card->gdev->dev,
960 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
966 QETH_CARD_TEXT(card, 2, "deladdr4");
967 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
969 QETH_CARD_TEXT(card, 2, "deladdr6");
970 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
971 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
973 QETH_CARD_TEXT(card, 2, "deladdr?");
974 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
977 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
979 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
982 QETH_CARD_TEXT(card, 2, "failed");
1008 static int qeth_l3_send_setadp_mode(struct qeth_card *card, __u32 command,
1015 QETH_CARD_TEXT(card, 4, "adpmode");
1017 iob = qeth_get_adapter_cmd(card, command,
1021 rc = qeth_send_ipa_cmd(card, iob, qeth_default_setadapterparms_cb,
1026 static int qeth_l3_setadapter_hstr(struct qeth_card *card)
1030 QETH_CARD_TEXT(card, 4, "adphstr");
1032 if (qeth_adp_supported(card, IPA_SETADP_SET_BROADCAST_MODE)) {
1033 rc = qeth_l3_send_setadp_mode(card,
1035 card->options.broadcast_mode);
1039 CARD_BUS_ID(card), rc);
1040 rc = qeth_l3_send_setadp_mode(card,
1042 card->options.macaddr_mode);
1045 "device %s: x%x\n", CARD_BUS_ID(card), rc);
1048 if (card->options.broadcast_mode == QETH_TR_BROADCAST_LOCAL)
1051 "on device %s:\n", CARD_BUS_ID(card));
1052 if (card->options.macaddr_mode == QETH_TR_MACADDR_CANONICAL)
1055 "on device %s:\n", CARD_BUS_ID(card));
1059 static int qeth_l3_setadapter_parms(struct qeth_card *card)
1065 if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
1066 dev_info(&card->gdev->dev,
1071 rc = qeth_query_setadapterparms(card);
1074 "0x%x\n", dev_name(&card->gdev->dev), rc);
1077 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
1078 rc = qeth_setadpparms_change_macaddr(card);
1080 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
1084 if ((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
1085 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))
1086 rc = qeth_l3_setadapter_hstr(card);
1091 static int qeth_l3_default_setassparms_cb(struct qeth_card *card,
1096 QETH_CARD_TEXT(card, 4, "defadpcb");
1102 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1104 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1108 card->info.csum_mask = cmd->data.setassparms.data.flags_32bit;
1109 QETH_CARD_TEXT_(card, 3, "csum:%d", card->info.csum_mask);
1113 card->info.tx_csum_mask =
1115 QETH_CARD_TEXT_(card, 3, "tcsu:%d", card->info.tx_csum_mask);
1122 struct qeth_card *card, enum qeth_ipa_funcs ipa_func, __u16 cmd_code,
1128 QETH_CARD_TEXT(card, 4, "getasscm");
1129 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETASSPARMS, prot);
1141 static int qeth_l3_send_setassparms(struct qeth_card *card,
1150 QETH_CARD_TEXT(card, 4, "sendassp");
1158 rc = qeth_send_ipa_cmd(card, iob, reply_cb, reply_param);
1163 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
1169 QETH_CARD_TEXT(card, 4, "simassp6");
1170 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1172 rc = qeth_l3_send_setassparms(card, iob, 0, 0,
1178 static int qeth_l3_send_simple_setassparms(struct qeth_card *card,
1185 QETH_CARD_TEXT(card, 4, "simassp4");
1188 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1190 rc = qeth_l3_send_setassparms(card, iob, length, data,
1195 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
1199 QETH_CARD_TEXT(card, 3, "ipaarp");
1201 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1202 dev_info(&card->gdev->dev,
1204 QETH_CARD_IFNAME(card));
1207 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
1210 dev_warn(&card->gdev->dev,
1212 QETH_CARD_IFNAME(card));
1217 static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card *card)
1221 QETH_CARD_TEXT(card, 3, "ipaipfrg");
1223 if (!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) {
1224 dev_info(&card->gdev->dev,
1226 QETH_CARD_IFNAME(card));
1230 rc = qeth_l3_send_simple_setassparms(card, IPA_IP_FRAGMENTATION,
1233 dev_warn(&card->gdev->dev,
1235 QETH_CARD_IFNAME(card));
1237 dev_info(&card->gdev->dev,
1242 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
1246 QETH_CARD_TEXT(card, 3, "stsrcmac");
1248 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
1249 dev_info(&card->gdev->dev,
1251 QETH_CARD_IFNAME(card));
1255 rc = qeth_l3_send_simple_setassparms(card, IPA_SOURCE_MAC,
1258 dev_warn(&card->gdev->dev,
1260 QETH_CARD_IFNAME(card));
1264 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
1268 QETH_CARD_TEXT(card, 3, "strtvlan");
1270 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
1271 dev_info(&card->gdev->dev,
1272 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
1276 rc = qeth_l3_send_simple_setassparms(card, IPA_VLAN_PRIO,
1279 dev_warn(&card->gdev->dev,
1281 QETH_CARD_IFNAME(card));
1283 dev_info(&card->gdev->dev, "VLAN enabled\n");
1288 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
1292 QETH_CARD_TEXT(card, 3, "stmcast");
1294 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1295 dev_info(&card->gdev->dev,
1297 QETH_CARD_IFNAME(card));
1301 rc = qeth_l3_send_simple_setassparms(card, IPA_MULTICASTING,
1304 dev_warn(&card->gdev->dev,
1306 QETH_CARD_IFNAME(card));
1308 dev_info(&card->gdev->dev, "Multicast enabled\n");
1309 card->dev->flags |= IFF_MULTICAST;
1314 static int qeth_l3_query_ipassists_cb(struct qeth_card *card,
1323 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
1324 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1326 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
1327 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1335 static int qeth_l3_query_ipassists(struct qeth_card *card,
1342 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
1343 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_query_ipassists_cb, NULL);
1348 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1352 QETH_CARD_TEXT(card, 3, "softipv6");
1354 if (card->info.type == QETH_CARD_TYPE_IQD)
1357 rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
1359 dev_err(&card->gdev->dev,
1361 QETH_CARD_IFNAME(card));
1364 rc = qeth_l3_send_simple_setassparms(card, IPA_IPV6,
1367 dev_err(&card->gdev->dev,
1369 QETH_CARD_IFNAME(card));
1372 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
1375 dev_err(&card->gdev->dev,
1377 QETH_CARD_IFNAME(card));
1380 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1383 dev_warn(&card->gdev->dev,
1385 QETH_CARD_IFNAME(card));
1389 dev_info(&card->gdev->dev, "IPV6 enabled\n");
1394 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1398 QETH_CARD_TEXT(card, 3, "strtipv6");
1400 if (!qeth_is_supported(card, IPA_IPV6)) {
1401 dev_info(&card->gdev->dev,
1402 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
1406 rc = qeth_l3_softsetup_ipv6(card);
1411 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
1415 QETH_CARD_TEXT(card, 3, "stbrdcst");
1416 card->info.broadcast_capable = 0;
1417 if (!qeth_is_supported(card, IPA_FILTERING)) {
1418 dev_info(&card->gdev->dev,
1420 QETH_CARD_IFNAME(card));
1424 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1427 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
1428 "%s failed\n", QETH_CARD_IFNAME(card));
1432 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1435 dev_warn(&card->gdev->dev,
1437 QETH_CARD_IFNAME(card));
1440 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1441 dev_info(&card->gdev->dev, "Broadcast enabled\n");
1442 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1445 dev_warn(&card->gdev->dev, "Setting up broadcast echo "
1446 "filtering for %s failed\n", QETH_CARD_IFNAME(card));
1449 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
1451 if (card->info.broadcast_capable)
1452 card->dev->flags |= IFF_BROADCAST;
1454 card->dev->flags &= ~IFF_BROADCAST;
1458 static int qeth_l3_send_checksum_command(struct qeth_card *card)
1462 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1465 dev_warn(&card->gdev->dev, "Starting HW checksumming for %s "
1467 QETH_CARD_IFNAME(card));
1470 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1472 card->info.csum_mask);
1474 dev_warn(&card->gdev->dev, "Enabling HW checksumming for %s "
1476 QETH_CARD_IFNAME(card));
1482 int qeth_l3_set_rx_csum(struct qeth_card *card,
1487 if (card->options.checksum_type == HW_CHECKSUMMING) {
1489 (card->state != CARD_STATE_DOWN)) {
1490 rc = qeth_l3_send_simple_setassparms(card,
1497 if (card->state != CARD_STATE_DOWN) {
1498 if (!qeth_is_supported(card,
1501 rc = qeth_l3_send_checksum_command(card);
1507 card->options.checksum_type = csum_type;
1511 static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
1515 QETH_CARD_TEXT(card, 3, "strtcsum");
1517 if (card->options.checksum_type == NO_CHECKSUMMING) {
1518 dev_info(&card->gdev->dev,
1520 QETH_CARD_IFNAME(card));
1523 if (card->options.checksum_type == SW_CHECKSUMMING) {
1524 dev_info(&card->gdev->dev,
1526 QETH_CARD_IFNAME(card));
1529 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
1530 dev_info(&card->gdev->dev,
1534 QETH_CARD_IFNAME(card));
1535 card->options.checksum_type = SW_CHECKSUMMING;
1538 rc = qeth_l3_send_checksum_command(card);
1540 dev_info(&card->gdev->dev,
1546 static int qeth_l3_start_ipa_tx_checksum(struct qeth_card *card)
1550 if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
1552 rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_CHECKSUM,
1556 rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_CHECKSUM,
1557 IPA_CMD_ASS_ENABLE, card->info.tx_csum_mask);
1560 dev_info(&card->gdev->dev, "HW TX Checksumming enabled\n");
1563 dev_warn(&card->gdev->dev, "Enabling HW TX checksumming for %s "
1564 "failed, using SW TX checksumming\n", QETH_CARD_IFNAME(card));
1568 static int qeth_l3_start_ipa_tso(struct qeth_card *card)
1572 QETH_CARD_TEXT(card, 3, "sttso");
1574 if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
1575 dev_info(&card->gdev->dev,
1577 QETH_CARD_IFNAME(card));
1580 rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_TSO,
1583 dev_warn(&card->gdev->dev, "Starting outbound TCP "
1585 QETH_CARD_IFNAME(card));
1587 dev_info(&card->gdev->dev,
1590 if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
1591 card->options.large_send = QETH_LARGE_SEND_NO;
1592 card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
1597 static int qeth_l3_start_ipassists(struct qeth_card *card)
1599 QETH_CARD_TEXT(card, 3, "strtipas");
1601 qeth_set_access_ctrl_online(card); /* go on*/
1602 qeth_l3_start_ipa_arp_processing(card); /* go on*/
1603 qeth_l3_start_ipa_ip_fragmentation(card); /* go on*/
1604 qeth_l3_start_ipa_source_mac(card); /* go on*/
1605 qeth_l3_start_ipa_vlan(card); /* go on*/
1606 qeth_l3_start_ipa_multicast(card); /* go on*/
1607 qeth_l3_start_ipa_ipv6(card); /* go on*/
1608 qeth_l3_start_ipa_broadcast(card); /* go on*/
1609 qeth_l3_start_ipa_checksum(card); /* go on*/
1610 qeth_l3_start_ipa_tx_checksum(card);
1611 qeth_l3_start_ipa_tso(card); /* go on*/
1615 static int qeth_l3_put_unique_id(struct qeth_card *card)
1622 QETH_CARD_TEXT(card, 2, "puniqeid");
1624 if ((card->info.unique_id & UNIQUE_ID_NOT_BY_CARD) ==
1627 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_DESTROY_ADDR,
1631 card->info.unique_id;
1633 card->dev->dev_addr, OSA_ADDR_LEN);
1634 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
1638 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1645 memcpy(card->dev->dev_addr,
1648 random_ether_addr(card->dev->dev_addr);
1653 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
1661 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1665 card->info.unique_id;
1667 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1672 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1679 card->info.unique_id = *((__u16 *)
1682 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1684 dev_warn(&card->gdev->dev, "The network adapter failed to "
1690 static int qeth_l3_get_unique_id(struct qeth_card *card)
1698 if (!qeth_is_supported(card, IPA_IPV6)) {
1699 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1704 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1708 card->info.unique_id;
1710 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1715 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
1726 QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
1734 card->info.promisc_mode = SET_PROMISC_MODE_OFF;
1735 dev_info(&card->gdev->dev, "The HiperSockets network "
1745 card->info.promisc_mode = SET_PROMISC_MODE_ON;
1746 dev_info(&card->gdev->dev, "The HiperSockets network "
1750 dev_warn(&card->gdev->dev, "The device is not "
1755 dev_warn(&card->gdev->dev, "A HiperSockets "
1765 cmd->data.diagass.action, QETH_CARD_IFNAME(card));
1772 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1779 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
1785 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1797 static void qeth_l3_add_mc(struct qeth_card *card, struct in_device *in4_dev)
1803 QETH_CARD_TEXT(card, 4, "addmc");
1812 if (!qeth_l3_add_ip(card, ipm))
1817 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1823 QETH_CARD_TEXT(card, 4, "addmcvl");
1824 if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
1827 vg = card->vlangrp;
1837 qeth_l3_add_mc(card, in_dev);
1843 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1847 QETH_CARD_TEXT(card, 4, "chkmcv4");
1848 in4_dev = in_dev_get(card->dev);
1852 qeth_l3_add_mc(card, in4_dev);
1853 qeth_l3_add_vlan_mc(card);
1859 static void qeth_l3_add_mc6(struct qeth_card *card, struct inet6_dev *in6_dev)
1865 QETH_CARD_TEXT(card, 4, "addmc6");
1875 if (!qeth_l3_add_ip(card, ipm))
1880 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1886 QETH_CARD_TEXT(card, 4, "admc6vl");
1887 if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
1890 vg = card->vlangrp;
1900 qeth_l3_add_mc6(card, in_dev);
1906 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1910 QETH_CARD_TEXT(card, 4, "chkmcv6");
1911 if (!qeth_is_supported(card, IPA_IPV6))
1913 in6_dev = in6_dev_get(card->dev);
1917 qeth_l3_add_mc6(card, in6_dev);
1918 qeth_l3_add_vlan_mc6(card);
1924 static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
1931 QETH_CARD_TEXT(card, 4, "frvaddr4");
1933 in_dev = in_dev_get(vlan_group_get_device(card->vlangrp, vid));
1942 if (!qeth_l3_delete_ip(card, addr))
1949 static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
1957 QETH_CARD_TEXT(card, 4, "frvaddr6");
1959 in6_dev = in6_dev_get(vlan_group_get_device(card->vlangrp, vid));
1969 if (!qeth_l3_delete_ip(card, addr))
1977 static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
1980 if (!card->vlangrp)
1982 qeth_l3_free_vlan_addresses4(card, vid);
1983 qeth_l3_free_vlan_addresses6(card, vid);
1989 struct qeth_card *card = dev->ml_priv;
1992 QETH_CARD_TEXT(card, 4, "vlanreg");
1993 spin_lock_irqsave(&card->vlanlock, flags);
1994 card->vlangrp = grp;
1995 spin_unlock_irqrestore(&card->vlanlock, flags);
2005 struct qeth_card *card = dev->ml_priv;
2008 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
2009 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
2010 QETH_CARD_TEXT(card, 3, "kidREC");
2013 spin_lock_irqsave(&card->vlanlock, flags);
2015 qeth_l3_free_vlan_addresses(card, vid);
2016 vlan_group_set_device(card->vlangrp, vid, NULL);
2017 spin_unlock_irqrestore(&card->vlanlock, flags);
2018 qeth_l3_set_multicast_list(card->dev);
2021 static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
2039 tg_addr, card->dev, 0);
2044 (card->dev->type == ARPHRD_IEEE802_TR) ?
2049 memcpy(tg_addr, card->dev->broadcast,
2050 card->dev->addr_len);
2052 card->stats.multicast++;
2056 memcpy(tg_addr, card->dev->broadcast,
2057 card->dev->addr_len);
2058 card->stats.multicast++;
2065 if (card->options.sniffer)
2069 memcpy(tg_addr, card->dev->dev_addr,
2070 card->dev->addr_len);
2073 card->dev->header_ops->create(skb, card->dev, prot,
2075 card->dev->addr_len);
2077 card->dev->header_ops->create(skb, card->dev, prot,
2078 tg_addr, "FAKELL", card->dev->addr_len);
2082 if (card->dev->type == ARPHRD_IEEE802_TR)
2083 skb->protocol = tr_type_trans(skb, card->dev);
2086 skb->protocol = eth_type_trans(skb, card->dev);
2094 switch (card->options.checksum_type) {
2115 static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
2127 if (card->options.performance_stats)
2128 card->perf_stats.bufs_rec++;
2129 while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
2131 skb->dev = card->dev;
2133 if (!(card->dev->flags & IFF_UP)) {
2140 vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
2142 if (vlan_tag && !card->options.sniffer)
2143 if (card->vlangrp)
2144 vlan_hwaccel_rx(skb, card->vlangrp,
2156 if (card->options.checksum_type == NO_CHECKSUMMING)
2165 QETH_CARD_TEXT(card, 3, "inbunkno");
2170 card->stats.rx_packets++;
2171 card->stats.rx_bytes += len;
2176 struct qeth_card *card)
2182 vg = card->vlangrp;
2193 if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card))
2201 struct qeth_card *card;
2206 list_for_each_entry(card, &qeth_core_card_list.list, list) {
2207 if (card->dev == dev) {
2211 rc = qeth_l3_verify_vlan_dev(dev, card);
2222 struct qeth_card *card = NULL;
2227 card = dev->ml_priv;
2229 card = vlan_dev_real_dev(dev)->ml_priv;
2230 if (card && card->options.layer2)
2231 card = NULL;
2232 if (card)
2233 QETH_CARD_TEXT_(card, 4, "%d", rc);
2234 return card ;
2237 static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
2242 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
2244 qeth_set_allowed_threads(card, 0, 1);
2245 if (card->options.sniffer &&
2246 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
2247 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
2248 if (card->read.state == CH_STATE_UP &&
2249 card->write.state == CH_STATE_UP &&
2250 (card->state == CARD_STATE_UP)) {
2252 qeth_l3_stop(card->dev);
2255 dev_close(card->dev);
2258 if (!card->use_hard_stop) {
2259 rc = qeth_send_stoplan(card);
2263 card->state = CARD_STATE_SOFTSETUP;
2265 if (card->state == CARD_STATE_SOFTSETUP) {
2266 qeth_l3_clear_ip_list(card, !card->use_hard_stop, 1);
2267 qeth_clear_ipacmd_list(card);
2268 card->state = CARD_STATE_HARDSETUP;
2270 if (card->state == CARD_STATE_HARDSETUP) {
2271 if (!card->use_hard_stop &&
2272 (card->info.type != QETH_CARD_TYPE_IQD)) {
2273 rc = qeth_l3_put_unique_id(card);
2277 qeth_qdio_clear_card(card, 0);
2278 qeth_clear_qdio_buffers(card);
2279 qeth_clear_working_pool_list(card);
2280 card->state = CARD_STATE_DOWN;
2282 if (card->state == CARD_STATE_DOWN) {
2283 qeth_clear_cmd_buffers(&card->read);
2284 qeth_clear_cmd_buffers(&card->write);
2286 card->use_hard_stop = 0;
2295 qeth_l3_handle_promisc_mode(struct qeth_card *card)
2297 struct net_device *dev = card->dev;
2300 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
2302 (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
2305 if (card->info.guestlan) { /* Guestlan trace */
2306 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
2307 qeth_setadp_promisc_mode(card);
2308 } else if (card->options.sniffer && /* HiperSockets trace */
2309 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
2311 QETH_CARD_TEXT(card, 3, "+promisc");
2312 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
2314 QETH_CARD_TEXT(card, 3, "-promisc");
2315 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
2322 struct qeth_card *card = dev->ml_priv;
2324 QETH_CARD_TEXT(card, 3, "setmulti");
2325 if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
2326 (card->state != CARD_STATE_UP))
2328 if (!card->options.sniffer) {
2329 qeth_l3_delete_mc_addresses(card);
2330 qeth_l3_add_multicast_ipv4(card);
2332 qeth_l3_add_multicast_ipv6(card);
2334 qeth_l3_set_ip_addr_list(card);
2335 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
2338 qeth_l3_handle_promisc_mode(card);
2364 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
2369 QETH_CARD_TEXT(card, 3, "arpstnoe");
2376 if (card->info.guestlan)
2378 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2381 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2387 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
2411 static int qeth_l3_arp_query_cb(struct qeth_card *card,
2421 QETH_CARD_TEXT(card, 4, "arpquecb");
2426 QETH_CARD_TEXT_(card, 4, "qaer1%i", cmd->hdr.return_code);
2431 QETH_CARD_TEXT_(card, 4, "qaer2%i", cmd->hdr.return_code);
2453 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
2457 QETH_CARD_TEXT_(card, 4, "anore%i",
2459 QETH_CARD_TEXT_(card, 4, "aseqn%i", cmd->data.setassparms.hdr.seq_no);
2460 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
2490 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2496 QETH_CARD_TEXT(card, 4, "sendarp");
2500 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2501 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2505 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2512 QETH_CARD_TEXT(card, 3, "arpquery");
2514 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2525 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2529 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2535 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2547 static int qeth_l3_arp_add_entry(struct qeth_card *card,
2555 QETH_CARD_TEXT(card, 3, "arpadent");
2562 if (card->info.guestlan)
2564 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2568 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2572 rc = qeth_l3_send_setassparms(card, iob,
2580 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2586 static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2594 QETH_CARD_TEXT(card, 3, "arprment");
2601 if (card->info.guestlan)
2603 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2607 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2611 rc = qeth_l3_send_setassparms(card, iob,
2619 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2625 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2630 QETH_CARD_TEXT(card, 3, "arpflush");
2637 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2639 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2642 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2647 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2655 struct qeth_card *card = dev->ml_priv;
2660 if (!card)
2663 if ((card->state != CARD_STATE_UP) &&
2664 (card->state != CARD_STATE_SOFTSETUP))
2673 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2680 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2691 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2702 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2709 rc = qeth_l3_arp_flush_cache(card);
2712 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);
2715 if ((card->info.type == QETH_CARD_TYPE_OSD ||
2716 card->info.type == QETH_CARD_TYPE_OSX) &&
2717 !card->info.guestlan)
2738 QETH_CARD_TEXT_(card, 2, "ioce%d", rc);
2742 int inline qeth_l3_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
2770 switch (card->info.link_type) {
2787 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2798 if (card->vlangrp && vlan_tx_tag_present(skb)) {
2799 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2822 if (card->info.type == QETH_CARD_TYPE_IQD)
2852 static inline void qeth_l3_hdr_csum(struct qeth_card *card,
2863 if (card->options.performance_stats)
2864 card->perf_stats.tx_csum++;
2867 static void qeth_tso_fill_header(struct qeth_card *card,
2919 struct qeth_card *card = dev->ml_priv;
2922 int cast_type = qeth_l3_get_cast_type(card, skb);
2923 struct qeth_qdio_out_q *queue = card->qdio.out_qs
2924 [qeth_get_priority_queue(card, skb, ipv, cast_type)];
2930 if (((card->info.type == QETH_CARD_TYPE_IQD) && (!ipv)) ||
2931 card->options.sniffer)
2934 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2935 card->stats.tx_carrier_errors++;
2940 (card->info.broadcast_capable == 0))
2943 if (card->options.performance_stats) {
2944 card->perf_stats.outbound_cnt++;
2945 card->perf_stats.outbound_start_time = qeth_get_micros();
2949 large_send = card->options.large_send;
2951 if ((card->info.type == QETH_CARD_TYPE_IQD) && (!large_send) &&
2967 if (card->info.type == QETH_CARD_TYPE_IQD) {
2972 if (card->dev->type == ARPHRD_IEEE802_TR)
2978 if (ipv == 6 && card->vlangrp &&
3002 if (card->options.performance_stats)
3003 card->perf_stats.tx_lin++;
3012 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
3013 qeth_tso_fill_header(card, hdr, new_skb);
3019 qeth_l3_fill_header(card, hdr, new_skb, ipv,
3022 qeth_l3_fill_header(card, hdr, new_skb, ipv,
3028 qeth_l3_hdr_csum(card, hdr, new_skb);
3031 elems = qeth_get_elements_no(card, (void *)hdr, new_skb,
3041 if (card->info.type != QETH_CARD_TYPE_IQD) {
3052 rc = qeth_do_send_packet(card, queue, new_skb, hdr,
3055 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
3059 card->stats.tx_packets++;
3060 card->stats.tx_bytes += tx_bytes;
3063 if (card->options.performance_stats) {
3065 card->perf_stats.large_send_bytes += tx_bytes;
3066 card->perf_stats.large_send_cnt++;
3069 card->perf_stats.sg_skbs_sent++;
3071 card->perf_stats.sg_frags_sent += nr_frags + 1;
3088 if (card->options.performance_stats)
3089 card->perf_stats.outbound_time += qeth_get_micros() -
3090 card->perf_stats.outbound_start_time;
3094 card->stats.tx_dropped++;
3095 card->stats.tx_errors++;
3105 struct qeth_card *card = dev->ml_priv;
3107 QETH_CARD_TEXT(card, 4, "qethopen");
3108 if (card->state != CARD_STATE_SOFTSETUP)
3110 card->data.state = CH_STATE_UP;
3111 card->state = CARD_STATE_UP;
3114 if (!card->lan_online && netif_carrier_ok(dev))
3121 struct qeth_card *card = dev->ml_priv;
3123 QETH_CARD_TEXT(card, 4, "qethstop");
3125 if (card->state == CARD_STATE_UP)
3126 card->state = CARD_STATE_SOFTSETUP;
3132 struct qeth_card *card = dev->ml_priv;
3134 return (card->options.checksum_type == HW_CHECKSUMMING);
3139 struct qeth_card *card = dev->ml_priv;
3147 return qeth_l3_set_rx_csum(card, csum_type);
3152 struct qeth_card *card = dev->ml_priv;
3156 rc = qeth_l3_set_large_send(card, QETH_LARGE_SEND_TSO);
3159 card->options.large_send = QETH_LARGE_SEND_NO;
3166 struct qeth_card *card = dev->ml_priv;
3169 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
3251 static int qeth_l3_setup_netdev(struct qeth_card *card)
3253 if (card->info.type == QETH_CARD_TYPE_OSD ||
3254 card->info.type == QETH_CARD_TYPE_OSX) {
3255 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
3256 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
3258 card->dev = alloc_trdev(0);
3260 if (!card->dev)
3262 card->dev->netdev_ops = &qeth_l3_netdev_ops;
3264 card->dev = alloc_etherdev(0);
3265 if (!card->dev)
3267 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
3270 qeth_l3_get_unique_id(card);
3271 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
3272 card->dev->dev_id = card->info.unique_id &
3275 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
3276 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
3277 if (!card->dev)
3279 card->dev->flags |= IFF_NOARP;
3280 card->dev->netdev_ops = &qeth_l3_netdev_ops;
3281 qeth_l3_iqd_read_initial_mac(card);
3285 card->dev->ml_priv = card;
3286 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
3287 card->dev->mtu = card->info.initial_mtu;
3288 SET_ETHTOOL_OPS(card->dev, &qeth_l3_ethtool_ops);
3289 card->dev->features |= NETIF_F_HW_VLAN_TX |
3292 card->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
3293 card->dev->gso_max_size = 15 * PAGE_SIZE;
3295 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
3296 return register_netdev(card->dev);
3304 struct qeth_card *card;
3309 card = (struct qeth_card *) card_ptr;
3310 net_dev = card->dev;
3311 if (card->options.performance_stats) {
3312 card->perf_stats.inbound_cnt++;
3313 card->perf_stats.inbound_start_time = qeth_get_micros();
3316 QETH_CARD_TEXT(card, 1, "qdinchk");
3317 QETH_CARD_TEXT_(card, 1, "%04X%04X",
3319 QETH_CARD_TEXT_(card, 1, "%04X", queue);
3320 qeth_schedule_recovery(card);
3325 buffer = &card->qdio.in_q->bufs[index];
3327 qeth_check_qdio_errors(card, buffer->buffer,
3329 qeth_l3_process_inbound_buffer(card, buffer, index);
3331 qeth_put_buffer_pool_entry(card, buffer->pool_entry);
3332 qeth_queue_input_buffer(card, index);
3334 if (card->options.performance_stats)
3335 card->perf_stats.inbound_time += qeth_get_micros() -
3336 card->perf_stats.inbound_start_time;
3341 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3344 card->options.layer2 = 0;
3345 card->discipline.input_handler = (qdio_handler_t *)
3347 card->discipline.output_handler = (qdio_handler_t *)
3349 card->discipline.recover = qeth_l3_recover;
3355 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3359 qeth_set_allowed_threads(card, 0, 1);
3360 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3363 card->use_hard_stop = 1;
3367 if (card->dev) {
3368 unregister_netdev(card->dev);
3369 card->dev = NULL;
3372 qeth_l3_clear_ip_list(card, 0, 0);
3373 qeth_l3_clear_ipato_list(card);
3379 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3383 BUG_ON(!card);
3384 mutex_lock(&card->discipline_mutex);
3385 mutex_lock(&card->conf_mutex);
3387 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
3389 recover_flag = card->state;
3390 rc = qeth_core_hardsetup_card(card);
3397 qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
3399 if (!card->dev && qeth_l3_setup_netdev(card)) {
3404 card->state = CARD_STATE_HARDSETUP;
3405 qeth_print_status_message(card);
3410 rc = qeth_send_startlan(card);
3414 dev_warn(&card->gdev->dev,
3416 card->lan_online = 0;
3422 card->lan_online = 1;
3424 rc = qeth_l3_setadapter_parms(card);
3427 if (!card->options.sniffer) {
3428 rc = qeth_l3_start_ipassists(card);
3431 qeth_l3_set_large_send(card, card->options.large_send);
3432 rc = qeth_l3_setrouting_v4(card);
3435 rc = qeth_l3_setrouting_v6(card);
3439 netif_tx_disable(card->dev);
3441 rc = qeth_init_qdio_queues(card);
3447 card->state = CARD_STATE_SOFTSETUP;
3448 netif_carrier_on(card->dev);
3450 qeth_set_allowed_threads(card, 0xffffffff, 0);
3451 qeth_l3_set_ip_addr_list(card);
3454 qeth_l3_open(card->dev);
3457 dev_open(card->dev);
3460 qeth_l3_set_multicast_list(card->dev);
3465 mutex_unlock(&card->conf_mutex);
3466 mutex_unlock(&card->discipline_mutex);
3469 card->use_hard_stop = 1;
3470 qeth_l3_stop_card(card, 0);
3471 ccw_device_set_offline(CARD_DDEV(card));
3472 ccw_device_set_offline(CARD_WDEV(card));
3473 ccw_device_set_offline(CARD_RDEV(card));
3475 card->state = CARD_STATE_RECOVER;
3477 card->state = CARD_STATE_DOWN;
3478 mutex_unlock(&card->conf_mutex);
3479 mutex_unlock(&card->discipline_mutex);
3491 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3495 mutex_lock(&card->discipline_mutex);
3496 mutex_lock(&card->conf_mutex);
3498 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
3500 if (card->dev && netif_carrier_ok(card->dev))
3501 netif_carrier_off(card->dev);
3502 recover_flag = card->state;
3503 qeth_l3_stop_card(card, recovery_mode);
3504 rc = ccw_device_set_offline(CARD_DDEV(card));
3505 rc2 = ccw_device_set_offline(CARD_WDEV(card));
3506 rc3 = ccw_device_set_offline(CARD_RDEV(card));
3512 card->state = CARD_STATE_RECOVER;
3515 mutex_unlock(&card->conf_mutex);
3516 mutex_unlock(&card->discipline_mutex);
3527 struct qeth_card *card;
3530 card = (struct qeth_card *) ptr;
3531 QETH_CARD_TEXT(card, 2, "recover1");
3532 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
3533 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
3535 QETH_CARD_TEXT(card, 2, "recover2");
3536 dev_warn(&card->gdev->dev,
3538 card->use_hard_stop = 1;
3539 __qeth_l3_set_offline(card->gdev, 1);
3540 rc = __qeth_l3_set_online(card->gdev, 1);
3542 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
3543 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3545 dev_info(&card->gdev->dev,
3549 dev_close(card->dev);
3551 dev_warn(&card->gdev->dev, "The qeth device driver "
3559 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3560 qeth_l3_clear_ip_list(card, 0, 0);
3561 qeth_qdio_clear_card(card, 0);
3562 qeth_clear_qdio_buffers(card);
3567 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3569 if (card->dev)
3570 netif_device_detach(card->dev);
3571 qeth_set_allowed_threads(card, 0, 1);
3572 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3575 if (card->state == CARD_STATE_UP) {
3576 card->use_hard_stop = 1;
3577 __qeth_l3_set_offline(card->gdev, 1);
3579 __qeth_l3_set_offline(card->gdev, 0);
3585 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3591 if (card->state == CARD_STATE_RECOVER) {
3592 rc = __qeth_l3_set_online(card->gdev, 1);
3595 dev_close(card->dev);
3599 rc = __qeth_l3_set_online(card->gdev, 0);
3601 qeth_set_allowed_threads(card, 0xffffffff, 0);
3602 if (card->dev)
3603 netif_device_attach(card->dev);
3605 dev_warn(&card->gdev->dev, "The qeth device driver "
3628 struct qeth_card *card;
3633 card = qeth_l3_get_card_from_dev(dev);
3634 QETH_CARD_TEXT(card, 3, "ipevent");
3635 if (!card)
3648 if (!qeth_l3_add_ip(card, addr))
3652 if (!qeth_l3_delete_ip(card, addr))
3658 qeth_l3_set_ip_addr_list(card);
3678 struct qeth_card *card;
3681 card = qeth_l3_get_card_from_dev(dev);
3682 if (!card)
3684 QETH_CARD_TEXT(card, 3, "ip6event");
3685 if (!qeth_is_supported(card, IPA_IPV6))
3698 if (!qeth_l3_add_ip(card, addr))
3702 if (!qeth_l3_delete_ip(card, addr))
3708 qeth_l3_set_ip_addr_list(card);