1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2007, 2009
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/string.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
18 #include <linux/slab.h>
19 #include <linux/etherdevice.h>
20 #include <linux/if_bridge.h>
21 #include <linux/list.h>
22 #include <linux/hash.h>
23 #include <linux/hashtable.h>
24 #include <net/switchdev.h>
26 #include <asm/css_chars.h>
27 #include <asm/setup.h>
28 #include "qeth_core.h"
31 static int qeth_l2_setdelmac_makerc(struct qeth_card
*card
, u16 retcode
)
36 QETH_CARD_TEXT_(card
, 2, "err%04x", retcode
);
41 case IPA_RC_L2_UNSUPPORTED_CMD
:
44 case IPA_RC_L2_ADDR_TABLE_FULL
:
47 case IPA_RC_L2_DUP_MAC
:
48 case IPA_RC_L2_DUP_LAYER3_MAC
:
51 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP
:
52 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP
:
55 case IPA_RC_L2_MAC_NOT_FOUND
:
65 static int qeth_l2_send_setdelmac_cb(struct qeth_card
*card
,
66 struct qeth_reply
*reply
,
69 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
71 return qeth_l2_setdelmac_makerc(card
, cmd
->hdr
.return_code
);
74 static int qeth_l2_send_setdelmac(struct qeth_card
*card
, __u8
*mac
,
75 enum qeth_ipa_cmds ipacmd
)
77 struct qeth_ipa_cmd
*cmd
;
78 struct qeth_cmd_buffer
*iob
;
80 QETH_CARD_TEXT(card
, 2, "L2sdmac");
81 iob
= qeth_ipa_alloc_cmd(card
, ipacmd
, QETH_PROT_IPV4
,
82 IPA_DATA_SIZEOF(setdelmac
));
86 cmd
->data
.setdelmac
.mac_length
= ETH_ALEN
;
87 ether_addr_copy(cmd
->data
.setdelmac
.mac
, mac
);
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
,
99 "MAC address %pM successfully registered\n", mac
);
103 dev_warn(&card
->gdev
->dev
,
104 "MAC address %pM already exists\n", mac
);
107 dev_warn(&card
->gdev
->dev
,
108 "MAC address %pM is not authorized\n", mac
);
115 static int qeth_l2_write_mac(struct qeth_card
*card
, u8
*mac
)
117 enum qeth_ipa_cmds cmd
= is_multicast_ether_addr(mac
) ?
118 IPA_CMD_SETGMAC
: IPA_CMD_SETVMAC
;
121 QETH_CARD_TEXT(card
, 2, "L2Wmac");
122 rc
= qeth_l2_send_setdelmac(card
, mac
, cmd
);
123 if (rc
== -EADDRINUSE
)
124 QETH_DBF_MESSAGE(2, "MAC already registered on device %x\n",
127 QETH_DBF_MESSAGE(2, "Failed to register MAC on device %x: %d\n",
128 CARD_DEVID(card
), rc
);
132 static int qeth_l2_remove_mac(struct qeth_card
*card
, u8
*mac
)
134 enum qeth_ipa_cmds cmd
= is_multicast_ether_addr(mac
) ?
135 IPA_CMD_DELGMAC
: IPA_CMD_DELVMAC
;
138 QETH_CARD_TEXT(card
, 2, "L2Rmac");
139 rc
= qeth_l2_send_setdelmac(card
, mac
, cmd
);
141 QETH_DBF_MESSAGE(2, "Failed to delete MAC on device %u: %d\n",
142 CARD_DEVID(card
), rc
);
146 static void qeth_l2_drain_rx_mode_cache(struct qeth_card
*card
)
148 struct qeth_mac
*mac
;
149 struct hlist_node
*tmp
;
152 hash_for_each_safe(card
->rx_mode_addrs
, i
, tmp
, mac
, hnode
) {
153 hash_del(&mac
->hnode
);
158 static void qeth_l2_fill_header(struct qeth_qdio_out_q
*queue
,
159 struct qeth_hdr
*hdr
, struct sk_buff
*skb
,
160 __be16 proto
, unsigned int data_len
)
162 int cast_type
= qeth_get_ether_cast_type(skb
);
163 struct vlan_ethhdr
*veth
= vlan_eth_hdr(skb
);
165 hdr
->hdr
.l2
.pkt_length
= data_len
;
167 if (skb_is_gso(skb
)) {
168 hdr
->hdr
.l2
.id
= QETH_HEADER_TYPE_L2_TSO
;
170 hdr
->hdr
.l2
.id
= QETH_HEADER_TYPE_LAYER2
;
171 if (skb
->ip_summed
== CHECKSUM_PARTIAL
)
172 qeth_tx_csum(skb
, &hdr
->hdr
.l2
.flags
[1], proto
);
175 /* set byte byte 3 to casting flags */
176 if (cast_type
== RTN_MULTICAST
)
177 hdr
->hdr
.l2
.flags
[2] |= QETH_LAYER2_FLAG_MULTICAST
;
178 else if (cast_type
== RTN_BROADCAST
)
179 hdr
->hdr
.l2
.flags
[2] |= QETH_LAYER2_FLAG_BROADCAST
;
181 hdr
->hdr
.l2
.flags
[2] |= QETH_LAYER2_FLAG_UNICAST
;
183 /* VSWITCH relies on the VLAN
184 * information to be present in
186 if (veth
->h_vlan_proto
== htons(ETH_P_8021Q
)) {
187 hdr
->hdr
.l2
.flags
[2] |= QETH_LAYER2_FLAG_VLAN
;
188 hdr
->hdr
.l2
.vlan_id
= ntohs(veth
->h_vlan_TCI
);
192 static int qeth_l2_setdelvlan_makerc(struct qeth_card
*card
, u16 retcode
)
195 QETH_CARD_TEXT_(card
, 2, "err%04x", retcode
);
200 case IPA_RC_L2_INVALID_VLAN_ID
:
202 case IPA_RC_L2_DUP_VLAN_ID
:
204 case IPA_RC_L2_VLAN_ID_NOT_FOUND
:
206 case IPA_RC_L2_VLAN_ID_NOT_ALLOWED
:
213 static int qeth_l2_send_setdelvlan_cb(struct qeth_card
*card
,
214 struct qeth_reply
*reply
,
217 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
219 QETH_CARD_TEXT(card
, 2, "L2sdvcb");
220 if (cmd
->hdr
.return_code
) {
221 QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n",
222 cmd
->data
.setdelvlan
.vlan_id
,
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
,
230 enum qeth_ipa_cmds ipacmd
)
232 struct qeth_ipa_cmd
*cmd
;
233 struct qeth_cmd_buffer
*iob
;
235 QETH_CARD_TEXT_(card
, 4, "L2sdv%x", ipacmd
);
236 iob
= qeth_ipa_alloc_cmd(card
, ipacmd
, QETH_PROT_IPV4
,
237 IPA_DATA_SIZEOF(setdelvlan
));
240 cmd
= __ipa_cmd(iob
);
241 cmd
->data
.setdelvlan
.vlan_id
= i
;
242 return qeth_send_ipa_cmd(card
, iob
, qeth_l2_send_setdelvlan_cb
, NULL
);
245 static int qeth_l2_vlan_rx_add_vid(struct net_device
*dev
,
246 __be16 proto
, u16 vid
)
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
);
257 static int qeth_l2_vlan_rx_kill_vid(struct net_device
*dev
,
258 __be16 proto
, u16 vid
)
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
,
270 enum qeth_pnso_mode mode
)
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
)));
276 if (mode
== QETH_PNSO_NONE
)
277 drain_workqueue(card
->event_wq
);
280 static void qeth_l2_dev2br_fdb_flush(struct qeth_card
*card
)
282 struct switchdev_notifier_fdb_info info
= {};
284 QETH_CARD_TEXT(card
, 2, "fdbflush");
287 /* flush all VLANs: */
289 info
.added_by_user
= false;
290 info
.offloaded
= true;
292 call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE
,
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
);
306 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
307 CARD_DEVID(card
), rc
);
308 QETH_CARD_TEXT_(card
, 2, "err%04x", rc
);
309 /* fall back to alternative mechanism: */
312 rc
= qeth_setadpparms_change_macaddr(card
);
315 QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
316 CARD_DEVID(card
), rc
);
317 QETH_CARD_TEXT_(card
, 2, "1err%04x", rc
);
319 /* Fall back once more, but some devices don't support a custom MAC
322 if (IS_OSM(card
) || IS_OSX(card
))
323 return (rc
) ? rc
: -EADDRNOTAVAIL
;
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;
342 static int qeth_l2_validate_addr(struct net_device
*dev
)
344 struct qeth_card
*card
= dev
->ml_priv
;
346 if (card
->info
.dev_addr_is_registered
)
347 return eth_validate_addr(dev
);
349 QETH_CARD_TEXT(card
, 4, "nomacadr");
353 static int qeth_l2_set_mac_address(struct net_device
*dev
, void *p
)
355 struct sockaddr
*addr
= p
;
356 struct qeth_card
*card
= dev
->ml_priv
;
357 u8 old_addr
[ETH_ALEN
];
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
);
367 if (!is_valid_ether_addr(addr
->sa_data
))
368 return -EADDRNOTAVAIL
;
370 /* don't register the same address twice */
371 if (ether_addr_equal_64bits(dev
->dev_addr
, addr
->sa_data
) &&
372 card
->info
.dev_addr_is_registered
)
375 /* add the new address, switch over, drop the old */
376 rc
= qeth_l2_send_setmac(card
, addr
->sa_data
);
379 ether_addr_copy(old_addr
, dev
->dev_addr
);
380 ether_addr_copy(dev
->dev_addr
, 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
)
397 role
= QETH_SBP_ROLE_PRIMARY
;
399 role
= QETH_SBP_ROLE_SECONDARY
;
401 role
= QETH_SBP_ROLE_NONE
;
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
429 * only if there is not in the hash table storage already
432 static void qeth_l2_add_mac(struct qeth_card
*card
, struct netdev_hw_addr
*ha
)
434 u32 mac_hash
= get_unaligned((u32
*)(&ha
->addr
[2]));
435 struct qeth_mac
*mac
;
437 hash_for_each_possible(card
->rx_mode_addrs
, mac
, hnode
, mac_hash
) {
438 if (ether_addr_equal_64bits(ha
->addr
, mac
->mac_addr
)) {
439 mac
->disp_flag
= QETH_DISP_ADDR_DO_NOTHING
;
444 mac
= kzalloc(sizeof(struct qeth_mac
), GFP_ATOMIC
);
448 ether_addr_copy(mac
->mac_addr
, ha
->addr
);
449 mac
->disp_flag
= QETH_DISP_ADDR_ADD
;
451 hash_add(card
->rx_mode_addrs
, &mac
->hnode
, mac_hash
);
454 static void qeth_l2_rx_mode_work(struct work_struct
*work
)
456 struct qeth_card
*card
= container_of(work
, struct qeth_card
,
458 struct net_device
*dev
= card
->dev
;
459 struct netdev_hw_addr
*ha
;
460 struct qeth_mac
*mac
;
461 struct hlist_node
*tmp
;
465 QETH_CARD_TEXT(card
, 3, "setmulti");
467 netif_addr_lock_bh(dev
);
468 netdev_for_each_mc_addr(ha
, dev
)
469 qeth_l2_add_mac(card
, ha
);
470 netdev_for_each_uc_addr(ha
, dev
)
471 qeth_l2_add_mac(card
, ha
);
472 netif_addr_unlock_bh(dev
);
474 hash_for_each_safe(card
->rx_mode_addrs
, i
, tmp
, mac
, hnode
) {
475 switch (mac
->disp_flag
) {
476 case QETH_DISP_ADDR_DELETE
:
477 qeth_l2_remove_mac(card
, mac
->mac_addr
);
478 hash_del(&mac
->hnode
);
481 case QETH_DISP_ADDR_ADD
:
482 rc
= qeth_l2_write_mac(card
, mac
->mac_addr
);
484 hash_del(&mac
->hnode
);
490 /* for next call to set_rx_mode(): */
491 mac
->disp_flag
= QETH_DISP_ADDR_DELETE
;
495 qeth_l2_set_promisc_mode(card
);
498 static netdev_tx_t
qeth_l2_hard_start_xmit(struct sk_buff
*skb
,
499 struct net_device
*dev
)
501 struct qeth_card
*card
= dev
->ml_priv
;
502 u16 txq
= skb_get_queue_mapping(skb
);
503 struct qeth_qdio_out_q
*queue
;
506 if (!skb_is_gso(skb
))
507 qdisc_skb_cb(skb
)->pkt_len
= skb
->len
;
509 txq
= qeth_iqd_translate_txq(dev
, txq
);
510 queue
= card
->qdio
.out_qs
[txq
];
512 rc
= qeth_xmit(card
, skb
, queue
, vlan_get_protocol(skb
),
513 qeth_l2_fill_header
);
517 QETH_TXQ_STAT_INC(queue
, tx_dropped
);
522 static u16
qeth_l2_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
523 struct net_device
*sb_dev
)
525 struct qeth_card
*card
= dev
->ml_priv
;
528 return qeth_iqd_select_queue(dev
, skb
,
529 qeth_get_ether_cast_type(skb
),
531 if (qeth_uses_tx_prio_queueing(card
))
532 return qeth_get_priority_queue(card
, skb
);
534 return netdev_pick_tx(dev
, skb
, sb_dev
);
537 static void qeth_l2_set_rx_mode(struct net_device
*dev
)
539 struct qeth_card
*card
= dev
->ml_priv
;
541 schedule_work(&card
->rx_mode_work
);
545 * qeth_l2_pnso() - perform network subchannel operation
546 * @card: qeth_card structure pointer
547 * @oc: Operation Code
548 * @cnc: Boolean Change-Notification Control
549 * @cb: Callback function will be executed for each element
550 * of the address list
551 * @priv: Pointer to pass to the callback function.
553 * Collects network information in a network address list and calls the
554 * callback function for every entry in the list. If "change-notification-
555 * control" is set, further changes in the address list will be reported
556 * via the IPA command.
558 static int qeth_l2_pnso(struct qeth_card
*card
, u8 oc
, int cnc
,
559 void (*cb
)(void *priv
, struct chsc_pnso_naid_l2
*entry
),
562 struct ccw_device
*ddev
= CARD_DDEV(card
);
563 struct chsc_pnso_area
*rr
;
564 u32 prev_instance
= 0;
565 int isfirstblock
= 1;
569 rr
= (struct chsc_pnso_area
*)get_zeroed_page(GFP_KERNEL
);
573 QETH_CARD_TEXT(card
, 2, "PNSO");
574 /* on the first iteration, naihdr.resume_token will be zero */
575 rc
= ccw_device_pnso(ddev
, rr
, oc
, rr
->naihdr
.resume_token
,
582 size
= rr
->naihdr
.naids
;
583 if (size
!= sizeof(struct chsc_pnso_naid_l2
)) {
588 elems
= (rr
->response
.length
- sizeof(struct chsc_header
) -
589 sizeof(struct chsc_pnso_naihdr
)) / size
;
591 if (!isfirstblock
&& (rr
->naihdr
.instance
!= prev_instance
)) {
592 /* Inform the caller that they need to scrap */
593 /* the data that was already reported via cb */
598 prev_instance
= rr
->naihdr
.instance
;
599 for (i
= 0; i
< elems
; i
++)
600 (*cb
)(priv
, &rr
->entries
[i
]);
601 } while ((rc
== -EBUSY
) || (!rc
&& /* list stored */
602 /* resume token is non-zero => list incomplete */
603 (rr
->naihdr
.resume_token
.t1
|| rr
->naihdr
.resume_token
.t2
)));
606 QETH_CARD_TEXT_(card
, 2, "PNrp%04x", rr
->response
.code
);
608 free_page((unsigned long)rr
);
612 static bool qeth_is_my_net_if_token(struct qeth_card
*card
,
613 struct net_if_token
*token
)
615 return ((card
->info
.ddev_devno
== token
->devnum
) &&
616 (card
->info
.cssid
== token
->cssid
) &&
617 (card
->info
.iid
== token
->iid
) &&
618 (card
->info
.ssid
== token
->ssid
) &&
619 (card
->info
.chpid
== token
->chpid
) &&
620 (card
->info
.chid
== token
->chid
));
624 * qeth_l2_dev2br_fdb_notify() - update fdb of master bridge
625 * @card: qeth_card structure pointer
626 * @code: event bitmask: high order bit 0x80 set to
627 * 1 - removal of an object
628 * 0 - addition of an object
630 * 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC
631 * @token: "network token" structure identifying 'physical' location
633 * @addr_lnid: structure with MAC address and VLAN ID of the target
635 static void qeth_l2_dev2br_fdb_notify(struct qeth_card
*card
, u8 code
,
636 struct net_if_token
*token
,
637 struct mac_addr_lnid
*addr_lnid
)
639 struct switchdev_notifier_fdb_info info
= {};
640 u8 ntfy_mac
[ETH_ALEN
];
642 ether_addr_copy(ntfy_mac
, addr_lnid
->mac
);
643 /* Ignore VLAN only changes */
644 if (!(code
& IPA_ADDR_CHANGE_CODE_MACADDR
))
646 /* Ignore mcast entries */
647 if (is_multicast_ether_addr(ntfy_mac
))
649 /* Ignore my own addresses */
650 if (qeth_is_my_net_if_token(card
, token
))
653 info
.addr
= ntfy_mac
;
654 /* don't report VLAN IDs */
656 info
.added_by_user
= false;
657 info
.offloaded
= true;
659 if (code
& IPA_ADDR_CHANGE_CODE_REMOVAL
) {
660 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE
,
661 card
->dev
, &info
.info
, NULL
);
662 QETH_CARD_TEXT(card
, 4, "andelmac");
663 QETH_CARD_TEXT_(card
, 4,
664 "mc%012llx", ether_addr_to_u64(ntfy_mac
));
666 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE
,
667 card
->dev
, &info
.info
, NULL
);
668 QETH_CARD_TEXT(card
, 4, "anaddmac");
669 QETH_CARD_TEXT_(card
, 4,
670 "mc%012llx", ether_addr_to_u64(ntfy_mac
));
674 static void qeth_l2_dev2br_an_set_cb(void *priv
,
675 struct chsc_pnso_naid_l2
*entry
)
677 u8 code
= IPA_ADDR_CHANGE_CODE_MACADDR
;
678 struct qeth_card
*card
= priv
;
680 if (entry
->addr_lnid
.lnid
< VLAN_N_VID
)
681 code
|= IPA_ADDR_CHANGE_CODE_VLANID
;
682 qeth_l2_dev2br_fdb_notify(card
, code
,
683 (struct net_if_token
*)&entry
->nit
,
684 (struct mac_addr_lnid
*)&entry
->addr_lnid
);
688 * qeth_l2_dev2br_an_set() -
689 * Enable or disable 'dev to bridge network address notification'
690 * @card: qeth_card structure pointer
691 * @enable: Enable or disable 'dev to bridge network address notification'
693 * Returns negative errno-compatible error indication or 0 on success.
695 * On enable, emits a series of address notifications for all
696 * currently registered hosts.
698 static int qeth_l2_dev2br_an_set(struct qeth_card
*card
, bool enable
)
703 QETH_CARD_TEXT(card
, 2, "anseton");
704 rc
= qeth_l2_pnso(card
, PNSO_OC_NET_ADDR_INFO
, 1,
705 qeth_l2_dev2br_an_set_cb
, card
);
707 /* address notification enabled, but inconsistent
708 * addresses reported -> disable address notification
710 qeth_l2_pnso(card
, PNSO_OC_NET_ADDR_INFO
, 0,
713 QETH_CARD_TEXT(card
, 2, "ansetoff");
714 rc
= qeth_l2_pnso(card
, PNSO_OC_NET_ADDR_INFO
, 0, NULL
, NULL
);
720 struct qeth_l2_br2dev_event_work
{
721 struct work_struct work
;
722 struct net_device
*br_dev
;
723 struct net_device
*lsync_dev
;
724 struct net_device
*dst_dev
;
726 unsigned char addr
[ETH_ALEN
];
729 static const struct net_device_ops qeth_l2_netdev_ops
;
731 static bool qeth_l2_must_learn(struct net_device
*netdev
,
732 struct net_device
*dstdev
)
734 struct qeth_priv
*priv
;
736 priv
= netdev_priv(netdev
);
737 return (netdev
!= dstdev
&&
738 (priv
->brport_features
& BR_LEARNING_SYNC
) &&
739 !(br_port_flag_is_set(netdev
, BR_ISOLATED
) &&
740 br_port_flag_is_set(dstdev
, BR_ISOLATED
)) &&
741 netdev
->netdev_ops
== &qeth_l2_netdev_ops
);
745 * qeth_l2_br2dev_worker() - update local MACs
746 * @work: bridge to device FDB update
748 * Update local MACs of a learning_sync bridgeport so it can receive
749 * messages for a destination port.
750 * In case of an isolated learning_sync port, also update its isolated
753 static void qeth_l2_br2dev_worker(struct work_struct
*work
)
755 struct qeth_l2_br2dev_event_work
*br2dev_event_work
=
756 container_of(work
, struct qeth_l2_br2dev_event_work
, work
);
757 struct net_device
*lsyncdev
= br2dev_event_work
->lsync_dev
;
758 struct net_device
*dstdev
= br2dev_event_work
->dst_dev
;
759 struct net_device
*brdev
= br2dev_event_work
->br_dev
;
760 unsigned long event
= br2dev_event_work
->event
;
761 unsigned char *addr
= br2dev_event_work
->addr
;
762 struct qeth_card
*card
= lsyncdev
->ml_priv
;
763 struct net_device
*lowerdev
;
764 struct list_head
*iter
;
767 QETH_CARD_TEXT_(card
, 4, "b2dw%04lx", event
);
768 QETH_CARD_TEXT_(card
, 4, "ma%012llx", ether_addr_to_u64(addr
));
771 /* Verify preconditions are still valid: */
772 if (!netif_is_bridge_port(lsyncdev
) ||
773 brdev
!= netdev_master_upper_dev_get_rcu(lsyncdev
))
775 if (!qeth_l2_must_learn(lsyncdev
, dstdev
))
778 if (br_port_flag_is_set(lsyncdev
, BR_ISOLATED
)) {
779 /* Update lsyncdev and its isolated sibling(s): */
780 iter
= &brdev
->adj_list
.lower
;
781 lowerdev
= netdev_next_lower_dev_rcu(brdev
, &iter
);
783 if (br_port_flag_is_set(lowerdev
, BR_ISOLATED
)) {
785 case SWITCHDEV_FDB_ADD_TO_DEVICE
:
786 err
= dev_uc_add(lowerdev
, addr
);
788 case SWITCHDEV_FDB_DEL_TO_DEVICE
:
789 err
= dev_uc_del(lowerdev
, addr
);
795 QETH_CARD_TEXT(card
, 2, "b2derris");
796 QETH_CARD_TEXT_(card
, 2,
797 "err%02lx%03d", event
,
801 lowerdev
= netdev_next_lower_dev_rcu(brdev
, &iter
);
805 case SWITCHDEV_FDB_ADD_TO_DEVICE
:
806 err
= dev_uc_add(lsyncdev
, addr
);
808 case SWITCHDEV_FDB_DEL_TO_DEVICE
:
809 err
= dev_uc_del(lsyncdev
, addr
);
815 QETH_CARD_TEXT_(card
, 2, "b2derr%02lx", event
);
823 kfree(br2dev_event_work
);
826 static int qeth_l2_br2dev_queue_work(struct net_device
*brdev
,
827 struct net_device
*lsyncdev
,
828 struct net_device
*dstdev
,
830 const unsigned char *addr
)
832 struct qeth_l2_br2dev_event_work
*worker_data
;
833 struct qeth_card
*card
;
835 worker_data
= kzalloc(sizeof(*worker_data
), GFP_ATOMIC
);
838 INIT_WORK(&worker_data
->work
, qeth_l2_br2dev_worker
);
839 worker_data
->br_dev
= brdev
;
840 worker_data
->lsync_dev
= lsyncdev
;
841 worker_data
->dst_dev
= dstdev
;
842 worker_data
->event
= event
;
843 ether_addr_copy(worker_data
->addr
, addr
);
845 card
= lsyncdev
->ml_priv
;
846 /* Take a reference on the sw port devices and the bridge */
850 queue_work(card
->event_wq
, &worker_data
->work
);
854 /* Called under rtnl_lock */
855 static int qeth_l2_switchdev_event(struct notifier_block
*unused
,
856 unsigned long event
, void *ptr
)
858 struct net_device
*dstdev
, *brdev
, *lowerdev
;
859 struct switchdev_notifier_fdb_info
*fdb_info
;
860 struct switchdev_notifier_info
*info
= ptr
;
861 struct list_head
*iter
;
862 struct qeth_card
*card
;
865 if (!(event
== SWITCHDEV_FDB_ADD_TO_DEVICE
||
866 event
== SWITCHDEV_FDB_DEL_TO_DEVICE
))
869 dstdev
= switchdev_notifier_info_to_dev(info
);
870 brdev
= netdev_master_upper_dev_get_rcu(dstdev
);
871 if (!brdev
|| !netif_is_bridge_master(brdev
))
873 fdb_info
= container_of(info
,
874 struct switchdev_notifier_fdb_info
,
876 iter
= &brdev
->adj_list
.lower
;
877 lowerdev
= netdev_next_lower_dev_rcu(brdev
, &iter
);
879 if (qeth_l2_must_learn(lowerdev
, dstdev
)) {
880 card
= lowerdev
->ml_priv
;
881 QETH_CARD_TEXT_(card
, 4, "b2dqw%03lx", event
);
882 rc
= qeth_l2_br2dev_queue_work(brdev
, lowerdev
,
886 QETH_CARD_TEXT(card
, 2, "b2dqwerr");
890 lowerdev
= netdev_next_lower_dev_rcu(brdev
, &iter
);
895 static struct notifier_block qeth_l2_sw_notifier
= {
896 .notifier_call
= qeth_l2_switchdev_event
,
899 static refcount_t qeth_l2_switchdev_notify_refcnt
;
901 /* Called under rtnl_lock */
902 static void qeth_l2_br2dev_get(void)
906 if (!refcount_inc_not_zero(&qeth_l2_switchdev_notify_refcnt
)) {
907 rc
= register_switchdev_notifier(&qeth_l2_sw_notifier
);
910 "failed to register qeth_l2_sw_notifier: %d\n",
913 refcount_set(&qeth_l2_switchdev_notify_refcnt
, 1);
914 QETH_DBF_MESSAGE(2, "qeth_l2_sw_notifier registered\n");
917 QETH_DBF_TEXT_(SETUP
, 2, "b2d+%04d",
918 qeth_l2_switchdev_notify_refcnt
.refs
.counter
);
921 /* Called under rtnl_lock */
922 static void qeth_l2_br2dev_put(void)
926 if (refcount_dec_and_test(&qeth_l2_switchdev_notify_refcnt
)) {
927 rc
= unregister_switchdev_notifier(&qeth_l2_sw_notifier
);
930 "failed to unregister qeth_l2_sw_notifier: %d\n",
934 "qeth_l2_sw_notifier unregistered\n");
937 QETH_DBF_TEXT_(SETUP
, 2, "b2d-%04d",
938 qeth_l2_switchdev_notify_refcnt
.refs
.counter
);
941 static int qeth_l2_bridge_getlink(struct sk_buff
*skb
, u32 pid
, u32 seq
,
942 struct net_device
*dev
, u32 filter_mask
,
945 struct qeth_priv
*priv
= netdev_priv(dev
);
946 struct qeth_card
*card
= dev
->ml_priv
;
947 u16 mode
= BRIDGE_MODE_UNDEF
;
949 /* Do not even show qeth devs that cannot do bridge_setlink */
950 if (!priv
->brport_hw_features
|| !netif_device_present(dev
) ||
951 qeth_bridgeport_is_in_use(card
))
954 return ndo_dflt_bridge_getlink(skb
, pid
, seq
, dev
,
955 mode
, priv
->brport_features
,
956 priv
->brport_hw_features
,
957 nlflags
, filter_mask
, NULL
);
960 static const struct nla_policy qeth_brport_policy
[IFLA_BRPORT_MAX
+ 1] = {
961 [IFLA_BRPORT_LEARNING_SYNC
] = { .type
= NLA_U8
},
965 * qeth_l2_bridge_setlink() - set bridgeport attributes
967 * @nlh: netlink message header
968 * @flags: bridge flags (here: BRIDGE_FLAGS_SELF)
969 * @extack: extended ACK report struct
971 * Called under rtnl_lock
973 static int qeth_l2_bridge_setlink(struct net_device
*dev
, struct nlmsghdr
*nlh
,
974 u16 flags
, struct netlink_ext_ack
*extack
)
976 struct qeth_priv
*priv
= netdev_priv(dev
);
977 struct nlattr
*bp_tb
[IFLA_BRPORT_MAX
+ 1];
978 struct qeth_card
*card
= dev
->ml_priv
;
979 struct nlattr
*attr
, *nested_attr
;
980 bool enable
, has_protinfo
= false;
984 if (!netif_device_present(dev
))
987 nlmsg_for_each_attr(attr
, nlh
, sizeof(struct ifinfomsg
), rem1
) {
988 if (nla_type(attr
) == IFLA_PROTINFO
) {
989 rc
= nla_parse_nested(bp_tb
, IFLA_BRPORT_MAX
, attr
,
990 qeth_brport_policy
, extack
);
994 } else if (nla_type(attr
) == IFLA_AF_SPEC
) {
995 nla_for_each_nested(nested_attr
, attr
, rem2
) {
996 if (nla_type(nested_attr
) == IFLA_BRIDGE_FLAGS
)
998 NL_SET_ERR_MSG_ATTR(extack
, nested_attr
,
999 "Unsupported attribute");
1003 NL_SET_ERR_MSG_ATTR(extack
, attr
, "Unsupported attribute");
1009 if (!bp_tb
[IFLA_BRPORT_LEARNING_SYNC
])
1011 if (!(priv
->brport_hw_features
& BR_LEARNING_SYNC
)) {
1012 NL_SET_ERR_MSG_ATTR(extack
, bp_tb
[IFLA_BRPORT_LEARNING_SYNC
],
1013 "Operation not supported by HW");
1016 if (!IS_ENABLED(CONFIG_NET_SWITCHDEV
)) {
1017 NL_SET_ERR_MSG_ATTR(extack
, bp_tb
[IFLA_BRPORT_LEARNING_SYNC
],
1018 "Requires NET_SWITCHDEV");
1021 enable
= !!nla_get_u8(bp_tb
[IFLA_BRPORT_LEARNING_SYNC
]);
1023 if (enable
== !!(priv
->brport_features
& BR_LEARNING_SYNC
))
1026 mutex_lock(&card
->sbp_lock
);
1027 /* do not change anything if BridgePort is enabled */
1028 if (qeth_bridgeport_is_in_use(card
)) {
1029 NL_SET_ERR_MSG(extack
, "n/a (BridgePort)");
1031 } else if (enable
) {
1032 qeth_l2_set_pnso_mode(card
, QETH_PNSO_ADDR_INFO
);
1033 rc
= qeth_l2_dev2br_an_set(card
, true);
1035 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
1037 priv
->brport_features
|= BR_LEARNING_SYNC
;
1038 qeth_l2_br2dev_get();
1041 rc
= qeth_l2_dev2br_an_set(card
, false);
1043 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
1044 priv
->brport_features
^= BR_LEARNING_SYNC
;
1045 qeth_l2_dev2br_fdb_flush(card
);
1046 qeth_l2_br2dev_put();
1049 mutex_unlock(&card
->sbp_lock
);
1054 static const struct net_device_ops qeth_l2_netdev_ops
= {
1055 .ndo_open
= qeth_open
,
1056 .ndo_stop
= qeth_stop
,
1057 .ndo_get_stats64
= qeth_get_stats64
,
1058 .ndo_start_xmit
= qeth_l2_hard_start_xmit
,
1059 .ndo_features_check
= qeth_features_check
,
1060 .ndo_select_queue
= qeth_l2_select_queue
,
1061 .ndo_validate_addr
= qeth_l2_validate_addr
,
1062 .ndo_set_rx_mode
= qeth_l2_set_rx_mode
,
1063 .ndo_eth_ioctl
= qeth_do_ioctl
,
1064 .ndo_siocdevprivate
= qeth_siocdevprivate
,
1065 .ndo_set_mac_address
= qeth_l2_set_mac_address
,
1066 .ndo_vlan_rx_add_vid
= qeth_l2_vlan_rx_add_vid
,
1067 .ndo_vlan_rx_kill_vid
= qeth_l2_vlan_rx_kill_vid
,
1068 .ndo_tx_timeout
= qeth_tx_timeout
,
1069 .ndo_fix_features
= qeth_fix_features
,
1070 .ndo_set_features
= qeth_set_features
,
1071 .ndo_bridge_getlink
= qeth_l2_bridge_getlink
,
1072 .ndo_bridge_setlink
= qeth_l2_bridge_setlink
,
1075 static int qeth_l2_setup_netdev(struct qeth_card
*card
)
1077 card
->dev
->needed_headroom
= sizeof(struct qeth_hdr
);
1078 card
->dev
->netdev_ops
= &qeth_l2_netdev_ops
;
1079 card
->dev
->priv_flags
|= IFF_UNICAST_FLT
;
1082 card
->dev
->features
|= NETIF_F_VLAN_CHALLENGED
;
1084 if (!IS_VM_NIC(card
))
1085 card
->dev
->hw_features
|= NETIF_F_HW_VLAN_CTAG_FILTER
;
1086 card
->dev
->features
|= NETIF_F_HW_VLAN_CTAG_FILTER
;
1089 if (IS_OSD(card
) && !IS_VM_NIC(card
)) {
1090 card
->dev
->features
|= NETIF_F_SG
;
1091 /* OSA 3S and earlier has no RX/TX support */
1092 if (qeth_is_supported(card
, IPA_OUTBOUND_CHECKSUM
)) {
1093 card
->dev
->hw_features
|= NETIF_F_IP_CSUM
;
1094 card
->dev
->vlan_features
|= NETIF_F_IP_CSUM
;
1097 if (qeth_is_supported6(card
, IPA_OUTBOUND_CHECKSUM_V6
)) {
1098 card
->dev
->hw_features
|= NETIF_F_IPV6_CSUM
;
1099 card
->dev
->vlan_features
|= NETIF_F_IPV6_CSUM
;
1101 if (qeth_is_supported(card
, IPA_INBOUND_CHECKSUM
) ||
1102 qeth_is_supported6(card
, IPA_INBOUND_CHECKSUM_V6
)) {
1103 card
->dev
->hw_features
|= NETIF_F_RXCSUM
;
1104 card
->dev
->vlan_features
|= NETIF_F_RXCSUM
;
1106 if (qeth_is_supported(card
, IPA_OUTBOUND_TSO
)) {
1107 card
->dev
->hw_features
|= NETIF_F_TSO
;
1108 card
->dev
->vlan_features
|= NETIF_F_TSO
;
1110 if (qeth_is_supported6(card
, IPA_OUTBOUND_TSO
)) {
1111 card
->dev
->hw_features
|= NETIF_F_TSO6
;
1112 card
->dev
->vlan_features
|= NETIF_F_TSO6
;
1115 if (card
->dev
->hw_features
& (NETIF_F_TSO
| NETIF_F_TSO6
)) {
1116 card
->dev
->needed_headroom
= sizeof(struct qeth_hdr_tso
);
1117 netif_keep_dst(card
->dev
);
1118 netif_set_gso_max_size(card
->dev
,
1119 PAGE_SIZE
* (QDIO_MAX_ELEMENTS_PER_BUFFER
- 1));
1122 netif_napi_add(card
->dev
, &card
->napi
, qeth_poll
, QETH_NAPI_WEIGHT
);
1123 return register_netdev(card
->dev
);
1126 static void qeth_l2_trace_features(struct qeth_card
*card
)
1128 /* Set BridgePort features */
1129 QETH_CARD_TEXT(card
, 2, "featuSBP");
1130 QETH_CARD_HEX(card
, 2, &card
->options
.sbp
.supported_funcs
,
1131 sizeof(card
->options
.sbp
.supported_funcs
));
1132 /* VNIC Characteristics features */
1133 QETH_CARD_TEXT(card
, 2, "feaVNICC");
1134 QETH_CARD_HEX(card
, 2, &card
->options
.vnicc
.sup_chars
,
1135 sizeof(card
->options
.vnicc
.sup_chars
));
1138 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card
*card
)
1140 if (!card
->options
.sbp
.reflect_promisc
&&
1141 card
->options
.sbp
.role
!= QETH_SBP_ROLE_NONE
) {
1142 /* Conditional to avoid spurious error messages */
1143 qeth_bridgeport_setrole(card
, card
->options
.sbp
.role
);
1144 /* Let the callback function refresh the stored role value. */
1145 qeth_bridgeport_query_ports(card
, &card
->options
.sbp
.role
,
1148 if (card
->options
.sbp
.hostnotification
) {
1149 if (qeth_bridgeport_an_set(card
, 1))
1150 card
->options
.sbp
.hostnotification
= 0;
1155 * qeth_l2_detect_dev2br_support() -
1156 * Detect whether this card supports 'dev to bridge fdb network address
1157 * change notification' and thus can support the learning_sync bridgeport
1159 * @card: qeth_card structure pointer
1161 static void qeth_l2_detect_dev2br_support(struct qeth_card
*card
)
1163 struct qeth_priv
*priv
= netdev_priv(card
->dev
);
1164 bool dev2br_supported
;
1166 QETH_CARD_TEXT(card
, 2, "d2brsup");
1170 /* dev2br requires valid cssid,iid,chid */
1171 dev2br_supported
= card
->info
.ids_valid
&&
1172 css_general_characteristics
.enarf
;
1173 QETH_CARD_TEXT_(card
, 2, "D2Bsup%02x", dev2br_supported
);
1175 if (dev2br_supported
)
1176 priv
->brport_hw_features
|= BR_LEARNING_SYNC
;
1178 priv
->brport_hw_features
&= ~BR_LEARNING_SYNC
;
1181 static void qeth_l2_enable_brport_features(struct qeth_card
*card
)
1183 struct qeth_priv
*priv
= netdev_priv(card
->dev
);
1186 if (priv
->brport_features
& BR_LEARNING_SYNC
) {
1187 if (priv
->brport_hw_features
& BR_LEARNING_SYNC
) {
1188 qeth_l2_set_pnso_mode(card
, QETH_PNSO_ADDR_INFO
);
1189 rc
= qeth_l2_dev2br_an_set(card
, true);
1190 if (rc
== -EAGAIN
) {
1191 /* Recoverable error, retry once */
1192 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
1193 qeth_l2_dev2br_fdb_flush(card
);
1194 qeth_l2_set_pnso_mode(card
, QETH_PNSO_ADDR_INFO
);
1195 rc
= qeth_l2_dev2br_an_set(card
, true);
1198 netdev_err(card
->dev
,
1199 "failed to enable bridge learning_sync: %d\n",
1201 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
1202 qeth_l2_dev2br_fdb_flush(card
);
1203 priv
->brport_features
^= BR_LEARNING_SYNC
;
1206 dev_warn(&card
->gdev
->dev
,
1207 "bridge learning_sync not supported\n");
1208 priv
->brport_features
^= BR_LEARNING_SYNC
;
1213 /* SETBRIDGEPORT support, async notifications */
1215 enum qeth_an_event_type
{anev_reg_unreg
, anev_abort
, anev_reset
};
1218 * qeth_bridge_emit_host_event() - bridgeport address change notification
1219 * @card: qeth_card structure pointer, for udev events.
1220 * @evtype: "normal" register/unregister, or abort, or reset. For abort
1221 * and reset token and addr_lnid are unused and may be NULL.
1222 * @code: event bitmask: high order bit 0x80 value 1 means removal of an
1223 * object, 0 - addition of an object.
1224 * 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
1225 * @token: "network token" structure identifying physical address of the port.
1226 * @addr_lnid: pointer to structure with MAC address and VLAN ID.
1228 * This function is called when registrations and deregistrations are
1229 * reported by the hardware, and also when notifications are enabled -
1230 * for all currently registered addresses.
1232 static void qeth_bridge_emit_host_event(struct qeth_card
*card
,
1233 enum qeth_an_event_type evtype
,
1235 struct net_if_token
*token
,
1236 struct mac_addr_lnid
*addr_lnid
)
1243 case anev_reg_unreg
:
1244 snprintf(str
[i
], sizeof(str
[i
]), "BRIDGEDHOST=%s",
1245 (code
& IPA_ADDR_CHANGE_CODE_REMOVAL
)
1246 ? "deregister" : "register");
1247 env
[i
] = str
[i
]; i
++;
1248 if (code
& IPA_ADDR_CHANGE_CODE_VLANID
) {
1249 snprintf(str
[i
], sizeof(str
[i
]), "VLAN=%d",
1251 env
[i
] = str
[i
]; i
++;
1253 if (code
& IPA_ADDR_CHANGE_CODE_MACADDR
) {
1254 snprintf(str
[i
], sizeof(str
[i
]), "MAC=%pM",
1256 env
[i
] = str
[i
]; i
++;
1258 snprintf(str
[i
], sizeof(str
[i
]), "NTOK_BUSID=%x.%x.%04x",
1259 token
->cssid
, token
->ssid
, token
->devnum
);
1260 env
[i
] = str
[i
]; i
++;
1261 snprintf(str
[i
], sizeof(str
[i
]), "NTOK_IID=%02x", token
->iid
);
1262 env
[i
] = str
[i
]; i
++;
1263 snprintf(str
[i
], sizeof(str
[i
]), "NTOK_CHPID=%02x",
1265 env
[i
] = str
[i
]; i
++;
1266 snprintf(str
[i
], sizeof(str
[i
]), "NTOK_CHID=%04x", token
->chid
);
1267 env
[i
] = str
[i
]; i
++;
1270 snprintf(str
[i
], sizeof(str
[i
]), "BRIDGEDHOST=abort");
1271 env
[i
] = str
[i
]; i
++;
1274 snprintf(str
[i
], sizeof(str
[i
]), "BRIDGEDHOST=reset");
1275 env
[i
] = str
[i
]; i
++;
1279 kobject_uevent_env(&card
->gdev
->dev
.kobj
, KOBJ_CHANGE
, env
);
1282 struct qeth_bridge_state_data
{
1283 struct work_struct worker
;
1284 struct qeth_card
*card
;
1289 static void qeth_bridge_state_change_worker(struct work_struct
*work
)
1291 struct qeth_bridge_state_data
*data
=
1292 container_of(work
, struct qeth_bridge_state_data
, worker
);
1293 char env_locrem
[32];
1303 snprintf(env_locrem
, sizeof(env_locrem
), "BRIDGEPORT=statechange");
1304 snprintf(env_role
, sizeof(env_role
), "ROLE=%s",
1305 (data
->role
== QETH_SBP_ROLE_NONE
) ? "none" :
1306 (data
->role
== QETH_SBP_ROLE_PRIMARY
) ? "primary" :
1307 (data
->role
== QETH_SBP_ROLE_SECONDARY
) ? "secondary" :
1309 snprintf(env_state
, sizeof(env_state
), "STATE=%s",
1310 (data
->state
== QETH_SBP_STATE_INACTIVE
) ? "inactive" :
1311 (data
->state
== QETH_SBP_STATE_STANDBY
) ? "standby" :
1312 (data
->state
== QETH_SBP_STATE_ACTIVE
) ? "active" :
1314 kobject_uevent_env(&data
->card
->gdev
->dev
.kobj
,
1319 static void qeth_bridge_state_change(struct qeth_card
*card
,
1320 struct qeth_ipa_cmd
*cmd
)
1322 struct qeth_sbp_port_data
*qports
= &cmd
->data
.sbp
.data
.port_data
;
1323 struct qeth_bridge_state_data
*data
;
1325 QETH_CARD_TEXT(card
, 2, "brstchng");
1326 if (qports
->num_entries
== 0) {
1327 QETH_CARD_TEXT(card
, 2, "BPempty");
1330 if (qports
->entry_length
!= sizeof(struct qeth_sbp_port_entry
)) {
1331 QETH_CARD_TEXT_(card
, 2, "BPsz%04x", qports
->entry_length
);
1335 data
= kzalloc(sizeof(*data
), GFP_ATOMIC
);
1337 QETH_CARD_TEXT(card
, 2, "BPSalloc");
1340 INIT_WORK(&data
->worker
, qeth_bridge_state_change_worker
);
1342 /* Information for the local port: */
1343 data
->role
= qports
->entry
[0].role
;
1344 data
->state
= qports
->entry
[0].state
;
1346 queue_work(card
->event_wq
, &data
->worker
);
1349 struct qeth_addr_change_data
{
1350 struct delayed_work dwork
;
1351 struct qeth_card
*card
;
1352 struct qeth_ipacmd_addr_change ac_event
;
1355 static void qeth_l2_dev2br_worker(struct work_struct
*work
)
1357 struct delayed_work
*dwork
= to_delayed_work(work
);
1358 struct qeth_addr_change_data
*data
;
1359 struct qeth_card
*card
;
1360 struct qeth_priv
*priv
;
1364 data
= container_of(dwork
, struct qeth_addr_change_data
, dwork
);
1366 priv
= netdev_priv(card
->dev
);
1368 QETH_CARD_TEXT(card
, 4, "dev2brew");
1370 if (READ_ONCE(card
->info
.pnso_mode
) == QETH_PNSO_NONE
)
1373 if (data
->ac_event
.lost_event_mask
) {
1374 /* Potential re-config in progress, try again later: */
1375 if (!rtnl_trylock()) {
1376 queue_delayed_work(card
->event_wq
, dwork
,
1377 msecs_to_jiffies(100));
1381 if (!netif_device_present(card
->dev
)) {
1387 "Address change notification overflow on device %x\n",
1389 /* Card fdb and bridge fdb are out of sync, card has stopped
1390 * notifications (no need to drain_workqueue). Purge all
1391 * 'extern_learn' entries from the parent bridge and restart
1392 * the notifications.
1394 qeth_l2_dev2br_fdb_flush(card
);
1395 rc
= qeth_l2_dev2br_an_set(card
, true);
1397 /* TODO: if we want to retry after -EAGAIN, be
1398 * aware there could be stale entries in the
1399 * workqueue now, that need to be drained.
1400 * For now we give up:
1402 netdev_err(card
->dev
,
1403 "bridge learning_sync failed to recover: %d\n",
1405 WRITE_ONCE(card
->info
.pnso_mode
,
1407 /* To remove fdb entries reported by an_set: */
1408 qeth_l2_dev2br_fdb_flush(card
);
1409 priv
->brport_features
^= BR_LEARNING_SYNC
;
1412 "Address Notification resynced on device %x\n",
1418 for (i
= 0; i
< data
->ac_event
.num_entries
; i
++) {
1419 struct qeth_ipacmd_addr_change_entry
*entry
=
1420 &data
->ac_event
.entry
[i
];
1421 qeth_l2_dev2br_fdb_notify(card
,
1432 static void qeth_addr_change_event_worker(struct work_struct
*work
)
1434 struct delayed_work
*dwork
= to_delayed_work(work
);
1435 struct qeth_addr_change_data
*data
;
1436 struct qeth_card
*card
;
1439 data
= container_of(dwork
, struct qeth_addr_change_data
, dwork
);
1442 QETH_CARD_TEXT(data
->card
, 4, "adrchgew");
1444 if (READ_ONCE(card
->info
.pnso_mode
) == QETH_PNSO_NONE
)
1447 if (data
->ac_event
.lost_event_mask
) {
1448 /* Potential re-config in progress, try again later: */
1449 if (!mutex_trylock(&card
->sbp_lock
)) {
1450 queue_delayed_work(card
->event_wq
, dwork
,
1451 msecs_to_jiffies(100));
1455 dev_info(&data
->card
->gdev
->dev
,
1456 "Address change notification stopped on %s (%s)\n",
1457 netdev_name(card
->dev
),
1458 (data
->ac_event
.lost_event_mask
== 0x01)
1460 : (data
->ac_event
.lost_event_mask
== 0x02)
1461 ? "Bridge port state change"
1462 : "Unknown reason");
1464 data
->card
->options
.sbp
.hostnotification
= 0;
1465 card
->info
.pnso_mode
= QETH_PNSO_NONE
;
1466 mutex_unlock(&data
->card
->sbp_lock
);
1467 qeth_bridge_emit_host_event(data
->card
, anev_abort
,
1470 for (i
= 0; i
< data
->ac_event
.num_entries
; i
++) {
1471 struct qeth_ipacmd_addr_change_entry
*entry
=
1472 &data
->ac_event
.entry
[i
];
1473 qeth_bridge_emit_host_event(data
->card
,
1484 static void qeth_addr_change_event(struct qeth_card
*card
,
1485 struct qeth_ipa_cmd
*cmd
)
1487 struct qeth_ipacmd_addr_change
*hostevs
=
1488 &cmd
->data
.addrchange
;
1489 struct qeth_addr_change_data
*data
;
1492 if (card
->info
.pnso_mode
== QETH_PNSO_NONE
)
1495 QETH_CARD_TEXT(card
, 4, "adrchgev");
1496 if (cmd
->hdr
.return_code
!= 0x0000) {
1497 if (cmd
->hdr
.return_code
== 0x0010) {
1498 if (hostevs
->lost_event_mask
== 0x00)
1499 hostevs
->lost_event_mask
= 0xff;
1501 QETH_CARD_TEXT_(card
, 2, "ACHN%04x",
1502 cmd
->hdr
.return_code
);
1506 extrasize
= sizeof(struct qeth_ipacmd_addr_change_entry
) *
1507 hostevs
->num_entries
;
1508 data
= kzalloc(sizeof(struct qeth_addr_change_data
) + extrasize
,
1511 QETH_CARD_TEXT(card
, 2, "ACNalloc");
1514 if (card
->info
.pnso_mode
== QETH_PNSO_BRIDGEPORT
)
1515 INIT_DELAYED_WORK(&data
->dwork
, qeth_addr_change_event_worker
);
1517 INIT_DELAYED_WORK(&data
->dwork
, qeth_l2_dev2br_worker
);
1519 memcpy(&data
->ac_event
, hostevs
,
1520 sizeof(struct qeth_ipacmd_addr_change
) + extrasize
);
1521 queue_delayed_work(card
->event_wq
, &data
->dwork
, 0);
1524 /* SETBRIDGEPORT support; sending commands */
1526 struct _qeth_sbp_cbctl
{
1530 enum qeth_sbp_roles
*role
;
1531 enum qeth_sbp_states
*state
;
1536 static int qeth_bridgeport_makerc(struct qeth_card
*card
,
1537 struct qeth_ipa_cmd
*cmd
)
1539 struct qeth_ipacmd_setbridgeport
*sbp
= &cmd
->data
.sbp
;
1540 enum qeth_ipa_sbp_cmd setcmd
= sbp
->hdr
.command_code
;
1541 u16 ipa_rc
= cmd
->hdr
.return_code
;
1542 u16 sbp_rc
= sbp
->hdr
.return_code
;
1545 if (ipa_rc
== IPA_RC_SUCCESS
&& sbp_rc
== IPA_RC_SUCCESS
)
1548 if ((IS_IQD(card
) && ipa_rc
== IPA_RC_SUCCESS
) ||
1549 (!IS_IQD(card
) && ipa_rc
== sbp_rc
)) {
1551 case IPA_RC_SUCCESS
:
1554 case IPA_RC_L2_UNSUPPORTED_CMD
:
1555 case IPA_RC_UNSUPPORTED_COMMAND
:
1558 case IPA_RC_SBP_OSA_NOT_CONFIGURED
:
1559 case IPA_RC_SBP_IQD_NOT_CONFIGURED
:
1560 rc
= -ENODEV
; /* maybe not the best code here? */
1561 dev_err(&card
->gdev
->dev
,
1562 "The device is not configured as a Bridge Port\n");
1564 case IPA_RC_SBP_OSA_OS_MISMATCH
:
1565 case IPA_RC_SBP_IQD_OS_MISMATCH
:
1567 dev_err(&card
->gdev
->dev
,
1568 "A Bridge Port is already configured by a different operating system\n");
1570 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY
:
1571 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY
:
1573 case IPA_SBP_SET_PRIMARY_BRIDGE_PORT
:
1575 dev_err(&card
->gdev
->dev
,
1576 "The LAN already has a primary Bridge Port\n");
1578 case IPA_SBP_SET_SECONDARY_BRIDGE_PORT
:
1580 dev_err(&card
->gdev
->dev
,
1581 "The device is already a primary Bridge Port\n");
1587 case IPA_RC_SBP_OSA_CURRENT_SECOND
:
1588 case IPA_RC_SBP_IQD_CURRENT_SECOND
:
1590 dev_err(&card
->gdev
->dev
,
1591 "The device is already a secondary Bridge Port\n");
1593 case IPA_RC_SBP_OSA_LIMIT_SECOND
:
1594 case IPA_RC_SBP_IQD_LIMIT_SECOND
:
1596 dev_err(&card
->gdev
->dev
,
1597 "The LAN cannot have more secondary Bridge Ports\n");
1599 case IPA_RC_SBP_OSA_CURRENT_PRIMARY
:
1600 case IPA_RC_SBP_IQD_CURRENT_PRIMARY
:
1602 dev_err(&card
->gdev
->dev
,
1603 "The device is already a primary Bridge Port\n");
1605 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN
:
1606 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN
:
1608 dev_err(&card
->gdev
->dev
,
1609 "The device is not authorized to be a Bridge Port\n");
1616 case IPA_RC_NOTSUPP
:
1619 case IPA_RC_UNSUPPORTED_COMMAND
:
1628 QETH_CARD_TEXT_(card
, 2, "SBPi%04x", ipa_rc
);
1629 QETH_CARD_TEXT_(card
, 2, "SBPc%04x", sbp_rc
);
1634 static struct qeth_cmd_buffer
*qeth_sbp_build_cmd(struct qeth_card
*card
,
1635 enum qeth_ipa_sbp_cmd sbp_cmd
,
1636 unsigned int data_length
)
1638 enum qeth_ipa_cmds ipa_cmd
= IS_IQD(card
) ? IPA_CMD_SETBRIDGEPORT_IQD
:
1639 IPA_CMD_SETBRIDGEPORT_OSA
;
1640 struct qeth_ipacmd_sbp_hdr
*hdr
;
1641 struct qeth_cmd_buffer
*iob
;
1643 iob
= qeth_ipa_alloc_cmd(card
, ipa_cmd
, QETH_PROT_NONE
,
1645 offsetof(struct qeth_ipacmd_setbridgeport
,
1650 hdr
= &__ipa_cmd(iob
)->data
.sbp
.hdr
;
1651 hdr
->cmdlength
= sizeof(*hdr
) + data_length
;
1652 hdr
->command_code
= sbp_cmd
;
1653 hdr
->used_total
= 1;
1658 static int qeth_bridgeport_query_support_cb(struct qeth_card
*card
,
1659 struct qeth_reply
*reply
, unsigned long data
)
1661 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
1662 struct _qeth_sbp_cbctl
*cbctl
= (struct _qeth_sbp_cbctl
*)reply
->param
;
1665 QETH_CARD_TEXT(card
, 2, "brqsupcb");
1666 rc
= qeth_bridgeport_makerc(card
, cmd
);
1670 cbctl
->data
.supported
=
1671 cmd
->data
.sbp
.data
.query_cmds_supp
.supported_cmds
;
1676 * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
1677 * @card: qeth_card structure pointer.
1679 * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
1680 * strucutre: card->options.sbp.supported_funcs.
1682 static void qeth_bridgeport_query_support(struct qeth_card
*card
)
1684 struct qeth_cmd_buffer
*iob
;
1685 struct _qeth_sbp_cbctl cbctl
;
1687 QETH_CARD_TEXT(card
, 2, "brqsuppo");
1688 iob
= qeth_sbp_build_cmd(card
, IPA_SBP_QUERY_COMMANDS_SUPPORTED
,
1689 SBP_DATA_SIZEOF(query_cmds_supp
));
1693 if (qeth_send_ipa_cmd(card
, iob
, qeth_bridgeport_query_support_cb
,
1695 card
->options
.sbp
.role
= QETH_SBP_ROLE_NONE
;
1696 card
->options
.sbp
.supported_funcs
= 0;
1699 card
->options
.sbp
.supported_funcs
= cbctl
.data
.supported
;
1702 static int qeth_bridgeport_query_ports_cb(struct qeth_card
*card
,
1703 struct qeth_reply
*reply
, unsigned long data
)
1705 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
1706 struct _qeth_sbp_cbctl
*cbctl
= (struct _qeth_sbp_cbctl
*)reply
->param
;
1707 struct qeth_sbp_port_data
*qports
;
1710 QETH_CARD_TEXT(card
, 2, "brqprtcb");
1711 rc
= qeth_bridgeport_makerc(card
, cmd
);
1715 qports
= &cmd
->data
.sbp
.data
.port_data
;
1716 if (qports
->entry_length
!= sizeof(struct qeth_sbp_port_entry
)) {
1717 QETH_CARD_TEXT_(card
, 2, "SBPs%04x", qports
->entry_length
);
1720 /* first entry contains the state of the local port */
1721 if (qports
->num_entries
> 0) {
1722 if (cbctl
->data
.qports
.role
)
1723 *cbctl
->data
.qports
.role
= qports
->entry
[0].role
;
1724 if (cbctl
->data
.qports
.state
)
1725 *cbctl
->data
.qports
.state
= qports
->entry
[0].state
;
1731 * qeth_bridgeport_query_ports() - query local bridgeport status.
1732 * @card: qeth_card structure pointer.
1733 * @role: Role of the port: 0-none, 1-primary, 2-secondary.
1734 * @state: State of the port: 0-inactive, 1-standby, 2-active.
1736 * Returns negative errno-compatible error indication or 0 on success.
1738 * 'role' and 'state' are not updated in case of hardware operation failure.
1740 int qeth_bridgeport_query_ports(struct qeth_card
*card
,
1741 enum qeth_sbp_roles
*role
, enum qeth_sbp_states
*state
)
1743 struct qeth_cmd_buffer
*iob
;
1744 struct _qeth_sbp_cbctl cbctl
= {
1753 QETH_CARD_TEXT(card
, 2, "brqports");
1754 if (!(card
->options
.sbp
.supported_funcs
& IPA_SBP_QUERY_BRIDGE_PORTS
))
1756 iob
= qeth_sbp_build_cmd(card
, IPA_SBP_QUERY_BRIDGE_PORTS
, 0);
1760 return qeth_send_ipa_cmd(card
, iob
, qeth_bridgeport_query_ports_cb
,
1764 static int qeth_bridgeport_set_cb(struct qeth_card
*card
,
1765 struct qeth_reply
*reply
, unsigned long data
)
1767 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*)data
;
1769 QETH_CARD_TEXT(card
, 2, "brsetrcb");
1770 return qeth_bridgeport_makerc(card
, cmd
);
1774 * qeth_bridgeport_setrole() - Assign primary role to the port.
1775 * @card: qeth_card structure pointer.
1776 * @role: Role to assign.
1778 * Returns negative errno-compatible error indication or 0 on success.
1780 int qeth_bridgeport_setrole(struct qeth_card
*card
, enum qeth_sbp_roles role
)
1782 struct qeth_cmd_buffer
*iob
;
1783 enum qeth_ipa_sbp_cmd setcmd
;
1784 unsigned int cmdlength
= 0;
1786 QETH_CARD_TEXT(card
, 2, "brsetrol");
1788 case QETH_SBP_ROLE_NONE
:
1789 setcmd
= IPA_SBP_RESET_BRIDGE_PORT_ROLE
;
1791 case QETH_SBP_ROLE_PRIMARY
:
1792 setcmd
= IPA_SBP_SET_PRIMARY_BRIDGE_PORT
;
1793 cmdlength
= SBP_DATA_SIZEOF(set_primary
);
1795 case QETH_SBP_ROLE_SECONDARY
:
1796 setcmd
= IPA_SBP_SET_SECONDARY_BRIDGE_PORT
;
1801 if (!(card
->options
.sbp
.supported_funcs
& setcmd
))
1803 iob
= qeth_sbp_build_cmd(card
, setcmd
, cmdlength
);
1807 return qeth_send_ipa_cmd(card
, iob
, qeth_bridgeport_set_cb
, NULL
);
1810 static void qeth_bridgeport_an_set_cb(void *priv
,
1811 struct chsc_pnso_naid_l2
*entry
)
1813 struct qeth_card
*card
= (struct qeth_card
*)priv
;
1816 code
= IPA_ADDR_CHANGE_CODE_MACADDR
;
1817 if (entry
->addr_lnid
.lnid
< VLAN_N_VID
)
1818 code
|= IPA_ADDR_CHANGE_CODE_VLANID
;
1819 qeth_bridge_emit_host_event(card
, anev_reg_unreg
, code
,
1820 (struct net_if_token
*)&entry
->nit
,
1821 (struct mac_addr_lnid
*)&entry
->addr_lnid
);
1825 * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
1826 * @card: qeth_card structure pointer.
1827 * @enable: 0 - disable, non-zero - enable notifications
1829 * Returns negative errno-compatible error indication or 0 on success.
1831 * On enable, emits a series of address notifications udev events for all
1832 * currently registered hosts.
1834 int qeth_bridgeport_an_set(struct qeth_card
*card
, int enable
)
1838 if (!card
->options
.sbp
.supported_funcs
)
1842 qeth_bridge_emit_host_event(card
, anev_reset
, 0, NULL
, NULL
);
1843 qeth_l2_set_pnso_mode(card
, QETH_PNSO_BRIDGEPORT
);
1844 rc
= qeth_l2_pnso(card
, PNSO_OC_NET_BRIDGE_INFO
, 1,
1845 qeth_bridgeport_an_set_cb
, card
);
1847 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
1849 rc
= qeth_l2_pnso(card
, PNSO_OC_NET_BRIDGE_INFO
, 0, NULL
, NULL
);
1850 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
1855 /* VNIC Characteristics support */
1857 /* handle VNICC IPA command return codes; convert to error codes */
1858 static int qeth_l2_vnicc_makerc(struct qeth_card
*card
, u16 ipa_rc
)
1863 case IPA_RC_SUCCESS
:
1865 case IPA_RC_L2_UNSUPPORTED_CMD
:
1866 case IPA_RC_NOTSUPP
:
1869 case IPA_RC_VNICC_OOSEQ
:
1872 case IPA_RC_VNICC_VNICBP
:
1875 case IPA_RC_L2_ADDR_TABLE_FULL
:
1878 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP
:
1885 QETH_CARD_TEXT_(card
, 2, "err%04x", ipa_rc
);
1889 /* generic VNICC request call back */
1890 static int qeth_l2_vnicc_request_cb(struct qeth_card
*card
,
1891 struct qeth_reply
*reply
,
1894 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
1895 struct qeth_ipacmd_vnicc
*rep
= &cmd
->data
.vnicc
;
1896 u32 sub_cmd
= cmd
->data
.vnicc
.hdr
.sub_command
;
1898 QETH_CARD_TEXT(card
, 2, "vniccrcb");
1899 if (cmd
->hdr
.return_code
)
1900 return qeth_l2_vnicc_makerc(card
, cmd
->hdr
.return_code
);
1901 /* return results to caller */
1902 card
->options
.vnicc
.sup_chars
= rep
->vnicc_cmds
.supported
;
1903 card
->options
.vnicc
.cur_chars
= rep
->vnicc_cmds
.enabled
;
1905 if (sub_cmd
== IPA_VNICC_QUERY_CMDS
)
1906 *(u32
*)reply
->param
= rep
->data
.query_cmds
.sup_cmds
;
1907 else if (sub_cmd
== IPA_VNICC_GET_TIMEOUT
)
1908 *(u32
*)reply
->param
= rep
->data
.getset_timeout
.timeout
;
1913 static struct qeth_cmd_buffer
*qeth_l2_vnicc_build_cmd(struct qeth_card
*card
,
1915 unsigned int data_length
)
1917 struct qeth_ipacmd_vnicc_hdr
*hdr
;
1918 struct qeth_cmd_buffer
*iob
;
1920 iob
= qeth_ipa_alloc_cmd(card
, IPA_CMD_VNICC
, QETH_PROT_NONE
,
1922 offsetof(struct qeth_ipacmd_vnicc
, data
));
1926 hdr
= &__ipa_cmd(iob
)->data
.vnicc
.hdr
;
1927 hdr
->data_length
= sizeof(*hdr
) + data_length
;
1928 hdr
->sub_command
= vnicc_cmd
;
1932 /* VNICC query VNIC characteristics request */
1933 static int qeth_l2_vnicc_query_chars(struct qeth_card
*card
)
1935 struct qeth_cmd_buffer
*iob
;
1937 QETH_CARD_TEXT(card
, 2, "vniccqch");
1938 iob
= qeth_l2_vnicc_build_cmd(card
, IPA_VNICC_QUERY_CHARS
, 0);
1942 return qeth_send_ipa_cmd(card
, iob
, qeth_l2_vnicc_request_cb
, NULL
);
1945 /* VNICC query sub commands request */
1946 static int qeth_l2_vnicc_query_cmds(struct qeth_card
*card
, u32 vnic_char
,
1949 struct qeth_cmd_buffer
*iob
;
1951 QETH_CARD_TEXT(card
, 2, "vniccqcm");
1952 iob
= qeth_l2_vnicc_build_cmd(card
, IPA_VNICC_QUERY_CMDS
,
1953 VNICC_DATA_SIZEOF(query_cmds
));
1957 __ipa_cmd(iob
)->data
.vnicc
.data
.query_cmds
.vnic_char
= vnic_char
;
1959 return qeth_send_ipa_cmd(card
, iob
, qeth_l2_vnicc_request_cb
, sup_cmds
);
1962 /* VNICC enable/disable characteristic request */
1963 static int qeth_l2_vnicc_set_char(struct qeth_card
*card
, u32 vnic_char
,
1966 struct qeth_cmd_buffer
*iob
;
1968 QETH_CARD_TEXT(card
, 2, "vniccedc");
1969 iob
= qeth_l2_vnicc_build_cmd(card
, cmd
, VNICC_DATA_SIZEOF(set_char
));
1973 __ipa_cmd(iob
)->data
.vnicc
.data
.set_char
.vnic_char
= vnic_char
;
1975 return qeth_send_ipa_cmd(card
, iob
, qeth_l2_vnicc_request_cb
, NULL
);
1978 /* VNICC get/set timeout for characteristic request */
1979 static int qeth_l2_vnicc_getset_timeout(struct qeth_card
*card
, u32 vnicc
,
1980 u32 cmd
, u32
*timeout
)
1982 struct qeth_vnicc_getset_timeout
*getset_timeout
;
1983 struct qeth_cmd_buffer
*iob
;
1985 QETH_CARD_TEXT(card
, 2, "vniccgst");
1986 iob
= qeth_l2_vnicc_build_cmd(card
, cmd
,
1987 VNICC_DATA_SIZEOF(getset_timeout
));
1991 getset_timeout
= &__ipa_cmd(iob
)->data
.vnicc
.data
.getset_timeout
;
1992 getset_timeout
->vnic_char
= vnicc
;
1994 if (cmd
== IPA_VNICC_SET_TIMEOUT
)
1995 getset_timeout
->timeout
= *timeout
;
1997 return qeth_send_ipa_cmd(card
, iob
, qeth_l2_vnicc_request_cb
, timeout
);
2000 /* recover user timeout setting */
2001 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card
*card
, u32 vnicc
,
2004 if (card
->options
.vnicc
.sup_chars
& vnicc
&&
2005 card
->options
.vnicc
.getset_timeout_sup
& vnicc
&&
2006 !qeth_l2_vnicc_getset_timeout(card
, vnicc
, IPA_VNICC_SET_TIMEOUT
,
2009 *timeout
= QETH_VNICC_DEFAULT_TIMEOUT
;
2013 /* set current VNICC flag state; called from sysfs store function */
2014 int qeth_l2_vnicc_set_state(struct qeth_card
*card
, u32 vnicc
, bool state
)
2019 QETH_CARD_TEXT(card
, 2, "vniccsch");
2021 /* check if characteristic and enable/disable are supported */
2022 if (!(card
->options
.vnicc
.sup_chars
& vnicc
) ||
2023 !(card
->options
.vnicc
.set_char_sup
& vnicc
))
2026 if (qeth_bridgeport_is_in_use(card
))
2029 /* set enable/disable command and store wanted characteristic */
2031 cmd
= IPA_VNICC_ENABLE
;
2032 card
->options
.vnicc
.wanted_chars
|= vnicc
;
2034 cmd
= IPA_VNICC_DISABLE
;
2035 card
->options
.vnicc
.wanted_chars
&= ~vnicc
;
2038 /* do we need to do anything? */
2039 if (card
->options
.vnicc
.cur_chars
== card
->options
.vnicc
.wanted_chars
)
2042 /* if card is not ready, simply stop here */
2043 if (!qeth_card_hw_is_reachable(card
)) {
2045 card
->options
.vnicc
.cur_chars
|= vnicc
;
2047 card
->options
.vnicc
.cur_chars
&= ~vnicc
;
2051 rc
= qeth_l2_vnicc_set_char(card
, vnicc
, cmd
);
2053 card
->options
.vnicc
.wanted_chars
=
2054 card
->options
.vnicc
.cur_chars
;
2056 /* successful online VNICC change; handle special cases */
2057 if (state
&& vnicc
== QETH_VNICC_RX_BCAST
)
2058 card
->options
.vnicc
.rx_bcast_enabled
= true;
2059 if (!state
&& vnicc
== QETH_VNICC_LEARNING
)
2060 qeth_l2_vnicc_recover_timeout(card
, vnicc
,
2061 &card
->options
.vnicc
.learning_timeout
);
2067 /* get current VNICC flag state; called from sysfs show function */
2068 int qeth_l2_vnicc_get_state(struct qeth_card
*card
, u32 vnicc
, bool *state
)
2072 QETH_CARD_TEXT(card
, 2, "vniccgch");
2074 /* check if characteristic is supported */
2075 if (!(card
->options
.vnicc
.sup_chars
& vnicc
))
2078 if (qeth_bridgeport_is_in_use(card
))
2081 /* if card is ready, query current VNICC state */
2082 if (qeth_card_hw_is_reachable(card
))
2083 rc
= qeth_l2_vnicc_query_chars(card
);
2085 *state
= (card
->options
.vnicc
.cur_chars
& vnicc
) ? true : false;
2089 /* set VNICC timeout; called from sysfs store function. Currently, only learning
2092 int qeth_l2_vnicc_set_timeout(struct qeth_card
*card
, u32 timeout
)
2096 QETH_CARD_TEXT(card
, 2, "vniccsto");
2098 /* check if characteristic and set_timeout are supported */
2099 if (!(card
->options
.vnicc
.sup_chars
& QETH_VNICC_LEARNING
) ||
2100 !(card
->options
.vnicc
.getset_timeout_sup
& QETH_VNICC_LEARNING
))
2103 if (qeth_bridgeport_is_in_use(card
))
2106 /* do we need to do anything? */
2107 if (card
->options
.vnicc
.learning_timeout
== timeout
)
2110 /* if card is not ready, simply store the value internally and return */
2111 if (!qeth_card_hw_is_reachable(card
)) {
2112 card
->options
.vnicc
.learning_timeout
= timeout
;
2116 /* send timeout value to card; if successful, store value internally */
2117 rc
= qeth_l2_vnicc_getset_timeout(card
, QETH_VNICC_LEARNING
,
2118 IPA_VNICC_SET_TIMEOUT
, &timeout
);
2120 card
->options
.vnicc
.learning_timeout
= timeout
;
2125 /* get current VNICC timeout; called from sysfs show function. Currently, only
2126 * learning supports timeout
2128 int qeth_l2_vnicc_get_timeout(struct qeth_card
*card
, u32
*timeout
)
2132 QETH_CARD_TEXT(card
, 2, "vniccgto");
2134 /* check if characteristic and get_timeout are supported */
2135 if (!(card
->options
.vnicc
.sup_chars
& QETH_VNICC_LEARNING
) ||
2136 !(card
->options
.vnicc
.getset_timeout_sup
& QETH_VNICC_LEARNING
))
2139 if (qeth_bridgeport_is_in_use(card
))
2142 /* if card is ready, get timeout. Otherwise, just return stored value */
2143 *timeout
= card
->options
.vnicc
.learning_timeout
;
2144 if (qeth_card_hw_is_reachable(card
))
2145 rc
= qeth_l2_vnicc_getset_timeout(card
, QETH_VNICC_LEARNING
,
2146 IPA_VNICC_GET_TIMEOUT
,
2152 /* check if VNICC is currently enabled */
2153 static bool _qeth_l2_vnicc_is_in_use(struct qeth_card
*card
)
2155 if (!card
->options
.vnicc
.sup_chars
)
2157 /* default values are only OK if rx_bcast was not enabled by user
2158 * or the card is offline.
2160 if (card
->options
.vnicc
.cur_chars
== QETH_VNICC_DEFAULT
) {
2161 if (!card
->options
.vnicc
.rx_bcast_enabled
||
2162 !qeth_card_hw_is_reachable(card
))
2169 * qeth_bridgeport_allowed - are any qeth_bridgeport functions allowed?
2170 * @card: qeth_card structure pointer
2172 * qeth_bridgeport functionality is mutually exclusive with usage of the
2173 * VNIC Characteristics and dev2br address notifications
2175 bool qeth_bridgeport_allowed(struct qeth_card
*card
)
2177 struct qeth_priv
*priv
= netdev_priv(card
->dev
);
2179 return (!_qeth_l2_vnicc_is_in_use(card
) &&
2180 !(priv
->brport_features
& BR_LEARNING_SYNC
));
2183 /* recover user characteristic setting */
2184 static bool qeth_l2_vnicc_recover_char(struct qeth_card
*card
, u32 vnicc
,
2187 u32 cmd
= enable
? IPA_VNICC_ENABLE
: IPA_VNICC_DISABLE
;
2189 if (card
->options
.vnicc
.sup_chars
& vnicc
&&
2190 card
->options
.vnicc
.set_char_sup
& vnicc
&&
2191 !qeth_l2_vnicc_set_char(card
, vnicc
, cmd
))
2193 card
->options
.vnicc
.wanted_chars
&= ~vnicc
;
2194 card
->options
.vnicc
.wanted_chars
|= QETH_VNICC_DEFAULT
& vnicc
;
2198 /* (re-)initialize VNICC */
2199 static void qeth_l2_vnicc_init(struct qeth_card
*card
)
2201 u32
*timeout
= &card
->options
.vnicc
.learning_timeout
;
2202 bool enable
, error
= false;
2203 unsigned int chars_len
, i
;
2204 unsigned long chars_tmp
;
2205 u32 sup_cmds
, vnicc
;
2207 QETH_CARD_TEXT(card
, 2, "vniccini");
2208 /* reset rx_bcast */
2209 card
->options
.vnicc
.rx_bcast_enabled
= 0;
2210 /* initial query and storage of VNIC characteristics */
2211 if (qeth_l2_vnicc_query_chars(card
)) {
2212 if (card
->options
.vnicc
.wanted_chars
!= QETH_VNICC_DEFAULT
||
2213 *timeout
!= QETH_VNICC_DEFAULT_TIMEOUT
)
2214 dev_err(&card
->gdev
->dev
, "Configuring the VNIC characteristics failed\n");
2215 /* fail quietly if user didn't change the default config */
2216 card
->options
.vnicc
.sup_chars
= 0;
2217 card
->options
.vnicc
.cur_chars
= 0;
2218 card
->options
.vnicc
.wanted_chars
= QETH_VNICC_DEFAULT
;
2221 /* get supported commands for each supported characteristic */
2222 chars_tmp
= card
->options
.vnicc
.sup_chars
;
2223 chars_len
= sizeof(card
->options
.vnicc
.sup_chars
) * BITS_PER_BYTE
;
2224 for_each_set_bit(i
, &chars_tmp
, chars_len
) {
2226 if (qeth_l2_vnicc_query_cmds(card
, vnicc
, &sup_cmds
)) {
2230 if ((sup_cmds
& IPA_VNICC_SET_TIMEOUT
) &&
2231 (sup_cmds
& IPA_VNICC_GET_TIMEOUT
))
2232 card
->options
.vnicc
.getset_timeout_sup
|= vnicc
;
2234 card
->options
.vnicc
.getset_timeout_sup
&= ~vnicc
;
2235 if ((sup_cmds
& IPA_VNICC_ENABLE
) &&
2236 (sup_cmds
& IPA_VNICC_DISABLE
))
2237 card
->options
.vnicc
.set_char_sup
|= vnicc
;
2239 card
->options
.vnicc
.set_char_sup
&= ~vnicc
;
2241 /* enforce assumed default values and recover settings, if changed */
2242 error
|= qeth_l2_vnicc_recover_timeout(card
, QETH_VNICC_LEARNING
,
2244 /* Change chars, if necessary */
2245 chars_tmp
= card
->options
.vnicc
.wanted_chars
^
2246 card
->options
.vnicc
.cur_chars
;
2247 chars_len
= sizeof(card
->options
.vnicc
.wanted_chars
) * BITS_PER_BYTE
;
2248 for_each_set_bit(i
, &chars_tmp
, chars_len
) {
2250 enable
= card
->options
.vnicc
.wanted_chars
& vnicc
;
2251 error
|= qeth_l2_vnicc_recover_char(card
, vnicc
, enable
);
2254 dev_err(&card
->gdev
->dev
, "Configuring the VNIC characteristics failed\n");
2257 /* configure default values of VNIC characteristics */
2258 static void qeth_l2_vnicc_set_defaults(struct qeth_card
*card
)
2260 /* characteristics values */
2261 card
->options
.vnicc
.sup_chars
= QETH_VNICC_ALL
;
2262 card
->options
.vnicc
.cur_chars
= QETH_VNICC_DEFAULT
;
2263 card
->options
.vnicc
.learning_timeout
= QETH_VNICC_DEFAULT_TIMEOUT
;
2264 /* supported commands */
2265 card
->options
.vnicc
.set_char_sup
= QETH_VNICC_ALL
;
2266 card
->options
.vnicc
.getset_timeout_sup
= QETH_VNICC_LEARNING
;
2267 /* settings wanted by users */
2268 card
->options
.vnicc
.wanted_chars
= QETH_VNICC_DEFAULT
;
2271 static const struct device_type qeth_l2_devtype
= {
2272 .name
= "qeth_layer2",
2273 .groups
= qeth_l2_attr_groups
,
2276 static int qeth_l2_probe_device(struct ccwgroup_device
*gdev
)
2278 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
2281 qeth_l2_vnicc_set_defaults(card
);
2282 mutex_init(&card
->sbp_lock
);
2284 if (gdev
->dev
.type
) {
2285 rc
= device_add_groups(&gdev
->dev
, qeth_l2_attr_groups
);
2289 gdev
->dev
.type
= &qeth_l2_devtype
;
2292 INIT_WORK(&card
->rx_mode_work
, qeth_l2_rx_mode_work
);
2296 static void qeth_l2_remove_device(struct ccwgroup_device
*gdev
)
2298 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
2299 struct qeth_priv
*priv
;
2301 if (gdev
->dev
.type
!= &qeth_l2_devtype
)
2302 device_remove_groups(&gdev
->dev
, qeth_l2_attr_groups
);
2304 qeth_set_allowed_threads(card
, 0, 1);
2305 wait_event(card
->wait_q
, qeth_threads_running(card
, 0xffffffff) == 0);
2307 if (gdev
->state
== CCWGROUP_ONLINE
)
2308 qeth_set_offline(card
, card
->discipline
, false);
2310 if (card
->dev
->reg_state
== NETREG_REGISTERED
) {
2311 priv
= netdev_priv(card
->dev
);
2312 if (priv
->brport_features
& BR_LEARNING_SYNC
) {
2314 qeth_l2_br2dev_put();
2317 unregister_netdev(card
->dev
);
2321 static int qeth_l2_set_online(struct qeth_card
*card
, bool carrier_ok
)
2323 struct net_device
*dev
= card
->dev
;
2326 qeth_l2_detect_dev2br_support(card
);
2328 mutex_lock(&card
->sbp_lock
);
2329 qeth_bridgeport_query_support(card
);
2330 if (card
->options
.sbp
.supported_funcs
) {
2331 qeth_l2_setup_bridgeport_attrs(card
);
2332 dev_info(&card
->gdev
->dev
,
2333 "The device represents a Bridge Capable Port\n");
2335 mutex_unlock(&card
->sbp_lock
);
2337 qeth_l2_register_dev_addr(card
);
2339 /* for the rx_bcast characteristic, init VNICC after setmac */
2340 qeth_l2_vnicc_init(card
);
2342 qeth_l2_trace_features(card
);
2345 QETH_CARD_TEXT(card
, 2, "softsetp");
2347 card
->state
= CARD_STATE_SOFTSETUP
;
2349 qeth_set_allowed_threads(card
, 0xffffffff, 0);
2351 if (dev
->reg_state
!= NETREG_REGISTERED
) {
2352 rc
= qeth_l2_setup_netdev(card
);
2357 netif_carrier_on(dev
);
2360 rc
= qeth_set_real_num_tx_queues(card
,
2361 qeth_tx_actual_queues(card
));
2364 goto err_set_queues
;
2368 netif_carrier_on(dev
);
2370 netif_carrier_off(dev
);
2372 netif_device_attach(dev
);
2373 qeth_enable_hw_features(dev
);
2374 qeth_l2_enable_brport_features(card
);
2376 if (card
->info
.open_when_online
) {
2377 card
->info
.open_when_online
= 0;
2378 dev_open(dev
, NULL
);
2386 qeth_set_allowed_threads(card
, 0, 1);
2387 card
->state
= CARD_STATE_DOWN
;
2391 static void qeth_l2_set_offline(struct qeth_card
*card
)
2393 struct qeth_priv
*priv
= netdev_priv(card
->dev
);
2395 qeth_set_allowed_threads(card
, 0, 1);
2396 qeth_l2_drain_rx_mode_cache(card
);
2398 if (card
->state
== CARD_STATE_SOFTSETUP
)
2399 card
->state
= CARD_STATE_DOWN
;
2401 qeth_l2_set_pnso_mode(card
, QETH_PNSO_NONE
);
2402 if (priv
->brport_features
& BR_LEARNING_SYNC
)
2403 qeth_l2_dev2br_fdb_flush(card
);
2406 /* Returns zero if the command is successfully "consumed" */
2407 static int qeth_l2_control_event(struct qeth_card
*card
,
2408 struct qeth_ipa_cmd
*cmd
)
2410 switch (cmd
->hdr
.command
) {
2411 case IPA_CMD_SETBRIDGEPORT_OSA
:
2412 case IPA_CMD_SETBRIDGEPORT_IQD
:
2413 if (cmd
->data
.sbp
.hdr
.command_code
==
2414 IPA_SBP_BRIDGE_PORT_STATE_CHANGE
) {
2415 qeth_bridge_state_change(card
, cmd
);
2420 case IPA_CMD_ADDRESS_CHANGE_NOTIF
:
2421 qeth_addr_change_event(card
, cmd
);
2428 const struct qeth_discipline qeth_l2_discipline
= {
2429 .setup
= qeth_l2_probe_device
,
2430 .remove
= qeth_l2_remove_device
,
2431 .set_online
= qeth_l2_set_online
,
2432 .set_offline
= qeth_l2_set_offline
,
2434 .control_event_handler
= qeth_l2_control_event
,
2436 EXPORT_SYMBOL_GPL(qeth_l2_discipline
);
2438 static int __init
qeth_l2_init(void)
2440 pr_info("register layer 2 discipline\n");
2441 refcount_set(&qeth_l2_switchdev_notify_refcnt
, 0);
2445 static void __exit
qeth_l2_exit(void)
2447 pr_info("unregister layer 2 discipline\n");
2450 module_init(qeth_l2_init
);
2451 module_exit(qeth_l2_exit
);
2452 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2453 MODULE_DESCRIPTION("qeth layer 2 discipline");
2454 MODULE_LICENSE("GPL");