Lines Matching refs:card
31 static int qeth_l2_setdelmac_makerc(struct qeth_card *card, u16 retcode)
36 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
65 static int qeth_l2_send_setdelmac_cb(struct qeth_card *card,
71 return qeth_l2_setdelmac_makerc(card, cmd->hdr.return_code);
74 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
80 QETH_CARD_TEXT(card, 2, "L2sdmac");
81 iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
88 return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelmac_cb, NULL);
91 static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
95 QETH_CARD_TEXT(card, 2, "L2Setmac");
96 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
98 dev_info(&card->gdev->dev,
103 dev_warn(&card->gdev->dev,
107 dev_warn(&card->gdev->dev,
115 static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac)
121 QETH_CARD_TEXT(card, 2, "L2Wmac");
122 rc = qeth_l2_send_setdelmac(card, mac, cmd);
125 CARD_DEVID(card));
128 CARD_DEVID(card), rc);
132 static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac)
138 QETH_CARD_TEXT(card, 2, "L2Rmac");
139 rc = qeth_l2_send_setdelmac(card, mac, cmd);
142 CARD_DEVID(card), rc);
146 static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card)
152 hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) {
192 static int qeth_l2_setdelvlan_makerc(struct qeth_card *card, u16 retcode)
195 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
213 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
219 QETH_CARD_TEXT(card, 2, "L2sdvcb");
223 CARD_DEVID(card), cmd->hdr.return_code);
224 QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
226 return qeth_l2_setdelvlan_makerc(card, cmd->hdr.return_code);
229 static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
235 QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
236 iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
242 return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelvlan_cb, NULL);
248 struct qeth_card *card = dev->ml_priv;
250 QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
254 return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
260 struct qeth_card *card = dev->ml_priv;
262 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
266 return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
269 static void qeth_l2_set_pnso_mode(struct qeth_card *card,
272 spin_lock_irq(get_ccwdev_lock(CARD_RDEV(card)));
273 WRITE_ONCE(card->info.pnso_mode, mode);
274 spin_unlock_irq(get_ccwdev_lock(CARD_RDEV(card)));
277 drain_workqueue(card->event_wq);
280 static void qeth_l2_dev2br_fdb_flush(struct qeth_card *card)
284 QETH_CARD_TEXT(card, 2, "fdbflush");
293 card->dev, &info.info, NULL);
296 static int qeth_l2_request_initial_mac(struct qeth_card *card)
300 QETH_CARD_TEXT(card, 2, "l2reqmac");
303 rc = qeth_vm_request_mac(card);
307 CARD_DEVID(card), rc);
308 QETH_CARD_TEXT_(card, 2, "err%04x", rc);
312 if (!IS_OSN(card)) {
313 rc = qeth_setadpparms_change_macaddr(card);
317 CARD_DEVID(card), rc);
318 QETH_CARD_TEXT_(card, 2, "1err%04x", rc);
323 if (IS_OSM(card) || IS_OSX(card))
325 eth_hw_addr_random(card->dev);
328 QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len);
332 static void qeth_l2_register_dev_addr(struct qeth_card *card)
334 if (!is_valid_ether_addr(card->dev->dev_addr))
335 qeth_l2_request_initial_mac(card);
337 if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr))
338 card->info.dev_addr_is_registered = 1;
340 card->info.dev_addr_is_registered = 0;
345 struct qeth_card *card = dev->ml_priv;
347 if (card->info.dev_addr_is_registered)
350 QETH_CARD_TEXT(card, 4, "nomacadr");
357 struct qeth_card *card = dev->ml_priv;
361 QETH_CARD_TEXT(card, 3, "setmac");
363 if (IS_OSM(card) || IS_OSX(card)) {
364 QETH_CARD_TEXT(card, 3, "setmcTYP");
367 QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
373 card->info.dev_addr_is_registered)
377 rc = qeth_l2_send_setmac(card, addr->sa_data);
383 if (card->info.dev_addr_is_registered)
384 qeth_l2_remove_mac(card, old_addr);
385 card->info.dev_addr_is_registered = 1;
389 static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable)
394 QETH_CARD_TEXT(card, 3, "pmisc2br");
397 if (card->options.sbp.reflect_promisc_primary)
404 rc = qeth_bridgeport_setrole(card, role);
405 QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc);
407 card->options.sbp.role = role;
408 card->info.promisc_mode = enable;
412 static void qeth_l2_set_promisc_mode(struct qeth_card *card)
414 bool enable = card->dev->flags & IFF_PROMISC;
416 if (card->info.promisc_mode == enable)
419 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) {
420 qeth_setadp_promisc_mode(card, enable);
422 mutex_lock(&card->sbp_lock);
423 if (card->options.sbp.reflect_promisc)
424 qeth_l2_promisc_to_bridge(card, enable);
425 mutex_unlock(&card->sbp_lock);
429 /* New MAC address is added to the hash table and marked to be written on card
433 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
438 hash_for_each_possible(card->rx_mode_addrs, mac, hnode, mac_hash) {
452 hash_add(card->rx_mode_addrs, &mac->hnode, mac_hash);
457 struct qeth_card *card = container_of(work, struct qeth_card,
459 struct net_device *dev = card->dev;
466 QETH_CARD_TEXT(card, 3, "setmulti");
470 qeth_l2_add_mac(card, ha);
472 qeth_l2_add_mac(card, ha);
475 hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) {
478 qeth_l2_remove_mac(card, mac->mac_addr);
483 rc = qeth_l2_write_mac(card, mac->mac_addr);
496 qeth_l2_set_promisc_mode(card);
499 static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
529 rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len,
540 struct qeth_card *card = dev->ml_priv;
547 if (IS_IQD(card))
549 queue = card->qdio.out_qs[txq];
551 if (IS_OSN(card))
552 rc = qeth_l2_xmit_osn(card, skb, queue);
554 rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb),
568 struct qeth_card *card = dev->ml_priv;
570 if (IS_IQD(card))
574 if (qeth_uses_tx_prio_queueing(card))
575 return qeth_get_priority_queue(card, skb);
582 struct qeth_card *card = dev->ml_priv;
584 schedule_work(&card->rx_mode_work);
589 * @card: qeth_card structure pointer
601 static int qeth_l2_pnso(struct qeth_card *card, u8 oc, int cnc,
605 struct ccw_device *ddev = CARD_DDEV(card);
616 QETH_CARD_TEXT(card, 2, "PNSO");
649 QETH_CARD_TEXT_(card, 2, "PNrp%04x", rr->response.code);
655 static bool qeth_is_my_net_if_token(struct qeth_card *card,
658 return ((card->info.ddev_devno == token->devnum) &&
659 (card->info.cssid == token->cssid) &&
660 (card->info.iid == token->iid) &&
661 (card->info.ssid == token->ssid) &&
662 (card->info.chpid == token->chpid) &&
663 (card->info.chid == token->chid));
668 * @card: qeth_card structure pointer
678 static void qeth_l2_dev2br_fdb_notify(struct qeth_card *card, u8 code,
693 if (qeth_is_my_net_if_token(card, token))
704 card->dev, &info.info, NULL);
705 QETH_CARD_TEXT(card, 4, "andelmac");
706 QETH_CARD_TEXT_(card, 4,
710 card->dev, &info.info, NULL);
711 QETH_CARD_TEXT(card, 4, "anaddmac");
712 QETH_CARD_TEXT_(card, 4,
721 struct qeth_card *card = priv;
725 qeth_l2_dev2br_fdb_notify(card, code,
733 * @card: qeth_card structure pointer
743 static int qeth_l2_dev2br_an_set(struct qeth_card *card, bool enable)
748 QETH_CARD_TEXT(card, 2, "anseton");
749 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 1,
750 qeth_l2_dev2br_an_set_cb, card);
755 qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0,
758 QETH_CARD_TEXT(card, 2, "ansetoff");
759 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0, NULL, NULL);
770 struct qeth_card *card = dev->ml_priv;
775 qeth_bridgeport_is_in_use(card))
802 struct qeth_card *card = dev->ml_priv;
842 mutex_lock(&card->sbp_lock);
844 if (qeth_bridgeport_is_in_use(card)) {
848 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
849 rc = qeth_l2_dev2br_an_set(card, true);
851 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
855 rc = qeth_l2_dev2br_an_set(card, false);
857 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
859 qeth_l2_dev2br_fdb_flush(card);
862 mutex_unlock(&card->sbp_lock);
896 static int qeth_l2_setup_netdev(struct qeth_card *card)
898 if (IS_OSN(card)) {
899 card->dev->netdev_ops = &qeth_osn_netdev_ops;
900 card->dev->flags |= IFF_NOARP;
904 card->dev->needed_headroom = sizeof(struct qeth_hdr);
905 card->dev->netdev_ops = &qeth_l2_netdev_ops;
906 card->dev->priv_flags |= IFF_UNICAST_FLT;
908 if (IS_OSM(card)) {
909 card->dev->features |= NETIF_F_VLAN_CHALLENGED;
911 if (!IS_VM_NIC(card))
912 card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
913 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
916 if (IS_OSD(card) && !IS_VM_NIC(card)) {
917 card->dev->features |= NETIF_F_SG;
919 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
920 card->dev->hw_features |= NETIF_F_IP_CSUM;
921 card->dev->vlan_features |= NETIF_F_IP_CSUM;
924 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
925 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
926 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
928 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
929 qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
930 card->dev->hw_features |= NETIF_F_RXCSUM;
931 card->dev->vlan_features |= NETIF_F_RXCSUM;
933 if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
934 card->dev->hw_features |= NETIF_F_TSO;
935 card->dev->vlan_features |= NETIF_F_TSO;
937 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
938 card->dev->hw_features |= NETIF_F_TSO6;
939 card->dev->vlan_features |= NETIF_F_TSO6;
942 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
943 card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
944 netif_keep_dst(card->dev);
945 netif_set_gso_max_size(card->dev,
950 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
951 return register_netdev(card->dev);
954 static void qeth_l2_trace_features(struct qeth_card *card)
957 QETH_CARD_TEXT(card, 2, "featuSBP");
958 QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
959 sizeof(card->options.sbp.supported_funcs));
961 QETH_CARD_TEXT(card, 2, "feaVNICC");
962 QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
963 sizeof(card->options.vnicc.sup_chars));
966 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
968 if (!card->options.sbp.reflect_promisc &&
969 card->options.sbp.role != QETH_SBP_ROLE_NONE) {
971 qeth_bridgeport_setrole(card, card->options.sbp.role);
973 qeth_bridgeport_query_ports(card, &card->options.sbp.role,
976 if (card->options.sbp.hostnotification) {
977 if (qeth_bridgeport_an_set(card, 1))
978 card->options.sbp.hostnotification = 0;
984 * Detect whether this card supports 'dev to bridge fdb network address
987 * @card: qeth_card structure pointer
989 static void qeth_l2_detect_dev2br_support(struct qeth_card *card)
991 struct qeth_priv *priv = netdev_priv(card->dev);
994 QETH_CARD_TEXT(card, 2, "d2brsup");
995 if (!IS_IQD(card))
999 dev2br_supported = card->info.ids_valid &&
1001 QETH_CARD_TEXT_(card, 2, "D2Bsup%02x", dev2br_supported);
1009 static void qeth_l2_enable_brport_features(struct qeth_card *card)
1011 struct qeth_priv *priv = netdev_priv(card->dev);
1016 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1017 rc = qeth_l2_dev2br_an_set(card, true);
1020 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1021 qeth_l2_dev2br_fdb_flush(card);
1022 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1023 rc = qeth_l2_dev2br_an_set(card, true);
1026 netdev_err(card->dev,
1029 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1030 qeth_l2_dev2br_fdb_flush(card);
1034 dev_warn(&card->gdev->dev,
1042 static void qeth_osn_assist_cb(struct qeth_card *card,
1053 struct qeth_card *card;
1059 card = dev->ml_priv;
1060 if (!card)
1062 QETH_CARD_TEXT(card, 2, "osnsdmc");
1063 if (!qeth_card_hw_is_reachable(card))
1066 iob = qeth_alloc_cmd(&card->write, IPA_PDU_HEADER_SIZE + data_len, 1,
1071 qeth_prepare_ipa_cmd(card, iob, (u16) data_len, NULL);
1075 return qeth_send_ipa_cmd(card, iob, NULL, NULL);
1083 struct qeth_card *card;
1089 card = qeth_get_card_by_busid(bus_id);
1090 if (!card || !IS_OSN(card))
1092 *dev = card->dev;
1094 QETH_CARD_TEXT(card, 2, "osnreg");
1097 card->osn_info.assist_cb = assist_cb;
1098 card->osn_info.data_cb = data_cb;
1105 struct qeth_card *card;
1109 card = dev->ml_priv;
1110 if (!card)
1112 QETH_CARD_TEXT(card, 2, "osndereg");
1113 card->osn_info.assist_cb = NULL;
1114 card->osn_info.data_cb = NULL;
1125 * @card: qeth_card structure pointer, for udev events.
1138 static void qeth_bridge_emit_host_event(struct qeth_card *card,
1185 kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1190 struct qeth_card *card;
1220 kobject_uevent_env(&data->card->gdev->dev.kobj,
1225 static void qeth_bridge_state_change(struct qeth_card *card,
1231 QETH_CARD_TEXT(card, 2, "brstchng");
1233 QETH_CARD_TEXT(card, 2, "BPempty");
1237 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1243 QETH_CARD_TEXT(card, 2, "BPSalloc");
1247 data->card = card;
1252 queue_work(card->event_wq, &data->worker);
1257 struct qeth_card *card;
1265 struct qeth_card *card;
1271 card = data->card;
1272 priv = netdev_priv(card->dev);
1274 QETH_CARD_TEXT(card, 4, "dev2brew");
1276 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE)
1281 queue_delayed_work(card->event_wq, dwork,
1285 if (!netif_device_present(card->dev))
1291 CARD_DEVID(card));
1292 /* Card fdb and bridge fdb are out of sync, card has stopped
1297 qeth_l2_dev2br_fdb_flush(card);
1298 rc = qeth_l2_dev2br_an_set(card, true);
1305 netdev_err(card->dev,
1308 WRITE_ONCE(card->info.pnso_mode,
1311 qeth_l2_dev2br_fdb_flush(card);
1316 CARD_DEVID(card));
1322 qeth_l2_dev2br_fdb_notify(card,
1340 struct qeth_card *card;
1344 card = data->card;
1346 QETH_CARD_TEXT(data->card, 4, "adrchgew");
1348 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE)
1353 if (!mutex_trylock(&card->sbp_lock)) {
1354 queue_delayed_work(card->event_wq, dwork,
1359 dev_info(&data->card->gdev->dev,
1361 netdev_name(card->dev),
1368 data->card->options.sbp.hostnotification = 0;
1369 card->info.pnso_mode = QETH_PNSO_NONE;
1370 mutex_unlock(&data->card->sbp_lock);
1371 qeth_bridge_emit_host_event(data->card, anev_abort,
1377 qeth_bridge_emit_host_event(data->card,
1388 static void qeth_addr_change_event(struct qeth_card *card,
1396 if (card->info.pnso_mode == QETH_PNSO_NONE)
1399 QETH_CARD_TEXT(card, 4, "adrchgev");
1405 QETH_CARD_TEXT_(card, 2, "ACHN%04x",
1415 QETH_CARD_TEXT(card, 2, "ACNalloc");
1418 if (card->info.pnso_mode == QETH_PNSO_BRIDGEPORT)
1422 data->card = card;
1425 queue_delayed_work(card->event_wq, &data->dwork, 0);
1440 static int qeth_bridgeport_makerc(struct qeth_card *card,
1452 if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
1453 (!IS_IQD(card) && ipa_rc == sbp_rc)) {
1465 dev_err(&card->gdev->dev,
1471 dev_err(&card->gdev->dev,
1479 dev_err(&card->gdev->dev,
1484 dev_err(&card->gdev->dev,
1494 dev_err(&card->gdev->dev,
1500 dev_err(&card->gdev->dev,
1506 dev_err(&card->gdev->dev,
1512 dev_err(&card->gdev->dev,
1532 QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
1533 QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
1538 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1542 enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :
1547 iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE,
1562 static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1569 QETH_CARD_TEXT(card, 2, "brqsupcb");
1570 rc = qeth_bridgeport_makerc(card, cmd);
1581 * @card: qeth_card structure pointer.
1584 * strucutre: card->options.sbp.supported_funcs.
1586 static void qeth_bridgeport_query_support(struct qeth_card *card)
1591 QETH_CARD_TEXT(card, 2, "brqsuppo");
1592 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1597 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1599 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1600 card->options.sbp.supported_funcs = 0;
1603 card->options.sbp.supported_funcs = cbctl.data.supported;
1606 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1614 QETH_CARD_TEXT(card, 2, "brqprtcb");
1615 rc = qeth_bridgeport_makerc(card, cmd);
1621 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1636 * @card: qeth_card structure pointer.
1644 int qeth_bridgeport_query_ports(struct qeth_card *card,
1657 QETH_CARD_TEXT(card, 2, "brqports");
1658 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1660 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1664 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1668 static int qeth_bridgeport_set_cb(struct qeth_card *card,
1673 QETH_CARD_TEXT(card, 2, "brsetrcb");
1674 return qeth_bridgeport_makerc(card, cmd);
1679 * @card: qeth_card structure pointer.
1684 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1690 QETH_CARD_TEXT(card, 2, "brsetrol");
1705 if (!(card->options.sbp.supported_funcs & setcmd))
1707 iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1711 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
1717 struct qeth_card *card = (struct qeth_card *)priv;
1723 qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
1730 * @card: qeth_card structure pointer.
1738 int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
1742 if (!card->options.sbp.supported_funcs)
1746 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
1747 qeth_l2_set_pnso_mode(card, QETH_PNSO_BRIDGEPORT);
1748 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 1,
1749 qeth_bridgeport_an_set_cb, card);
1751 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1753 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 0, NULL, NULL);
1754 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1762 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
1789 QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
1794 static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
1802 QETH_CARD_TEXT(card, 2, "vniccrcb");
1804 return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
1806 card->options.vnicc.sup_chars = rep->vnicc_cmds.supported;
1807 card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled;
1817 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card,
1824 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE,
1837 static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
1841 QETH_CARD_TEXT(card, 2, "vniccqch");
1842 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0);
1846 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1850 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
1855 QETH_CARD_TEXT(card, 2, "vniccqcm");
1856 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS,
1863 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds);
1867 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
1872 QETH_CARD_TEXT(card, 2, "vniccedc");
1873 iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char));
1879 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1883 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
1889 QETH_CARD_TEXT(card, 2, "vniccgst");
1890 iob = qeth_l2_vnicc_build_cmd(card, cmd,
1901 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout);
1905 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
1908 if (card->options.vnicc.sup_chars & vnicc &&
1909 card->options.vnicc.getset_timeout_sup & vnicc &&
1910 !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
1918 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
1923 QETH_CARD_TEXT(card, 2, "vniccsch");
1926 if (!(card->options.vnicc.sup_chars & vnicc) ||
1927 !(card->options.vnicc.set_char_sup & vnicc))
1930 if (qeth_bridgeport_is_in_use(card))
1936 card->options.vnicc.wanted_chars |= vnicc;
1939 card->options.vnicc.wanted_chars &= ~vnicc;
1943 if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
1946 /* if card is not ready, simply stop here */
1947 if (!qeth_card_hw_is_reachable(card)) {
1949 card->options.vnicc.cur_chars |= vnicc;
1951 card->options.vnicc.cur_chars &= ~vnicc;
1955 rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
1957 card->options.vnicc.wanted_chars =
1958 card->options.vnicc.cur_chars;
1962 card->options.vnicc.rx_bcast_enabled = true;
1964 qeth_l2_vnicc_recover_timeout(card, vnicc,
1965 &card->options.vnicc.learning_timeout);
1972 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
1976 QETH_CARD_TEXT(card, 2, "vniccgch");
1979 if (!(card->options.vnicc.sup_chars & vnicc))
1982 if (qeth_bridgeport_is_in_use(card))
1985 /* if card is ready, query current VNICC state */
1986 if (qeth_card_hw_is_reachable(card))
1987 rc = qeth_l2_vnicc_query_chars(card);
1989 *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
1996 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
2000 QETH_CARD_TEXT(card, 2, "vniccsto");
2003 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2004 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2007 if (qeth_bridgeport_is_in_use(card))
2011 if (card->options.vnicc.learning_timeout == timeout)
2014 /* if card is not ready, simply store the value internally and return */
2015 if (!qeth_card_hw_is_reachable(card)) {
2016 card->options.vnicc.learning_timeout = timeout;
2020 /* send timeout value to card; if successful, store value internally */
2021 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2024 card->options.vnicc.learning_timeout = timeout;
2032 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
2036 QETH_CARD_TEXT(card, 2, "vniccgto");
2039 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2040 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2043 if (qeth_bridgeport_is_in_use(card))
2046 /* if card is ready, get timeout. Otherwise, just return stored value */
2047 *timeout = card->options.vnicc.learning_timeout;
2048 if (qeth_card_hw_is_reachable(card))
2049 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2057 static bool _qeth_l2_vnicc_is_in_use(struct qeth_card *card)
2059 if (!card->options.vnicc.sup_chars)
2062 * or the card is offline.
2064 if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
2065 if (!card->options.vnicc.rx_bcast_enabled ||
2066 !qeth_card_hw_is_reachable(card))
2074 * @card: qeth_card structure pointer
2079 bool qeth_bridgeport_allowed(struct qeth_card *card)
2081 struct qeth_priv *priv = netdev_priv(card->dev);
2083 return (!_qeth_l2_vnicc_is_in_use(card) &&
2088 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
2093 if (card->options.vnicc.sup_chars & vnicc &&
2094 card->options.vnicc.set_char_sup & vnicc &&
2095 !qeth_l2_vnicc_set_char(card, vnicc, cmd))
2097 card->options.vnicc.wanted_chars &= ~vnicc;
2098 card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
2103 static void qeth_l2_vnicc_init(struct qeth_card *card)
2105 u32 *timeout = &card->options.vnicc.learning_timeout;
2111 QETH_CARD_TEXT(card, 2, "vniccini");
2113 card->options.vnicc.rx_bcast_enabled = 0;
2115 if (qeth_l2_vnicc_query_chars(card)) {
2116 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
2118 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2120 card->options.vnicc.sup_chars = 0;
2121 card->options.vnicc.cur_chars = 0;
2122 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2126 chars_tmp = card->options.vnicc.sup_chars;
2127 chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
2130 if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
2136 card->options.vnicc.getset_timeout_sup |= vnicc;
2138 card->options.vnicc.getset_timeout_sup &= ~vnicc;
2141 card->options.vnicc.set_char_sup |= vnicc;
2143 card->options.vnicc.set_char_sup &= ~vnicc;
2146 error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
2149 chars_tmp = card->options.vnicc.wanted_chars ^
2150 card->options.vnicc.cur_chars;
2151 chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
2154 enable = card->options.vnicc.wanted_chars & vnicc;
2155 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
2158 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2162 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
2165 card->options.vnicc.sup_chars = QETH_VNICC_ALL;
2166 card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
2167 card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2169 card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
2170 card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
2172 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2182 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2185 if (IS_OSN(card))
2188 qeth_l2_vnicc_set_defaults(card);
2189 mutex_init(&card->sbp_lock);
2197 INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
2203 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2207 qeth_set_allowed_threads(card, 0, 1);
2208 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2211 qeth_set_offline(card, card->discipline, false);
2213 cancel_work_sync(&card->close_dev_work);
2214 if (card->dev->reg_state == NETREG_REGISTERED)
2215 unregister_netdev(card->dev);
2218 static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok)
2220 struct net_device *dev = card->dev;
2223 qeth_l2_detect_dev2br_support(card);
2225 mutex_lock(&card->sbp_lock);
2226 qeth_bridgeport_query_support(card);
2227 if (card->options.sbp.supported_funcs) {
2228 qeth_l2_setup_bridgeport_attrs(card);
2229 dev_info(&card->gdev->dev,
2232 mutex_unlock(&card->sbp_lock);
2234 qeth_l2_register_dev_addr(card);
2237 qeth_l2_vnicc_init(card);
2239 qeth_l2_trace_features(card);
2242 QETH_CARD_TEXT(card, 2, "softsetp");
2244 card->state = CARD_STATE_SOFTSETUP;
2246 qeth_set_allowed_threads(card, 0xffffffff, 0);
2249 rc = qeth_l2_setup_netdev(card);
2257 rc = qeth_set_real_num_tx_queues(card,
2258 qeth_tx_actual_queues(card));
2271 qeth_l2_enable_brport_features(card);
2275 napi_schedule(&card->napi);
2286 qeth_set_allowed_threads(card, 0, 1);
2287 card->state = CARD_STATE_DOWN;
2291 static void qeth_l2_set_offline(struct qeth_card *card)
2293 struct qeth_priv *priv = netdev_priv(card->dev);
2295 qeth_set_allowed_threads(card, 0, 1);
2296 qeth_l2_drain_rx_mode_cache(card);
2298 if (card->state == CARD_STATE_SOFTSETUP)
2299 card->state = CARD_STATE_DOWN;
2301 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
2304 qeth_l2_dev2br_fdb_flush(card);
2310 static int qeth_l2_control_event(struct qeth_card *card,
2318 qeth_bridge_state_change(card, cmd);
2324 qeth_addr_change_event(card, cmd);