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, const __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, const __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 ether_addr_to_u64(mac), CARD_DEVID(card));
128 ether_addr_to_u64(mac), 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 ether_addr_to_u64(mac), 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 rc = qeth_setadpparms_change_macaddr(card);
316 CARD_DEVID(card), rc);
317 QETH_CARD_TEXT_(card, 2, "1err%04x", rc);
322 if (IS_OSM(card) || IS_OSX(card))
324 eth_hw_addr_random(card->dev);
327 QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len);
331 static void qeth_l2_register_dev_addr(struct qeth_card *card)
333 if (!is_valid_ether_addr(card->dev->dev_addr))
334 qeth_l2_request_initial_mac(card);
336 if (!qeth_l2_send_setmac(card, card->dev->dev_addr))
337 card->info.dev_addr_is_registered = 1;
339 card->info.dev_addr_is_registered = 0;
344 struct qeth_card *card = dev->ml_priv;
346 if (card->info.dev_addr_is_registered)
349 QETH_CARD_TEXT(card, 4, "nomacadr");
356 struct qeth_card *card = dev->ml_priv;
360 QETH_CARD_TEXT(card, 3, "setmac");
362 if (IS_OSM(card) || IS_OSX(card)) {
363 QETH_CARD_TEXT(card, 3, "setmcTYP");
366 QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
372 card->info.dev_addr_is_registered)
376 rc = qeth_l2_send_setmac(card, addr->sa_data);
382 if (card->info.dev_addr_is_registered)
383 qeth_l2_remove_mac(card, old_addr);
384 card->info.dev_addr_is_registered = 1;
388 static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable)
393 QETH_CARD_TEXT(card, 3, "pmisc2br");
396 if (card->options.sbp.reflect_promisc_primary)
403 rc = qeth_bridgeport_setrole(card, role);
404 QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc);
406 card->options.sbp.role = role;
407 card->info.promisc_mode = enable;
411 static void qeth_l2_set_promisc_mode(struct qeth_card *card)
413 bool enable = card->dev->flags & IFF_PROMISC;
415 if (card->info.promisc_mode == enable)
418 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) {
419 qeth_setadp_promisc_mode(card, enable);
421 mutex_lock(&card->sbp_lock);
422 if (card->options.sbp.reflect_promisc)
423 qeth_l2_promisc_to_bridge(card, enable);
424 mutex_unlock(&card->sbp_lock);
428 /* New MAC address is added to the hash table and marked to be written on card
432 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
437 hash_for_each_possible(card->rx_mode_addrs, mac, hnode, mac_hash) {
451 hash_add(card->rx_mode_addrs, &mac->hnode, mac_hash);
456 struct qeth_card *card = container_of(work, struct qeth_card,
458 struct net_device *dev = card->dev;
465 QETH_CARD_TEXT(card, 3, "setmulti");
469 qeth_l2_add_mac(card, ha);
471 qeth_l2_add_mac(card, ha);
474 hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) {
477 qeth_l2_remove_mac(card, mac->mac_addr);
482 rc = qeth_l2_write_mac(card, mac->mac_addr);
495 qeth_l2_set_promisc_mode(card);
501 struct qeth_card *card = dev->ml_priv;
508 if (IS_IQD(card))
510 queue = card->qdio.out_qs[txq];
512 rc = qeth_xmit(card, skb, queue, vlan_get_protocol(skb),
531 struct qeth_card *card = dev->ml_priv;
533 schedule_work(&card->rx_mode_work);
538 * @card: qeth_card structure pointer
550 static int qeth_l2_pnso(struct qeth_card *card, u8 oc, int cnc,
554 struct ccw_device *ddev = CARD_DDEV(card);
565 QETH_CARD_TEXT(card, 2, "PNSO");
598 QETH_CARD_TEXT_(card, 2, "PNrp%04x", rr->response.code);
604 static bool qeth_is_my_net_if_token(struct qeth_card *card,
607 return ((card->info.ddev_devno == token->devnum) &&
608 (card->info.cssid == token->cssid) &&
609 (card->info.iid == token->iid) &&
610 (card->info.ssid == token->ssid) &&
611 (card->info.chpid == token->chpid) &&
612 (card->info.chid == token->chid));
617 * @card: qeth_card structure pointer
627 static void qeth_l2_dev2br_fdb_notify(struct qeth_card *card, u8 code,
642 if (qeth_is_my_net_if_token(card, token))
653 card->dev, &info.info, NULL);
654 QETH_CARD_TEXT(card, 4, "andelmac");
655 QETH_CARD_TEXT_(card, 4,
659 card->dev, &info.info, NULL);
660 QETH_CARD_TEXT(card, 4, "anaddmac");
661 QETH_CARD_TEXT_(card, 4,
670 struct qeth_card *card = priv;
674 qeth_l2_dev2br_fdb_notify(card, code,
682 * @card: qeth_card structure pointer
690 static int qeth_l2_dev2br_an_set(struct qeth_card *card, bool enable)
695 QETH_CARD_TEXT(card, 2, "anseton");
696 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 1,
697 qeth_l2_dev2br_an_set_cb, card);
702 qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0,
705 QETH_CARD_TEXT(card, 2, "ansetoff");
706 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0, NULL, NULL);
756 struct qeth_card *card = lsyncdev->ml_priv;
761 QETH_CARD_TEXT_(card, 4, "b2dw%04lx", event);
762 QETH_CARD_TEXT_(card, 4, "ma%012llx", ether_addr_to_u64(addr));
789 QETH_CARD_TEXT(card, 2, "b2derris");
790 QETH_CARD_TEXT_(card, 2,
809 QETH_CARD_TEXT_(card, 2, "b2derr%02lx", event);
827 struct qeth_card *card;
839 card = lsyncdev->ml_priv;
844 queue_work(card->event_wq, &worker_data->work);
856 struct qeth_card *card;
874 card = lowerdev->ml_priv;
875 QETH_CARD_TEXT_(card, 4, "b2dqw%03lx", event);
880 QETH_CARD_TEXT(card, 2, "b2dqwerr");
940 struct qeth_card *card = dev->ml_priv;
945 qeth_bridgeport_is_in_use(card))
972 struct qeth_card *card = dev->ml_priv;
1020 mutex_lock(&card->sbp_lock);
1022 if (qeth_bridgeport_is_in_use(card)) {
1026 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1027 rc = qeth_l2_dev2br_an_set(card, true);
1029 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1035 rc = qeth_l2_dev2br_an_set(card, false);
1037 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1039 qeth_l2_dev2br_fdb_flush(card);
1043 mutex_unlock(&card->sbp_lock);
1088 static int qeth_l2_setup_netdev(struct qeth_card *card)
1090 card->dev->netdev_ops = IS_IQD(card) ? &qeth_l2_iqd_netdev_ops :
1092 card->dev->needed_headroom = sizeof(struct qeth_hdr);
1093 card->dev->priv_flags |= IFF_UNICAST_FLT;
1095 if (IS_OSM(card)) {
1096 card->dev->features |= NETIF_F_VLAN_CHALLENGED;
1098 if (!IS_VM_NIC(card))
1099 card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1100 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1103 if (IS_OSD(card) && !IS_VM_NIC(card)) {
1104 card->dev->features |= NETIF_F_SG;
1106 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
1107 card->dev->hw_features |= NETIF_F_IP_CSUM;
1108 card->dev->vlan_features |= NETIF_F_IP_CSUM;
1111 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
1112 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
1113 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
1115 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
1116 qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
1117 card->dev->hw_features |= NETIF_F_RXCSUM;
1118 card->dev->vlan_features |= NETIF_F_RXCSUM;
1120 if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
1121 card->dev->hw_features |= NETIF_F_TSO;
1122 card->dev->vlan_features |= NETIF_F_TSO;
1124 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
1125 card->dev->hw_features |= NETIF_F_TSO6;
1126 card->dev->vlan_features |= NETIF_F_TSO6;
1129 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
1130 card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
1131 netif_keep_dst(card->dev);
1132 netif_set_tso_max_size(card->dev,
1136 netif_napi_add(card->dev, &card->napi, qeth_poll);
1137 return register_netdev(card->dev);
1140 static void qeth_l2_trace_features(struct qeth_card *card)
1143 QETH_CARD_TEXT(card, 2, "featuSBP");
1144 QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
1145 sizeof(card->options.sbp.supported_funcs));
1147 QETH_CARD_TEXT(card, 2, "feaVNICC");
1148 QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
1149 sizeof(card->options.vnicc.sup_chars));
1152 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
1154 if (!card->options.sbp.reflect_promisc &&
1155 card->options.sbp.role != QETH_SBP_ROLE_NONE) {
1157 qeth_bridgeport_setrole(card, card->options.sbp.role);
1159 qeth_bridgeport_query_ports(card, &card->options.sbp.role,
1162 if (card->options.sbp.hostnotification) {
1163 if (qeth_bridgeport_an_set(card, 1))
1164 card->options.sbp.hostnotification = 0;
1170 * Detect whether this card supports 'dev to bridge fdb network address
1173 * @card: qeth_card structure pointer
1175 static void qeth_l2_detect_dev2br_support(struct qeth_card *card)
1177 struct qeth_priv *priv = netdev_priv(card->dev);
1180 QETH_CARD_TEXT(card, 2, "d2brsup");
1181 if (!IS_IQD(card))
1185 dev2br_supported = card->info.ids_valid &&
1187 QETH_CARD_TEXT_(card, 2, "D2Bsup%02x", dev2br_supported);
1195 static void qeth_l2_enable_brport_features(struct qeth_card *card)
1197 struct qeth_priv *priv = netdev_priv(card->dev);
1202 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1203 rc = qeth_l2_dev2br_an_set(card, true);
1206 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1207 qeth_l2_dev2br_fdb_flush(card);
1208 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1209 rc = qeth_l2_dev2br_an_set(card, true);
1212 netdev_err(card->dev,
1215 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1216 qeth_l2_dev2br_fdb_flush(card);
1220 dev_warn(&card->gdev->dev,
1233 * @card: qeth_card structure pointer, for udev events.
1246 static void qeth_bridge_emit_host_event(struct qeth_card *card,
1294 kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1299 struct qeth_card *card;
1329 kobject_uevent_env(&data->card->gdev->dev.kobj,
1334 static void qeth_bridge_state_change(struct qeth_card *card,
1340 QETH_CARD_TEXT(card, 2, "brstchng");
1342 QETH_CARD_TEXT(card, 2, "BPempty");
1346 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1352 QETH_CARD_TEXT(card, 2, "BPSalloc");
1356 data->card = card;
1361 queue_work(card->event_wq, &data->worker);
1366 struct qeth_card *card;
1374 struct qeth_card *card;
1380 card = data->card;
1381 priv = netdev_priv(card->dev);
1383 QETH_CARD_TEXT(card, 4, "dev2brew");
1385 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE)
1391 queue_delayed_work(card->event_wq, dwork,
1396 if (!netif_device_present(card->dev)) {
1403 CARD_DEVID(card));
1404 /* Card fdb and bridge fdb are out of sync, card has stopped
1409 qeth_l2_dev2br_fdb_flush(card);
1410 rc = qeth_l2_dev2br_an_set(card, true);
1417 netdev_err(card->dev,
1420 WRITE_ONCE(card->info.pnso_mode,
1423 qeth_l2_dev2br_fdb_flush(card);
1428 CARD_DEVID(card));
1436 qeth_l2_dev2br_fdb_notify(card,
1451 struct qeth_card *card;
1455 card = data->card;
1457 QETH_CARD_TEXT(data->card, 4, "adrchgew");
1459 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE)
1464 if (!mutex_trylock(&card->sbp_lock)) {
1465 queue_delayed_work(card->event_wq, dwork,
1470 dev_info(&data->card->gdev->dev,
1472 netdev_name(card->dev),
1479 data->card->options.sbp.hostnotification = 0;
1480 card->info.pnso_mode = QETH_PNSO_NONE;
1481 mutex_unlock(&data->card->sbp_lock);
1482 qeth_bridge_emit_host_event(data->card, anev_abort,
1488 qeth_bridge_emit_host_event(data->card,
1499 static void qeth_addr_change_event(struct qeth_card *card,
1507 if (card->info.pnso_mode == QETH_PNSO_NONE)
1510 QETH_CARD_TEXT(card, 4, "adrchgev");
1516 QETH_CARD_TEXT_(card, 2, "ACHN%04x",
1526 QETH_CARD_TEXT(card, 2, "ACNalloc");
1529 if (card->info.pnso_mode == QETH_PNSO_BRIDGEPORT)
1533 data->card = card;
1536 queue_delayed_work(card->event_wq, &data->dwork, 0);
1551 static int qeth_bridgeport_makerc(struct qeth_card *card,
1563 if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
1564 (!IS_IQD(card) && ipa_rc == sbp_rc)) {
1576 dev_err(&card->gdev->dev,
1582 dev_err(&card->gdev->dev,
1590 dev_err(&card->gdev->dev,
1595 dev_err(&card->gdev->dev,
1605 dev_err(&card->gdev->dev,
1611 dev_err(&card->gdev->dev,
1617 dev_err(&card->gdev->dev,
1623 dev_err(&card->gdev->dev,
1643 QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
1644 QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
1649 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1653 enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :
1658 iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE,
1673 static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1680 QETH_CARD_TEXT(card, 2, "brqsupcb");
1681 rc = qeth_bridgeport_makerc(card, cmd);
1692 * @card: qeth_card structure pointer.
1695 * strucutre: card->options.sbp.supported_funcs.
1697 static void qeth_bridgeport_query_support(struct qeth_card *card)
1702 QETH_CARD_TEXT(card, 2, "brqsuppo");
1703 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1708 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1710 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1711 card->options.sbp.supported_funcs = 0;
1714 card->options.sbp.supported_funcs = cbctl.data.supported;
1717 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1725 QETH_CARD_TEXT(card, 2, "brqprtcb");
1726 rc = qeth_bridgeport_makerc(card, cmd);
1732 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1747 * @card: qeth_card structure pointer.
1755 int qeth_bridgeport_query_ports(struct qeth_card *card,
1768 QETH_CARD_TEXT(card, 2, "brqports");
1769 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1771 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1775 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1779 static int qeth_bridgeport_set_cb(struct qeth_card *card,
1784 QETH_CARD_TEXT(card, 2, "brsetrcb");
1785 return qeth_bridgeport_makerc(card, cmd);
1790 * @card: qeth_card structure pointer.
1795 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1801 QETH_CARD_TEXT(card, 2, "brsetrol");
1816 if (!(card->options.sbp.supported_funcs & setcmd))
1818 iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1822 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
1828 struct qeth_card *card = (struct qeth_card *)priv;
1834 qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
1841 * @card: qeth_card structure pointer.
1849 int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
1853 if (!card->options.sbp.supported_funcs)
1857 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
1858 qeth_l2_set_pnso_mode(card, QETH_PNSO_BRIDGEPORT);
1859 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 1,
1860 qeth_bridgeport_an_set_cb, card);
1862 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1864 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 0, NULL, NULL);
1865 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1873 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
1900 QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
1905 static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
1913 QETH_CARD_TEXT(card, 2, "vniccrcb");
1915 return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
1917 card->options.vnicc.sup_chars = rep->vnicc_cmds.supported;
1918 card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled;
1928 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card,
1935 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE,
1948 static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
1952 QETH_CARD_TEXT(card, 2, "vniccqch");
1953 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0);
1957 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1961 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
1966 QETH_CARD_TEXT(card, 2, "vniccqcm");
1967 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS,
1974 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds);
1978 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
1983 QETH_CARD_TEXT(card, 2, "vniccedc");
1984 iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char));
1990 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1994 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
2000 QETH_CARD_TEXT(card, 2, "vniccgst");
2001 iob = qeth_l2_vnicc_build_cmd(card, cmd,
2012 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout);
2016 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
2019 if (card->options.vnicc.sup_chars & vnicc &&
2020 card->options.vnicc.getset_timeout_sup & vnicc &&
2021 !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
2029 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
2034 QETH_CARD_TEXT(card, 2, "vniccsch");
2037 if (!(card->options.vnicc.sup_chars & vnicc) ||
2038 !(card->options.vnicc.set_char_sup & vnicc))
2041 if (qeth_bridgeport_is_in_use(card))
2047 card->options.vnicc.wanted_chars |= vnicc;
2050 card->options.vnicc.wanted_chars &= ~vnicc;
2054 if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
2057 /* if card is not ready, simply stop here */
2058 if (!qeth_card_hw_is_reachable(card)) {
2060 card->options.vnicc.cur_chars |= vnicc;
2062 card->options.vnicc.cur_chars &= ~vnicc;
2066 rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
2068 card->options.vnicc.wanted_chars =
2069 card->options.vnicc.cur_chars;
2073 card->options.vnicc.rx_bcast_enabled = true;
2075 qeth_l2_vnicc_recover_timeout(card, vnicc,
2076 &card->options.vnicc.learning_timeout);
2083 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
2087 QETH_CARD_TEXT(card, 2, "vniccgch");
2090 if (!(card->options.vnicc.sup_chars & vnicc))
2093 if (qeth_bridgeport_is_in_use(card))
2096 /* if card is ready, query current VNICC state */
2097 if (qeth_card_hw_is_reachable(card))
2098 rc = qeth_l2_vnicc_query_chars(card);
2100 *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
2107 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
2111 QETH_CARD_TEXT(card, 2, "vniccsto");
2114 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2115 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2118 if (qeth_bridgeport_is_in_use(card))
2122 if (card->options.vnicc.learning_timeout == timeout)
2125 /* if card is not ready, simply store the value internally and return */
2126 if (!qeth_card_hw_is_reachable(card)) {
2127 card->options.vnicc.learning_timeout = timeout;
2131 /* send timeout value to card; if successful, store value internally */
2132 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2135 card->options.vnicc.learning_timeout = timeout;
2143 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
2147 QETH_CARD_TEXT(card, 2, "vniccgto");
2150 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2151 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2154 if (qeth_bridgeport_is_in_use(card))
2157 /* if card is ready, get timeout. Otherwise, just return stored value */
2158 *timeout = card->options.vnicc.learning_timeout;
2159 if (qeth_card_hw_is_reachable(card))
2160 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2168 static bool _qeth_l2_vnicc_is_in_use(struct qeth_card *card)
2170 if (!card->options.vnicc.sup_chars)
2173 * or the card is offline.
2175 if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
2176 if (!card->options.vnicc.rx_bcast_enabled ||
2177 !qeth_card_hw_is_reachable(card))
2185 * @card: qeth_card structure pointer
2190 bool qeth_bridgeport_allowed(struct qeth_card *card)
2192 struct qeth_priv *priv = netdev_priv(card->dev);
2194 return (!_qeth_l2_vnicc_is_in_use(card) &&
2199 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
2204 if (card->options.vnicc.sup_chars & vnicc &&
2205 card->options.vnicc.set_char_sup & vnicc &&
2206 !qeth_l2_vnicc_set_char(card, vnicc, cmd))
2208 card->options.vnicc.wanted_chars &= ~vnicc;
2209 card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
2214 static void qeth_l2_vnicc_init(struct qeth_card *card)
2216 u32 *timeout = &card->options.vnicc.learning_timeout;
2222 QETH_CARD_TEXT(card, 2, "vniccini");
2224 card->options.vnicc.rx_bcast_enabled = 0;
2226 if (qeth_l2_vnicc_query_chars(card)) {
2227 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
2229 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2231 card->options.vnicc.sup_chars = 0;
2232 card->options.vnicc.cur_chars = 0;
2233 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2237 chars_tmp = card->options.vnicc.sup_chars;
2238 chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
2241 if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
2247 card->options.vnicc.getset_timeout_sup |= vnicc;
2249 card->options.vnicc.getset_timeout_sup &= ~vnicc;
2252 card->options.vnicc.set_char_sup |= vnicc;
2254 card->options.vnicc.set_char_sup &= ~vnicc;
2257 error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
2260 chars_tmp = card->options.vnicc.wanted_chars ^
2261 card->options.vnicc.cur_chars;
2262 chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
2265 enable = card->options.vnicc.wanted_chars & vnicc;
2266 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
2269 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2273 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
2276 card->options.vnicc.sup_chars = QETH_VNICC_ALL;
2277 card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
2278 card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2280 card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
2281 card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
2283 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2293 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2296 qeth_l2_vnicc_set_defaults(card);
2297 mutex_init(&card->sbp_lock);
2307 INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
2313 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2319 qeth_set_allowed_threads(card, 0, 1);
2320 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2323 qeth_set_offline(card, card->discipline, false);
2325 if (card->dev->reg_state == NETREG_REGISTERED) {
2326 priv = netdev_priv(card->dev);
2332 unregister_netdev(card->dev);
2336 static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok)
2338 struct net_device *dev = card->dev;
2341 qeth_l2_detect_dev2br_support(card);
2343 mutex_lock(&card->sbp_lock);
2344 qeth_bridgeport_query_support(card);
2345 if (card->options.sbp.supported_funcs) {
2346 qeth_l2_setup_bridgeport_attrs(card);
2347 dev_info(&card->gdev->dev,
2350 mutex_unlock(&card->sbp_lock);
2352 qeth_l2_register_dev_addr(card);
2355 qeth_l2_vnicc_init(card);
2357 qeth_l2_trace_features(card);
2360 QETH_CARD_TEXT(card, 2, "softsetp");
2362 card->state = CARD_STATE_SOFTSETUP;
2364 qeth_set_allowed_threads(card, 0xffffffff, 0);
2367 rc = qeth_l2_setup_netdev(card);
2375 rc = qeth_set_real_num_tx_queues(card,
2376 qeth_tx_actual_queues(card));
2389 qeth_l2_enable_brport_features(card);
2393 napi_schedule(&card->napi);
2404 qeth_set_allowed_threads(card, 0, 1);
2405 card->state = CARD_STATE_DOWN;
2409 static void qeth_l2_set_offline(struct qeth_card *card)
2411 struct qeth_priv *priv = netdev_priv(card->dev);
2413 qeth_set_allowed_threads(card, 0, 1);
2414 qeth_l2_drain_rx_mode_cache(card);
2416 if (card->state == CARD_STATE_SOFTSETUP)
2417 card->state = CARD_STATE_DOWN;
2419 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
2421 qeth_l2_dev2br_fdb_flush(card);
2425 static int qeth_l2_control_event(struct qeth_card *card,
2433 qeth_bridge_state_change(card, cmd);
2439 qeth_addr_change_event(card, cmd);