projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
s390/qeth: translate SETVLAN/DELVLAN errors
[linux-2.6-block.git] / drivers / s390 / net / qeth_l2_main.c
CommitLineData
4a71df50 1/*
bbcfcdc8 2 * Copyright IBM Corp. 2007, 2009
4a71df50
FB		 3 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
4 * Frank Pavlic <fpavlic@de.ibm.com>,
5 * Thomas Spatzier <tspat@de.ibm.com>,
6 * Frank Blaschka <frank.blaschka@de.ibm.com>
7 */
8
74eacdb9
FB		 9#define KMSG_COMPONENT "qeth"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
4a71df50
FB		 12#include <linux/module.h>
13#include <linux/moduleparam.h>
14#include <linux/string.h>
15#include <linux/errno.h>
16#include <linux/kernel.h>
5a0e3ad6 17#include <linux/slab.h>
4a71df50 18#include <linux/etherdevice.h>
4a71df50 19#include <linux/ip.h>
ccffad25 20#include <linux/list.h>
fe5c8028
LD		 21#include <linux/hash.h>
22#include <linux/hashtable.h>
23#include <linux/string.h>
ec61bd2f 24#include <asm/setup.h>
4a71df50 25#include "qeth_core.h"
b4d72c08 26#include "qeth_l2.h"
4a71df50 27
4a71df50
FB		 28static int qeth_l2_set_offline(struct ccwgroup_device *);
29static int qeth_l2_stop(struct net_device *);
fe5c8028 30static void qeth_l2_set_rx_mode(struct net_device *);
c044dc21
EC		 31static void qeth_bridgeport_query_support(struct qeth_card *card);
32static void qeth_bridge_state_change(struct qeth_card *card,
33 struct qeth_ipa_cmd *cmd);
34static void qeth_bridge_host_event(struct qeth_card *card,
35 struct qeth_ipa_cmd *cmd);
caa1f0b1 36static void qeth_l2_vnicc_set_defaults(struct qeth_card *card);
a45b3faf 37static void qeth_l2_vnicc_init(struct qeth_card *card);
349d13d5
HW		 38static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
39 u32 *timeout);
4a71df50 40
4a71df50
FB		 41static int qeth_l2_verify_dev(struct net_device *dev)
42{
43 struct qeth_card *card;
44 unsigned long flags;
45 int rc = 0;
46
47 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
48 list_for_each_entry(card, &qeth_core_card_list.list, list) {
49 if (card->dev == dev) {
50 rc = QETH_REAL_CARD;
51 break;
52 }
53 }
54 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
55
56 return rc;
57}
58
59static struct net_device *qeth_l2_netdev_by_devno(unsigned char *read_dev_no)
60{
61 struct qeth_card *card;
62 struct net_device *ndev;
f06f6f32 63 __u16 temp_dev_no;
4a71df50 64 unsigned long flags;
f06f6f32 65 struct ccw_dev_id read_devid;
4a71df50
FB		 66
67 ndev = NULL;
68 memcpy(&temp_dev_no, read_dev_no, 2);
69 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
70 list_for_each_entry(card, &qeth_core_card_list.list, list) {
f06f6f32
CH		 71 ccw_device_get_id(CARD_RDEV(card), &read_devid);
72 if (read_devid.devno == temp_dev_no) {
4a71df50
FB		 73 ndev = card->dev;
74 break;
75 }
76 }
77 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
78 return ndev;
79}
80
2aa48671 81static int qeth_setdelmac_makerc(struct qeth_card *card, int retcode)
4a71df50 82{
efbbc1d5 83 int rc;
4a71df50 84
efbbc1d5 85 if (retcode)
1aec42bc 86 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
efbbc1d5
EC		 87 switch (retcode) {
88 case IPA_RC_SUCCESS:
89 rc = 0;
90 break;
91 case IPA_RC_L2_UNSUPPORTED_CMD:
ffb95251 92 rc = -EOPNOTSUPP;
efbbc1d5
EC		 93 break;
94 case IPA_RC_L2_ADDR_TABLE_FULL:
95 rc = -ENOSPC;
96 break;
97 case IPA_RC_L2_DUP_MAC:
98 case IPA_RC_L2_DUP_LAYER3_MAC:
99 rc = -EEXIST;
100 break;
101 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
102 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
103 rc = -EPERM;
104 break;
105 case IPA_RC_L2_MAC_NOT_FOUND:
106 rc = -ENOENT;
107 break;
1aec42bc
TR		 108 case -ENOMEM:
109 rc = -ENOMEM;
110 break;
efbbc1d5
EC		 111 default:
112 rc = -EIO;
113 break;
4a71df50 114 }
efbbc1d5 115 return rc;
4a71df50
FB		 116}
117
ac988d78
JW		 118static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
119 enum qeth_ipa_cmds ipacmd)
120{
121 struct qeth_ipa_cmd *cmd;
122 struct qeth_cmd_buffer *iob;
123
124 QETH_CARD_TEXT(card, 2, "L2sdmac");
125 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
126 if (!iob)
127 return -ENOMEM;
128 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
129 cmd->data.setdelmac.mac_length = OSA_ADDR_LEN;
130 memcpy(&cmd->data.setdelmac.mac, mac, OSA_ADDR_LEN);
2aa48671
JW		 131 return qeth_setdelmac_makerc(card, qeth_send_ipa_cmd(card, iob,
132 NULL, NULL));
ac988d78
JW		 133}
134
135static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
136{
137 int rc;
138
139 QETH_CARD_TEXT(card, 2, "L2Setmac");
140 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
141 if (rc == 0) {
142 card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
143 memcpy(card->dev->dev_addr, mac, OSA_ADDR_LEN);
144 dev_info(&card->gdev->dev,
145 "MAC address %pM successfully registered on device %s\n",
146 card->dev->dev_addr, card->dev->name);
147 } else {
148 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
149 switch (rc) {
150 case -EEXIST:
151 dev_warn(&card->gdev->dev,
152 "MAC address %pM already exists\n", mac);
153 break;
154 case -EPERM:
155 dev_warn(&card->gdev->dev,
156 "MAC address %pM is not authorized\n", mac);
157 break;
158 }
159 }
160 return rc;
161}
162
163static int qeth_l2_send_delmac(struct qeth_card *card, __u8 *mac)
164{
165 int rc;
166
167 QETH_CARD_TEXT(card, 2, "L2Delmac");
168 if (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
169 return 0;
170 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELVMAC);
171 if (rc == 0)
172 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
173 return rc;
174}
175
4a71df50
FB		 176static int qeth_l2_send_setgroupmac(struct qeth_card *card, __u8 *mac)
177{
efbbc1d5 178 int rc;
4a71df50 179
efbbc1d5 180 QETH_CARD_TEXT(card, 2, "L2Sgmac");
754e0b8d 181 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETGMAC);
efbbc1d5
EC		 182 if (rc == -EEXIST)
183 QETH_DBF_MESSAGE(2, "Group MAC %pM already existing on %s\n",
184 mac, QETH_CARD_IFNAME(card));
185 else if (rc)
186 QETH_DBF_MESSAGE(2, "Could not set group MAC %pM on %s: %d\n",
187 mac, QETH_CARD_IFNAME(card), rc);
188 return rc;
4a71df50
FB		 189}
190
191static int qeth_l2_send_delgroupmac(struct qeth_card *card, __u8 *mac)
192{
efbbc1d5
EC		 193 int rc;
194
847a50fd 195 QETH_CARD_TEXT(card, 2, "L2Dgmac");
754e0b8d 196 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELGMAC);
efbbc1d5
EC		 197 if (rc)
198 QETH_DBF_MESSAGE(2,
199 "Could not delete group MAC %pM on %s: %d\n",
200 mac, QETH_CARD_IFNAME(card), rc);
201 return rc;
4a71df50
FB		 202}
203
fe5c8028
LD		 204static int qeth_l2_write_mac(struct qeth_card *card, struct qeth_mac *mac)
205{
fe5c8028 206 if (mac->is_uc) {
979d7929 207 return qeth_l2_send_setdelmac(card, mac->mac_addr,
754e0b8d 208 IPA_CMD_SETVMAC);
7db2266a 209 } else {
979d7929
JW		 210 return qeth_l2_send_setgroupmac(card, mac->mac_addr);
211 }
212}
213
214static int qeth_l2_remove_mac(struct qeth_card *card, struct qeth_mac *mac)
215{
216 if (mac->is_uc) {
217 return qeth_l2_send_setdelmac(card, mac->mac_addr,
218 IPA_CMD_DELVMAC);
219 } else {
220 return qeth_l2_send_delgroupmac(card, mac->mac_addr);
7db2266a 221 }
4a71df50
FB		 222}
223
c07cbf2e 224static void qeth_l2_del_all_macs(struct qeth_card *card)
4a71df50 225{
fe5c8028
LD		 226 struct qeth_mac *mac;
227 struct hlist_node *tmp;
228 int i;
4a71df50
FB		 229
230 spin_lock_bh(&card->mclock);
fe5c8028 231 hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
fe5c8028
LD		 232 hash_del(&mac->hnode);
233 kfree(mac);
4a71df50
FB		 234 }
235 spin_unlock_bh(&card->mclock);
236}
237
cef6ff22 238static int qeth_l2_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
4a71df50 239{
ce73e10e
KDW		 240 if (card->info.type == QETH_CARD_TYPE_OSN)
241 return RTN_UNSPEC;
242 if (is_broadcast_ether_addr(skb->data))
243 return RTN_BROADCAST;
244 if (is_multicast_ether_addr(skb->data))
245 return RTN_MULTICAST;
246 return RTN_UNSPEC;
4a71df50
FB		 247}
248
cef6ff22
JW		 249static void qeth_l2_hdr_csum(struct qeth_card *card, struct qeth_hdr *hdr,
250 struct sk_buff *skb)
4d7def2a
TR		 251{
252 struct iphdr *iph = ip_hdr(skb);
253
254 /* tcph->check contains already the pseudo hdr checksum
255 * so just set the header flags
256 */
257 if (iph->protocol == IPPROTO_UDP)
258 hdr->hdr.l2.flags[1] |= QETH_HDR_EXT_UDP;
259 hdr->hdr.l2.flags[1] |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
260 QETH_HDR_EXT_CSUM_HDR_REQ;
261 iph->check = 0;
262 if (card->options.performance_stats)
263 card->perf_stats.tx_csum++;
264}
265
ae79fe03
JW		 266static void qeth_l2_fill_header(struct qeth_hdr *hdr, struct sk_buff *skb,
267 int cast_type, unsigned int data_len)
4a71df50 268{
683d718a 269 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb_mac_header(skb);
4a71df50
FB		 270
271 memset(hdr, 0, sizeof(struct qeth_hdr));
272 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
ae79fe03 273 hdr->hdr.l2.pkt_length = data_len;
4a71df50
FB		 274
275 /* set byte byte 3 to casting flags */
276 if (cast_type == RTN_MULTICAST)
277 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
278 else if (cast_type == RTN_BROADCAST)
279 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
280 else
ce73e10e 281 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
4a71df50 282
4a71df50
FB		 283 /* VSWITCH relies on the VLAN
284 * information to be present in
285 * the QDIO header */
286 if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
287 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
288 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
289 }
290}
291
2aa48671
JW		 292static int qeth_setdelvlan_makerc(struct qeth_card *card, int retcode)
293{
294 if (retcode)
295 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
296
297 switch (retcode) {
298 case IPA_RC_SUCCESS:
299 return 0;
300 case IPA_RC_L2_INVALID_VLAN_ID:
301 return -EINVAL;
302 case IPA_RC_L2_DUP_VLAN_ID:
303 return -EEXIST;
304 case IPA_RC_L2_VLAN_ID_NOT_FOUND:
305 return -ENOENT;
306 case IPA_RC_L2_VLAN_ID_NOT_ALLOWED:
307 return -EPERM;
308 case -ENOMEM:
309 return -ENOMEM;
310 default:
311 return -EIO;
312 }
313}
314
4a71df50 315static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
2aa48671
JW		 316 struct qeth_reply *reply,
317 unsigned long data)
4a71df50 318{
2aa48671 319 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
4a71df50 320
847a50fd 321 QETH_CARD_TEXT(card, 2, "L2sdvcb");
4a71df50 322 if (cmd->hdr.return_code) {
2aa48671
JW		 323 QETH_DBF_MESSAGE(2, "Error in processing VLAN %i on %s: 0x%x.\n",
324 cmd->data.setdelvlan.vlan_id,
325 QETH_CARD_IFNAME(card), cmd->hdr.return_code);
847a50fd
CO		 326 QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
327 QETH_CARD_TEXT_(card, 2, "err%d", cmd->hdr.return_code);
4a71df50
FB		 328 }
329 return 0;
330}
331
332static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
2aa48671 333 enum qeth_ipa_cmds ipacmd)
4a71df50
FB		 334{
335 struct qeth_ipa_cmd *cmd;
336 struct qeth_cmd_buffer *iob;
337
847a50fd 338 QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
4a71df50 339 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
1aec42bc
TR		 340 if (!iob)
341 return -ENOMEM;
4a71df50
FB		 342 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
343 cmd->data.setdelvlan.vlan_id = i;
2aa48671
JW		 344 return qeth_setdelvlan_makerc(card, qeth_send_ipa_cmd(card, iob,
345 qeth_l2_send_setdelvlan_cb, NULL));
4a71df50
FB		 346}
347
70919e23 348static void qeth_l2_process_vlans(struct qeth_card *card)
4a71df50
FB		 349{
350 struct qeth_vlan_vid *id;
847a50fd 351 QETH_CARD_TEXT(card, 3, "L2prcvln");
4a71df50
FB		 352 spin_lock_bh(&card->vlanlock);
353 list_for_each_entry(id, &card->vid_list, list) {
70919e23 354 qeth_l2_send_setdelvlan(card, id->vid, IPA_CMD_SETVLAN);
4a71df50
FB		 355 }
356 spin_unlock_bh(&card->vlanlock);
357}
358
80d5c368
PM		 359static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
360 __be16 proto, u16 vid)
4a71df50 361{
509e2562 362 struct qeth_card *card = dev->ml_priv;
4a71df50 363 struct qeth_vlan_vid *id;
1aec42bc 364 int rc;
4a71df50 365
847a50fd 366 QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
10651db7 367 if (!vid)
8e586137 368 return 0;
5113fec0 369 if (card->info.type == QETH_CARD_TYPE_OSM) {
847a50fd 370 QETH_CARD_TEXT(card, 3, "aidOSM");
8e586137 371 return 0;
5113fec0 372 }
8e98ac48 373 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
847a50fd 374 QETH_CARD_TEXT(card, 3, "aidREC");
8e586137 375 return 0;
8e98ac48 376 }
4a71df50
FB		 377 id = kmalloc(sizeof(struct qeth_vlan_vid), GFP_ATOMIC);
378 if (id) {
379 id->vid = vid;
1aec42bc
TR		 380 rc = qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
381 if (rc) {
382 kfree(id);
383 return rc;
384 }
4a71df50
FB		 385 spin_lock_bh(&card->vlanlock);
386 list_add_tail(&id->list, &card->vid_list);
387 spin_unlock_bh(&card->vlanlock);
8e586137
JP		 388 } else {
389 return -ENOMEM;
4a71df50 390 }
8e586137 391 return 0;
4a71df50
FB		 392}
393
80d5c368
PM		 394static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
395 __be16 proto, u16 vid)
4a71df50
FB		 396{
397 struct qeth_vlan_vid *id, *tmpid = NULL;
509e2562 398 struct qeth_card *card = dev->ml_priv;
1aec42bc 399 int rc = 0;
4a71df50 400
847a50fd 401 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
5113fec0 402 if (card->info.type == QETH_CARD_TYPE_OSM) {
847a50fd 403 QETH_CARD_TEXT(card, 3, "kidOSM");
8e586137 404 return 0;
5113fec0 405 }
8e98ac48 406 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
847a50fd 407 QETH_CARD_TEXT(card, 3, "kidREC");
8e586137 408 return 0;
8e98ac48 409 }
4a71df50
FB		 410 spin_lock_bh(&card->vlanlock);
411 list_for_each_entry(id, &card->vid_list, list) {
412 if (id->vid == vid) {
413 list_del(&id->list);
414 tmpid = id;
415 break;
416 }
417 }
418 spin_unlock_bh(&card->vlanlock);
419 if (tmpid) {
1aec42bc 420 rc = qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
4a71df50
FB		 421 kfree(tmpid);
422 }
fe5c8028 423 qeth_l2_set_rx_mode(card->dev);
1aec42bc 424 return rc;
4a71df50
FB		 425}
426
b2f4de8b 427static void qeth_l2_stop_card(struct qeth_card *card, int recovery_mode)
4a71df50 428{
d11ba0c4
PT		 429 QETH_DBF_TEXT(SETUP , 2, "stopcard");
430 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
4a71df50
FB		 431
432 qeth_set_allowed_threads(card, 0, 1);
4a71df50
FB		 433 if (card->read.state == CH_STATE_UP &&
434 card->write.state == CH_STATE_UP &&
435 (card->state == CARD_STATE_UP)) {
436 if (recovery_mode &&
437 card->info.type != QETH_CARD_TYPE_OSN) {
438 qeth_l2_stop(card->dev);
439 } else {
440 rtnl_lock();
441 dev_close(card->dev);
442 rtnl_unlock();
443 }
70919e23 444 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
4a71df50
FB		 445 card->state = CARD_STATE_SOFTSETUP;
446 }
447 if (card->state == CARD_STATE_SOFTSETUP) {
c07cbf2e 448 qeth_l2_del_all_macs(card);
4a71df50
FB		 449 qeth_clear_ipacmd_list(card);
450 card->state = CARD_STATE_HARDSETUP;
451 }
452 if (card->state == CARD_STATE_HARDSETUP) {
453 qeth_qdio_clear_card(card, 0);
454 qeth_clear_qdio_buffers(card);
455 qeth_clear_working_pool_list(card);
456 card->state = CARD_STATE_DOWN;
457 }
458 if (card->state == CARD_STATE_DOWN) {
459 qeth_clear_cmd_buffers(&card->read);
460 qeth_clear_cmd_buffers(&card->write);
461 }
4a71df50
FB		 462}
463
a1c3ed4c
FB		 464static int qeth_l2_process_inbound_buffer(struct qeth_card *card,
465 int budget, int *done)
4a71df50 466{
a1c3ed4c 467 int work_done = 0;
4a71df50
FB		 468 struct sk_buff *skb;
469 struct qeth_hdr *hdr;
4a71df50
FB		 470 unsigned int len;
471
a1c3ed4c 472 *done = 0;
18af5c17 473 WARN_ON_ONCE(!budget);
a1c3ed4c
FB		 474 while (budget) {
475 skb = qeth_core_get_next_skb(card,
b3332930 476 &card->qdio.in_q->bufs[card->rx.b_index],
a1c3ed4c
FB		 477 &card->rx.b_element, &card->rx.e_offset, &hdr);
478 if (!skb) {
479 *done = 1;
480 break;
4a71df50 481 }
a1c3ed4c 482 skb->dev = card->dev;
4a71df50
FB		 483 switch (hdr->hdr.l2.id) {
484 case QETH_HEADER_TYPE_LAYER2:
485 skb->pkt_type = PACKET_HOST;
486 skb->protocol = eth_type_trans(skb, skb->dev);
4d7def2a
TR		 487 if ((card->dev->features & NETIF_F_RXCSUM)
488 && ((hdr->hdr.l2.flags[1] &
489 (QETH_HDR_EXT_CSUM_HDR_REQ |
490 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
491 (QETH_HDR_EXT_CSUM_HDR_REQ |
492 QETH_HDR_EXT_CSUM_TRANSP_REQ)))
493 skb->ip_summed = CHECKSUM_UNNECESSARY;
494 else
495 skb->ip_summed = CHECKSUM_NONE;
12883725
UB		 496 if (skb->protocol == htons(ETH_P_802_2))
497 *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
4a71df50 498 len = skb->len;
9abfa8cb 499 napi_gro_receive(&card->napi, skb);
4a71df50
FB		 500 break;
501 case QETH_HEADER_TYPE_OSN:
2d488c2f
UB		 502 if (card->info.type == QETH_CARD_TYPE_OSN) {
503 skb_push(skb, sizeof(struct qeth_hdr));
504 skb_copy_to_linear_data(skb, hdr,
4a71df50 505 sizeof(struct qeth_hdr));
2d488c2f
UB		 506 len = skb->len;
507 card->osn_info.data_cb(skb);
508 break;
509 }
510 /* else unknown */
4a71df50
FB		 511 default:
512 dev_kfree_skb_any(skb);
847a50fd 513 QETH_CARD_TEXT(card, 3, "inbunkno");
d11ba0c4 514 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
4a71df50
FB		 515 continue;
516 }
a1c3ed4c
FB		 517 work_done++;
518 budget--;
4a71df50
FB		 519 card->stats.rx_packets++;
520 card->stats.rx_bytes += len;
521 }
a1c3ed4c
FB		 522 return work_done;
523}
524
4a71df50
FB		 525static int qeth_l2_request_initial_mac(struct qeth_card *card)
526{
527 int rc = 0;
528 char vendor_pre[] = {0x02, 0x00, 0x00};
529
ec61bd2f 530 QETH_DBF_TEXT(SETUP, 2, "l2reqmac");
d11ba0c4 531 QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card));
4a71df50 532
ec61bd2f
JW		 533 if (MACHINE_IS_VM) {
534 rc = qeth_vm_request_mac(card);
535 if (!rc)
536 goto out;
537 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %s: x%x\n",
538 CARD_BUS_ID(card), rc);
539 QETH_DBF_TEXT_(SETUP, 2, "err%04x", rc);
540 /* fall back to alternative mechanism: */
541 }
542
5113fec0
UB		 543 if (card->info.type == QETH_CARD_TYPE_IQD ||
544 card->info.type == QETH_CARD_TYPE_OSM ||
545 card->info.type == QETH_CARD_TYPE_OSX ||
546 card->info.guestlan) {
4a71df50
FB		 547 rc = qeth_setadpparms_change_macaddr(card);
548 if (rc) {
14cc21b6
FB		 549 QETH_DBF_MESSAGE(2, "couldn't get MAC address on "
550 "device %s: x%x\n", CARD_BUS_ID(card), rc);
1aec42bc 551 QETH_DBF_TEXT_(SETUP, 2, "1err%04x", rc);
4a71df50
FB		 552 return rc;
553 }
4a71df50 554 } else {
1833611d 555 eth_random_addr(card->dev->dev_addr);
4a71df50
FB		 556 memcpy(card->dev->dev_addr, vendor_pre, 3);
557 }
ec61bd2f
JW		 558out:
559 QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, card->dev->addr_len);
4a71df50
FB		 560 return 0;
561}
562
563static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
564{
565 struct sockaddr *addr = p;
509e2562 566 struct qeth_card *card = dev->ml_priv;
4a71df50
FB		 567 int rc = 0;
568
847a50fd 569 QETH_CARD_TEXT(card, 3, "setmac");
4a71df50
FB		 570
571 if (qeth_l2_verify_dev(dev) != QETH_REAL_CARD) {
847a50fd 572 QETH_CARD_TEXT(card, 3, "setmcINV");
4a71df50
FB		 573 return -EOPNOTSUPP;
574 }
575
5113fec0
UB		 576 if (card->info.type == QETH_CARD_TYPE_OSN ||
577 card->info.type == QETH_CARD_TYPE_OSM ||
578 card->info.type == QETH_CARD_TYPE_OSX) {
847a50fd 579 QETH_CARD_TEXT(card, 3, "setmcTYP");
4a71df50
FB		 580 return -EOPNOTSUPP;
581 }
847a50fd 582 QETH_CARD_HEX(card, 3, addr->sa_data, OSA_ADDR_LEN);
8e98ac48 583 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
847a50fd 584 QETH_CARD_TEXT(card, 3, "setmcREC");
8e98ac48
UB		 585 return -ERESTARTSYS;
586 }
4a71df50 587 rc = qeth_l2_send_delmac(card, &card->dev->dev_addr[0]);
efbbc1d5 588 if (!rc || (rc == -ENOENT))
4a71df50 589 rc = qeth_l2_send_setmac(card, addr->sa_data);
e0a8114c 590 return rc ? -EINVAL : 0;
4a71df50
FB		 591}
592
0db587b0
EC		 593static void qeth_promisc_to_bridge(struct qeth_card *card)
594{
595 struct net_device *dev = card->dev;
596 enum qeth_ipa_promisc_modes promisc_mode;
597 int role;
598 int rc;
599
600 QETH_CARD_TEXT(card, 3, "pmisc2br");
601
602 if (!card->options.sbp.reflect_promisc)
603 return;
604 promisc_mode = (dev->flags & IFF_PROMISC) ? SET_PROMISC_MODE_ON
605 : SET_PROMISC_MODE_OFF;
606 if (promisc_mode == card->info.promisc_mode)
607 return;
608
609 if (promisc_mode == SET_PROMISC_MODE_ON) {
610 if (card->options.sbp.reflect_promisc_primary)
611 role = QETH_SBP_ROLE_PRIMARY;
612 else
613 role = QETH_SBP_ROLE_SECONDARY;
614 } else
615 role = QETH_SBP_ROLE_NONE;
616
617 rc = qeth_bridgeport_setrole(card, role);
618 QETH_DBF_TEXT_(SETUP, 2, "bpm%c%04x",
619 (promisc_mode == SET_PROMISC_MODE_ON) ? '+' : '-', rc);
620 if (!rc) {
621 card->options.sbp.role = role;
622 card->info.promisc_mode = promisc_mode;
623 }
fe5c8028
LD		 624
625}
626/* New MAC address is added to the hash table and marked to be written on card
627 * only if there is not in the hash table storage already
628 *
629*/
cef6ff22
JW		 630static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha,
631 u8 is_uc)
fe5c8028 632{
cef6ff22 633 u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
fe5c8028
LD		 634 struct qeth_mac *mac;
635
cef6ff22 636 hash_for_each_possible(card->mac_htable, mac, hnode, mac_hash) {
fe5c8028
LD		 637 if (is_uc == mac->is_uc &&
638 !memcmp(ha->addr, mac->mac_addr, OSA_ADDR_LEN)) {
5f78e29c 639 mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
fe5c8028
LD		 640 return;
641 }
642 }
643
644 mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
645
646 if (!mac)
647 return;
648
649 memcpy(mac->mac_addr, ha->addr, OSA_ADDR_LEN);
650 mac->is_uc = is_uc;
5f78e29c 651 mac->disp_flag = QETH_DISP_ADDR_ADD;
fe5c8028 652
cef6ff22 653 hash_add(card->mac_htable, &mac->hnode, mac_hash);
0db587b0
EC		 654}
655
fe5c8028 656static void qeth_l2_set_rx_mode(struct net_device *dev)
4a71df50 657{
509e2562 658 struct qeth_card *card = dev->ml_priv;
ccffad25 659 struct netdev_hw_addr *ha;
fe5c8028
LD		 660 struct qeth_mac *mac;
661 struct hlist_node *tmp;
662 int i;
663 int rc;
4a71df50
FB		 664
665 if (card->info.type == QETH_CARD_TYPE_OSN)
fe5c8028 666 return;
4a71df50 667
847a50fd 668 QETH_CARD_TEXT(card, 3, "setmulti");
8e98ac48
UB		 669 if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
670 (card->state != CARD_STATE_UP))
671 return;
fe5c8028 672
4a71df50 673 spin_lock_bh(&card->mclock);
fe5c8028 674
22bedad3 675 netdev_for_each_mc_addr(ha, dev)
fe5c8028 676 qeth_l2_add_mac(card, ha, 0);
7db2266a 677
32e7bfc4 678 netdev_for_each_uc_addr(ha, dev)
fe5c8028
LD		 679 qeth_l2_add_mac(card, ha, 1);
680
681 hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
5f78e29c 682 if (mac->disp_flag == QETH_DISP_ADDR_DELETE) {
979d7929 683 qeth_l2_remove_mac(card, mac);
fe5c8028
LD		 684 hash_del(&mac->hnode);
685 kfree(mac);
686
5f78e29c 687 } else if (mac->disp_flag == QETH_DISP_ADDR_ADD) {
fe5c8028
LD		 688 rc = qeth_l2_write_mac(card, mac);
689 if (rc) {
690 hash_del(&mac->hnode);
691 kfree(mac);
692 } else
5f78e29c 693 mac->disp_flag = QETH_DISP_ADDR_DELETE;
fe5c8028 694 } else
5f78e29c 695 mac->disp_flag = QETH_DISP_ADDR_DELETE;
fe5c8028 696 }
7db2266a 697
4a71df50 698 spin_unlock_bh(&card->mclock);
fe5c8028 699
0db587b0
EC		 700 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
701 qeth_setadp_promisc_mode(card);
702 else
703 qeth_promisc_to_bridge(card);
4a71df50
FB		 704}
705
7286384b
JW		 706static int qeth_l2_xmit_iqd(struct qeth_card *card, struct sk_buff *skb,
707 struct qeth_qdio_out_q *queue, int cast_type)
4a71df50 708{
7286384b
JW		 709 unsigned int data_offset = ETH_HLEN;
710 struct qeth_hdr *hdr;
4a71df50 711 int rc;
4a71df50 712
7286384b
JW		 713 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
714 if (!hdr)
715 return -ENOMEM;
ae79fe03 716 qeth_l2_fill_header(hdr, skb, cast_type, skb->len);
7286384b
JW		 717 skb_copy_from_linear_data(skb, ((char *)hdr) + sizeof(*hdr),
718 data_offset);
290b8348 719
7286384b
JW		 720 if (!qeth_get_elements_no(card, skb, 1, data_offset)) {
721 rc = -E2BIG;
722 goto out;
4a71df50 723 }
7c2e9ba3 724 rc = qeth_do_send_packet_fast(queue, skb, hdr, data_offset,
f1588177 725 sizeof(*hdr) + data_offset);
7286384b
JW		 726out:
727 if (rc)
728 kmem_cache_free(qeth_core_header_cache, hdr);
729 return rc;
730}
4a71df50 731
7286384b
JW		 732static int qeth_l2_xmit_osa(struct qeth_card *card, struct sk_buff *skb,
733 struct qeth_qdio_out_q *queue, int cast_type)
734{
0d6f02d3 735 int push_len = sizeof(struct qeth_hdr);
7286384b 736 unsigned int elements, nr_frags;
0d6f02d3
JW		 737 unsigned int hdr_elements = 0;
738 struct qeth_hdr *hdr = NULL;
739 unsigned int hd_len = 0;
7286384b 740 int rc;
4a71df50 741
d52aec97
EC		 742 /* fix hardware limitation: as long as we do not have sbal
743 * chaining we can not send long frag lists
744 */
7286384b
JW		 745 if (!qeth_get_elements_no(card, skb, 0, 0)) {
746 rc = skb_linearize(skb);
6059c905
EC		 747
748 if (card->options.performance_stats) {
7286384b 749 if (rc)
6059c905
EC		 750 card->perf_stats.tx_linfail++;
751 else
752 card->perf_stats.tx_lin++;
753 }
7286384b
JW		 754 if (rc)
755 return rc;
d52aec97 756 }
7286384b 757 nr_frags = skb_shinfo(skb)->nr_frags;
d52aec97 758
0d6f02d3
JW		 759 rc = skb_cow_head(skb, push_len);
760 if (rc)
761 return rc;
762 push_len = qeth_push_hdr(skb, &hdr, push_len);
763 if (push_len < 0)
764 return push_len;
765 if (!push_len) {
766 /* hdr was allocated from cache */
767 hd_len = sizeof(*hdr);
768 hdr_elements = 1;
769 }
770 qeth_l2_fill_header(hdr, skb, cast_type, skb->len - push_len);
771 if (skb->ip_summed == CHECKSUM_PARTIAL)
772 qeth_l2_hdr_csum(card, hdr, skb);
4a71df50 773
0d6f02d3 774 elements = qeth_get_elements_no(card, skb, hdr_elements, 0);
64ef8957 775 if (!elements) {
7286384b
JW		 776 rc = -E2BIG;
777 goto out;
f61a0d05 778 }
0d6f02d3
JW		 779 elements += hdr_elements;
780
781 /* TODO: remove the skb_orphan() once TX completion is fast enough */
782 skb_orphan(skb);
783 rc = qeth_do_send_packet(card, queue, skb, hdr, 0, hd_len, elements);
7286384b 784out:
4a71df50 785 if (!rc) {
886e1974
JW		 786 if (card->options.performance_stats && nr_frags) {
787 card->perf_stats.sg_skbs_sent++;
788 /* nr_frags + skb->data */
789 card->perf_stats.sg_frags_sent += nr_frags + 1;
d52aec97 790 }
4a71df50 791 } else {
0d6f02d3
JW		 792 if (hd_len)
793 kmem_cache_free(qeth_core_header_cache, hdr);
794 if (rc == -EBUSY)
795 /* roll back to ETH header */
796 skb_pull(skb, push_len);
7286384b
JW		 797 }
798 return rc;
799}
683d718a 800
7286384b
JW		 801static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
802 struct qeth_qdio_out_q *queue)
803{
804 unsigned int elements;
805 struct qeth_hdr *hdr;
806
807 if (skb->protocol == htons(ETH_P_IPV6))
808 return -EPROTONOSUPPORT;
809
810 hdr = (struct qeth_hdr *)skb->data;
811 elements = qeth_get_elements_no(card, skb, 0, 0);
812 if (!elements)
813 return -E2BIG;
814 if (qeth_hdr_chk_and_bounce(skb, &hdr, sizeof(*hdr)))
815 return -EINVAL;
9c3bfda9 816 return qeth_do_send_packet(card, queue, skb, hdr, 0, 0, elements);
7286384b
JW		 817}
818
819static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
820 struct net_device *dev)
821{
822 struct qeth_card *card = dev->ml_priv;
823 int cast_type = qeth_l2_get_cast_type(card, skb);
824 struct qeth_qdio_out_q *queue;
825 int tx_bytes = skb->len;
826 int rc;
827
828 if (card->qdio.do_prio_queueing || (cast_type &&
829 card->info.is_multicast_different))
830 queue = card->qdio.out_qs[qeth_get_priority_queue(card, skb,
831 qeth_get_ip_version(skb), cast_type)];
832 else
833 queue = card->qdio.out_qs[card->qdio.default_out_queue];
834
835 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
836 card->stats.tx_carrier_errors++;
837 goto tx_drop;
4a71df50
FB		 838 }
839
7286384b
JW		 840 if (card->options.performance_stats) {
841 card->perf_stats.outbound_cnt++;
842 card->perf_stats.outbound_start_time = qeth_get_micros();
843 }
844 netif_stop_queue(dev);
845
846 switch (card->info.type) {
847 case QETH_CARD_TYPE_OSN:
848 rc = qeth_l2_xmit_osn(card, skb, queue);
849 break;
850 case QETH_CARD_TYPE_IQD:
851 rc = qeth_l2_xmit_iqd(card, skb, queue, cast_type);
852 break;
853 default:
854 rc = qeth_l2_xmit_osa(card, skb, queue, cast_type);
855 }
856
857 if (!rc) {
858 card->stats.tx_packets++;
859 card->stats.tx_bytes += tx_bytes;
860 if (card->options.performance_stats)
861 card->perf_stats.outbound_time += qeth_get_micros() -
862 card->perf_stats.outbound_start_time;
863 netif_wake_queue(dev);
864 return NETDEV_TX_OK;
865 } else if (rc == -EBUSY) {
866 return NETDEV_TX_BUSY;
867 } /* else fall through */
4a71df50
FB		 868
869tx_drop:
870 card->stats.tx_dropped++;
871 card->stats.tx_errors++;
4a71df50 872 dev_kfree_skb_any(skb);
d0ec0f54 873 netif_wake_queue(dev);
4a71df50
FB		 874 return NETDEV_TX_OK;
875}
876
39423440 877static int __qeth_l2_open(struct net_device *dev)
4a71df50 878{
509e2562 879 struct qeth_card *card = dev->ml_priv;
a1c3ed4c 880 int rc = 0;
4a71df50 881
847a50fd 882 QETH_CARD_TEXT(card, 4, "qethopen");
39423440
UB		 883 if (card->state == CARD_STATE_UP)
884 return rc;
4a71df50
FB		 885 if (card->state != CARD_STATE_SOFTSETUP)
886 return -ENODEV;
887
888 if ((card->info.type != QETH_CARD_TYPE_OSN) &&
889 (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))) {
847a50fd 890 QETH_CARD_TEXT(card, 4, "nomacadr");
4a71df50
FB		 891 return -EPERM;
892 }
893 card->data.state = CH_STATE_UP;
894 card->state = CARD_STATE_UP;
4a71df50
FB		 895 netif_start_queue(dev);
896
a1c3ed4c
FB		 897 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
898 napi_enable(&card->napi);
899 napi_schedule(&card->napi);
900 } else
901 rc = -EIO;
902 return rc;
4a71df50
FB		 903}
904
39423440
UB		 905static int qeth_l2_open(struct net_device *dev)
906{
907 struct qeth_card *card = dev->ml_priv;
908
909 QETH_CARD_TEXT(card, 5, "qethope_");
910 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
911 QETH_CARD_TEXT(card, 3, "openREC");
912 return -ERESTARTSYS;
913 }
914 return __qeth_l2_open(dev);
915}
916
4a71df50
FB		 917static int qeth_l2_stop(struct net_device *dev)
918{
509e2562 919 struct qeth_card *card = dev->ml_priv;
4a71df50 920
847a50fd 921 QETH_CARD_TEXT(card, 4, "qethstop");
4a71df50 922 netif_tx_disable(dev);
a1c3ed4c 923 if (card->state == CARD_STATE_UP) {
4a71df50 924 card->state = CARD_STATE_SOFTSETUP;
a1c3ed4c
FB		 925 napi_disable(&card->napi);
926 }
4a71df50
FB		 927 return 0;
928}
929
2d2ebb3e
JW		 930static const struct device_type qeth_l2_devtype = {
931 .name = "qeth_layer2",
932 .groups = qeth_l2_attr_groups,
933};
934
4a71df50
FB		 935static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
936{
937 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
9111e788 938 int rc;
4a71df50 939
2d2ebb3e
JW		 940 if (gdev->dev.type == &qeth_generic_devtype) {
941 rc = qeth_l2_create_device_attributes(&gdev->dev);
942 if (rc)
943 return rc;
944 }
4a71df50 945 INIT_LIST_HEAD(&card->vid_list);
fe5c8028 946 hash_init(card->mac_htable);
4a71df50 947 card->options.layer2 = 1;
1da74b1c 948 card->info.hwtrap = 0;
caa1f0b1 949 qeth_l2_vnicc_set_defaults(card);
4a71df50
FB		 950 return 0;
951}
952
953static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
954{
955 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
956
2d2ebb3e
JW		 957 if (cgdev->dev.type == &qeth_generic_devtype)
958 qeth_l2_remove_device_attributes(&cgdev->dev);
f2148565 959 qeth_set_allowed_threads(card, 0, 1);
4a71df50
FB		 960 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
961
70919e23 962 if (cgdev->state == CCWGROUP_ONLINE)
4a71df50 963 qeth_l2_set_offline(cgdev);
4a71df50
FB		 964
965 if (card->dev) {
7831b4ff 966 netif_napi_del(&card->napi);
4a71df50
FB		 967 unregister_netdev(card->dev);
968 card->dev = NULL;
969 }
4a71df50
FB		 970 return;
971}
972
0fc0b732 973static const struct ethtool_ops qeth_l2_ethtool_ops = {
4a71df50 974 .get_link = ethtool_op_get_link,
4a71df50
FB		 975 .get_strings = qeth_core_get_strings,
976 .get_ethtool_stats = qeth_core_get_ethtool_stats,
df8b4ec8 977 .get_sset_count = qeth_core_get_sset_count,
4a71df50 978 .get_drvinfo = qeth_core_get_drvinfo,
993e19c0 979 .get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
4a71df50
FB		 980};
981
0fc0b732 982static const struct ethtool_ops qeth_l2_osn_ops = {
4a71df50
FB		 983 .get_strings = qeth_core_get_strings,
984 .get_ethtool_stats = qeth_core_get_ethtool_stats,
df8b4ec8 985 .get_sset_count = qeth_core_get_sset_count,
4a71df50
FB		 986 .get_drvinfo = qeth_core_get_drvinfo,
987};
988
3d58cefd 989static const struct net_device_ops qeth_l2_netdev_ops = {
8403b13c
FB		 990 .ndo_open = qeth_l2_open,
991 .ndo_stop = qeth_l2_stop,
992 .ndo_get_stats = qeth_get_stats,
993 .ndo_start_xmit = qeth_l2_hard_start_xmit,
994 .ndo_validate_addr = eth_validate_addr,
fe5c8028 995 .ndo_set_rx_mode = qeth_l2_set_rx_mode,
942d6984 996 .ndo_do_ioctl = qeth_do_ioctl,
8403b13c
FB		 997 .ndo_set_mac_address = qeth_l2_set_mac_address,
998 .ndo_change_mtu = qeth_change_mtu,
999 .ndo_vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid,
1000 .ndo_vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid,
1001 .ndo_tx_timeout = qeth_tx_timeout,
8f43fb00
TR		 1002 .ndo_fix_features = qeth_fix_features,
1003 .ndo_set_features = qeth_set_features
8403b13c
FB		 1004};
1005
4a71df50
FB		 1006static int qeth_l2_setup_netdev(struct qeth_card *card)
1007{
1008 switch (card->info.type) {
4a71df50 1009 case QETH_CARD_TYPE_IQD:
c835a677
TG		 1010 card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN,
1011 ether_setup);
4a71df50
FB		 1012 break;
1013 case QETH_CARD_TYPE_OSN:
c835a677
TG		 1014 card->dev = alloc_netdev(0, "osn%d", NET_NAME_UNKNOWN,
1015 ether_setup);
4a71df50
FB		 1016 break;
1017 default:
1018 card->dev = alloc_etherdev(0);
1019 }
1020
1021 if (!card->dev)
1022 return -ENODEV;
1023
509e2562 1024 card->dev->ml_priv = card;
4a71df50 1025 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
4a71df50 1026 card->dev->mtu = card->info.initial_mtu;
46b3ef4c
JW		 1027 card->dev->min_mtu = 64;
1028 card->dev->max_mtu = ETH_MAX_MTU;
8403b13c 1029 card->dev->netdev_ops = &qeth_l2_netdev_ops;
25e2c341
JW		 1030 if (card->info.type == QETH_CARD_TYPE_OSN) {
1031 card->dev->ethtool_ops = &qeth_l2_osn_ops;
1032 card->dev->flags |= IFF_NOARP;
1033 } else {
1034 card->dev->ethtool_ops = &qeth_l2_ethtool_ops;
1035 }
f646968f 1036 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
4d7def2a 1037 if (card->info.type == QETH_CARD_TYPE_OSD && !card->info.guestlan) {
8f43fb00 1038 card->dev->hw_features = NETIF_F_SG;
9bdc4411 1039 card->dev->vlan_features = NETIF_F_SG;
8f43fb00 1040 /* OSA 3S and earlier has no RX/TX support */
9bdc4411 1041 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
8f43fb00 1042 card->dev->hw_features |= NETIF_F_IP_CSUM;
9bdc4411
HW		 1043 card->dev->vlan_features |= NETIF_F_IP_CSUM;
1044 }
1045 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
8f43fb00 1046 card->dev->hw_features |= NETIF_F_RXCSUM;
9bdc4411
HW		 1047 card->dev->vlan_features |= NETIF_F_RXCSUM;
1048 }
4d7def2a 1049 }
0d6f02d3
JW		 1050 if (card->info.type != QETH_CARD_TYPE_OSN &&
1051 card->info.type != QETH_CARD_TYPE_IQD) {
1052 card->dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1053 card->dev->needed_headroom = sizeof(struct qeth_hdr);
1054 }
1055
4a71df50
FB		 1056 card->info.broadcast_capable = 1;
1057 qeth_l2_request_initial_mac(card);
d52aec97
EC		 1058 card->dev->gso_max_size = (QETH_MAX_BUFFER_ELEMENTS(card) - 1) *
1059 PAGE_SIZE;
4a71df50 1060 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
d73ef324 1061 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
e5ebe632 1062 netif_carrier_off(card->dev);
4a71df50
FB		 1063 return register_netdev(card->dev);
1064}
1065
4d7def2a
TR		 1066static int qeth_l2_start_ipassists(struct qeth_card *card)
1067{
1068 /* configure isolation level */
1069 if (qeth_set_access_ctrl_online(card, 0))
1070 return -ENODEV;
4d7def2a
TR		 1071 return 0;
1072}
1073
521c10ea
JW		 1074static void qeth_l2_trace_features(struct qeth_card *card)
1075{
a45b3faf
HW		 1076 /* Set BridgePort features */
1077 QETH_CARD_TEXT(card, 2, "featuSBP");
521c10ea
JW		 1078 QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
1079 sizeof(card->options.sbp.supported_funcs));
a45b3faf
HW		 1080 /* VNIC Characteristics features */
1081 QETH_CARD_TEXT(card, 2, "feaVNICC");
1082 QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
1083 sizeof(card->options.vnicc.sup_chars));
521c10ea
JW		 1084}
1085
4a71df50
FB		 1086static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
1087{
1088 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1089 int rc = 0;
1090 enum qeth_card_states recover_flag;
1091
9dc48ccc 1092 mutex_lock(&card->discipline_mutex);
c4949f07 1093 mutex_lock(&card->conf_mutex);
d11ba0c4
PT		 1094 QETH_DBF_TEXT(SETUP, 2, "setonlin");
1095 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
4a71df50 1096
4a71df50 1097 recover_flag = card->state;
4a71df50
FB		 1098 rc = qeth_core_hardsetup_card(card);
1099 if (rc) {
1aec42bc 1100 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
aa909224 1101 rc = -ENODEV;
4a71df50
FB		 1102 goto out_remove;
1103 }
c044dc21
EC		 1104 qeth_bridgeport_query_support(card);
1105 if (card->options.sbp.supported_funcs)
1106 dev_info(&card->gdev->dev,
9c23f4da 1107 "The device represents a Bridge Capable Port\n");
4a71df50 1108
aa909224
UB		 1109 if (!card->dev && qeth_l2_setup_netdev(card)) {
1110 rc = -ENODEV;
4a71df50 1111 goto out_remove;
aa909224 1112 }
4a71df50
FB		 1113
1114 if (card->info.type != QETH_CARD_TYPE_OSN)
1115 qeth_l2_send_setmac(card, &card->dev->dev_addr[0]);
1116
1da74b1c
FB		 1117 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
1118 if (card->info.hwtrap &&
1119 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
1120 card->info.hwtrap = 0;
1121 } else
1122 card->info.hwtrap = 0;
1123
a45b3faf
HW		 1124 /* for the rx_bcast characteristic, init VNICC after setmac */
1125 qeth_l2_vnicc_init(card);
1126
1127 qeth_trace_features(card);
1128 qeth_l2_trace_features(card);
1129
b4d72c08
EC		 1130 qeth_l2_setup_bridgeport_attrs(card);
1131
4a71df50 1132 card->state = CARD_STATE_HARDSETUP;
a1c3ed4c 1133 memset(&card->rx, 0, sizeof(struct qeth_rx));
4a71df50
FB		 1134 qeth_print_status_message(card);
1135
1136 /* softsetup */
d11ba0c4 1137 QETH_DBF_TEXT(SETUP, 2, "softsetp");
4a71df50 1138
5113fec0 1139 if ((card->info.type == QETH_CARD_TYPE_OSD) ||
0f54761d 1140 (card->info.type == QETH_CARD_TYPE_OSX)) {
8f43fb00
TR		 1141 rc = qeth_l2_start_ipassists(card);
1142 if (rc)
0f54761d 1143 goto out_remove;
0f54761d 1144 }
5113fec0
UB		 1145
1146 if (card->info.type != QETH_CARD_TYPE_OSN &&
1147 card->info.type != QETH_CARD_TYPE_OSM)
70919e23 1148 qeth_l2_process_vlans(card);
4a71df50
FB		 1149
1150 netif_tx_disable(card->dev);
1151
1152 rc = qeth_init_qdio_queues(card);
1153 if (rc) {
d11ba0c4 1154 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
aa909224 1155 rc = -ENODEV;
4a71df50
FB		 1156 goto out_remove;
1157 }
1158 card->state = CARD_STATE_SOFTSETUP;
2b6203bb
UB		 1159 if (card->lan_online)
1160 netif_carrier_on(card->dev);
1161 else
1162 netif_carrier_off(card->dev);
4a71df50
FB		 1163
1164 qeth_set_allowed_threads(card, 0xffffffff, 0);
1165 if (recover_flag == CARD_STATE_RECOVER) {
1166 if (recovery_mode &&
1167 card->info.type != QETH_CARD_TYPE_OSN) {
39423440 1168 __qeth_l2_open(card->dev);
4a71df50
FB		 1169 } else {
1170 rtnl_lock();
1171 dev_open(card->dev);
1172 rtnl_unlock();
1173 }
1174 /* this also sets saved unicast addresses */
fe5c8028 1175 qeth_l2_set_rx_mode(card->dev);
e830baa9
HW		 1176 rtnl_lock();
1177 qeth_recover_features(card->dev);
1178 rtnl_unlock();
4a71df50
FB		 1179 }
1180 /* let user_space know that device is online */
1181 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
c4949f07 1182 mutex_unlock(&card->conf_mutex);
9dc48ccc 1183 mutex_unlock(&card->discipline_mutex);
4a71df50 1184 return 0;
aa909224 1185
4a71df50 1186out_remove:
4a71df50
FB		 1187 qeth_l2_stop_card(card, 0);
1188 ccw_device_set_offline(CARD_DDEV(card));
1189 ccw_device_set_offline(CARD_WDEV(card));
1190 ccw_device_set_offline(CARD_RDEV(card));
22ae2790 1191 qdio_free(CARD_DDEV(card));
4a71df50
FB		 1192 if (recover_flag == CARD_STATE_RECOVER)
1193 card->state = CARD_STATE_RECOVER;
1194 else
1195 card->state = CARD_STATE_DOWN;
c4949f07 1196 mutex_unlock(&card->conf_mutex);
9dc48ccc 1197 mutex_unlock(&card->discipline_mutex);
aa909224 1198 return rc;
4a71df50
FB		 1199}
1200
1201static int qeth_l2_set_online(struct ccwgroup_device *gdev)
1202{
1203 return __qeth_l2_set_online(gdev, 0);
1204}
1205
1206static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev,
1207 int recovery_mode)
1208{
1209 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
1210 int rc = 0, rc2 = 0, rc3 = 0;
1211 enum qeth_card_states recover_flag;
1212
9dc48ccc 1213 mutex_lock(&card->discipline_mutex);
c4949f07 1214 mutex_lock(&card->conf_mutex);
d11ba0c4
PT		 1215 QETH_DBF_TEXT(SETUP, 3, "setoffl");
1216 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
4a71df50
FB		 1217
1218 if (card->dev && netif_carrier_ok(card->dev))
1219 netif_carrier_off(card->dev);
1220 recover_flag = card->state;
1da74b1c
FB		 1221 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
1222 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
1223 card->info.hwtrap = 1;
1224 }
0f5623c9 1225 qeth_l2_stop_card(card, recovery_mode);
4a71df50
FB		 1226 rc = ccw_device_set_offline(CARD_DDEV(card));
1227 rc2 = ccw_device_set_offline(CARD_WDEV(card));
1228 rc3 = ccw_device_set_offline(CARD_RDEV(card));
1229 if (!rc)
1230 rc = (rc2) ? rc2 : rc3;
1231 if (rc)
d11ba0c4 1232 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
22ae2790 1233 qdio_free(CARD_DDEV(card));
4a71df50
FB		 1234 if (recover_flag == CARD_STATE_UP)
1235 card->state = CARD_STATE_RECOVER;
1236 /* let user_space know that device is offline */
1237 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
c4949f07 1238 mutex_unlock(&card->conf_mutex);
9dc48ccc 1239 mutex_unlock(&card->discipline_mutex);
4a71df50
FB		 1240 return 0;
1241}
1242
1243static int qeth_l2_set_offline(struct ccwgroup_device *cgdev)
1244{
1245 return __qeth_l2_set_offline(cgdev, 0);
1246}
1247
1248static int qeth_l2_recover(void *ptr)
1249{
1250 struct qeth_card *card;
1251 int rc = 0;
1252
1253 card = (struct qeth_card *) ptr;
847a50fd 1254 QETH_CARD_TEXT(card, 2, "recover1");
4a71df50
FB		 1255 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
1256 return 0;
847a50fd 1257 QETH_CARD_TEXT(card, 2, "recover2");
74eacdb9
FB		 1258 dev_warn(&card->gdev->dev,
1259 "A recovery process has been started for the device\n");
65d8013c 1260 qeth_set_recovery_task(card);
4a71df50
FB		 1261 __qeth_l2_set_offline(card->gdev, 1);
1262 rc = __qeth_l2_set_online(card->gdev, 1);
4a71df50 1263 if (!rc)
74eacdb9
FB		 1264 dev_info(&card->gdev->dev,
1265 "Device successfully recovered!\n");
28a7e4c9 1266 else {
0f54761d
SR		 1267 qeth_close_dev(card);
1268 dev_warn(&card->gdev->dev, "The qeth device driver "
2efaf5ff 1269 "failed to recover an error on the device\n");
28a7e4c9 1270 }
65d8013c 1271 qeth_clear_recovery_task(card);
a1c3ed4c
FB		 1272 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
1273 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
4a71df50
FB		 1274 return 0;
1275}
1276
1277static int __init qeth_l2_init(void)
1278{
74eacdb9 1279 pr_info("register layer 2 discipline\n");
4a71df50
FB		 1280 return 0;
1281}
1282
1283static void __exit qeth_l2_exit(void)
1284{
74eacdb9 1285 pr_info("unregister layer 2 discipline\n");
4a71df50
FB		 1286}
1287
bbcfcdc8
FB		 1288static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev)
1289{
1290 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1291
1292 if (card->dev)
1293 netif_device_detach(card->dev);
1294 qeth_set_allowed_threads(card, 0, 1);
1295 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
1296 if (gdev->state == CCWGROUP_OFFLINE)
1297 return 0;
1298 if (card->state == CARD_STATE_UP) {
1da74b1c
FB		 1299 if (card->info.hwtrap)
1300 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
bbcfcdc8
FB		 1301 __qeth_l2_set_offline(card->gdev, 1);
1302 } else
1303 __qeth_l2_set_offline(card->gdev, 0);
1304 return 0;
1305}
1306
1307static int qeth_l2_pm_resume(struct ccwgroup_device *gdev)
1308{
1309 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1310 int rc = 0;
1311
1312 if (gdev->state == CCWGROUP_OFFLINE)
1313 goto out;
1314
1315 if (card->state == CARD_STATE_RECOVER) {
1316 rc = __qeth_l2_set_online(card->gdev, 1);
1317 if (rc) {
869da90b
UB		 1318 rtnl_lock();
1319 dev_close(card->dev);
1320 rtnl_unlock();
bbcfcdc8
FB		 1321 }
1322 } else
1323 rc = __qeth_l2_set_online(card->gdev, 0);
1324out:
1325 qeth_set_allowed_threads(card, 0xffffffff, 0);
1326 if (card->dev)
1327 netif_device_attach(card->dev);
1328 if (rc)
1329 dev_warn(&card->gdev->dev, "The qeth device driver "
1330 "failed to recover an error on the device\n");
1331 return rc;
1332}
1333
c044dc21
EC		 1334/* Returns zero if the command is successfully "consumed" */
1335static int qeth_l2_control_event(struct qeth_card *card,
1336 struct qeth_ipa_cmd *cmd)
1337{
1338 switch (cmd->hdr.command) {
9c23f4da
EC		 1339 case IPA_CMD_SETBRIDGEPORT_OSA:
1340 case IPA_CMD_SETBRIDGEPORT_IQD:
c044dc21
EC		 1341 if (cmd->data.sbp.hdr.command_code ==
1342 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
1343 qeth_bridge_state_change(card, cmd);
1344 return 0;
1345 } else
1346 return 1;
1347 case IPA_CMD_ADDRESS_CHANGE_NOTIF:
1348 qeth_bridge_host_event(card, cmd);
1349 return 0;
1350 default:
1351 return 1;
1352 }
1353}
1354
c041f2d4 1355struct qeth_discipline qeth_l2_discipline = {
2d2ebb3e 1356 .devtype = &qeth_l2_devtype,
c041f2d4
SO		 1357 .start_poll = qeth_qdio_start_poll,
1358 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
1359 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler,
d73ef324 1360 .process_rx_buffer = qeth_l2_process_inbound_buffer,
c041f2d4
SO		 1361 .recover = qeth_l2_recover,
1362 .setup = qeth_l2_probe_device,
4a71df50
FB		 1363 .remove = qeth_l2_remove_device,
1364 .set_online = qeth_l2_set_online,
1365 .set_offline = qeth_l2_set_offline,
bbcfcdc8
FB		 1366 .freeze = qeth_l2_pm_suspend,
1367 .thaw = qeth_l2_pm_resume,
1368 .restore = qeth_l2_pm_resume,
942d6984 1369 .do_ioctl = NULL,
c044dc21 1370 .control_event_handler = qeth_l2_control_event,
4a71df50 1371};
c041f2d4 1372EXPORT_SYMBOL_GPL(qeth_l2_discipline);
4a71df50
FB		 1373
1374static int qeth_osn_send_control_data(struct qeth_card *card, int len,
1375 struct qeth_cmd_buffer *iob)
1376{
1377 unsigned long flags;
1378 int rc = 0;
1379
847a50fd 1380 QETH_CARD_TEXT(card, 5, "osndctrd");
4a71df50
FB		 1381
1382 wait_event(card->wait_q,
1383 atomic_cmpxchg(&card->write.irq_pending, 0, 1) == 0);
1384 qeth_prepare_control_data(card, len, iob);
847a50fd 1385 QETH_CARD_TEXT(card, 6, "osnoirqp");
4a71df50
FB		 1386 spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags);
1387 rc = ccw_device_start(card->write.ccwdev, &card->write.ccw,
1388 (addr_t) iob, 0, 0);
1389 spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags);
1390 if (rc) {
14cc21b6 1391 QETH_DBF_MESSAGE(2, "qeth_osn_send_control_data: "
4a71df50 1392 "ccw_device_start rc = %i\n", rc);
847a50fd 1393 QETH_CARD_TEXT_(card, 2, " err%d", rc);
4a71df50
FB		 1394 qeth_release_buffer(iob->channel, iob);
1395 atomic_set(&card->write.irq_pending, 0);
1396 wake_up(&card->wait_q);
1397 }
1398 return rc;
1399}
1400
1401static int qeth_osn_send_ipa_cmd(struct qeth_card *card,
1402 struct qeth_cmd_buffer *iob, int data_len)
1403{
1404 u16 s1, s2;
1405
847a50fd 1406 QETH_CARD_TEXT(card, 4, "osndipa");
4a71df50
FB		 1407
1408 qeth_prepare_ipa_cmd(card, iob, QETH_PROT_OSN2);
1409 s1 = (u16)(IPA_PDU_HEADER_SIZE + data_len);
1410 s2 = (u16)data_len;
1411 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2);
1412 memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2);
1413 memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2);
1414 memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2);
1415 return qeth_osn_send_control_data(card, s1, iob);
1416}
1417
1418int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
1419{
1420 struct qeth_cmd_buffer *iob;
1421 struct qeth_card *card;
1422 int rc;
1423
4a71df50
FB		 1424 if (!dev)
1425 return -ENODEV;
509e2562 1426 card = dev->ml_priv;
4a71df50
FB		 1427 if (!card)
1428 return -ENODEV;
847a50fd 1429 QETH_CARD_TEXT(card, 2, "osnsdmc");
c3521254 1430 if (!qeth_card_hw_is_reachable(card))
4a71df50
FB		 1431 return -ENODEV;
1432 iob = qeth_wait_for_buffer(&card->write);
1433 memcpy(iob->data+IPA_PDU_HEADER_SIZE, data, data_len);
1434 rc = qeth_osn_send_ipa_cmd(card, iob, data_len);
1435 return rc;
1436}
1437EXPORT_SYMBOL(qeth_osn_assist);
1438
1439int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
1440 int (*assist_cb)(struct net_device *, void *),
1441 int (*data_cb)(struct sk_buff *))
1442{
1443 struct qeth_card *card;
1444
4a71df50
FB		 1445 *dev = qeth_l2_netdev_by_devno(read_dev_no);
1446 if (*dev == NULL)
1447 return -ENODEV;
509e2562 1448 card = (*dev)->ml_priv;
4a71df50
FB		 1449 if (!card)
1450 return -ENODEV;
847a50fd 1451 QETH_CARD_TEXT(card, 2, "osnreg");
4a71df50
FB		 1452 if ((assist_cb == NULL) || (data_cb == NULL))
1453 return -EINVAL;
1454 card->osn_info.assist_cb = assist_cb;
1455 card->osn_info.data_cb = data_cb;
1456 return 0;
1457}
1458EXPORT_SYMBOL(qeth_osn_register);
1459
1460void qeth_osn_deregister(struct net_device *dev)
1461{
1462 struct qeth_card *card;
1463
4a71df50
FB		 1464 if (!dev)
1465 return;
509e2562 1466 card = dev->ml_priv;
4a71df50
FB		 1467 if (!card)
1468 return;
847a50fd 1469 QETH_CARD_TEXT(card, 2, "osndereg");
4a71df50
FB		 1470 card->osn_info.assist_cb = NULL;
1471 card->osn_info.data_cb = NULL;
1472 return;
1473}
1474EXPORT_SYMBOL(qeth_osn_deregister);
1475
b4d72c08
EC		 1476/* SETBRIDGEPORT support, async notifications */
1477
9f48b9db
EC		 1478enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
1479
1480/**
1481 * qeth_bridge_emit_host_event() - bridgeport address change notification
1482 * @card: qeth_card structure pointer, for udev events.
1483 * @evtype: "normal" register/unregister, or abort, or reset. For abort
1484 * and reset token and addr_lnid are unused and may be NULL.
1485 * @code: event bitmask: high order bit 0x80 value 1 means removal of an
1486 * object, 0 - addition of an object.
1487 * 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
1488 * @token: "network token" structure identifying physical address of the port.
1489 * @addr_lnid: pointer to structure with MAC address and VLAN ID.
1490 *
1491 * This function is called when registrations and deregistrations are
1492 * reported by the hardware, and also when notifications are enabled -
1493 * for all currently registered addresses.
1494 */
1495static void qeth_bridge_emit_host_event(struct qeth_card *card,
1496 enum qeth_an_event_type evtype,
1497 u8 code, struct net_if_token *token, struct mac_addr_lnid *addr_lnid)
1498{
1499 char str[7][32];
1500 char *env[8];
1501 int i = 0;
1502
1503 switch (evtype) {
1504 case anev_reg_unreg:
1505 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
1506 (code & IPA_ADDR_CHANGE_CODE_REMOVAL)
1507 ? "deregister" : "register");
1508 env[i] = str[i]; i++;
1509 if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
1510 snprintf(str[i], sizeof(str[i]), "VLAN=%d",
1511 addr_lnid->lnid);
1512 env[i] = str[i]; i++;
1513 }
1514 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
9846e70b 1515 snprintf(str[i], sizeof(str[i]), "MAC=%pM",
4d7def2a 1516 addr_lnid->mac);
9f48b9db
EC		 1517 env[i] = str[i]; i++;
1518 }
1519 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
1520 token->cssid, token->ssid, token->devnum);
1521 env[i] = str[i]; i++;
1522 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
1523 env[i] = str[i]; i++;
1524 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
1525 token->chpid);
1526 env[i] = str[i]; i++;
1527 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
1528 env[i] = str[i]; i++;
1529 break;
1530 case anev_abort:
1531 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
1532 env[i] = str[i]; i++;
1533 break;
1534 case anev_reset:
1535 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
1536 env[i] = str[i]; i++;
1537 break;
1538 }
1539 env[i] = NULL;
1540 kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1541}
1542
b4d72c08
EC		 1543struct qeth_bridge_state_data {
1544 struct work_struct worker;
1545 struct qeth_card *card;
1546 struct qeth_sbp_state_change qports;
1547};
1548
1549static void qeth_bridge_state_change_worker(struct work_struct *work)
1550{
1551 struct qeth_bridge_state_data *data =
1552 container_of(work, struct qeth_bridge_state_data, worker);
1553 /* We are only interested in the first entry - local port */
1554 struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
1555 char env_locrem[32];
1556 char env_role[32];
1557 char env_state[32];
1558 char *env[] = {
1559 env_locrem,
1560 env_role,
1561 env_state,
1562 NULL
1563 };
1564
1565 /* Role should not change by itself, but if it did, */
1566 /* information from the hardware is authoritative. */
1567 mutex_lock(&data->card->conf_mutex);
1568 data->card->options.sbp.role = entry->role;
1569 mutex_unlock(&data->card->conf_mutex);
1570
1571 snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
1572 snprintf(env_role, sizeof(env_role), "ROLE=%s",
1573 (entry->role == QETH_SBP_ROLE_NONE) ? "none" :
1574 (entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
1575 (entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
1576 "<INVALID>");
1577 snprintf(env_state, sizeof(env_state), "STATE=%s",
1578 (entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
1579 (entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
1580 (entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
1581 "<INVALID>");
1582 kobject_uevent_env(&data->card->gdev->dev.kobj,
1583 KOBJ_CHANGE, env);
1584 kfree(data);
1585}
1586
c044dc21
EC		 1587static void qeth_bridge_state_change(struct qeth_card *card,
1588 struct qeth_ipa_cmd *cmd)
b4d72c08
EC		 1589{
1590 struct qeth_sbp_state_change *qports =
1591 &cmd->data.sbp.data.state_change;
1592 struct qeth_bridge_state_data *data;
1593 int extrasize;
1594
1595 QETH_CARD_TEXT(card, 2, "brstchng");
1596 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
8a593148 1597 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
b4d72c08
EC		 1598 return;
1599 }
1600 extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
1601 data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
1602 GFP_ATOMIC);
1603 if (!data) {
1604 QETH_CARD_TEXT(card, 2, "BPSalloc");
1605 return;
1606 }
1607 INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
1608 data->card = card;
1609 memcpy(&data->qports, qports,
1610 sizeof(struct qeth_sbp_state_change) + extrasize);
1611 queue_work(qeth_wq, &data->worker);
1612}
b4d72c08 1613
9f48b9db
EC		 1614struct qeth_bridge_host_data {
1615 struct work_struct worker;
1616 struct qeth_card *card;
1617 struct qeth_ipacmd_addr_change hostevs;
1618};
1619
1620static void qeth_bridge_host_event_worker(struct work_struct *work)
1621{
1622 struct qeth_bridge_host_data *data =
1623 container_of(work, struct qeth_bridge_host_data, worker);
1624 int i;
1625
1626 if (data->hostevs.lost_event_mask) {
1627 dev_info(&data->card->gdev->dev,
9c23f4da 1628"Address notification from the Bridge Port stopped %s (%s)\n",
9f48b9db
EC		 1629 data->card->dev->name,
1630 (data->hostevs.lost_event_mask == 0x01)
1631 ? "Overflow"
1632 : (data->hostevs.lost_event_mask == 0x02)
1633 ? "Bridge port state change"
1634 : "Unknown reason");
1635 mutex_lock(&data->card->conf_mutex);
1636 data->card->options.sbp.hostnotification = 0;
1637 mutex_unlock(&data->card->conf_mutex);
1638 qeth_bridge_emit_host_event(data->card, anev_abort,
1639 0, NULL, NULL);
1640 } else
1641 for (i = 0; i < data->hostevs.num_entries; i++) {
1642 struct qeth_ipacmd_addr_change_entry *entry =
1643 &data->hostevs.entry[i];
1644 qeth_bridge_emit_host_event(data->card,
1645 anev_reg_unreg,
1646 entry->change_code,
1647 &entry->token, &entry->addr_lnid);
1648 }
1649 kfree(data);
1650}
1651
c044dc21
EC		 1652static void qeth_bridge_host_event(struct qeth_card *card,
1653 struct qeth_ipa_cmd *cmd)
9f48b9db
EC		 1654{
1655 struct qeth_ipacmd_addr_change *hostevs =
1656 &cmd->data.addrchange;
1657 struct qeth_bridge_host_data *data;
1658 int extrasize;
1659
1660 QETH_CARD_TEXT(card, 2, "brhostev");
1661 if (cmd->hdr.return_code != 0x0000) {
1662 if (cmd->hdr.return_code == 0x0010) {
1663 if (hostevs->lost_event_mask == 0x00)
1664 hostevs->lost_event_mask = 0xff;
1665 } else {
1666 QETH_CARD_TEXT_(card, 2, "BPHe%04x",
1667 cmd->hdr.return_code);
1668 return;
1669 }
1670 }
1671 extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
1672 hostevs->num_entries;
1673 data = kzalloc(sizeof(struct qeth_bridge_host_data) + extrasize,
1674 GFP_ATOMIC);
1675 if (!data) {
1676 QETH_CARD_TEXT(card, 2, "BPHalloc");
1677 return;
1678 }
1679 INIT_WORK(&data->worker, qeth_bridge_host_event_worker);
1680 data->card = card;
1681 memcpy(&data->hostevs, hostevs,
1682 sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1683 queue_work(qeth_wq, &data->worker);
1684}
9f48b9db 1685
b4d72c08
EC		 1686/* SETBRIDGEPORT support; sending commands */
1687
1688struct _qeth_sbp_cbctl {
1689 u16 ipa_rc;
1690 u16 cmd_rc;
1691 union {
1692 u32 supported;
1693 struct {
1694 enum qeth_sbp_roles *role;
1695 enum qeth_sbp_states *state;
1696 } qports;
1697 } data;
1698};
1699
1700/**
1701 * qeth_bridgeport_makerc() - derive "traditional" error from hardware codes.
1702 * @card: qeth_card structure pointer, for debug messages.
1703 * @cbctl: state structure with hardware return codes.
1704 * @setcmd: IPA command code
1705 *
1706 * Returns negative errno-compatible error indication or 0 on success.
1707 */
1708static int qeth_bridgeport_makerc(struct qeth_card *card,
1709 struct _qeth_sbp_cbctl *cbctl, enum qeth_ipa_sbp_cmd setcmd)
1710{
1711 int rc;
9c23f4da 1712 int is_iqd = (card->info.type == QETH_CARD_TYPE_IQD);
b4d72c08 1713
9c23f4da
EC		 1714 if ((is_iqd && (cbctl->ipa_rc == IPA_RC_SUCCESS)) ||
1715 (!is_iqd && (cbctl->ipa_rc == cbctl->cmd_rc)))
b4d72c08 1716 switch (cbctl->cmd_rc) {
2063a5f5 1717 case IPA_RC_SUCCESS:
b4d72c08
EC		 1718 rc = 0;
1719 break;
2063a5f5
KM		 1720 case IPA_RC_L2_UNSUPPORTED_CMD:
1721 case IPA_RC_UNSUPPORTED_COMMAND:
ffb95251 1722 rc = -EOPNOTSUPP;
b4d72c08 1723 break;
2063a5f5
KM		 1724 case IPA_RC_SBP_OSA_NOT_CONFIGURED:
1725 case IPA_RC_SBP_IQD_NOT_CONFIGURED:
b4d72c08
EC		 1726 rc = -ENODEV; /* maybe not the best code here? */
1727 dev_err(&card->gdev->dev,
9c23f4da 1728 "The device is not configured as a Bridge Port\n");
b4d72c08 1729 break;
2063a5f5
KM		 1730 case IPA_RC_SBP_OSA_OS_MISMATCH:
1731 case IPA_RC_SBP_IQD_OS_MISMATCH:
1b05cf62
EC		 1732 rc = -EPERM;
1733 dev_err(&card->gdev->dev,
1734 "A Bridge Port is already configured by a different operating system\n");
1735 break;
2063a5f5
KM		 1736 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
1737 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
b4d72c08
EC		 1738 switch (setcmd) {
1739 case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
1740 rc = -EEXIST;
1741 dev_err(&card->gdev->dev,
9c23f4da 1742 "The LAN already has a primary Bridge Port\n");
b4d72c08
EC		 1743 break;
1744 case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
1745 rc = -EBUSY;
1746 dev_err(&card->gdev->dev,
9c23f4da 1747 "The device is already a primary Bridge Port\n");
b4d72c08
EC		 1748 break;
1749 default:
1750 rc = -EIO;
1751 }
1752 break;
2063a5f5
KM		 1753 case IPA_RC_SBP_OSA_CURRENT_SECOND:
1754 case IPA_RC_SBP_IQD_CURRENT_SECOND:
b4d72c08
EC		 1755 rc = -EBUSY;
1756 dev_err(&card->gdev->dev,
9c23f4da 1757 "The device is already a secondary Bridge Port\n");
b4d72c08 1758 break;
2063a5f5
KM		 1759 case IPA_RC_SBP_OSA_LIMIT_SECOND:
1760 case IPA_RC_SBP_IQD_LIMIT_SECOND:
b4d72c08
EC		 1761 rc = -EEXIST;
1762 dev_err(&card->gdev->dev,
9c23f4da 1763 "The LAN cannot have more secondary Bridge Ports\n");
b4d72c08 1764 break;
2063a5f5
KM		 1765 case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
1766 case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
b4d72c08
EC		 1767 rc = -EBUSY;
1768 dev_err(&card->gdev->dev,
9c23f4da 1769 "The device is already a primary Bridge Port\n");
b4d72c08 1770 break;
2063a5f5
KM		 1771 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
1772 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
b4d72c08
EC		 1773 rc = -EACCES;
1774 dev_err(&card->gdev->dev,
9c23f4da 1775 "The device is not authorized to be a Bridge Port\n");
b4d72c08
EC		 1776 break;
1777 default:
1778 rc = -EIO;
1779 }
9c23f4da
EC		 1780 else
1781 switch (cbctl->ipa_rc) {
1782 case IPA_RC_NOTSUPP:
ffb95251 1783 rc = -EOPNOTSUPP;
9c23f4da
EC		 1784 break;
1785 case IPA_RC_UNSUPPORTED_COMMAND:
ffb95251 1786 rc = -EOPNOTSUPP;
9c23f4da
EC		 1787 break;
1788 default:
1789 rc = -EIO;
1790 }
1791
b4d72c08
EC		 1792 if (rc) {
1793 QETH_CARD_TEXT_(card, 2, "SBPi%04x", cbctl->ipa_rc);
1794 QETH_CARD_TEXT_(card, 2, "SBPc%04x", cbctl->cmd_rc);
1795 }
1796 return rc;
1797}
1798
d65626ad
JW		 1799static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1800 enum qeth_ipa_sbp_cmd sbp_cmd,
1801 unsigned int cmd_length)
9c23f4da 1802{
d65626ad
JW		 1803 enum qeth_ipa_cmds ipa_cmd = (card->info.type == QETH_CARD_TYPE_IQD) ?
1804 IPA_CMD_SETBRIDGEPORT_IQD :
1805 IPA_CMD_SETBRIDGEPORT_OSA;
1806 struct qeth_cmd_buffer *iob;
1807 struct qeth_ipa_cmd *cmd;
1808
1809 iob = qeth_get_ipacmd_buffer(card, ipa_cmd, 0);
1810 if (!iob)
1811 return iob;
1812 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1813 cmd->data.sbp.hdr.cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) +
1814 cmd_length;
1815 cmd->data.sbp.hdr.command_code = sbp_cmd;
1816 cmd->data.sbp.hdr.used_total = 1;
1817 cmd->data.sbp.hdr.seq_no = 1;
1818 return iob;
9c23f4da
EC		 1819}
1820
b4d72c08
EC		 1821static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1822 struct qeth_reply *reply, unsigned long data)
1823{
1824 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1825 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1826 QETH_CARD_TEXT(card, 2, "brqsupcb");
1827 cbctl->ipa_rc = cmd->hdr.return_code;
1828 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1829 if ((cbctl->ipa_rc == 0) && (cbctl->cmd_rc == 0)) {
1830 cbctl->data.supported =
1831 cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1832 } else {
1833 cbctl->data.supported = 0;
1834 }
1835 return 0;
1836}
1837
1838/**
1839 * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
1840 * @card: qeth_card structure pointer.
1841 *
1842 * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
1843 * strucutre: card->options.sbp.supported_funcs.
1844 */
c044dc21 1845static void qeth_bridgeport_query_support(struct qeth_card *card)
b4d72c08
EC		 1846{
1847 struct qeth_cmd_buffer *iob;
b4d72c08
EC		 1848 struct _qeth_sbp_cbctl cbctl;
1849
1850 QETH_CARD_TEXT(card, 2, "brqsuppo");
d65626ad
JW		 1851 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1852 sizeof(struct qeth_sbp_query_cmds_supp));
1aec42bc
TR		 1853 if (!iob)
1854 return;
b4d72c08
EC		 1855 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1856 (void *)&cbctl) ||
1857 qeth_bridgeport_makerc(card, &cbctl,
1858 IPA_SBP_QUERY_COMMANDS_SUPPORTED)) {
1859 /* non-zero makerc signifies failure, and produce messages */
1860 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1861 return;
1862 }
1863 card->options.sbp.supported_funcs = cbctl.data.supported;
1864}
b4d72c08
EC		 1865
1866static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1867 struct qeth_reply *reply, unsigned long data)
1868{
1869 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1870 struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
1871 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1872
1873 QETH_CARD_TEXT(card, 2, "brqprtcb");
1874 cbctl->ipa_rc = cmd->hdr.return_code;
1875 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1876 if ((cbctl->ipa_rc != 0) || (cbctl->cmd_rc != 0))
1877 return 0;
1878 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1879 cbctl->cmd_rc = 0xffff;
1880 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1881 return 0;
1882 }
1883 /* first entry contains the state of the local port */
1884 if (qports->num_entries > 0) {
1885 if (cbctl->data.qports.role)
1886 *cbctl->data.qports.role = qports->entry[0].role;
1887 if (cbctl->data.qports.state)
1888 *cbctl->data.qports.state = qports->entry[0].state;
1889 }
1890 return 0;
1891}
1892
1893/**
1894 * qeth_bridgeport_query_ports() - query local bridgeport status.
1895 * @card: qeth_card structure pointer.
1896 * @role: Role of the port: 0-none, 1-primary, 2-secondary.
1897 * @state: State of the port: 0-inactive, 1-standby, 2-active.
1898 *
1899 * Returns negative errno-compatible error indication or 0 on success.
1900 *
1901 * 'role' and 'state' are not updated in case of hardware operation failure.
1902 */
1903int qeth_bridgeport_query_ports(struct qeth_card *card,
1904 enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
1905{
1906 int rc = 0;
1907 struct qeth_cmd_buffer *iob;
b4d72c08
EC		 1908 struct _qeth_sbp_cbctl cbctl = {
1909 .data = {
1910 .qports = {
1911 .role = role,
1912 .state = state,
1913 },
1914 },
1915 };
1916
1917 QETH_CARD_TEXT(card, 2, "brqports");
1918 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1919 return -EOPNOTSUPP;
d65626ad 1920 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1aec42bc
TR		 1921 if (!iob)
1922 return -ENOMEM;
b4d72c08
EC		 1923 rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1924 (void *)&cbctl);
c88394e7 1925 if (rc < 0)
b4d72c08 1926 return rc;
c88394e7 1927 return qeth_bridgeport_makerc(card, &cbctl, IPA_SBP_QUERY_BRIDGE_PORTS);
b4d72c08
EC		 1928}
1929EXPORT_SYMBOL_GPL(qeth_bridgeport_query_ports);
1930
1931static int qeth_bridgeport_set_cb(struct qeth_card *card,
1932 struct qeth_reply *reply, unsigned long data)
1933{
1934 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1935 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1936 QETH_CARD_TEXT(card, 2, "brsetrcb");
1937 cbctl->ipa_rc = cmd->hdr.return_code;
1938 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1939 return 0;
1940}
1941
1942/**
1943 * qeth_bridgeport_setrole() - Assign primary role to the port.
1944 * @card: qeth_card structure pointer.
1945 * @role: Role to assign.
1946 *
1947 * Returns negative errno-compatible error indication or 0 on success.
1948 */
1949int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1950{
1951 int rc = 0;
1952 int cmdlength;
1953 struct qeth_cmd_buffer *iob;
b4d72c08
EC		 1954 struct _qeth_sbp_cbctl cbctl;
1955 enum qeth_ipa_sbp_cmd setcmd;
1956
1957 QETH_CARD_TEXT(card, 2, "brsetrol");
1958 switch (role) {
1959 case QETH_SBP_ROLE_NONE:
1960 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
d65626ad 1961 cmdlength = sizeof(struct qeth_sbp_reset_role);
b4d72c08
EC		 1962 break;
1963 case QETH_SBP_ROLE_PRIMARY:
1964 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
d65626ad 1965 cmdlength = sizeof(struct qeth_sbp_set_primary);
b4d72c08
EC		 1966 break;
1967 case QETH_SBP_ROLE_SECONDARY:
1968 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
d65626ad 1969 cmdlength = sizeof(struct qeth_sbp_set_secondary);
b4d72c08
EC		 1970 break;
1971 default:
1972 return -EINVAL;
1973 }
1974 if (!(card->options.sbp.supported_funcs & setcmd))
1975 return -EOPNOTSUPP;
d65626ad 1976 iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1aec42bc
TR		 1977 if (!iob)
1978 return -ENOMEM;
b4d72c08
EC		 1979 rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb,
1980 (void *)&cbctl);
c88394e7 1981 if (rc < 0)
b4d72c08 1982 return rc;
c88394e7 1983 return qeth_bridgeport_makerc(card, &cbctl, setcmd);
b4d72c08
EC		 1984}
1985
9f48b9db
EC		 1986/**
1987 * qeth_anset_makerc() - derive "traditional" error from hardware codes.
1988 * @card: qeth_card structure pointer, for debug messages.
1989 *
1990 * Returns negative errno-compatible error indication or 0 on success.
1991 */
1992static int qeth_anset_makerc(struct qeth_card *card, int pnso_rc, u16 response)
1993{
1994 int rc;
1995
1996 if (pnso_rc == 0)
1997 switch (response) {
1998 case 0x0001:
1999 rc = 0;
2000 break;
2001 case 0x0004:
2002 case 0x0100:
2003 case 0x0106:
ffb95251 2004 rc = -EOPNOTSUPP;
9f48b9db
EC		 2005 dev_err(&card->gdev->dev,
2006 "Setting address notification failed\n");
2007 break;
2008 case 0x0107:
2009 rc = -EAGAIN;
2010 break;
2011 default:
2012 rc = -EIO;
2013 }
2014 else
2015 rc = -EIO;
2016
2017 if (rc) {
2018 QETH_CARD_TEXT_(card, 2, "SBPp%04x", pnso_rc);
2019 QETH_CARD_TEXT_(card, 2, "SBPr%04x", response);
2020 }
2021 return rc;
2022}
2023
2024static void qeth_bridgeport_an_set_cb(void *priv,
2025 enum qdio_brinfo_entry_type type, void *entry)
2026{
2027 struct qeth_card *card = (struct qeth_card *)priv;
2028 struct qdio_brinfo_entry_l2 *l2entry;
2029 u8 code;
2030
2031 if (type != l2_addr_lnid) {
2032 WARN_ON_ONCE(1);
2033 return;
2034 }
2035
2036 l2entry = (struct qdio_brinfo_entry_l2 *)entry;
2037 code = IPA_ADDR_CHANGE_CODE_MACADDR;
2038 if (l2entry->addr_lnid.lnid)
2039 code |= IPA_ADDR_CHANGE_CODE_VLANID;
2040 qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
2041 (struct net_if_token *)&l2entry->nit,
2042 (struct mac_addr_lnid *)&l2entry->addr_lnid);
2043}
2044
2045/**
2046 * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
2047 * @card: qeth_card structure pointer.
2048 * @enable: 0 - disable, non-zero - enable notifications
2049 *
2050 * Returns negative errno-compatible error indication or 0 on success.
2051 *
2052 * On enable, emits a series of address notifications udev events for all
2053 * currently registered hosts.
2054 */
2055int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
2056{
2057 int rc;
2058 u16 response;
2059 struct ccw_device *ddev;
2060 struct subchannel_id schid;
2061
2062 if (!card)
2063 return -EINVAL;
2064 if (!card->options.sbp.supported_funcs)
2065 return -EOPNOTSUPP;
2066 ddev = CARD_DDEV(card);
2067 ccw_device_get_schid(ddev, &schid);
2068
2069 if (enable) {
2070 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
2071 rc = qdio_pnso_brinfo(schid, 1, &response,
2072 qeth_bridgeport_an_set_cb, card);
2073 } else
2074 rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL);
2075 return qeth_anset_makerc(card, rc, response);
2076}
2077EXPORT_SYMBOL_GPL(qeth_bridgeport_an_set);
2078
caa1f0b1
HW		 2079static bool qeth_bridgeport_is_in_use(struct qeth_card *card)
2080{
2081 return (card->options.sbp.role || card->options.sbp.reflect_promisc ||
2082 card->options.sbp.hostnotification);
2083}
2084
a45b3faf
HW		 2085/* VNIC Characteristics support */
2086
2087/* handle VNICC IPA command return codes; convert to error codes */
2088static int qeth_l2_vnicc_makerc(struct qeth_card *card, int ipa_rc)
2089{
2090 int rc;
2091
2092 switch (ipa_rc) {
2093 case IPA_RC_SUCCESS:
2094 return ipa_rc;
2095 case IPA_RC_L2_UNSUPPORTED_CMD:
2096 case IPA_RC_NOTSUPP:
2097 rc = -EOPNOTSUPP;
2098 break;
2099 case IPA_RC_VNICC_OOSEQ:
2100 rc = -EALREADY;
2101 break;
2102 case IPA_RC_VNICC_VNICBP:
2103 rc = -EBUSY;
2104 break;
2105 case IPA_RC_L2_ADDR_TABLE_FULL:
2106 rc = -ENOSPC;
2107 break;
2108 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
2109 rc = -EACCES;
2110 break;
2111 default:
2112 rc = -EIO;
2113 }
2114
2115 QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
2116 return rc;
2117}
2118
2119/* generic VNICC request call back control */
2120struct _qeth_l2_vnicc_request_cbctl {
2121 u32 sub_cmd;
caa1f0b1
HW		 2122 struct {
2123 u32 vnic_char;
349d13d5 2124 u32 timeout;
caa1f0b1
HW		 2125 } param;
2126 struct {
349d13d5
HW		 2127 union{
2128 u32 *sup_cmds;
2129 u32 *timeout;
2130 };
caa1f0b1 2131 } result;
a45b3faf
HW		 2132};
2133
2134/* generic VNICC request call back */
2135static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
2136 struct qeth_reply *reply,
2137 unsigned long data)
2138{
caa1f0b1
HW		 2139 struct _qeth_l2_vnicc_request_cbctl *cbctl =
2140 (struct _qeth_l2_vnicc_request_cbctl *) reply->param;
a45b3faf
HW		 2141 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
2142 struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;
2143
2144 QETH_CARD_TEXT(card, 2, "vniccrcb");
2145 if (cmd->hdr.return_code)
2146 return 0;
2147 /* return results to caller */
2148 card->options.vnicc.sup_chars = rep->hdr.sup;
2149 card->options.vnicc.cur_chars = rep->hdr.cur;
2150
caa1f0b1
HW		 2151 if (cbctl->sub_cmd == IPA_VNICC_QUERY_CMDS)
2152 *cbctl->result.sup_cmds = rep->query_cmds.sup_cmds;
2153
349d13d5
HW		 2154 if (cbctl->sub_cmd == IPA_VNICC_GET_TIMEOUT)
2155 *cbctl->result.timeout = rep->getset_timeout.timeout;
2156
a45b3faf
HW		 2157 return 0;
2158}
2159
2160/* generic VNICC request */
2161static int qeth_l2_vnicc_request(struct qeth_card *card,
2162 struct _qeth_l2_vnicc_request_cbctl *cbctl)
2163{
2164 struct qeth_ipacmd_vnicc *req;
2165 struct qeth_cmd_buffer *iob;
2166 struct qeth_ipa_cmd *cmd;
2167 int rc;
2168
2169 QETH_CARD_TEXT(card, 2, "vniccreq");
2170
2171 /* get new buffer for request */
2172 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_VNICC, 0);
2173 if (!iob)
2174 return -ENOMEM;
2175
2176 /* create header for request */
2177 cmd = (struct qeth_ipa_cmd *)(iob->data + IPA_PDU_HEADER_SIZE);
2178 req = &cmd->data.vnicc;
2179
2180 /* create sub command header for request */
2181 req->sub_hdr.data_length = sizeof(req->sub_hdr);
2182 req->sub_hdr.sub_command = cbctl->sub_cmd;
2183
2184 /* create sub command specific request fields */
2185 switch (cbctl->sub_cmd) {
2186 case IPA_VNICC_QUERY_CHARS:
2187 break;
caa1f0b1
HW		 2188 case IPA_VNICC_QUERY_CMDS:
2189 req->sub_hdr.data_length += sizeof(req->query_cmds);
2190 req->query_cmds.vnic_char = cbctl->param.vnic_char;
2191 break;
2192 case IPA_VNICC_ENABLE:
2193 case IPA_VNICC_DISABLE:
2194 req->sub_hdr.data_length += sizeof(req->set_char);
2195 req->set_char.vnic_char = cbctl->param.vnic_char;
2196 break;
349d13d5
HW		 2197 case IPA_VNICC_SET_TIMEOUT:
2198 req->getset_timeout.timeout = cbctl->param.timeout;
2199 /* fallthrough */
2200 case IPA_VNICC_GET_TIMEOUT:
2201 req->sub_hdr.data_length += sizeof(req->getset_timeout);
2202 req->getset_timeout.vnic_char = cbctl->param.vnic_char;
2203 break;
a45b3faf
HW		 2204 default:
2205 qeth_release_buffer(iob->channel, iob);
2206 return -EOPNOTSUPP;
2207 }
2208
2209 /* send request */
2210 rc = qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb,
2211 (void *) cbctl);
2212
2213 return qeth_l2_vnicc_makerc(card, rc);
2214}
2215
2216/* VNICC query VNIC characteristics request */
2217static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
2218{
2219 struct _qeth_l2_vnicc_request_cbctl cbctl;
2220
2221 /* prepare callback control */
2222 cbctl.sub_cmd = IPA_VNICC_QUERY_CHARS;
2223
2224 QETH_CARD_TEXT(card, 2, "vniccqch");
2225 return qeth_l2_vnicc_request(card, &cbctl);
2226}
2227
caa1f0b1
HW		 2228/* VNICC query sub commands request */
2229static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
2230 u32 *sup_cmds)
2231{
2232 struct _qeth_l2_vnicc_request_cbctl cbctl;
2233
2234 /* prepare callback control */
2235 cbctl.sub_cmd = IPA_VNICC_QUERY_CMDS;
2236 cbctl.param.vnic_char = vnic_char;
2237 cbctl.result.sup_cmds = sup_cmds;
2238
2239 QETH_CARD_TEXT(card, 2, "vniccqcm");
2240 return qeth_l2_vnicc_request(card, &cbctl);
2241}
2242
2243/* VNICC enable/disable characteristic request */
2244static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
2245 u32 cmd)
2246{
2247 struct _qeth_l2_vnicc_request_cbctl cbctl;
2248
2249 /* prepare callback control */
2250 cbctl.sub_cmd = cmd;
2251 cbctl.param.vnic_char = vnic_char;
2252
2253 QETH_CARD_TEXT(card, 2, "vniccedc");
2254 return qeth_l2_vnicc_request(card, &cbctl);
2255}
2256
349d13d5
HW		 2257/* VNICC get/set timeout for characteristic request */
2258static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
2259 u32 cmd, u32 *timeout)
2260{
2261 struct _qeth_l2_vnicc_request_cbctl cbctl;
2262
2263 /* prepare callback control */
2264 cbctl.sub_cmd = cmd;
2265 cbctl.param.vnic_char = vnicc;
2266 if (cmd == IPA_VNICC_SET_TIMEOUT)
2267 cbctl.param.timeout = *timeout;
2268 if (cmd == IPA_VNICC_GET_TIMEOUT)
2269 cbctl.result.timeout = timeout;
2270
2271 QETH_CARD_TEXT(card, 2, "vniccgst");
2272 return qeth_l2_vnicc_request(card, &cbctl);
2273}
2274
caa1f0b1
HW		 2275/* set current VNICC flag state; called from sysfs store function */
2276int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
2277{
2278 int rc = 0;
2279 u32 cmd;
2280
2281 QETH_CARD_TEXT(card, 2, "vniccsch");
2282
2283 /* do not change anything if BridgePort is enabled */
2284 if (qeth_bridgeport_is_in_use(card))
2285 return -EBUSY;
2286
2287 /* check if characteristic and enable/disable are supported */
2288 if (!(card->options.vnicc.sup_chars & vnicc) ||
2289 !(card->options.vnicc.set_char_sup & vnicc))
2290 return -EOPNOTSUPP;
2291
2292 /* set enable/disable command and store wanted characteristic */
2293 if (state) {
2294 cmd = IPA_VNICC_ENABLE;
2295 card->options.vnicc.wanted_chars |= vnicc;
2296 } else {
2297 cmd = IPA_VNICC_DISABLE;
2298 card->options.vnicc.wanted_chars &= ~vnicc;
2299 }
2300
2301 /* do we need to do anything? */
2302 if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
2303 return rc;
2304
2305 /* if card is not ready, simply stop here */
2306 if (!qeth_card_hw_is_reachable(card)) {
2307 if (state)
2308 card->options.vnicc.cur_chars |= vnicc;
2309 else
2310 card->options.vnicc.cur_chars &= ~vnicc;
2311 return rc;
2312 }
2313
2314 rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
2315 if (rc)
2316 card->options.vnicc.wanted_chars =
2317 card->options.vnicc.cur_chars;
349d13d5
HW		 2318 else {
2319 /* successful online VNICC change; handle special cases */
2320 if (state && vnicc == QETH_VNICC_RX_BCAST)
2321 card->options.vnicc.rx_bcast_enabled = true;
2322 if (!state && vnicc == QETH_VNICC_LEARNING)
2323 qeth_l2_vnicc_recover_timeout(card, vnicc,
2324 &card->options.vnicc.learning_timeout);
2325 }
caa1f0b1
HW		 2326
2327 return rc;
2328}
2329
2330/* get current VNICC flag state; called from sysfs show function */
2331int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
2332{
2333 int rc = 0;
2334
2335 QETH_CARD_TEXT(card, 2, "vniccgch");
2336
2337 /* do not get anything if BridgePort is enabled */
2338 if (qeth_bridgeport_is_in_use(card))
2339 return -EBUSY;
2340
2341 /* check if characteristic is supported */
2342 if (!(card->options.vnicc.sup_chars & vnicc))
2343 return -EOPNOTSUPP;
2344
2345 /* if card is ready, query current VNICC state */
2346 if (qeth_card_hw_is_reachable(card))
2347 rc = qeth_l2_vnicc_query_chars(card);
2348
2349 *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
2350 return rc;
2351}
2352
349d13d5
HW		 2353/* set VNICC timeout; called from sysfs store function. Currently, only learning
2354 * supports timeout
2355 */
2356int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
2357{
2358 int rc = 0;
2359
2360 QETH_CARD_TEXT(card, 2, "vniccsto");
2361
2362 /* do not change anything if BridgePort is enabled */
2363 if (qeth_bridgeport_is_in_use(card))
2364 return -EBUSY;
2365
2366 /* check if characteristic and set_timeout are supported */
2367 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2368 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2369 return -EOPNOTSUPP;
2370
2371 /* do we need to do anything? */
2372 if (card->options.vnicc.learning_timeout == timeout)
2373 return rc;
2374
2375 /* if card is not ready, simply store the value internally and return */
2376 if (!qeth_card_hw_is_reachable(card)) {
2377 card->options.vnicc.learning_timeout = timeout;
2378 return rc;
2379 }
2380
2381 /* send timeout value to card; if successful, store value internally */
2382 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2383 IPA_VNICC_SET_TIMEOUT, &timeout);
2384 if (!rc)
2385 card->options.vnicc.learning_timeout = timeout;
2386
2387 return rc;
2388}
2389
2390/* get current VNICC timeout; called from sysfs show function. Currently, only
2391 * learning supports timeout
2392 */
2393int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
2394{
2395 int rc = 0;
2396
2397 QETH_CARD_TEXT(card, 2, "vniccgto");
2398
2399 /* do not get anything if BridgePort is enabled */
2400 if (qeth_bridgeport_is_in_use(card))
2401 return -EBUSY;
2402
2403 /* check if characteristic and get_timeout are supported */
2404 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2405 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2406 return -EOPNOTSUPP;
2407 /* if card is ready, get timeout. Otherwise, just return stored value */
2408 *timeout = card->options.vnicc.learning_timeout;
2409 if (qeth_card_hw_is_reachable(card))
2410 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2411 IPA_VNICC_GET_TIMEOUT,
2412 timeout);
2413
2414 return rc;
2415}
2416
caa1f0b1
HW		 2417/* check if VNICC is currently enabled */
2418bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
2419{
2420 /* if everything is turned off, VNICC is not active */
2421 if (!card->options.vnicc.cur_chars)
2422 return false;
2423 /* default values are only OK if rx_bcast was not enabled by user
2424 * or the card is offline.
2425 */
2426 if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
2427 if (!card->options.vnicc.rx_bcast_enabled ||
2428 !qeth_card_hw_is_reachable(card))
2429 return false;
2430 }
2431 return true;
2432}
2433
349d13d5
HW		 2434/* recover user timeout setting */
2435static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
2436 u32 *timeout)
2437{
2438 if (card->options.vnicc.sup_chars & vnicc &&
2439 card->options.vnicc.getset_timeout_sup & vnicc &&
2440 !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
2441 timeout))
2442 return false;
2443 *timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2444 return true;
2445}
2446
caa1f0b1
HW		 2447/* recover user characteristic setting */
2448static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
2449 bool enable)
2450{
2451 u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;
2452
2453 if (card->options.vnicc.sup_chars & vnicc &&
2454 card->options.vnicc.set_char_sup & vnicc &&
2455 !qeth_l2_vnicc_set_char(card, vnicc, cmd))
2456 return false;
2457 card->options.vnicc.wanted_chars &= ~vnicc;
2458 card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
2459 return true;
2460}
2461
a45b3faf
HW		 2462/* (re-)initialize VNICC */
2463static void qeth_l2_vnicc_init(struct qeth_card *card)
2464{
349d13d5 2465 u32 *timeout = &card->options.vnicc.learning_timeout;
caa1f0b1
HW		 2466 unsigned int chars_len, i;
2467 unsigned long chars_tmp;
2468 u32 sup_cmds, vnicc;
2469 bool enable, error;
2470
a45b3faf 2471 QETH_CARD_TEXT(card, 2, "vniccini");
caa1f0b1
HW		 2472 /* reset rx_bcast */
2473 card->options.vnicc.rx_bcast_enabled = 0;
a45b3faf
HW		 2474 /* initial query and storage of VNIC characteristics */
2475 if (qeth_l2_vnicc_query_chars(card)) {
349d13d5
HW		 2476 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
2477 *timeout != QETH_VNICC_DEFAULT_TIMEOUT)
caa1f0b1
HW		 2478 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2479 /* fail quietly if user didn't change the default config */
a45b3faf
HW		 2480 card->options.vnicc.sup_chars = 0;
2481 card->options.vnicc.cur_chars = 0;
caa1f0b1
HW		 2482 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2483 return;
a45b3faf 2484 }
caa1f0b1
HW		 2485 /* get supported commands for each supported characteristic */
2486 chars_tmp = card->options.vnicc.sup_chars;
2487 chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
2488 for_each_set_bit(i, &chars_tmp, chars_len) {
2489 vnicc = BIT(i);
2490 qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds);
349d13d5
HW		 2491 if (!(sup_cmds & IPA_VNICC_SET_TIMEOUT) ||
2492 !(sup_cmds & IPA_VNICC_GET_TIMEOUT))
2493 card->options.vnicc.getset_timeout_sup &= ~vnicc;
caa1f0b1
HW		 2494 if (!(sup_cmds & IPA_VNICC_ENABLE) ||
2495 !(sup_cmds & IPA_VNICC_DISABLE))
2496 card->options.vnicc.set_char_sup &= ~vnicc;
2497 }
2498 /* enforce assumed default values and recover settings, if changed */
349d13d5
HW		 2499 error = qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
2500 timeout);
caa1f0b1
HW		 2501 chars_tmp = card->options.vnicc.wanted_chars ^ QETH_VNICC_DEFAULT;
2502 chars_tmp |= QETH_VNICC_BRIDGE_INVISIBLE;
2503 chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
2504 for_each_set_bit(i, &chars_tmp, chars_len) {
2505 vnicc = BIT(i);
2506 enable = card->options.vnicc.wanted_chars & vnicc;
2507 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
2508 }
2509 if (error)
2510 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2511}
2512
2513/* configure default values of VNIC characteristics */
2514static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
2515{
2516 /* characteristics values */
2517 card->options.vnicc.sup_chars = QETH_VNICC_ALL;
2518 card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
349d13d5 2519 card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
caa1f0b1
HW		 2520 /* supported commands */
2521 card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
349d13d5 2522 card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
caa1f0b1
HW		 2523 /* settings wanted by users */
2524 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
a45b3faf
HW		 2525}
2526
4a71df50
FB		 2527module_init(qeth_l2_init);
2528module_exit(qeth_l2_exit);
2529MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2530MODULE_DESCRIPTION("qeth layer 2 discipline");
2531MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)