]> Git Repo - linux.git/blob - drivers/s390/net/qeth_l2_main.c
nfsd4: a client's own opens needn't prevent delegations
[linux.git] / drivers / s390 / net / qeth_l2_main.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *    Copyright IBM Corp. 2007, 2009
4  *    Author(s): Utz Bacher <[email protected]>,
5  *               Frank Pavlic <[email protected]>,
6  *               Thomas Spatzier <[email protected]>,
7  *               Frank Blaschka <[email protected]>
8  */
9
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
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/list.h>
21 #include <linux/hash.h>
22 #include <linux/hashtable.h>
23 #include <asm/chsc.h>
24 #include <asm/setup.h>
25 #include "qeth_core.h"
26 #include "qeth_l2.h"
27
28 static void qeth_bridgeport_query_support(struct qeth_card *card);
29 static void qeth_bridge_state_change(struct qeth_card *card,
30                                         struct qeth_ipa_cmd *cmd);
31 static void qeth_addr_change_event(struct qeth_card *card,
32                                    struct qeth_ipa_cmd *cmd);
33 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card);
34 static void qeth_l2_vnicc_init(struct qeth_card *card);
35 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
36                                           u32 *timeout);
37
38 static int qeth_l2_setdelmac_makerc(struct qeth_card *card, u16 retcode)
39 {
40         int rc;
41
42         if (retcode)
43                 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
44         switch (retcode) {
45         case IPA_RC_SUCCESS:
46                 rc = 0;
47                 break;
48         case IPA_RC_L2_UNSUPPORTED_CMD:
49                 rc = -EOPNOTSUPP;
50                 break;
51         case IPA_RC_L2_ADDR_TABLE_FULL:
52                 rc = -ENOSPC;
53                 break;
54         case IPA_RC_L2_DUP_MAC:
55         case IPA_RC_L2_DUP_LAYER3_MAC:
56                 rc = -EADDRINUSE;
57                 break;
58         case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
59         case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
60                 rc = -EADDRNOTAVAIL;
61                 break;
62         case IPA_RC_L2_MAC_NOT_FOUND:
63                 rc = -ENOENT;
64                 break;
65         default:
66                 rc = -EIO;
67                 break;
68         }
69         return rc;
70 }
71
72 static int qeth_l2_send_setdelmac_cb(struct qeth_card *card,
73                                      struct qeth_reply *reply,
74                                      unsigned long data)
75 {
76         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
77
78         return qeth_l2_setdelmac_makerc(card, cmd->hdr.return_code);
79 }
80
81 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
82                            enum qeth_ipa_cmds ipacmd)
83 {
84         struct qeth_ipa_cmd *cmd;
85         struct qeth_cmd_buffer *iob;
86
87         QETH_CARD_TEXT(card, 2, "L2sdmac");
88         iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
89                                  IPA_DATA_SIZEOF(setdelmac));
90         if (!iob)
91                 return -ENOMEM;
92         cmd = __ipa_cmd(iob);
93         cmd->data.setdelmac.mac_length = ETH_ALEN;
94         ether_addr_copy(cmd->data.setdelmac.mac, mac);
95         return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelmac_cb, NULL);
96 }
97
98 static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
99 {
100         int rc;
101
102         QETH_CARD_TEXT(card, 2, "L2Setmac");
103         rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
104         if (rc == 0) {
105                 dev_info(&card->gdev->dev,
106                          "MAC address %pM successfully registered\n", mac);
107         } else {
108                 switch (rc) {
109                 case -EADDRINUSE:
110                         dev_warn(&card->gdev->dev,
111                                 "MAC address %pM already exists\n", mac);
112                         break;
113                 case -EADDRNOTAVAIL:
114                         dev_warn(&card->gdev->dev,
115                                 "MAC address %pM is not authorized\n", mac);
116                         break;
117                 }
118         }
119         return rc;
120 }
121
122 static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac)
123 {
124         enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
125                                         IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;
126         int rc;
127
128         QETH_CARD_TEXT(card, 2, "L2Wmac");
129         rc = qeth_l2_send_setdelmac(card, mac, cmd);
130         if (rc == -EADDRINUSE)
131                 QETH_DBF_MESSAGE(2, "MAC already registered on device %x\n",
132                                  CARD_DEVID(card));
133         else if (rc)
134                 QETH_DBF_MESSAGE(2, "Failed to register MAC on device %x: %d\n",
135                                  CARD_DEVID(card), rc);
136         return rc;
137 }
138
139 static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac)
140 {
141         enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
142                                         IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;
143         int rc;
144
145         QETH_CARD_TEXT(card, 2, "L2Rmac");
146         rc = qeth_l2_send_setdelmac(card, mac, cmd);
147         if (rc)
148                 QETH_DBF_MESSAGE(2, "Failed to delete MAC on device %u: %d\n",
149                                  CARD_DEVID(card), rc);
150         return rc;
151 }
152
153 static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card)
154 {
155         struct qeth_mac *mac;
156         struct hlist_node *tmp;
157         int i;
158
159         hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
160                 hash_del(&mac->hnode);
161                 kfree(mac);
162         }
163 }
164
165 static void qeth_l2_fill_header(struct qeth_qdio_out_q *queue,
166                                 struct qeth_hdr *hdr, struct sk_buff *skb,
167                                 int ipv, unsigned int data_len)
168 {
169         int cast_type = qeth_get_ether_cast_type(skb);
170         struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
171
172         hdr->hdr.l2.pkt_length = data_len;
173
174         if (skb_is_gso(skb)) {
175                 hdr->hdr.l2.id = QETH_HEADER_TYPE_L2_TSO;
176         } else {
177                 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
178                 if (skb->ip_summed == CHECKSUM_PARTIAL)
179                         qeth_tx_csum(skb, &hdr->hdr.l2.flags[1], ipv);
180         }
181
182         /* set byte byte 3 to casting flags */
183         if (cast_type == RTN_MULTICAST)
184                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
185         else if (cast_type == RTN_BROADCAST)
186                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
187         else
188                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
189
190         /* VSWITCH relies on the VLAN
191          * information to be present in
192          * the QDIO header */
193         if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
194                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
195                 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
196         }
197 }
198
199 static int qeth_l2_setdelvlan_makerc(struct qeth_card *card, u16 retcode)
200 {
201         if (retcode)
202                 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
203
204         switch (retcode) {
205         case IPA_RC_SUCCESS:
206                 return 0;
207         case IPA_RC_L2_INVALID_VLAN_ID:
208                 return -EINVAL;
209         case IPA_RC_L2_DUP_VLAN_ID:
210                 return -EEXIST;
211         case IPA_RC_L2_VLAN_ID_NOT_FOUND:
212                 return -ENOENT;
213         case IPA_RC_L2_VLAN_ID_NOT_ALLOWED:
214                 return -EPERM;
215         default:
216                 return -EIO;
217         }
218 }
219
220 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
221                                       struct qeth_reply *reply,
222                                       unsigned long data)
223 {
224         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
225
226         QETH_CARD_TEXT(card, 2, "L2sdvcb");
227         if (cmd->hdr.return_code) {
228                 QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n",
229                                  cmd->data.setdelvlan.vlan_id,
230                                  CARD_DEVID(card), cmd->hdr.return_code);
231                 QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
232         }
233         return qeth_l2_setdelvlan_makerc(card, cmd->hdr.return_code);
234 }
235
236 static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
237                                    enum qeth_ipa_cmds ipacmd)
238 {
239         struct qeth_ipa_cmd *cmd;
240         struct qeth_cmd_buffer *iob;
241
242         QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
243         iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
244                                  IPA_DATA_SIZEOF(setdelvlan));
245         if (!iob)
246                 return -ENOMEM;
247         cmd = __ipa_cmd(iob);
248         cmd->data.setdelvlan.vlan_id = i;
249         return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelvlan_cb, NULL);
250 }
251
252 static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
253                                    __be16 proto, u16 vid)
254 {
255         struct qeth_card *card = dev->ml_priv;
256
257         QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
258         if (!vid)
259                 return 0;
260
261         return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
262 }
263
264 static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
265                                     __be16 proto, u16 vid)
266 {
267         struct qeth_card *card = dev->ml_priv;
268
269         QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
270         if (!vid)
271                 return 0;
272
273         return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
274 }
275
276 static void qeth_l2_stop_card(struct qeth_card *card)
277 {
278         QETH_CARD_TEXT(card, 2, "stopcard");
279
280         qeth_set_allowed_threads(card, 0, 1);
281
282         cancel_work_sync(&card->rx_mode_work);
283         qeth_l2_drain_rx_mode_cache(card);
284
285         if (card->state == CARD_STATE_SOFTSETUP) {
286                 qeth_clear_ipacmd_list(card);
287                 qeth_drain_output_queues(card);
288                 cancel_delayed_work_sync(&card->buffer_reclaim_work);
289                 card->state = CARD_STATE_DOWN;
290         }
291
292         qeth_qdio_clear_card(card, 0);
293         qeth_clear_working_pool_list(card);
294         flush_workqueue(card->event_wq);
295         qeth_flush_local_addrs(card);
296         card->info.promisc_mode = 0;
297 }
298
299 static int qeth_l2_request_initial_mac(struct qeth_card *card)
300 {
301         int rc = 0;
302
303         QETH_CARD_TEXT(card, 2, "l2reqmac");
304
305         if (MACHINE_IS_VM) {
306                 rc = qeth_vm_request_mac(card);
307                 if (!rc)
308                         goto out;
309                 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
310                                  CARD_DEVID(card), rc);
311                 QETH_CARD_TEXT_(card, 2, "err%04x", rc);
312                 /* fall back to alternative mechanism: */
313         }
314
315         if (!IS_OSN(card)) {
316                 rc = qeth_setadpparms_change_macaddr(card);
317                 if (!rc)
318                         goto out;
319                 QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
320                                  CARD_DEVID(card), rc);
321                 QETH_CARD_TEXT_(card, 2, "1err%04x", rc);
322                 /* fall back once more: */
323         }
324
325         /* some devices don't support a custom MAC address: */
326         if (IS_OSM(card) || IS_OSX(card))
327                 return (rc) ? rc : -EADDRNOTAVAIL;
328         eth_hw_addr_random(card->dev);
329
330 out:
331         QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len);
332         return 0;
333 }
334
335 static void qeth_l2_register_dev_addr(struct qeth_card *card)
336 {
337         if (!is_valid_ether_addr(card->dev->dev_addr))
338                 qeth_l2_request_initial_mac(card);
339
340         if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr))
341                 card->info.dev_addr_is_registered = 1;
342         else
343                 card->info.dev_addr_is_registered = 0;
344 }
345
346 static int qeth_l2_validate_addr(struct net_device *dev)
347 {
348         struct qeth_card *card = dev->ml_priv;
349
350         if (card->info.dev_addr_is_registered)
351                 return eth_validate_addr(dev);
352
353         QETH_CARD_TEXT(card, 4, "nomacadr");
354         return -EPERM;
355 }
356
357 static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
358 {
359         struct sockaddr *addr = p;
360         struct qeth_card *card = dev->ml_priv;
361         u8 old_addr[ETH_ALEN];
362         int rc = 0;
363
364         QETH_CARD_TEXT(card, 3, "setmac");
365
366         if (IS_OSM(card) || IS_OSX(card)) {
367                 QETH_CARD_TEXT(card, 3, "setmcTYP");
368                 return -EOPNOTSUPP;
369         }
370         QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
371         if (!is_valid_ether_addr(addr->sa_data))
372                 return -EADDRNOTAVAIL;
373
374         /* don't register the same address twice */
375         if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
376             card->info.dev_addr_is_registered)
377                 return 0;
378
379         /* add the new address, switch over, drop the old */
380         rc = qeth_l2_send_setmac(card, addr->sa_data);
381         if (rc)
382                 return rc;
383         ether_addr_copy(old_addr, dev->dev_addr);
384         ether_addr_copy(dev->dev_addr, addr->sa_data);
385
386         if (card->info.dev_addr_is_registered)
387                 qeth_l2_remove_mac(card, old_addr);
388         card->info.dev_addr_is_registered = 1;
389         return 0;
390 }
391
392 static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable)
393 {
394         int role;
395         int rc;
396
397         QETH_CARD_TEXT(card, 3, "pmisc2br");
398
399         if (enable) {
400                 if (card->options.sbp.reflect_promisc_primary)
401                         role = QETH_SBP_ROLE_PRIMARY;
402                 else
403                         role = QETH_SBP_ROLE_SECONDARY;
404         } else
405                 role = QETH_SBP_ROLE_NONE;
406
407         rc = qeth_bridgeport_setrole(card, role);
408         QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc);
409         if (!rc) {
410                 card->options.sbp.role = role;
411                 card->info.promisc_mode = enable;
412         }
413 }
414
415 static void qeth_l2_set_promisc_mode(struct qeth_card *card)
416 {
417         bool enable = card->dev->flags & IFF_PROMISC;
418
419         if (card->info.promisc_mode == enable)
420                 return;
421
422         if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) {
423                 qeth_setadp_promisc_mode(card, enable);
424         } else {
425                 mutex_lock(&card->sbp_lock);
426                 if (card->options.sbp.reflect_promisc)
427                         qeth_l2_promisc_to_bridge(card, enable);
428                 mutex_unlock(&card->sbp_lock);
429         }
430 }
431
432 /* New MAC address is added to the hash table and marked to be written on card
433  * only if there is not in the hash table storage already
434  *
435 */
436 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
437 {
438         u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
439         struct qeth_mac *mac;
440
441         hash_for_each_possible(card->mac_htable, mac, hnode, mac_hash) {
442                 if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) {
443                         mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
444                         return;
445                 }
446         }
447
448         mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
449         if (!mac)
450                 return;
451
452         ether_addr_copy(mac->mac_addr, ha->addr);
453         mac->disp_flag = QETH_DISP_ADDR_ADD;
454
455         hash_add(card->mac_htable, &mac->hnode, mac_hash);
456 }
457
458 static void qeth_l2_rx_mode_work(struct work_struct *work)
459 {
460         struct qeth_card *card = container_of(work, struct qeth_card,
461                                               rx_mode_work);
462         struct net_device *dev = card->dev;
463         struct netdev_hw_addr *ha;
464         struct qeth_mac *mac;
465         struct hlist_node *tmp;
466         int i;
467         int rc;
468
469         QETH_CARD_TEXT(card, 3, "setmulti");
470
471         netif_addr_lock_bh(dev);
472         netdev_for_each_mc_addr(ha, dev)
473                 qeth_l2_add_mac(card, ha);
474         netdev_for_each_uc_addr(ha, dev)
475                 qeth_l2_add_mac(card, ha);
476         netif_addr_unlock_bh(dev);
477
478         hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
479                 switch (mac->disp_flag) {
480                 case QETH_DISP_ADDR_DELETE:
481                         qeth_l2_remove_mac(card, mac->mac_addr);
482                         hash_del(&mac->hnode);
483                         kfree(mac);
484                         break;
485                 case QETH_DISP_ADDR_ADD:
486                         rc = qeth_l2_write_mac(card, mac->mac_addr);
487                         if (rc) {
488                                 hash_del(&mac->hnode);
489                                 kfree(mac);
490                                 break;
491                         }
492                         /* fall through */
493                 default:
494                         /* for next call to set_rx_mode(): */
495                         mac->disp_flag = QETH_DISP_ADDR_DELETE;
496                 }
497         }
498
499         qeth_l2_set_promisc_mode(card);
500 }
501
502 static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
503                             struct qeth_qdio_out_q *queue)
504 {
505         gfp_t gfp = GFP_ATOMIC | (skb_pfmemalloc(skb) ? __GFP_MEMALLOC : 0);
506         struct qeth_hdr *hdr = (struct qeth_hdr *)skb->data;
507         addr_t end = (addr_t)(skb->data + sizeof(*hdr));
508         addr_t start = (addr_t)skb->data;
509         unsigned int elements = 0;
510         unsigned int hd_len = 0;
511         int rc;
512
513         if (skb->protocol == htons(ETH_P_IPV6))
514                 return -EPROTONOSUPPORT;
515
516         if (qeth_get_elements_for_range(start, end) > 1) {
517                 /* Misaligned HW header, move it to its own buffer element. */
518                 hdr = kmem_cache_alloc(qeth_core_header_cache, gfp);
519                 if (!hdr)
520                         return -ENOMEM;
521                 hd_len = sizeof(*hdr);
522                 skb_copy_from_linear_data(skb, (char *)hdr, hd_len);
523                 elements++;
524         }
525
526         elements += qeth_count_elements(skb, hd_len);
527         if (elements > queue->max_elements) {
528                 rc = -E2BIG;
529                 goto out;
530         }
531
532         rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len,
533                                  elements);
534 out:
535         if (rc && hd_len)
536                 kmem_cache_free(qeth_core_header_cache, hdr);
537         return rc;
538 }
539
540 static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
541                                            struct net_device *dev)
542 {
543         struct qeth_card *card = dev->ml_priv;
544         u16 txq = skb_get_queue_mapping(skb);
545         struct qeth_qdio_out_q *queue;
546         int rc;
547
548         if (!skb_is_gso(skb))
549                 qdisc_skb_cb(skb)->pkt_len = skb->len;
550         if (IS_IQD(card))
551                 txq = qeth_iqd_translate_txq(dev, txq);
552         queue = card->qdio.out_qs[txq];
553
554         if (IS_OSN(card))
555                 rc = qeth_l2_xmit_osn(card, skb, queue);
556         else
557                 rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb),
558                                qeth_l2_fill_header);
559
560         if (!rc)
561                 return NETDEV_TX_OK;
562
563         QETH_TXQ_STAT_INC(queue, tx_dropped);
564         kfree_skb(skb);
565         return NETDEV_TX_OK;
566 }
567
568 static u16 qeth_l2_select_queue(struct net_device *dev, struct sk_buff *skb,
569                                 struct net_device *sb_dev)
570 {
571         struct qeth_card *card = dev->ml_priv;
572
573         if (IS_IQD(card))
574                 return qeth_iqd_select_queue(dev, skb,
575                                              qeth_get_ether_cast_type(skb),
576                                              sb_dev);
577
578         return IS_VM_NIC(card) ? netdev_pick_tx(dev, skb, sb_dev) :
579                                  qeth_get_priority_queue(card, skb);
580 }
581
582 static const struct device_type qeth_l2_devtype = {
583         .name = "qeth_layer2",
584         .groups = qeth_l2_attr_groups,
585 };
586
587 static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
588 {
589         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
590         int rc;
591
592         if (IS_OSN(card))
593                 dev_notice(&gdev->dev, "OSN support will be dropped in 2021\n");
594
595         qeth_l2_vnicc_set_defaults(card);
596         mutex_init(&card->sbp_lock);
597
598         if (gdev->dev.type == &qeth_generic_devtype) {
599                 rc = qeth_l2_create_device_attributes(&gdev->dev);
600                 if (rc)
601                         return rc;
602         }
603
604         hash_init(card->mac_htable);
605         INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
606         return 0;
607 }
608
609 static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
610 {
611         struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
612
613         if (cgdev->dev.type == &qeth_generic_devtype)
614                 qeth_l2_remove_device_attributes(&cgdev->dev);
615         qeth_set_allowed_threads(card, 0, 1);
616         wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
617
618         if (cgdev->state == CCWGROUP_ONLINE)
619                 qeth_set_offline(card, false);
620
621         cancel_work_sync(&card->close_dev_work);
622         if (card->dev->reg_state == NETREG_REGISTERED)
623                 unregister_netdev(card->dev);
624 }
625
626 static void qeth_l2_set_rx_mode(struct net_device *dev)
627 {
628         struct qeth_card *card = dev->ml_priv;
629
630         schedule_work(&card->rx_mode_work);
631 }
632
633 /**
634  *      qeth_l2_pnso() - perform network subchannel operation
635  *      @card: qeth_card structure pointer
636  *      @cnc: Boolean Change-Notification Control
637  *      @cb: Callback function will be executed for each element
638  *              of the address list
639  *      @priv: Pointer to pass to the callback function.
640  *
641  *      Collects network information in a network address list and calls the
642  *      callback function for every entry in the list. If "change-notification-
643  *      control" is set, further changes in the address list will be reported
644  *      via the IPA command.
645  */
646 static int qeth_l2_pnso(struct qeth_card *card, int cnc,
647                         void (*cb)(void *priv, struct chsc_pnso_naid_l2 *entry),
648                         void *priv)
649 {
650         struct ccw_device *ddev = CARD_DDEV(card);
651         struct chsc_pnso_area *rr;
652         u32 prev_instance = 0;
653         int isfirstblock = 1;
654         int i, size, elems;
655         int rc;
656
657         QETH_CARD_TEXT(card, 2, "PNSO");
658         rr = (struct chsc_pnso_area *)get_zeroed_page(GFP_KERNEL);
659         if (rr == NULL)
660                 return -ENOMEM;
661         do {
662                 /* on the first iteration, naihdr.resume_token will be zero */
663                 rc = ccw_device_pnso(ddev, rr, rr->naihdr.resume_token, cnc);
664                 if (rc)
665                         continue;
666                 if (cb == NULL)
667                         continue;
668
669                 size = rr->naihdr.naids;
670                 if (size != sizeof(struct chsc_pnso_naid_l2)) {
671                         WARN_ON_ONCE(1);
672                         continue;
673                 }
674
675                 elems = (rr->response.length - sizeof(struct chsc_header) -
676                          sizeof(struct chsc_pnso_naihdr)) / size;
677
678                 if (!isfirstblock && (rr->naihdr.instance != prev_instance)) {
679                         /* Inform the caller that they need to scrap */
680                         /* the data that was already reported via cb */
681                         rc = -EAGAIN;
682                         break;
683                 }
684                 isfirstblock = 0;
685                 prev_instance = rr->naihdr.instance;
686                 for (i = 0; i < elems; i++)
687                         (*cb)(priv, &rr->entries[i]);
688         } while ((rc == -EBUSY) || (!rc && /* list stored */
689                    /* resume token is non-zero => list incomplete */
690                    (rr->naihdr.resume_token.t1 || rr->naihdr.resume_token.t2)));
691
692         if (rc)
693                 QETH_CARD_TEXT_(card, 2, "PNrp%04x", rr->response.code);
694
695         free_page((unsigned long)rr);
696         return rc;
697 }
698
699 static const struct net_device_ops qeth_l2_netdev_ops = {
700         .ndo_open               = qeth_open,
701         .ndo_stop               = qeth_stop,
702         .ndo_get_stats64        = qeth_get_stats64,
703         .ndo_start_xmit         = qeth_l2_hard_start_xmit,
704         .ndo_features_check     = qeth_features_check,
705         .ndo_select_queue       = qeth_l2_select_queue,
706         .ndo_validate_addr      = qeth_l2_validate_addr,
707         .ndo_set_rx_mode        = qeth_l2_set_rx_mode,
708         .ndo_do_ioctl           = qeth_do_ioctl,
709         .ndo_set_mac_address    = qeth_l2_set_mac_address,
710         .ndo_vlan_rx_add_vid    = qeth_l2_vlan_rx_add_vid,
711         .ndo_vlan_rx_kill_vid   = qeth_l2_vlan_rx_kill_vid,
712         .ndo_tx_timeout         = qeth_tx_timeout,
713         .ndo_fix_features       = qeth_fix_features,
714         .ndo_set_features       = qeth_set_features
715 };
716
717 static const struct net_device_ops qeth_osn_netdev_ops = {
718         .ndo_open               = qeth_open,
719         .ndo_stop               = qeth_stop,
720         .ndo_get_stats64        = qeth_get_stats64,
721         .ndo_start_xmit         = qeth_l2_hard_start_xmit,
722         .ndo_validate_addr      = eth_validate_addr,
723         .ndo_tx_timeout         = qeth_tx_timeout,
724 };
725
726 static int qeth_l2_setup_netdev(struct qeth_card *card)
727 {
728         int rc;
729
730         if (IS_OSN(card)) {
731                 card->dev->netdev_ops = &qeth_osn_netdev_ops;
732                 card->dev->flags |= IFF_NOARP;
733                 goto add_napi;
734         }
735
736         rc = qeth_setup_netdev(card);
737         if (rc)
738                 return rc;
739
740         card->dev->needed_headroom = sizeof(struct qeth_hdr);
741         card->dev->netdev_ops = &qeth_l2_netdev_ops;
742         card->dev->priv_flags |= IFF_UNICAST_FLT;
743
744         if (IS_OSM(card)) {
745                 card->dev->features |= NETIF_F_VLAN_CHALLENGED;
746         } else {
747                 if (!IS_VM_NIC(card))
748                         card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
749                 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
750         }
751
752         if (IS_OSD(card) && !IS_VM_NIC(card)) {
753                 card->dev->features |= NETIF_F_SG;
754                 /* OSA 3S and earlier has no RX/TX support */
755                 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
756                         card->dev->hw_features |= NETIF_F_IP_CSUM;
757                         card->dev->vlan_features |= NETIF_F_IP_CSUM;
758                 }
759         }
760         if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
761                 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
762                 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
763         }
764         if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
765             qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
766                 card->dev->hw_features |= NETIF_F_RXCSUM;
767                 card->dev->vlan_features |= NETIF_F_RXCSUM;
768         }
769         if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
770                 card->dev->hw_features |= NETIF_F_TSO;
771                 card->dev->vlan_features |= NETIF_F_TSO;
772         }
773         if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
774                 card->dev->hw_features |= NETIF_F_TSO6;
775                 card->dev->vlan_features |= NETIF_F_TSO6;
776         }
777
778         if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
779                 card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
780                 netif_keep_dst(card->dev);
781                 netif_set_gso_max_size(card->dev,
782                                        PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1));
783         }
784
785 add_napi:
786         netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
787         return register_netdev(card->dev);
788 }
789
790 static void qeth_l2_trace_features(struct qeth_card *card)
791 {
792         /* Set BridgePort features */
793         QETH_CARD_TEXT(card, 2, "featuSBP");
794         QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
795                       sizeof(card->options.sbp.supported_funcs));
796         /* VNIC Characteristics features */
797         QETH_CARD_TEXT(card, 2, "feaVNICC");
798         QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
799                       sizeof(card->options.vnicc.sup_chars));
800 }
801
802 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
803 {
804         if (!card->options.sbp.reflect_promisc &&
805             card->options.sbp.role != QETH_SBP_ROLE_NONE) {
806                 /* Conditional to avoid spurious error messages */
807                 qeth_bridgeport_setrole(card, card->options.sbp.role);
808                 /* Let the callback function refresh the stored role value. */
809                 qeth_bridgeport_query_ports(card, &card->options.sbp.role,
810                                             NULL);
811         }
812         if (card->options.sbp.hostnotification) {
813                 if (qeth_bridgeport_an_set(card, 1))
814                         card->options.sbp.hostnotification = 0;
815         } else {
816                 qeth_bridgeport_an_set(card, 0);
817         }
818 }
819
820 static int qeth_l2_set_online(struct qeth_card *card)
821 {
822         struct ccwgroup_device *gdev = card->gdev;
823         struct net_device *dev = card->dev;
824         int rc = 0;
825         bool carrier_ok;
826
827         rc = qeth_core_hardsetup_card(card, &carrier_ok);
828         if (rc) {
829                 QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
830                 rc = -ENODEV;
831                 goto out_remove;
832         }
833
834         mutex_lock(&card->sbp_lock);
835         qeth_bridgeport_query_support(card);
836         if (card->options.sbp.supported_funcs) {
837                 qeth_l2_setup_bridgeport_attrs(card);
838                 dev_info(&card->gdev->dev,
839                          "The device represents a Bridge Capable Port\n");
840         }
841         mutex_unlock(&card->sbp_lock);
842
843         qeth_l2_register_dev_addr(card);
844
845         /* for the rx_bcast characteristic, init VNICC after setmac */
846         qeth_l2_vnicc_init(card);
847
848         qeth_trace_features(card);
849         qeth_l2_trace_features(card);
850
851         qeth_print_status_message(card);
852
853         /* softsetup */
854         QETH_CARD_TEXT(card, 2, "softsetp");
855
856         card->state = CARD_STATE_SOFTSETUP;
857
858         qeth_set_allowed_threads(card, 0xffffffff, 0);
859
860         if (dev->reg_state != NETREG_REGISTERED) {
861                 rc = qeth_l2_setup_netdev(card);
862                 if (rc)
863                         goto out_remove;
864
865                 if (carrier_ok)
866                         netif_carrier_on(dev);
867         } else {
868                 rtnl_lock();
869                 if (carrier_ok)
870                         netif_carrier_on(dev);
871                 else
872                         netif_carrier_off(dev);
873
874                 netif_device_attach(dev);
875                 qeth_enable_hw_features(dev);
876
877                 if (card->info.open_when_online) {
878                         card->info.open_when_online = 0;
879                         dev_open(dev, NULL);
880                 }
881                 rtnl_unlock();
882         }
883         /* let user_space know that device is online */
884         kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
885         return 0;
886
887 out_remove:
888         qeth_l2_stop_card(card);
889         qeth_stop_channel(&card->data);
890         qeth_stop_channel(&card->write);
891         qeth_stop_channel(&card->read);
892         qdio_free(CARD_DDEV(card));
893         return rc;
894 }
895
896 static void qeth_l2_set_offline(struct qeth_card *card)
897 {
898         qeth_l2_stop_card(card);
899 }
900
901 static int __init qeth_l2_init(void)
902 {
903         pr_info("register layer 2 discipline\n");
904         return 0;
905 }
906
907 static void __exit qeth_l2_exit(void)
908 {
909         pr_info("unregister layer 2 discipline\n");
910 }
911
912 /* Returns zero if the command is successfully "consumed" */
913 static int qeth_l2_control_event(struct qeth_card *card,
914                                         struct qeth_ipa_cmd *cmd)
915 {
916         switch (cmd->hdr.command) {
917         case IPA_CMD_SETBRIDGEPORT_OSA:
918         case IPA_CMD_SETBRIDGEPORT_IQD:
919                 if (cmd->data.sbp.hdr.command_code ==
920                                 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
921                         qeth_bridge_state_change(card, cmd);
922                         return 0;
923                 } else
924                         return 1;
925         case IPA_CMD_ADDRESS_CHANGE_NOTIF:
926                 qeth_addr_change_event(card, cmd);
927                 return 0;
928         default:
929                 return 1;
930         }
931 }
932
933 struct qeth_discipline qeth_l2_discipline = {
934         .devtype = &qeth_l2_devtype,
935         .setup = qeth_l2_probe_device,
936         .remove = qeth_l2_remove_device,
937         .set_online = qeth_l2_set_online,
938         .set_offline = qeth_l2_set_offline,
939         .do_ioctl = NULL,
940         .control_event_handler = qeth_l2_control_event,
941 };
942 EXPORT_SYMBOL_GPL(qeth_l2_discipline);
943
944 #ifdef CONFIG_QETH_OSN
945 static void qeth_osn_assist_cb(struct qeth_card *card,
946                                struct qeth_cmd_buffer *iob,
947                                unsigned int data_length)
948 {
949         qeth_notify_cmd(iob, 0);
950         qeth_put_cmd(iob);
951 }
952
953 int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
954 {
955         struct qeth_cmd_buffer *iob;
956         struct qeth_card *card;
957
958         if (data_len < 0)
959                 return -EINVAL;
960         if (!dev)
961                 return -ENODEV;
962         card = dev->ml_priv;
963         if (!card)
964                 return -ENODEV;
965         QETH_CARD_TEXT(card, 2, "osnsdmc");
966         if (!qeth_card_hw_is_reachable(card))
967                 return -ENODEV;
968
969         iob = qeth_alloc_cmd(&card->write, IPA_PDU_HEADER_SIZE + data_len, 1,
970                              QETH_IPA_TIMEOUT);
971         if (!iob)
972                 return -ENOMEM;
973
974         qeth_prepare_ipa_cmd(card, iob, (u16) data_len, NULL);
975
976         memcpy(__ipa_cmd(iob), data, data_len);
977         iob->callback = qeth_osn_assist_cb;
978         return qeth_send_ipa_cmd(card, iob, NULL, NULL);
979 }
980 EXPORT_SYMBOL(qeth_osn_assist);
981
982 int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
983                   int (*assist_cb)(struct net_device *, void *),
984                   int (*data_cb)(struct sk_buff *))
985 {
986         struct qeth_card *card;
987         char bus_id[16];
988         u16 devno;
989
990         memcpy(&devno, read_dev_no, 2);
991         sprintf(bus_id, "0.0.%04x", devno);
992         card = qeth_get_card_by_busid(bus_id);
993         if (!card || !IS_OSN(card))
994                 return -ENODEV;
995         *dev = card->dev;
996
997         QETH_CARD_TEXT(card, 2, "osnreg");
998         if ((assist_cb == NULL) || (data_cb == NULL))
999                 return -EINVAL;
1000         card->osn_info.assist_cb = assist_cb;
1001         card->osn_info.data_cb = data_cb;
1002         return 0;
1003 }
1004 EXPORT_SYMBOL(qeth_osn_register);
1005
1006 void qeth_osn_deregister(struct net_device *dev)
1007 {
1008         struct qeth_card *card;
1009
1010         if (!dev)
1011                 return;
1012         card = dev->ml_priv;
1013         if (!card)
1014                 return;
1015         QETH_CARD_TEXT(card, 2, "osndereg");
1016         card->osn_info.assist_cb = NULL;
1017         card->osn_info.data_cb = NULL;
1018         return;
1019 }
1020 EXPORT_SYMBOL(qeth_osn_deregister);
1021 #endif
1022
1023 /* SETBRIDGEPORT support, async notifications */
1024
1025 enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
1026
1027 /**
1028  * qeth_bridge_emit_host_event() - bridgeport address change notification
1029  * @card:  qeth_card structure pointer, for udev events.
1030  * @evtype:  "normal" register/unregister, or abort, or reset. For abort
1031  *            and reset token and addr_lnid are unused and may be NULL.
1032  * @code:  event bitmask: high order bit 0x80 value 1 means removal of an
1033  *                        object, 0 - addition of an object.
1034  *                        0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
1035  * @token: "network token" structure identifying physical address of the port.
1036  * @addr_lnid: pointer to structure with MAC address and VLAN ID.
1037  *
1038  * This function is called when registrations and deregistrations are
1039  * reported by the hardware, and also when notifications are enabled -
1040  * for all currently registered addresses.
1041  */
1042 static void qeth_bridge_emit_host_event(struct qeth_card *card,
1043                                         enum qeth_an_event_type evtype,
1044                                         u8 code,
1045                                         struct net_if_token *token,
1046                                         struct mac_addr_lnid *addr_lnid)
1047 {
1048         char str[7][32];
1049         char *env[8];
1050         int i = 0;
1051
1052         switch (evtype) {
1053         case anev_reg_unreg:
1054                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
1055                                 (code & IPA_ADDR_CHANGE_CODE_REMOVAL)
1056                                 ? "deregister" : "register");
1057                 env[i] = str[i]; i++;
1058                 if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
1059                         snprintf(str[i], sizeof(str[i]), "VLAN=%d",
1060                                 addr_lnid->lnid);
1061                         env[i] = str[i]; i++;
1062                 }
1063                 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
1064                         snprintf(str[i], sizeof(str[i]), "MAC=%pM",
1065                                 addr_lnid->mac);
1066                         env[i] = str[i]; i++;
1067                 }
1068                 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
1069                         token->cssid, token->ssid, token->devnum);
1070                 env[i] = str[i]; i++;
1071                 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
1072                 env[i] = str[i]; i++;
1073                 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
1074                                 token->chpid);
1075                 env[i] = str[i]; i++;
1076                 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
1077                 env[i] = str[i]; i++;
1078                 break;
1079         case anev_abort:
1080                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
1081                 env[i] = str[i]; i++;
1082                 break;
1083         case anev_reset:
1084                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
1085                 env[i] = str[i]; i++;
1086                 break;
1087         }
1088         env[i] = NULL;
1089         kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1090 }
1091
1092 struct qeth_bridge_state_data {
1093         struct work_struct worker;
1094         struct qeth_card *card;
1095         struct qeth_sbp_state_change qports;
1096 };
1097
1098 static void qeth_bridge_state_change_worker(struct work_struct *work)
1099 {
1100         struct qeth_bridge_state_data *data =
1101                 container_of(work, struct qeth_bridge_state_data, worker);
1102         /* We are only interested in the first entry - local port */
1103         struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
1104         char env_locrem[32];
1105         char env_role[32];
1106         char env_state[32];
1107         char *env[] = {
1108                 env_locrem,
1109                 env_role,
1110                 env_state,
1111                 NULL
1112         };
1113
1114         /* Role should not change by itself, but if it did, */
1115         /* information from the hardware is authoritative.  */
1116         mutex_lock(&data->card->sbp_lock);
1117         data->card->options.sbp.role = entry->role;
1118         mutex_unlock(&data->card->sbp_lock);
1119
1120         snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
1121         snprintf(env_role, sizeof(env_role), "ROLE=%s",
1122                 (entry->role == QETH_SBP_ROLE_NONE) ? "none" :
1123                 (entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
1124                 (entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
1125                 "<INVALID>");
1126         snprintf(env_state, sizeof(env_state), "STATE=%s",
1127                 (entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
1128                 (entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
1129                 (entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
1130                 "<INVALID>");
1131         kobject_uevent_env(&data->card->gdev->dev.kobj,
1132                                 KOBJ_CHANGE, env);
1133         kfree(data);
1134 }
1135
1136 static void qeth_bridge_state_change(struct qeth_card *card,
1137                                         struct qeth_ipa_cmd *cmd)
1138 {
1139         struct qeth_sbp_state_change *qports =
1140                  &cmd->data.sbp.data.state_change;
1141         struct qeth_bridge_state_data *data;
1142         int extrasize;
1143
1144         QETH_CARD_TEXT(card, 2, "brstchng");
1145         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1146                 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1147                 return;
1148         }
1149         extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
1150         data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
1151                 GFP_ATOMIC);
1152         if (!data) {
1153                 QETH_CARD_TEXT(card, 2, "BPSalloc");
1154                 return;
1155         }
1156         INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
1157         data->card = card;
1158         memcpy(&data->qports, qports,
1159                         sizeof(struct qeth_sbp_state_change) + extrasize);
1160         queue_work(card->event_wq, &data->worker);
1161 }
1162
1163 struct qeth_addr_change_data {
1164         struct work_struct worker;
1165         struct qeth_card *card;
1166         struct qeth_ipacmd_addr_change ac_event;
1167 };
1168
1169 static void qeth_addr_change_event_worker(struct work_struct *work)
1170 {
1171         struct qeth_addr_change_data *data =
1172                 container_of(work, struct qeth_addr_change_data, worker);
1173         int i;
1174
1175         QETH_CARD_TEXT(data->card, 4, "adrchgew");
1176         if (data->ac_event.lost_event_mask) {
1177                 dev_info(&data->card->gdev->dev,
1178                          "Address change notification stopped on %s (%s)\n",
1179                          data->card->dev->name,
1180                         (data->ac_event.lost_event_mask == 0x01)
1181                         ? "Overflow"
1182                         : (data->ac_event.lost_event_mask == 0x02)
1183                         ? "Bridge port state change"
1184                         : "Unknown reason");
1185                 mutex_lock(&data->card->sbp_lock);
1186                 data->card->options.sbp.hostnotification = 0;
1187                 mutex_unlock(&data->card->sbp_lock);
1188                 qeth_bridge_emit_host_event(data->card, anev_abort,
1189                                             0, NULL, NULL);
1190         } else
1191                 for (i = 0; i < data->ac_event.num_entries; i++) {
1192                         struct qeth_ipacmd_addr_change_entry *entry =
1193                                         &data->ac_event.entry[i];
1194                         qeth_bridge_emit_host_event(data->card,
1195                                                     anev_reg_unreg,
1196                                                     entry->change_code,
1197                                                     &entry->token,
1198                                                     &entry->addr_lnid);
1199                 }
1200         kfree(data);
1201 }
1202
1203 static void qeth_addr_change_event(struct qeth_card *card,
1204                                    struct qeth_ipa_cmd *cmd)
1205 {
1206         struct qeth_ipacmd_addr_change *hostevs =
1207                  &cmd->data.addrchange;
1208         struct qeth_addr_change_data *data;
1209         int extrasize;
1210
1211         QETH_CARD_TEXT(card, 4, "adrchgev");
1212         if (cmd->hdr.return_code != 0x0000) {
1213                 if (cmd->hdr.return_code == 0x0010) {
1214                         if (hostevs->lost_event_mask == 0x00)
1215                                 hostevs->lost_event_mask = 0xff;
1216                 } else {
1217                         QETH_CARD_TEXT_(card, 2, "ACHN%04x",
1218                                 cmd->hdr.return_code);
1219                         return;
1220                 }
1221         }
1222         extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
1223                                                 hostevs->num_entries;
1224         data = kzalloc(sizeof(struct qeth_addr_change_data) + extrasize,
1225                        GFP_ATOMIC);
1226         if (!data) {
1227                 QETH_CARD_TEXT(card, 2, "ACNalloc");
1228                 return;
1229         }
1230         INIT_WORK(&data->worker, qeth_addr_change_event_worker);
1231         data->card = card;
1232         memcpy(&data->ac_event, hostevs,
1233                         sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1234         queue_work(card->event_wq, &data->worker);
1235 }
1236
1237 /* SETBRIDGEPORT support; sending commands */
1238
1239 struct _qeth_sbp_cbctl {
1240         union {
1241                 u32 supported;
1242                 struct {
1243                         enum qeth_sbp_roles *role;
1244                         enum qeth_sbp_states *state;
1245                 } qports;
1246         } data;
1247 };
1248
1249 static int qeth_bridgeport_makerc(struct qeth_card *card,
1250                                   struct qeth_ipa_cmd *cmd)
1251 {
1252         struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp;
1253         enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code;
1254         u16 ipa_rc = cmd->hdr.return_code;
1255         u16 sbp_rc = sbp->hdr.return_code;
1256         int rc;
1257
1258         if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS)
1259                 return 0;
1260
1261         if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
1262             (!IS_IQD(card) && ipa_rc == sbp_rc)) {
1263                 switch (sbp_rc) {
1264                 case IPA_RC_SUCCESS:
1265                         rc = 0;
1266                         break;
1267                 case IPA_RC_L2_UNSUPPORTED_CMD:
1268                 case IPA_RC_UNSUPPORTED_COMMAND:
1269                         rc = -EOPNOTSUPP;
1270                         break;
1271                 case IPA_RC_SBP_OSA_NOT_CONFIGURED:
1272                 case IPA_RC_SBP_IQD_NOT_CONFIGURED:
1273                         rc = -ENODEV; /* maybe not the best code here? */
1274                         dev_err(&card->gdev->dev,
1275         "The device is not configured as a Bridge Port\n");
1276                         break;
1277                 case IPA_RC_SBP_OSA_OS_MISMATCH:
1278                 case IPA_RC_SBP_IQD_OS_MISMATCH:
1279                         rc = -EPERM;
1280                         dev_err(&card->gdev->dev,
1281         "A Bridge Port is already configured by a different operating system\n");
1282                         break;
1283                 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
1284                 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
1285                         switch (setcmd) {
1286                         case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
1287                                 rc = -EEXIST;
1288                                 dev_err(&card->gdev->dev,
1289         "The LAN already has a primary Bridge Port\n");
1290                                 break;
1291                         case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
1292                                 rc = -EBUSY;
1293                                 dev_err(&card->gdev->dev,
1294         "The device is already a primary Bridge Port\n");
1295                                 break;
1296                         default:
1297                                 rc = -EIO;
1298                         }
1299                         break;
1300                 case IPA_RC_SBP_OSA_CURRENT_SECOND:
1301                 case IPA_RC_SBP_IQD_CURRENT_SECOND:
1302                         rc = -EBUSY;
1303                         dev_err(&card->gdev->dev,
1304         "The device is already a secondary Bridge Port\n");
1305                         break;
1306                 case IPA_RC_SBP_OSA_LIMIT_SECOND:
1307                 case IPA_RC_SBP_IQD_LIMIT_SECOND:
1308                         rc = -EEXIST;
1309                         dev_err(&card->gdev->dev,
1310         "The LAN cannot have more secondary Bridge Ports\n");
1311                         break;
1312                 case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
1313                 case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
1314                         rc = -EBUSY;
1315                         dev_err(&card->gdev->dev,
1316         "The device is already a primary Bridge Port\n");
1317                         break;
1318                 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
1319                 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
1320                         rc = -EACCES;
1321                         dev_err(&card->gdev->dev,
1322         "The device is not authorized to be a Bridge Port\n");
1323                         break;
1324                 default:
1325                         rc = -EIO;
1326                 }
1327         } else {
1328                 switch (ipa_rc) {
1329                 case IPA_RC_NOTSUPP:
1330                         rc = -EOPNOTSUPP;
1331                         break;
1332                 case IPA_RC_UNSUPPORTED_COMMAND:
1333                         rc = -EOPNOTSUPP;
1334                         break;
1335                 default:
1336                         rc = -EIO;
1337                 }
1338         }
1339
1340         if (rc) {
1341                 QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
1342                 QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
1343         }
1344         return rc;
1345 }
1346
1347 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1348                                                   enum qeth_ipa_sbp_cmd sbp_cmd,
1349                                                   unsigned int data_length)
1350 {
1351         enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :
1352                                                     IPA_CMD_SETBRIDGEPORT_OSA;
1353         struct qeth_ipacmd_sbp_hdr *hdr;
1354         struct qeth_cmd_buffer *iob;
1355
1356         iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE,
1357                                  data_length +
1358                                  offsetof(struct qeth_ipacmd_setbridgeport,
1359                                           data));
1360         if (!iob)
1361                 return iob;
1362
1363         hdr = &__ipa_cmd(iob)->data.sbp.hdr;
1364         hdr->cmdlength = sizeof(*hdr) + data_length;
1365         hdr->command_code = sbp_cmd;
1366         hdr->used_total = 1;
1367         hdr->seq_no = 1;
1368         return iob;
1369 }
1370
1371 static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1372         struct qeth_reply *reply, unsigned long data)
1373 {
1374         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1375         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1376         int rc;
1377
1378         QETH_CARD_TEXT(card, 2, "brqsupcb");
1379         rc = qeth_bridgeport_makerc(card, cmd);
1380         if (rc)
1381                 return rc;
1382
1383         cbctl->data.supported =
1384                 cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1385         return 0;
1386 }
1387
1388 /**
1389  * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
1390  * @card:                            qeth_card structure pointer.
1391  *
1392  * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
1393  * strucutre: card->options.sbp.supported_funcs.
1394  */
1395 static void qeth_bridgeport_query_support(struct qeth_card *card)
1396 {
1397         struct qeth_cmd_buffer *iob;
1398         struct _qeth_sbp_cbctl cbctl;
1399
1400         QETH_CARD_TEXT(card, 2, "brqsuppo");
1401         iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1402                                  SBP_DATA_SIZEOF(query_cmds_supp));
1403         if (!iob)
1404                 return;
1405
1406         if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1407                               &cbctl)) {
1408                 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1409                 card->options.sbp.supported_funcs = 0;
1410                 return;
1411         }
1412         card->options.sbp.supported_funcs = cbctl.data.supported;
1413 }
1414
1415 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1416         struct qeth_reply *reply, unsigned long data)
1417 {
1418         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1419         struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
1420         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1421         int rc;
1422
1423         QETH_CARD_TEXT(card, 2, "brqprtcb");
1424         rc = qeth_bridgeport_makerc(card, cmd);
1425         if (rc)
1426                 return rc;
1427
1428         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1429                 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1430                 return -EINVAL;
1431         }
1432         /* first entry contains the state of the local port */
1433         if (qports->num_entries > 0) {
1434                 if (cbctl->data.qports.role)
1435                         *cbctl->data.qports.role = qports->entry[0].role;
1436                 if (cbctl->data.qports.state)
1437                         *cbctl->data.qports.state = qports->entry[0].state;
1438         }
1439         return 0;
1440 }
1441
1442 /**
1443  * qeth_bridgeport_query_ports() - query local bridgeport status.
1444  * @card:                          qeth_card structure pointer.
1445  * @role:   Role of the port: 0-none, 1-primary, 2-secondary.
1446  * @state:  State of the port: 0-inactive, 1-standby, 2-active.
1447  *
1448  * Returns negative errno-compatible error indication or 0 on success.
1449  *
1450  * 'role' and 'state' are not updated in case of hardware operation failure.
1451  */
1452 int qeth_bridgeport_query_ports(struct qeth_card *card,
1453         enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
1454 {
1455         struct qeth_cmd_buffer *iob;
1456         struct _qeth_sbp_cbctl cbctl = {
1457                 .data = {
1458                         .qports = {
1459                                 .role = role,
1460                                 .state = state,
1461                         },
1462                 },
1463         };
1464
1465         QETH_CARD_TEXT(card, 2, "brqports");
1466         if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1467                 return -EOPNOTSUPP;
1468         iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1469         if (!iob)
1470                 return -ENOMEM;
1471
1472         return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1473                                  &cbctl);
1474 }
1475
1476 static int qeth_bridgeport_set_cb(struct qeth_card *card,
1477         struct qeth_reply *reply, unsigned long data)
1478 {
1479         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1480
1481         QETH_CARD_TEXT(card, 2, "brsetrcb");
1482         return qeth_bridgeport_makerc(card, cmd);
1483 }
1484
1485 /**
1486  * qeth_bridgeport_setrole() - Assign primary role to the port.
1487  * @card:                      qeth_card structure pointer.
1488  * @role:                      Role to assign.
1489  *
1490  * Returns negative errno-compatible error indication or 0 on success.
1491  */
1492 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1493 {
1494         struct qeth_cmd_buffer *iob;
1495         enum qeth_ipa_sbp_cmd setcmd;
1496         unsigned int cmdlength = 0;
1497
1498         QETH_CARD_TEXT(card, 2, "brsetrol");
1499         switch (role) {
1500         case QETH_SBP_ROLE_NONE:
1501                 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
1502                 break;
1503         case QETH_SBP_ROLE_PRIMARY:
1504                 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
1505                 cmdlength = SBP_DATA_SIZEOF(set_primary);
1506                 break;
1507         case QETH_SBP_ROLE_SECONDARY:
1508                 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
1509                 break;
1510         default:
1511                 return -EINVAL;
1512         }
1513         if (!(card->options.sbp.supported_funcs & setcmd))
1514                 return -EOPNOTSUPP;
1515         iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1516         if (!iob)
1517                 return -ENOMEM;
1518
1519         return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
1520 }
1521
1522 static void qeth_bridgeport_an_set_cb(void *priv,
1523                                       struct chsc_pnso_naid_l2 *entry)
1524 {
1525         struct qeth_card *card = (struct qeth_card *)priv;
1526         u8 code;
1527
1528         code = IPA_ADDR_CHANGE_CODE_MACADDR;
1529         if (entry->addr_lnid.lnid < VLAN_N_VID)
1530                 code |= IPA_ADDR_CHANGE_CODE_VLANID;
1531         qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
1532                                     (struct net_if_token *)&entry->nit,
1533                                     (struct mac_addr_lnid *)&entry->addr_lnid);
1534 }
1535
1536 /**
1537  * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
1538  * @card:                     qeth_card structure pointer.
1539  * @enable:                   0 - disable, non-zero - enable notifications
1540  *
1541  * Returns negative errno-compatible error indication or 0 on success.
1542  *
1543  * On enable, emits a series of address notifications udev events for all
1544  * currently registered hosts.
1545  */
1546 int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
1547 {
1548         int rc;
1549
1550         if (!card->options.sbp.supported_funcs)
1551                 return -EOPNOTSUPP;
1552
1553         if (enable) {
1554                 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
1555                 rc = qeth_l2_pnso(card, 1, qeth_bridgeport_an_set_cb, card);
1556         } else
1557                 rc = qeth_l2_pnso(card, 0, NULL, NULL);
1558         return rc;
1559 }
1560
1561 static bool qeth_bridgeport_is_in_use(struct qeth_card *card)
1562 {
1563         return (card->options.sbp.role || card->options.sbp.reflect_promisc ||
1564                 card->options.sbp.hostnotification);
1565 }
1566
1567 /* VNIC Characteristics support */
1568
1569 /* handle VNICC IPA command return codes; convert to error codes */
1570 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
1571 {
1572         int rc;
1573
1574         switch (ipa_rc) {
1575         case IPA_RC_SUCCESS:
1576                 return ipa_rc;
1577         case IPA_RC_L2_UNSUPPORTED_CMD:
1578         case IPA_RC_NOTSUPP:
1579                 rc = -EOPNOTSUPP;
1580                 break;
1581         case IPA_RC_VNICC_OOSEQ:
1582                 rc = -EALREADY;
1583                 break;
1584         case IPA_RC_VNICC_VNICBP:
1585                 rc = -EBUSY;
1586                 break;
1587         case IPA_RC_L2_ADDR_TABLE_FULL:
1588                 rc = -ENOSPC;
1589                 break;
1590         case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
1591                 rc = -EACCES;
1592                 break;
1593         default:
1594                 rc = -EIO;
1595         }
1596
1597         QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
1598         return rc;
1599 }
1600
1601 /* generic VNICC request call back */
1602 static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
1603                                     struct qeth_reply *reply,
1604                                     unsigned long data)
1605 {
1606         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1607         struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;
1608         u32 sub_cmd = cmd->data.vnicc.hdr.sub_command;
1609
1610         QETH_CARD_TEXT(card, 2, "vniccrcb");
1611         if (cmd->hdr.return_code)
1612                 return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
1613         /* return results to caller */
1614         card->options.vnicc.sup_chars = rep->vnicc_cmds.supported;
1615         card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled;
1616
1617         if (sub_cmd == IPA_VNICC_QUERY_CMDS)
1618                 *(u32 *)reply->param = rep->data.query_cmds.sup_cmds;
1619         else if (sub_cmd == IPA_VNICC_GET_TIMEOUT)
1620                 *(u32 *)reply->param = rep->data.getset_timeout.timeout;
1621
1622         return 0;
1623 }
1624
1625 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card,
1626                                                        u32 vnicc_cmd,
1627                                                        unsigned int data_length)
1628 {
1629         struct qeth_ipacmd_vnicc_hdr *hdr;
1630         struct qeth_cmd_buffer *iob;
1631
1632         iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE,
1633                                  data_length +
1634                                  offsetof(struct qeth_ipacmd_vnicc, data));
1635         if (!iob)
1636                 return NULL;
1637
1638         hdr = &__ipa_cmd(iob)->data.vnicc.hdr;
1639         hdr->data_length = sizeof(*hdr) + data_length;
1640         hdr->sub_command = vnicc_cmd;
1641         return iob;
1642 }
1643
1644 /* VNICC query VNIC characteristics request */
1645 static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
1646 {
1647         struct qeth_cmd_buffer *iob;
1648
1649         QETH_CARD_TEXT(card, 2, "vniccqch");
1650         iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0);
1651         if (!iob)
1652                 return -ENOMEM;
1653
1654         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1655 }
1656
1657 /* VNICC query sub commands request */
1658 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
1659                                     u32 *sup_cmds)
1660 {
1661         struct qeth_cmd_buffer *iob;
1662
1663         QETH_CARD_TEXT(card, 2, "vniccqcm");
1664         iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS,
1665                                       VNICC_DATA_SIZEOF(query_cmds));
1666         if (!iob)
1667                 return -ENOMEM;
1668
1669         __ipa_cmd(iob)->data.vnicc.data.query_cmds.vnic_char = vnic_char;
1670
1671         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds);
1672 }
1673
1674 /* VNICC enable/disable characteristic request */
1675 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
1676                                       u32 cmd)
1677 {
1678         struct qeth_cmd_buffer *iob;
1679
1680         QETH_CARD_TEXT(card, 2, "vniccedc");
1681         iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char));
1682         if (!iob)
1683                 return -ENOMEM;
1684
1685         __ipa_cmd(iob)->data.vnicc.data.set_char.vnic_char = vnic_char;
1686
1687         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1688 }
1689
1690 /* VNICC get/set timeout for characteristic request */
1691 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
1692                                         u32 cmd, u32 *timeout)
1693 {
1694         struct qeth_vnicc_getset_timeout *getset_timeout;
1695         struct qeth_cmd_buffer *iob;
1696
1697         QETH_CARD_TEXT(card, 2, "vniccgst");
1698         iob = qeth_l2_vnicc_build_cmd(card, cmd,
1699                                       VNICC_DATA_SIZEOF(getset_timeout));
1700         if (!iob)
1701                 return -ENOMEM;
1702
1703         getset_timeout = &__ipa_cmd(iob)->data.vnicc.data.getset_timeout;
1704         getset_timeout->vnic_char = vnicc;
1705
1706         if (cmd == IPA_VNICC_SET_TIMEOUT)
1707                 getset_timeout->timeout = *timeout;
1708
1709         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout);
1710 }
1711
1712 /* set current VNICC flag state; called from sysfs store function */
1713 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
1714 {
1715         int rc = 0;
1716         u32 cmd;
1717
1718         QETH_CARD_TEXT(card, 2, "vniccsch");
1719
1720         /* check if characteristic and enable/disable are supported */
1721         if (!(card->options.vnicc.sup_chars & vnicc) ||
1722             !(card->options.vnicc.set_char_sup & vnicc))
1723                 return -EOPNOTSUPP;
1724
1725         if (qeth_bridgeport_is_in_use(card))
1726                 return -EBUSY;
1727
1728         /* set enable/disable command and store wanted characteristic */
1729         if (state) {
1730                 cmd = IPA_VNICC_ENABLE;
1731                 card->options.vnicc.wanted_chars |= vnicc;
1732         } else {
1733                 cmd = IPA_VNICC_DISABLE;
1734                 card->options.vnicc.wanted_chars &= ~vnicc;
1735         }
1736
1737         /* do we need to do anything? */
1738         if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
1739                 return rc;
1740
1741         /* if card is not ready, simply stop here */
1742         if (!qeth_card_hw_is_reachable(card)) {
1743                 if (state)
1744                         card->options.vnicc.cur_chars |= vnicc;
1745                 else
1746                         card->options.vnicc.cur_chars &= ~vnicc;
1747                 return rc;
1748         }
1749
1750         rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
1751         if (rc)
1752                 card->options.vnicc.wanted_chars =
1753                         card->options.vnicc.cur_chars;
1754         else {
1755                 /* successful online VNICC change; handle special cases */
1756                 if (state && vnicc == QETH_VNICC_RX_BCAST)
1757                         card->options.vnicc.rx_bcast_enabled = true;
1758                 if (!state && vnicc == QETH_VNICC_LEARNING)
1759                         qeth_l2_vnicc_recover_timeout(card, vnicc,
1760                                         &card->options.vnicc.learning_timeout);
1761         }
1762
1763         return rc;
1764 }
1765
1766 /* get current VNICC flag state; called from sysfs show function */
1767 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
1768 {
1769         int rc = 0;
1770
1771         QETH_CARD_TEXT(card, 2, "vniccgch");
1772
1773         /* check if characteristic is supported */
1774         if (!(card->options.vnicc.sup_chars & vnicc))
1775                 return -EOPNOTSUPP;
1776
1777         if (qeth_bridgeport_is_in_use(card))
1778                 return -EBUSY;
1779
1780         /* if card is ready, query current VNICC state */
1781         if (qeth_card_hw_is_reachable(card))
1782                 rc = qeth_l2_vnicc_query_chars(card);
1783
1784         *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
1785         return rc;
1786 }
1787
1788 /* set VNICC timeout; called from sysfs store function. Currently, only learning
1789  * supports timeout
1790  */
1791 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
1792 {
1793         int rc = 0;
1794
1795         QETH_CARD_TEXT(card, 2, "vniccsto");
1796
1797         /* check if characteristic and set_timeout are supported */
1798         if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
1799             !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
1800                 return -EOPNOTSUPP;
1801
1802         if (qeth_bridgeport_is_in_use(card))
1803                 return -EBUSY;
1804
1805         /* do we need to do anything? */
1806         if (card->options.vnicc.learning_timeout == timeout)
1807                 return rc;
1808
1809         /* if card is not ready, simply store the value internally and return */
1810         if (!qeth_card_hw_is_reachable(card)) {
1811                 card->options.vnicc.learning_timeout = timeout;
1812                 return rc;
1813         }
1814
1815         /* send timeout value to card; if successful, store value internally */
1816         rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
1817                                           IPA_VNICC_SET_TIMEOUT, &timeout);
1818         if (!rc)
1819                 card->options.vnicc.learning_timeout = timeout;
1820
1821         return rc;
1822 }
1823
1824 /* get current VNICC timeout; called from sysfs show function. Currently, only
1825  * learning supports timeout
1826  */
1827 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
1828 {
1829         int rc = 0;
1830
1831         QETH_CARD_TEXT(card, 2, "vniccgto");
1832
1833         /* check if characteristic and get_timeout are supported */
1834         if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
1835             !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
1836                 return -EOPNOTSUPP;
1837
1838         if (qeth_bridgeport_is_in_use(card))
1839                 return -EBUSY;
1840
1841         /* if card is ready, get timeout. Otherwise, just return stored value */
1842         *timeout = card->options.vnicc.learning_timeout;
1843         if (qeth_card_hw_is_reachable(card))
1844                 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
1845                                                   IPA_VNICC_GET_TIMEOUT,
1846                                                   timeout);
1847
1848         return rc;
1849 }
1850
1851 /* check if VNICC is currently enabled */
1852 bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
1853 {
1854         if (!card->options.vnicc.sup_chars)
1855                 return false;
1856         /* default values are only OK if rx_bcast was not enabled by user
1857          * or the card is offline.
1858          */
1859         if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
1860                 if (!card->options.vnicc.rx_bcast_enabled ||
1861                     !qeth_card_hw_is_reachable(card))
1862                         return false;
1863         }
1864         return true;
1865 }
1866
1867 /* recover user timeout setting */
1868 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
1869                                           u32 *timeout)
1870 {
1871         if (card->options.vnicc.sup_chars & vnicc &&
1872             card->options.vnicc.getset_timeout_sup & vnicc &&
1873             !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
1874                                           timeout))
1875                 return false;
1876         *timeout = QETH_VNICC_DEFAULT_TIMEOUT;
1877         return true;
1878 }
1879
1880 /* recover user characteristic setting */
1881 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
1882                                        bool enable)
1883 {
1884         u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;
1885
1886         if (card->options.vnicc.sup_chars & vnicc &&
1887             card->options.vnicc.set_char_sup & vnicc &&
1888             !qeth_l2_vnicc_set_char(card, vnicc, cmd))
1889                 return false;
1890         card->options.vnicc.wanted_chars &= ~vnicc;
1891         card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
1892         return true;
1893 }
1894
1895 /* (re-)initialize VNICC */
1896 static void qeth_l2_vnicc_init(struct qeth_card *card)
1897 {
1898         u32 *timeout = &card->options.vnicc.learning_timeout;
1899         bool enable, error = false;
1900         unsigned int chars_len, i;
1901         unsigned long chars_tmp;
1902         u32 sup_cmds, vnicc;
1903
1904         QETH_CARD_TEXT(card, 2, "vniccini");
1905         /* reset rx_bcast */
1906         card->options.vnicc.rx_bcast_enabled = 0;
1907         /* initial query and storage of VNIC characteristics */
1908         if (qeth_l2_vnicc_query_chars(card)) {
1909                 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
1910                     *timeout != QETH_VNICC_DEFAULT_TIMEOUT)
1911                         dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
1912                 /* fail quietly if user didn't change the default config */
1913                 card->options.vnicc.sup_chars = 0;
1914                 card->options.vnicc.cur_chars = 0;
1915                 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
1916                 return;
1917         }
1918         /* get supported commands for each supported characteristic */
1919         chars_tmp = card->options.vnicc.sup_chars;
1920         chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
1921         for_each_set_bit(i, &chars_tmp, chars_len) {
1922                 vnicc = BIT(i);
1923                 if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
1924                         sup_cmds = 0;
1925                         error = true;
1926                 }
1927                 if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) &&
1928                     (sup_cmds & IPA_VNICC_GET_TIMEOUT))
1929                         card->options.vnicc.getset_timeout_sup |= vnicc;
1930                 else
1931                         card->options.vnicc.getset_timeout_sup &= ~vnicc;
1932                 if ((sup_cmds & IPA_VNICC_ENABLE) &&
1933                     (sup_cmds & IPA_VNICC_DISABLE))
1934                         card->options.vnicc.set_char_sup |= vnicc;
1935                 else
1936                         card->options.vnicc.set_char_sup &= ~vnicc;
1937         }
1938         /* enforce assumed default values and recover settings, if changed  */
1939         error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
1940                                                timeout);
1941         /* Change chars, if necessary  */
1942         chars_tmp = card->options.vnicc.wanted_chars ^
1943                     card->options.vnicc.cur_chars;
1944         chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
1945         for_each_set_bit(i, &chars_tmp, chars_len) {
1946                 vnicc = BIT(i);
1947                 enable = card->options.vnicc.wanted_chars & vnicc;
1948                 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
1949         }
1950         if (error)
1951                 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
1952 }
1953
1954 /* configure default values of VNIC characteristics */
1955 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
1956 {
1957         /* characteristics values */
1958         card->options.vnicc.sup_chars = QETH_VNICC_ALL;
1959         card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
1960         card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
1961         /* supported commands */
1962         card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
1963         card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
1964         /* settings wanted by users */
1965         card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
1966 }
1967
1968 module_init(qeth_l2_init);
1969 module_exit(qeth_l2_exit);
1970 MODULE_AUTHOR("Frank Blaschka <[email protected]>");
1971 MODULE_DESCRIPTION("qeth layer 2 discipline");
1972 MODULE_LICENSE("GPL");
This page took 0.146693 seconds and 4 git commands to generate.