1
2
3
4
5
6
7
8
9#define KMSG_COMPONENT "qeth"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
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>
17#include <linux/slab.h>
18#include <linux/etherdevice.h>
19#include <linux/mii.h>
20#include <linux/ip.h>
21#include <linux/list.h>
22#include <asm/setup.h>
23
24#include "qeth_core.h"
25#include "qeth_l2.h"
26
27static int qeth_l2_set_offline(struct ccwgroup_device *);
28static int qeth_l2_stop(struct net_device *);
29static int qeth_l2_send_delmac(struct qeth_card *, __u8 *);
30static int qeth_l2_send_setdelmac(struct qeth_card *, __u8 *,
31 enum qeth_ipa_cmds,
32 int (*reply_cb) (struct qeth_card *,
33 struct qeth_reply*,
34 unsigned long));
35static void qeth_l2_set_multicast_list(struct net_device *);
36static int qeth_l2_recover(void *);
37static void qeth_bridgeport_query_support(struct qeth_card *card);
38static void qeth_bridge_state_change(struct qeth_card *card,
39 struct qeth_ipa_cmd *cmd);
40static void qeth_bridge_host_event(struct qeth_card *card,
41 struct qeth_ipa_cmd *cmd);
42
43static int qeth_l2_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
44{
45 struct qeth_card *card = dev->ml_priv;
46 struct mii_ioctl_data *mii_data;
47 int rc = 0;
48
49 if (!card)
50 return -ENODEV;
51
52 if ((card->state != CARD_STATE_UP) &&
53 (card->state != CARD_STATE_SOFTSETUP))
54 return -ENODEV;
55
56 if (card->info.type == QETH_CARD_TYPE_OSN)
57 return -EPERM;
58
59 switch (cmd) {
60 case SIOC_QETH_ADP_SET_SNMP_CONTROL:
61 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);
62 break;
63 case SIOC_QETH_GET_CARD_TYPE:
64 if ((card->info.type == QETH_CARD_TYPE_OSD ||
65 card->info.type == QETH_CARD_TYPE_OSM ||
66 card->info.type == QETH_CARD_TYPE_OSX) &&
67 !card->info.guestlan)
68 return 1;
69 return 0;
70 break;
71 case SIOCGMIIPHY:
72 mii_data = if_mii(rq);
73 mii_data->phy_id = 0;
74 break;
75 case SIOCGMIIREG:
76 mii_data = if_mii(rq);
77 if (mii_data->phy_id != 0)
78 rc = -EINVAL;
79 else
80 mii_data->val_out = qeth_mdio_read(dev,
81 mii_data->phy_id, mii_data->reg_num);
82 break;
83 case SIOC_QETH_QUERY_OAT:
84 rc = qeth_query_oat_command(card, rq->ifr_ifru.ifru_data);
85 break;
86 default:
87 rc = -EOPNOTSUPP;
88 }
89 if (rc)
90 QETH_CARD_TEXT_(card, 2, "ioce%d", rc);
91 return rc;
92}
93
94static int qeth_l2_verify_dev(struct net_device *dev)
95{
96 struct qeth_card *card;
97 unsigned long flags;
98 int rc = 0;
99
100 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
101 list_for_each_entry(card, &qeth_core_card_list.list, list) {
102 if (card->dev == dev) {
103 rc = QETH_REAL_CARD;
104 break;
105 }
106 }
107 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
108
109 return rc;
110}
111
112static struct net_device *qeth_l2_netdev_by_devno(unsigned char *read_dev_no)
113{
114 struct qeth_card *card;
115 struct net_device *ndev;
116 __u16 temp_dev_no;
117 unsigned long flags;
118 struct ccw_dev_id read_devid;
119
120 ndev = NULL;
121 memcpy(&temp_dev_no, read_dev_no, 2);
122 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
123 list_for_each_entry(card, &qeth_core_card_list.list, list) {
124 ccw_device_get_id(CARD_RDEV(card), &read_devid);
125 if (read_devid.devno == temp_dev_no) {
126 ndev = card->dev;
127 break;
128 }
129 }
130 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
131 return ndev;
132}
133
134static int qeth_l2_send_setgroupmac_cb(struct qeth_card *card,
135 struct qeth_reply *reply,
136 unsigned long data)
137{
138 struct qeth_ipa_cmd *cmd;
139 __u8 *mac;
140
141 QETH_CARD_TEXT(card, 2, "L2Sgmacb");
142 cmd = (struct qeth_ipa_cmd *) data;
143 mac = &cmd->data.setdelmac.mac[0];
144
145 if (cmd->hdr.return_code == IPA_RC_L2_DUP_MAC) {
146 QETH_DBF_MESSAGE(2, "Group MAC already existing on device %x\n",
147 CARD_DEVID(card));
148 cmd->hdr.return_code = 0;
149 }
150 if (cmd->hdr.return_code)
151 QETH_DBF_MESSAGE(2, "Could not set group MAC on device %x: %x\n",
152 CARD_DEVID(card), cmd->hdr.return_code);
153 return 0;
154}
155
156static int qeth_l2_send_setgroupmac(struct qeth_card *card, __u8 *mac)
157{
158 QETH_CARD_TEXT(card, 2, "L2Sgmac");
159 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETGMAC,
160 qeth_l2_send_setgroupmac_cb);
161}
162
163static int qeth_l2_send_delgroupmac_cb(struct qeth_card *card,
164 struct qeth_reply *reply,
165 unsigned long data)
166{
167 struct qeth_ipa_cmd *cmd;
168 __u8 *mac;
169
170 QETH_CARD_TEXT(card, 2, "L2Dgmacb");
171 cmd = (struct qeth_ipa_cmd *) data;
172 mac = &cmd->data.setdelmac.mac[0];
173 if (cmd->hdr.return_code)
174 QETH_DBF_MESSAGE(2, "Could not delete group MAC on device %x: %x\n",
175 CARD_DEVID(card), cmd->hdr.return_code);
176 return 0;
177}
178
179static int qeth_l2_send_delgroupmac(struct qeth_card *card, __u8 *mac)
180{
181 QETH_CARD_TEXT(card, 2, "L2Dgmac");
182 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELGMAC,
183 qeth_l2_send_delgroupmac_cb);
184}
185
186static void qeth_l2_add_mc(struct qeth_card *card, __u8 *mac, int vmac)
187{
188 struct qeth_mc_mac *mc;
189 int rc;
190
191 mc = kmalloc(sizeof(struct qeth_mc_mac), GFP_ATOMIC);
192
193 if (!mc)
194 return;
195
196 memcpy(mc->mc_addr, mac, OSA_ADDR_LEN);
197 mc->mc_addrlen = OSA_ADDR_LEN;
198 mc->is_vmac = vmac;
199
200 if (vmac) {
201 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC,
202 NULL);
203 } else {
204 rc = qeth_l2_send_setgroupmac(card, mac);
205 }
206
207 if (!rc)
208 list_add_tail(&mc->list, &card->mc_list);
209 else
210 kfree(mc);
211}
212
213static void qeth_l2_del_all_mc(struct qeth_card *card, int del)
214{
215 struct qeth_mc_mac *mc, *tmp;
216
217 spin_lock_bh(&card->mclock);
218 list_for_each_entry_safe(mc, tmp, &card->mc_list, list) {
219 if (del) {
220 if (mc->is_vmac)
221 qeth_l2_send_setdelmac(card, mc->mc_addr,
222 IPA_CMD_DELVMAC, NULL);
223 else
224 qeth_l2_send_delgroupmac(card, mc->mc_addr);
225 }
226 list_del(&mc->list);
227 kfree(mc);
228 }
229 spin_unlock_bh(&card->mclock);
230}
231
232static inline int qeth_l2_get_cast_type(struct qeth_card *card,
233 struct sk_buff *skb)
234{
235 if (card->info.type == QETH_CARD_TYPE_OSN)
236 return RTN_UNSPEC;
237 if (is_broadcast_ether_addr(skb->data))
238 return RTN_BROADCAST;
239 if (is_multicast_ether_addr(skb->data))
240 return RTN_MULTICAST;
241 return RTN_UNSPEC;
242}
243
244static inline void qeth_l2_hdr_csum(struct qeth_card *card,
245 struct qeth_hdr *hdr, struct sk_buff *skb)
246{
247 struct iphdr *iph = ip_hdr(skb);
248
249
250
251
252 if (iph->protocol == IPPROTO_UDP)
253 hdr->hdr.l2.flags[1] |= QETH_HDR_EXT_UDP;
254 hdr->hdr.l2.flags[1] |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
255 QETH_HDR_EXT_CSUM_HDR_REQ;
256 iph->check = 0;
257 if (card->options.performance_stats)
258 card->perf_stats.tx_csum++;
259}
260
261static void qeth_l2_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
262 struct sk_buff *skb, int cast_type)
263{
264 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb_mac_header(skb);
265
266 memset(hdr, 0, sizeof(struct qeth_hdr));
267 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
268
269
270 if (cast_type == RTN_MULTICAST)
271 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
272 else if (cast_type == RTN_BROADCAST)
273 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
274 else
275 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
276
277 hdr->hdr.l2.pkt_length = skb->len-QETH_HEADER_SIZE;
278
279
280
281 if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
282 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
283 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
284 }
285}
286
287static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
288 struct qeth_reply *reply, unsigned long data)
289{
290 struct qeth_ipa_cmd *cmd;
291
292 QETH_CARD_TEXT(card, 2, "L2sdvcb");
293 cmd = (struct qeth_ipa_cmd *) data;
294 if (cmd->hdr.return_code) {
295 QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x\n",
296 cmd->data.setdelvlan.vlan_id,
297 CARD_DEVID(card), cmd->hdr.return_code);
298 QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
299 QETH_CARD_TEXT_(card, 2, "err%d", cmd->hdr.return_code);
300 }
301 return 0;
302}
303
304static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
305 enum qeth_ipa_cmds ipacmd)
306{
307 struct qeth_ipa_cmd *cmd;
308 struct qeth_cmd_buffer *iob;
309
310 QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
311 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
312 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
313 cmd->data.setdelvlan.vlan_id = i;
314 return qeth_send_ipa_cmd(card, iob,
315 qeth_l2_send_setdelvlan_cb, NULL);
316}
317
318static void qeth_l2_process_vlans(struct qeth_card *card)
319{
320 struct qeth_vlan_vid *id;
321 QETH_CARD_TEXT(card, 3, "L2prcvln");
322 spin_lock_bh(&card->vlanlock);
323 list_for_each_entry(id, &card->vid_list, list) {
324 qeth_l2_send_setdelvlan(card, id->vid, IPA_CMD_SETVLAN);
325 }
326 spin_unlock_bh(&card->vlanlock);
327}
328
329static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
330 __be16 proto, u16 vid)
331{
332 struct qeth_card *card = dev->ml_priv;
333 struct qeth_vlan_vid *id;
334
335 QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
336 if (!vid)
337 return 0;
338 if (card->info.type == QETH_CARD_TYPE_OSM) {
339 QETH_CARD_TEXT(card, 3, "aidOSM");
340 return 0;
341 }
342 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
343 QETH_CARD_TEXT(card, 3, "aidREC");
344 return 0;
345 }
346 id = kmalloc(sizeof(struct qeth_vlan_vid), GFP_ATOMIC);
347 if (id) {
348 id->vid = vid;
349 qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
350 spin_lock_bh(&card->vlanlock);
351 list_add_tail(&id->list, &card->vid_list);
352 spin_unlock_bh(&card->vlanlock);
353 } else {
354 return -ENOMEM;
355 }
356 return 0;
357}
358
359static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
360 __be16 proto, u16 vid)
361{
362 struct qeth_vlan_vid *id, *tmpid = NULL;
363 struct qeth_card *card = dev->ml_priv;
364
365 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
366 if (card->info.type == QETH_CARD_TYPE_OSM) {
367 QETH_CARD_TEXT(card, 3, "kidOSM");
368 return 0;
369 }
370 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
371 QETH_CARD_TEXT(card, 3, "kidREC");
372 return 0;
373 }
374 spin_lock_bh(&card->vlanlock);
375 list_for_each_entry(id, &card->vid_list, list) {
376 if (id->vid == vid) {
377 list_del(&id->list);
378 tmpid = id;
379 break;
380 }
381 }
382 spin_unlock_bh(&card->vlanlock);
383 if (tmpid) {
384 qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
385 kfree(tmpid);
386 }
387 qeth_l2_set_multicast_list(card->dev);
388 return 0;
389}
390
391static netdev_features_t qeth_l2_fix_features(struct net_device *dev,
392 netdev_features_t features)
393{
394 struct qeth_card *card = dev->ml_priv;
395
396 QETH_DBF_TEXT(SETUP, 2, "fixfeat");
397 if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
398 features &= ~NETIF_F_IP_CSUM;
399 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM))
400 features &= ~NETIF_F_RXCSUM;
401 QETH_DBF_HEX(SETUP, 2, &features, sizeof(features));
402 return features;
403}
404
405static int qeth_l2_set_features(struct net_device *dev,
406 netdev_features_t features)
407{
408 struct qeth_card *card = dev->ml_priv;
409 netdev_features_t changed = dev->features ^ features;
410
411 QETH_DBF_TEXT(SETUP, 2, "setfeat");
412 QETH_DBF_HEX(SETUP, 2, &features, sizeof(features));
413
414 if (card->state == CARD_STATE_DOWN ||
415 card->state == CARD_STATE_RECOVER)
416 return 0;
417
418 if (!(changed & NETIF_F_RXCSUM))
419 return 0;
420 return qeth_set_rx_csum(card, features & NETIF_F_RXCSUM ? 1 : 0);
421}
422
423static int qeth_l2_stop_card(struct qeth_card *card, int recovery_mode)
424{
425 int rc = 0;
426
427 QETH_DBF_TEXT(SETUP , 2, "stopcard");
428 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
429
430 qeth_set_allowed_threads(card, 0, 1);
431 if (card->read.state == CH_STATE_UP &&
432 card->write.state == CH_STATE_UP &&
433 (card->state == CARD_STATE_UP)) {
434 if (recovery_mode &&
435 card->info.type != QETH_CARD_TYPE_OSN) {
436 qeth_l2_stop(card->dev);
437 } else {
438 rtnl_lock();
439 dev_close(card->dev);
440 rtnl_unlock();
441 }
442 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
443 card->state = CARD_STATE_SOFTSETUP;
444 }
445 if (card->state == CARD_STATE_SOFTSETUP) {
446 qeth_l2_del_all_mc(card, 0);
447 qeth_clear_ipacmd_list(card);
448 card->state = CARD_STATE_HARDSETUP;
449 }
450 if (card->state == CARD_STATE_HARDSETUP) {
451 qeth_qdio_clear_card(card, 0);
452 qeth_clear_qdio_buffers(card);
453 qeth_clear_working_pool_list(card);
454 card->state = CARD_STATE_DOWN;
455 }
456 if (card->state == CARD_STATE_DOWN) {
457 qeth_clear_cmd_buffers(&card->read);
458 qeth_clear_cmd_buffers(&card->write);
459 }
460
461 flush_workqueue(card->event_wq);
462 return rc;
463}
464
465static int qeth_l2_process_inbound_buffer(struct qeth_card *card,
466 int budget, int *done)
467{
468 int work_done = 0;
469 struct sk_buff *skb;
470 struct qeth_hdr *hdr;
471 unsigned int len;
472
473 *done = 0;
474 WARN_ON_ONCE(!budget);
475 while (budget) {
476 skb = qeth_core_get_next_skb(card,
477 &card->qdio.in_q->bufs[card->rx.b_index],
478 &card->rx.b_element, &card->rx.e_offset, &hdr);
479 if (!skb) {
480 *done = 1;
481 break;
482 }
483 skb->dev = card->dev;
484 switch (hdr->hdr.l2.id) {
485 case QETH_HEADER_TYPE_LAYER2:
486 skb->pkt_type = PACKET_HOST;
487 skb->protocol = eth_type_trans(skb, skb->dev);
488 if ((card->dev->features & NETIF_F_RXCSUM)
489 && ((hdr->hdr.l2.flags[1] &
490 (QETH_HDR_EXT_CSUM_HDR_REQ |
491 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
492 (QETH_HDR_EXT_CSUM_HDR_REQ |
493 QETH_HDR_EXT_CSUM_TRANSP_REQ)))
494 skb->ip_summed = CHECKSUM_UNNECESSARY;
495 else
496 skb->ip_summed = CHECKSUM_NONE;
497 if (skb->protocol == htons(ETH_P_802_2))
498 *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
499 len = skb->len;
500 napi_gro_receive(&card->napi, skb);
501 break;
502 case QETH_HEADER_TYPE_OSN:
503 if (card->info.type == QETH_CARD_TYPE_OSN) {
504 skb_push(skb, sizeof(struct qeth_hdr));
505 skb_copy_to_linear_data(skb, hdr,
506 sizeof(struct qeth_hdr));
507 len = skb->len;
508 card->osn_info.data_cb(skb);
509 break;
510 }
511
512 default:
513 dev_kfree_skb_any(skb);
514 QETH_CARD_TEXT(card, 3, "inbunkno");
515 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
516 continue;
517 }
518 work_done++;
519 budget--;
520 card->stats.rx_packets++;
521 card->stats.rx_bytes += len;
522 }
523 return work_done;
524}
525
526static int qeth_l2_poll(struct napi_struct *napi, int budget)
527{
528 struct qeth_card *card = container_of(napi, struct qeth_card, napi);
529 int work_done = 0;
530 struct qeth_qdio_buffer *buffer;
531 int done;
532 int new_budget = budget;
533
534 if (card->options.performance_stats) {
535 card->perf_stats.inbound_cnt++;
536 card->perf_stats.inbound_start_time = qeth_get_micros();
537 }
538
539 while (1) {
540 if (!card->rx.b_count) {
541 card->rx.qdio_err = 0;
542 card->rx.b_count = qdio_get_next_buffers(
543 card->data.ccwdev, 0, &card->rx.b_index,
544 &card->rx.qdio_err);
545 if (card->rx.b_count <= 0) {
546 card->rx.b_count = 0;
547 break;
548 }
549 card->rx.b_element =
550 &card->qdio.in_q->bufs[card->rx.b_index]
551 .buffer->element[0];
552 card->rx.e_offset = 0;
553 }
554
555 while (card->rx.b_count) {
556 buffer = &card->qdio.in_q->bufs[card->rx.b_index];
557 if (!(card->rx.qdio_err &&
558 qeth_check_qdio_errors(card, buffer->buffer,
559 card->rx.qdio_err, "qinerr")))
560 work_done += qeth_l2_process_inbound_buffer(
561 card, new_budget, &done);
562 else
563 done = 1;
564
565 if (done) {
566 if (card->options.performance_stats)
567 card->perf_stats.bufs_rec++;
568 qeth_put_buffer_pool_entry(card,
569 buffer->pool_entry);
570 qeth_queue_input_buffer(card, card->rx.b_index);
571 card->rx.b_count--;
572 if (card->rx.b_count) {
573 card->rx.b_index =
574 (card->rx.b_index + 1) %
575 QDIO_MAX_BUFFERS_PER_Q;
576 card->rx.b_element =
577 &card->qdio.in_q
578 ->bufs[card->rx.b_index]
579 .buffer->element[0];
580 card->rx.e_offset = 0;
581 }
582 }
583
584 if (work_done >= budget)
585 goto out;
586 else
587 new_budget = budget - work_done;
588 }
589 }
590
591 napi_complete(napi);
592 if (qdio_start_irq(card->data.ccwdev, 0))
593 napi_schedule(&card->napi);
594out:
595 if (card->options.performance_stats)
596 card->perf_stats.inbound_time += qeth_get_micros() -
597 card->perf_stats.inbound_start_time;
598 return work_done;
599}
600
601static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
602 enum qeth_ipa_cmds ipacmd,
603 int (*reply_cb) (struct qeth_card *,
604 struct qeth_reply*,
605 unsigned long))
606{
607 struct qeth_ipa_cmd *cmd;
608 struct qeth_cmd_buffer *iob;
609
610 QETH_CARD_TEXT(card, 2, "L2sdmac");
611 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
612 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
613 cmd->data.setdelmac.mac_length = OSA_ADDR_LEN;
614 memcpy(&cmd->data.setdelmac.mac, mac, OSA_ADDR_LEN);
615 return qeth_send_ipa_cmd(card, iob, reply_cb, NULL);
616}
617
618static int qeth_l2_send_setmac_cb(struct qeth_card *card,
619 struct qeth_reply *reply,
620 unsigned long data)
621{
622 struct qeth_ipa_cmd *cmd;
623
624 QETH_CARD_TEXT(card, 2, "L2Smaccb");
625 cmd = (struct qeth_ipa_cmd *) data;
626 if (cmd->hdr.return_code) {
627 QETH_CARD_TEXT_(card, 2, "L2er%x", cmd->hdr.return_code);
628 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
629 switch (cmd->hdr.return_code) {
630 case IPA_RC_L2_DUP_MAC:
631 case IPA_RC_L2_DUP_LAYER3_MAC:
632 dev_warn(&card->gdev->dev,
633 "MAC address %pM already exists\n",
634 cmd->data.setdelmac.mac);
635 break;
636 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
637 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
638 dev_warn(&card->gdev->dev,
639 "MAC address %pM is not authorized\n",
640 cmd->data.setdelmac.mac);
641 break;
642 default:
643 break;
644 }
645 } else {
646 card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
647 memcpy(card->dev->dev_addr, cmd->data.setdelmac.mac,
648 OSA_ADDR_LEN);
649 dev_info(&card->gdev->dev,
650 "MAC address %pM successfully registered on device %s\n",
651 card->dev->dev_addr, card->dev->name);
652 }
653 return 0;
654}
655
656static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
657{
658 QETH_CARD_TEXT(card, 2, "L2Setmac");
659 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC,
660 qeth_l2_send_setmac_cb);
661}
662
663static int qeth_l2_send_delmac_cb(struct qeth_card *card,
664 struct qeth_reply *reply,
665 unsigned long data)
666{
667 struct qeth_ipa_cmd *cmd;
668
669 QETH_CARD_TEXT(card, 2, "L2Dmaccb");
670 cmd = (struct qeth_ipa_cmd *) data;
671 if (cmd->hdr.return_code) {
672 QETH_CARD_TEXT_(card, 2, "err%d", cmd->hdr.return_code);
673 return 0;
674 }
675 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
676
677 return 0;
678}
679
680static int qeth_l2_send_delmac(struct qeth_card *card, __u8 *mac)
681{
682 QETH_CARD_TEXT(card, 2, "L2Delmac");
683 if (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
684 return 0;
685 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELVMAC,
686 qeth_l2_send_delmac_cb);
687}
688
689static int qeth_l2_request_initial_mac(struct qeth_card *card)
690{
691 int rc = 0;
692 char vendor_pre[] = {0x02, 0x00, 0x00};
693
694 QETH_DBF_TEXT(SETUP, 2, "l2reqmac");
695 QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card));
696
697 if (MACHINE_IS_VM) {
698 rc = qeth_vm_request_mac(card);
699 if (!rc)
700 goto out;
701 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
702 CARD_DEVID(card), rc);
703 QETH_DBF_TEXT_(SETUP, 2, "err%04x", rc);
704
705 }
706
707 if (qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
708 rc = qeth_query_setadapterparms(card);
709 if (rc) {
710 QETH_DBF_MESSAGE(2, "could not query adapter parameters on device %x: %#x\n",
711 CARD_DEVID(card), rc);
712 }
713 }
714
715 if (!IS_OSN(card)) {
716 rc = qeth_setadpparms_change_macaddr(card);
717 if (!rc && is_valid_ether_addr(card->dev->dev_addr))
718 goto out;
719 QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
720 CARD_DEVID(card), rc);
721 QETH_DBF_TEXT_(SETUP, 2, "1err%04x", rc);
722
723 }
724
725
726 if (card->info.type == QETH_CARD_TYPE_OSM ||
727 card->info.type == QETH_CARD_TYPE_OSX)
728 return (rc) ? rc : -EADDRNOTAVAIL;
729
730 eth_random_addr(card->dev->dev_addr);
731 memcpy(card->dev->dev_addr, vendor_pre, 3);
732out:
733 QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, card->dev->addr_len);
734 return 0;
735}
736
737static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
738{
739 struct sockaddr *addr = p;
740 struct qeth_card *card = dev->ml_priv;
741 int rc = 0;
742
743 QETH_CARD_TEXT(card, 3, "setmac");
744
745 if (qeth_l2_verify_dev(dev) != QETH_REAL_CARD) {
746 QETH_CARD_TEXT(card, 3, "setmcINV");
747 return -EOPNOTSUPP;
748 }
749
750 if (card->info.type == QETH_CARD_TYPE_OSN ||
751 card->info.type == QETH_CARD_TYPE_OSM ||
752 card->info.type == QETH_CARD_TYPE_OSX) {
753 QETH_CARD_TEXT(card, 3, "setmcTYP");
754 return -EOPNOTSUPP;
755 }
756 QETH_CARD_HEX(card, 3, addr->sa_data, OSA_ADDR_LEN);
757 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
758 QETH_CARD_TEXT(card, 3, "setmcREC");
759 return -ERESTARTSYS;
760 }
761 rc = qeth_l2_send_delmac(card, &card->dev->dev_addr[0]);
762 if (!rc || (rc == IPA_RC_L2_MAC_NOT_FOUND))
763 rc = qeth_l2_send_setmac(card, addr->sa_data);
764 return rc ? -EINVAL : 0;
765}
766
767static void qeth_promisc_to_bridge(struct qeth_card *card)
768{
769 struct net_device *dev = card->dev;
770 enum qeth_ipa_promisc_modes promisc_mode;
771 int role;
772 int rc;
773
774 QETH_CARD_TEXT(card, 3, "pmisc2br");
775
776 if (!card->options.sbp.reflect_promisc)
777 return;
778 promisc_mode = (dev->flags & IFF_PROMISC) ? SET_PROMISC_MODE_ON
779 : SET_PROMISC_MODE_OFF;
780 if (promisc_mode == card->info.promisc_mode)
781 return;
782
783 if (promisc_mode == SET_PROMISC_MODE_ON) {
784 if (card->options.sbp.reflect_promisc_primary)
785 role = QETH_SBP_ROLE_PRIMARY;
786 else
787 role = QETH_SBP_ROLE_SECONDARY;
788 } else
789 role = QETH_SBP_ROLE_NONE;
790
791 rc = qeth_bridgeport_setrole(card, role);
792 QETH_DBF_TEXT_(SETUP, 2, "bpm%c%04x",
793 (promisc_mode == SET_PROMISC_MODE_ON) ? '+' : '-', rc);
794 if (!rc) {
795 card->options.sbp.role = role;
796 card->info.promisc_mode = promisc_mode;
797 }
798}
799
800static void qeth_l2_set_multicast_list(struct net_device *dev)
801{
802 struct qeth_card *card = dev->ml_priv;
803 struct netdev_hw_addr *ha;
804
805 if (card->info.type == QETH_CARD_TYPE_OSN)
806 return ;
807
808 QETH_CARD_TEXT(card, 3, "setmulti");
809 if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
810 (card->state != CARD_STATE_UP))
811 return;
812 qeth_l2_del_all_mc(card, 1);
813 spin_lock_bh(&card->mclock);
814 netdev_for_each_mc_addr(ha, dev)
815 qeth_l2_add_mc(card, ha->addr, 0);
816
817 netdev_for_each_uc_addr(ha, dev)
818 qeth_l2_add_mc(card, ha->addr, 1);
819
820 spin_unlock_bh(&card->mclock);
821 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
822 qeth_setadp_promisc_mode(card);
823 else
824 qeth_promisc_to_bridge(card);
825}
826
827static int qeth_l2_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
828{
829 int rc;
830 struct qeth_hdr *hdr = NULL;
831 int elements = 0;
832 struct qeth_card *card = dev->ml_priv;
833 struct sk_buff *new_skb = skb;
834 int cast_type = qeth_l2_get_cast_type(card, skb);
835 struct qeth_qdio_out_q *queue;
836 int tx_bytes = skb->len;
837 int data_offset = -1;
838 int elements_needed = 0;
839 int hd_len = 0;
840
841 if (card->qdio.do_prio_queueing || (cast_type &&
842 card->info.is_multicast_different))
843 queue = card->qdio.out_qs[qeth_get_priority_queue(card, skb,
844 qeth_get_ip_version(skb), cast_type)];
845 else
846 queue = card->qdio.out_qs[card->qdio.default_out_queue];
847
848 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
849 card->stats.tx_carrier_errors++;
850 goto tx_drop;
851 }
852
853 if ((card->info.type == QETH_CARD_TYPE_OSN) &&
854 (skb->protocol == htons(ETH_P_IPV6)))
855 goto tx_drop;
856
857 if (card->options.performance_stats) {
858 card->perf_stats.outbound_cnt++;
859 card->perf_stats.outbound_start_time = qeth_get_micros();
860 }
861 netif_stop_queue(dev);
862
863 if (card->info.type == QETH_CARD_TYPE_OSN)
864 hdr = (struct qeth_hdr *)skb->data;
865 else {
866 if (card->info.type == QETH_CARD_TYPE_IQD) {
867 new_skb = skb;
868 data_offset = ETH_HLEN;
869 hd_len = ETH_HLEN;
870 hdr = kmem_cache_alloc(qeth_core_header_cache,
871 GFP_ATOMIC);
872 if (!hdr)
873 goto tx_drop;
874 elements_needed++;
875 skb_reset_mac_header(new_skb);
876 qeth_l2_fill_header(card, hdr, new_skb, cast_type);
877 hdr->hdr.l2.pkt_length = new_skb->len;
878 memcpy(((char *)hdr) + sizeof(struct qeth_hdr),
879 skb_mac_header(new_skb), ETH_HLEN);
880 } else {
881
882 new_skb = skb_realloc_headroom(skb,
883 sizeof(struct qeth_hdr));
884 if (!new_skb)
885 goto tx_drop;
886 hdr = (struct qeth_hdr *)skb_push(new_skb,
887 sizeof(struct qeth_hdr));
888 skb_set_mac_header(new_skb, sizeof(struct qeth_hdr));
889 qeth_l2_fill_header(card, hdr, new_skb, cast_type);
890 if (new_skb->ip_summed == CHECKSUM_PARTIAL)
891 qeth_l2_hdr_csum(card, hdr, new_skb);
892 }
893 }
894
895 elements = qeth_get_elements_no(card, new_skb, elements_needed,
896 (data_offset > 0) ? data_offset : 0);
897 if (!elements) {
898 if (data_offset >= 0)
899 kmem_cache_free(qeth_core_header_cache, hdr);
900 goto tx_drop;
901 }
902
903 if (card->info.type != QETH_CARD_TYPE_IQD) {
904 if (qeth_hdr_chk_and_bounce(new_skb, &hdr,
905 sizeof(struct qeth_hdr_layer2)))
906 goto tx_drop;
907 rc = qeth_do_send_packet(card, queue, new_skb, hdr,
908 elements);
909 } else
910 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
911 elements, data_offset, hd_len);
912 if (!rc) {
913 card->stats.tx_packets++;
914 card->stats.tx_bytes += tx_bytes;
915 if (new_skb != skb)
916 dev_kfree_skb_any(skb);
917 rc = NETDEV_TX_OK;
918 } else {
919 if (data_offset >= 0)
920 kmem_cache_free(qeth_core_header_cache, hdr);
921
922 if (rc == -EBUSY) {
923 if (new_skb != skb)
924 dev_kfree_skb_any(new_skb);
925 return NETDEV_TX_BUSY;
926 } else
927 goto tx_drop;
928 }
929
930 netif_wake_queue(dev);
931 if (card->options.performance_stats)
932 card->perf_stats.outbound_time += qeth_get_micros() -
933 card->perf_stats.outbound_start_time;
934 return rc;
935
936tx_drop:
937 card->stats.tx_dropped++;
938 card->stats.tx_errors++;
939 if ((new_skb != skb) && new_skb)
940 dev_kfree_skb_any(new_skb);
941 dev_kfree_skb_any(skb);
942 netif_wake_queue(dev);
943 return NETDEV_TX_OK;
944}
945
946static int __qeth_l2_open(struct net_device *dev)
947{
948 struct qeth_card *card = dev->ml_priv;
949 int rc = 0;
950
951 QETH_CARD_TEXT(card, 4, "qethopen");
952 if (card->state == CARD_STATE_UP)
953 return rc;
954 if (card->state != CARD_STATE_SOFTSETUP)
955 return -ENODEV;
956
957 if ((card->info.type != QETH_CARD_TYPE_OSN) &&
958 (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))) {
959 QETH_CARD_TEXT(card, 4, "nomacadr");
960 return -EPERM;
961 }
962 card->data.state = CH_STATE_UP;
963 card->state = CARD_STATE_UP;
964 netif_start_queue(dev);
965
966 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
967 napi_enable(&card->napi);
968 napi_schedule(&card->napi);
969 } else
970 rc = -EIO;
971 return rc;
972}
973
974static int qeth_l2_open(struct net_device *dev)
975{
976 struct qeth_card *card = dev->ml_priv;
977
978 QETH_CARD_TEXT(card, 5, "qethope_");
979 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
980 QETH_CARD_TEXT(card, 3, "openREC");
981 return -ERESTARTSYS;
982 }
983 return __qeth_l2_open(dev);
984}
985
986static int qeth_l2_stop(struct net_device *dev)
987{
988 struct qeth_card *card = dev->ml_priv;
989
990 QETH_CARD_TEXT(card, 4, "qethstop");
991 netif_tx_disable(dev);
992 if (card->state == CARD_STATE_UP) {
993 card->state = CARD_STATE_SOFTSETUP;
994 napi_disable(&card->napi);
995 }
996 return 0;
997}
998
999static const struct device_type qeth_l2_devtype = {
1000 .name = "qeth_layer2",
1001 .groups = qeth_l2_attr_groups,
1002};
1003
1004static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
1005{
1006 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1007 int rc;
1008
1009 if (gdev->dev.type == &qeth_generic_devtype) {
1010 rc = qeth_l2_create_device_attributes(&gdev->dev);
1011 if (rc)
1012 return rc;
1013 }
1014 INIT_LIST_HEAD(&card->vid_list);
1015 INIT_LIST_HEAD(&card->mc_list);
1016 card->options.layer2 = 1;
1017 card->info.hwtrap = 0;
1018 return 0;
1019}
1020
1021static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
1022{
1023 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
1024
1025 if (cgdev->dev.type == &qeth_generic_devtype)
1026 qeth_l2_remove_device_attributes(&cgdev->dev);
1027 qeth_set_allowed_threads(card, 0, 1);
1028 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
1029
1030 if (cgdev->state == CCWGROUP_ONLINE)
1031 qeth_l2_set_offline(cgdev);
1032
1033 cancel_work_sync(&card->close_dev_work);
1034 if (card->dev) {
1035 unregister_netdev(card->dev);
1036 free_netdev(card->dev);
1037 card->dev = NULL;
1038 }
1039 return;
1040}
1041
1042static const struct ethtool_ops qeth_l2_ethtool_ops = {
1043 .get_link = ethtool_op_get_link,
1044 .get_strings = qeth_core_get_strings,
1045 .get_ethtool_stats = qeth_core_get_ethtool_stats,
1046 .get_sset_count = qeth_core_get_sset_count,
1047 .get_drvinfo = qeth_core_get_drvinfo,
1048 .get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
1049};
1050
1051static const struct ethtool_ops qeth_l2_osn_ops = {
1052 .get_strings = qeth_core_get_strings,
1053 .get_ethtool_stats = qeth_core_get_ethtool_stats,
1054 .get_sset_count = qeth_core_get_sset_count,
1055 .get_drvinfo = qeth_core_get_drvinfo,
1056};
1057
1058static const struct net_device_ops qeth_l2_netdev_ops = {
1059 .ndo_open = qeth_l2_open,
1060 .ndo_stop = qeth_l2_stop,
1061 .ndo_get_stats = qeth_get_stats,
1062 .ndo_start_xmit = qeth_l2_hard_start_xmit,
1063 .ndo_validate_addr = eth_validate_addr,
1064 .ndo_set_rx_mode = qeth_l2_set_multicast_list,
1065 .ndo_do_ioctl = qeth_l2_do_ioctl,
1066 .ndo_set_mac_address = qeth_l2_set_mac_address,
1067 .ndo_change_mtu_rh74 = qeth_change_mtu,
1068 .ndo_vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid,
1069 .ndo_vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid,
1070 .ndo_tx_timeout = qeth_tx_timeout,
1071 .ndo_fix_features = qeth_l2_fix_features,
1072 .ndo_set_features = qeth_l2_set_features
1073};
1074
1075static int qeth_l2_setup_netdev(struct qeth_card *card)
1076{
1077 switch (card->info.type) {
1078 case QETH_CARD_TYPE_IQD:
1079 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
1080 break;
1081 case QETH_CARD_TYPE_OSN:
1082 card->dev = alloc_netdev(0, "osn%d", ether_setup);
1083 card->dev->flags |= IFF_NOARP;
1084 break;
1085 default:
1086 card->dev = alloc_etherdev(0);
1087 }
1088
1089 if (!card->dev)
1090 return -ENODEV;
1091
1092 card->dev->ml_priv = card;
1093 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
1094 card->dev->mtu = card->info.initial_mtu;
1095 card->dev->netdev_ops = &qeth_l2_netdev_ops;
1096 if (card->info.type != QETH_CARD_TYPE_OSN)
1097 SET_ETHTOOL_OPS(card->dev, &qeth_l2_ethtool_ops);
1098 else
1099 SET_ETHTOOL_OPS(card->dev, &qeth_l2_osn_ops);
1100 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1101 if (card->info.type == QETH_CARD_TYPE_OSD && !card->info.guestlan) {
1102 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
1103 card->dev->hw_features |= NETIF_F_IP_CSUM;
1104 card->dev->vlan_features |= NETIF_F_IP_CSUM;
1105 }
1106 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
1107 card->dev->hw_features |= NETIF_F_RXCSUM;
1108 card->dev->vlan_features |= NETIF_F_RXCSUM;
1109 }
1110 }
1111 card->info.broadcast_capable = 1;
1112 qeth_l2_request_initial_mac(card);
1113 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
1114 netif_napi_add(card->dev, &card->napi, qeth_l2_poll, QETH_NAPI_WEIGHT);
1115 netif_carrier_off(card->dev);
1116 return register_netdev(card->dev);
1117}
1118
1119static int qeth_l2_start_ipassists(struct qeth_card *card)
1120{
1121
1122 if (qeth_set_access_ctrl_online(card, 0))
1123 return -ENODEV;
1124 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM))
1125 qeth_set_rx_csum(card, 1);
1126 qeth_start_ipa_tx_checksum(card);
1127 return 0;
1128}
1129
1130static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
1131{
1132 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1133 int rc = 0;
1134 enum qeth_card_states recover_flag;
1135
1136 mutex_lock(&card->discipline_mutex);
1137 mutex_lock(&card->conf_mutex);
1138 QETH_DBF_TEXT(SETUP, 2, "setonlin");
1139 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
1140
1141 recover_flag = card->state;
1142 rc = qeth_core_hardsetup_card(card);
1143 if (rc) {
1144 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
1145 rc = -ENODEV;
1146 goto out_remove;
1147 }
1148 qeth_bridgeport_query_support(card);
1149 if (card->options.sbp.supported_funcs)
1150 dev_info(&card->gdev->dev,
1151 "The device represents a Bridge Capable Port\n");
1152 qeth_trace_features(card);
1153
1154 if (!card->dev && qeth_l2_setup_netdev(card)) {
1155 rc = -ENODEV;
1156 goto out_remove;
1157 }
1158
1159 if (card->info.type != QETH_CARD_TYPE_OSN)
1160 qeth_l2_send_setmac(card, &card->dev->dev_addr[0]);
1161
1162 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
1163 if (card->info.hwtrap &&
1164 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
1165 card->info.hwtrap = 0;
1166 } else
1167 card->info.hwtrap = 0;
1168
1169 qeth_l2_setup_bridgeport_attrs(card);
1170
1171 card->state = CARD_STATE_HARDSETUP;
1172 memset(&card->rx, 0, sizeof(struct qeth_rx));
1173 qeth_print_status_message(card);
1174
1175
1176 QETH_DBF_TEXT(SETUP, 2, "softsetp");
1177
1178 rc = qeth_send_startlan(card);
1179 if (rc) {
1180 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
1181 if (rc == 0xe080) {
1182 dev_warn(&card->gdev->dev,
1183 "The LAN is offline\n");
1184 card->lan_online = 0;
1185 goto contin;
1186 }
1187 rc = -ENODEV;
1188 goto out_remove;
1189 } else
1190 card->lan_online = 1;
1191
1192contin:
1193 if ((card->info.type == QETH_CARD_TYPE_OSD) ||
1194 (card->info.type == QETH_CARD_TYPE_OSX)) {
1195 if (qeth_l2_start_ipassists(card))
1196 goto out_remove;
1197 }
1198
1199 if (card->info.type != QETH_CARD_TYPE_OSN &&
1200 card->info.type != QETH_CARD_TYPE_OSM)
1201 qeth_l2_process_vlans(card);
1202
1203 netif_tx_disable(card->dev);
1204
1205 rc = qeth_init_qdio_queues(card);
1206 if (rc) {
1207 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
1208 rc = -ENODEV;
1209 goto out_remove;
1210 }
1211 card->state = CARD_STATE_SOFTSETUP;
1212 if (card->lan_online)
1213 netif_carrier_on(card->dev);
1214 else
1215 netif_carrier_off(card->dev);
1216
1217 qeth_set_allowed_threads(card, 0xffffffff, 0);
1218 if (recover_flag == CARD_STATE_RECOVER) {
1219 if (recovery_mode &&
1220 card->info.type != QETH_CARD_TYPE_OSN) {
1221 __qeth_l2_open(card->dev);
1222 } else {
1223 rtnl_lock();
1224 dev_open(card->dev);
1225 rtnl_unlock();
1226 }
1227
1228 qeth_l2_set_multicast_list(card->dev);
1229 }
1230
1231 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
1232 mutex_unlock(&card->conf_mutex);
1233 mutex_unlock(&card->discipline_mutex);
1234 return 0;
1235
1236out_remove:
1237 qeth_l2_stop_card(card, 0);
1238 ccw_device_set_offline(CARD_DDEV(card));
1239 ccw_device_set_offline(CARD_WDEV(card));
1240 ccw_device_set_offline(CARD_RDEV(card));
1241 qdio_free(CARD_DDEV(card));
1242 if (recover_flag == CARD_STATE_RECOVER)
1243 card->state = CARD_STATE_RECOVER;
1244 else
1245 card->state = CARD_STATE_DOWN;
1246 mutex_unlock(&card->conf_mutex);
1247 mutex_unlock(&card->discipline_mutex);
1248 return rc;
1249}
1250
1251static int qeth_l2_set_online(struct ccwgroup_device *gdev)
1252{
1253 return __qeth_l2_set_online(gdev, 0);
1254}
1255
1256static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev,
1257 int recovery_mode)
1258{
1259 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
1260 int rc = 0, rc2 = 0, rc3 = 0;
1261 enum qeth_card_states recover_flag;
1262
1263 mutex_lock(&card->discipline_mutex);
1264 mutex_lock(&card->conf_mutex);
1265 QETH_DBF_TEXT(SETUP, 3, "setoffl");
1266 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
1267
1268 if (card->dev && netif_carrier_ok(card->dev))
1269 netif_carrier_off(card->dev);
1270 recover_flag = card->state;
1271 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
1272 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
1273 card->info.hwtrap = 1;
1274 }
1275 qeth_l2_stop_card(card, recovery_mode);
1276 rc = ccw_device_set_offline(CARD_DDEV(card));
1277 rc2 = ccw_device_set_offline(CARD_WDEV(card));
1278 rc3 = ccw_device_set_offline(CARD_RDEV(card));
1279 if (!rc)
1280 rc = (rc2) ? rc2 : rc3;
1281 if (rc)
1282 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
1283 qdio_free(CARD_DDEV(card));
1284 if (recover_flag == CARD_STATE_UP)
1285 card->state = CARD_STATE_RECOVER;
1286
1287 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
1288 mutex_unlock(&card->conf_mutex);
1289 mutex_unlock(&card->discipline_mutex);
1290 return 0;
1291}
1292
1293static int qeth_l2_set_offline(struct ccwgroup_device *cgdev)
1294{
1295 return __qeth_l2_set_offline(cgdev, 0);
1296}
1297
1298static int qeth_l2_recover(void *ptr)
1299{
1300 struct qeth_card *card;
1301 int rc = 0;
1302
1303 card = (struct qeth_card *) ptr;
1304 QETH_CARD_TEXT(card, 2, "recover1");
1305 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
1306 return 0;
1307 QETH_CARD_TEXT(card, 2, "recover2");
1308 dev_warn(&card->gdev->dev,
1309 "A recovery process has been started for the device\n");
1310 qeth_set_recovery_task(card);
1311 __qeth_l2_set_offline(card->gdev, 1);
1312 rc = __qeth_l2_set_online(card->gdev, 1);
1313 if (!rc)
1314 dev_info(&card->gdev->dev,
1315 "Device successfully recovered!\n");
1316 else {
1317 qeth_close_dev(card);
1318 dev_warn(&card->gdev->dev, "The qeth device driver "
1319 "failed to recover an error on the device\n");
1320 }
1321 qeth_clear_recovery_task(card);
1322 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
1323 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
1324 return 0;
1325}
1326
1327static int __init qeth_l2_init(void)
1328{
1329 pr_info("register layer 2 discipline\n");
1330 return 0;
1331}
1332
1333static void __exit qeth_l2_exit(void)
1334{
1335 pr_info("unregister layer 2 discipline\n");
1336}
1337
1338static void qeth_l2_shutdown(struct ccwgroup_device *gdev)
1339{
1340 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1341 qeth_set_allowed_threads(card, 0, 1);
1342 if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap)
1343 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
1344 qeth_qdio_clear_card(card, 0);
1345 qeth_clear_qdio_buffers(card);
1346 qdio_free(CARD_DDEV(card));
1347}
1348
1349static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev)
1350{
1351 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1352
1353 if (card->dev)
1354 netif_device_detach(card->dev);
1355 qeth_set_allowed_threads(card, 0, 1);
1356 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
1357 if (gdev->state == CCWGROUP_OFFLINE)
1358 return 0;
1359 if (card->state == CARD_STATE_UP) {
1360 if (card->info.hwtrap)
1361 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
1362 __qeth_l2_set_offline(card->gdev, 1);
1363 } else
1364 __qeth_l2_set_offline(card->gdev, 0);
1365 return 0;
1366}
1367
1368static int qeth_l2_pm_resume(struct ccwgroup_device *gdev)
1369{
1370 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1371 int rc = 0;
1372
1373 if (gdev->state == CCWGROUP_OFFLINE)
1374 goto out;
1375
1376 if (card->state == CARD_STATE_RECOVER) {
1377 rc = __qeth_l2_set_online(card->gdev, 1);
1378 if (rc) {
1379 rtnl_lock();
1380 dev_close(card->dev);
1381 rtnl_unlock();
1382 }
1383 } else
1384 rc = __qeth_l2_set_online(card->gdev, 0);
1385out:
1386 qeth_set_allowed_threads(card, 0xffffffff, 0);
1387 if (card->dev)
1388 netif_device_attach(card->dev);
1389 if (rc)
1390 dev_warn(&card->gdev->dev, "The qeth device driver "
1391 "failed to recover an error on the device\n");
1392 return rc;
1393}
1394
1395
1396static int qeth_l2_control_event(struct qeth_card *card,
1397 struct qeth_ipa_cmd *cmd)
1398{
1399 switch (cmd->hdr.command) {
1400 case IPA_CMD_SETBRIDGEPORT_OSA:
1401 case IPA_CMD_SETBRIDGEPORT_IQD:
1402 if (cmd->data.sbp.hdr.command_code ==
1403 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
1404 qeth_bridge_state_change(card, cmd);
1405 return 0;
1406 } else
1407 return 1;
1408 case IPA_CMD_ADDRESS_CHANGE_NOTIF:
1409 qeth_bridge_host_event(card, cmd);
1410 return 0;
1411 default:
1412 return 1;
1413 }
1414}
1415
1416struct qeth_discipline qeth_l2_discipline = {
1417 .devtype = &qeth_l2_devtype,
1418 .start_poll = qeth_qdio_start_poll,
1419 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
1420 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler,
1421 .recover = qeth_l2_recover,
1422 .setup = qeth_l2_probe_device,
1423 .remove = qeth_l2_remove_device,
1424 .set_online = qeth_l2_set_online,
1425 .set_offline = qeth_l2_set_offline,
1426 .shutdown = qeth_l2_shutdown,
1427 .freeze = qeth_l2_pm_suspend,
1428 .thaw = qeth_l2_pm_resume,
1429 .restore = qeth_l2_pm_resume,
1430 .control_event_handler = qeth_l2_control_event,
1431};
1432EXPORT_SYMBOL_GPL(qeth_l2_discipline);
1433
1434static int qeth_osn_send_control_data(struct qeth_card *card, int len,
1435 struct qeth_cmd_buffer *iob)
1436{
1437 unsigned long flags;
1438 int rc = 0;
1439
1440 QETH_CARD_TEXT(card, 5, "osndctrd");
1441
1442 wait_event(card->wait_q,
1443 atomic_cmpxchg(&card->write.irq_pending, 0, 1) == 0);
1444 qeth_prepare_control_data(card, len, iob);
1445 QETH_CARD_TEXT(card, 6, "osnoirqp");
1446 spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags);
1447 rc = ccw_device_start(card->write.ccwdev, &card->write.ccw,
1448 (addr_t) iob, 0, 0);
1449 spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags);
1450 if (rc) {
1451 QETH_DBF_MESSAGE(2, "qeth_osn_send_control_data: "
1452 "ccw_device_start rc = %i\n", rc);
1453 QETH_CARD_TEXT_(card, 2, " err%d", rc);
1454 qeth_release_buffer(iob->channel, iob);
1455 atomic_set(&card->write.irq_pending, 0);
1456 wake_up(&card->wait_q);
1457 }
1458 return rc;
1459}
1460
1461static int qeth_osn_send_ipa_cmd(struct qeth_card *card,
1462 struct qeth_cmd_buffer *iob, int data_len)
1463{
1464 u16 s1, s2;
1465
1466 QETH_CARD_TEXT(card, 4, "osndipa");
1467
1468 qeth_prepare_ipa_cmd(card, iob, QETH_PROT_OSN2);
1469 s1 = (u16)(IPA_PDU_HEADER_SIZE + data_len);
1470 s2 = (u16)data_len;
1471 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2);
1472 memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2);
1473 memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2);
1474 memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2);
1475 return qeth_osn_send_control_data(card, s1, iob);
1476}
1477
1478int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
1479{
1480 struct qeth_cmd_buffer *iob;
1481 struct qeth_card *card;
1482 int rc;
1483
1484 if (!dev)
1485 return -ENODEV;
1486 card = dev->ml_priv;
1487 if (!card)
1488 return -ENODEV;
1489 QETH_CARD_TEXT(card, 2, "osnsdmc");
1490 if ((card->state != CARD_STATE_UP) &&
1491 (card->state != CARD_STATE_SOFTSETUP))
1492 return -ENODEV;
1493 iob = qeth_wait_for_buffer(&card->write);
1494 memcpy(iob->data+IPA_PDU_HEADER_SIZE, data, data_len);
1495 rc = qeth_osn_send_ipa_cmd(card, iob, data_len);
1496 return rc;
1497}
1498EXPORT_SYMBOL(qeth_osn_assist);
1499
1500int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
1501 int (*assist_cb)(struct net_device *, void *),
1502 int (*data_cb)(struct sk_buff *))
1503{
1504 struct qeth_card *card;
1505
1506 *dev = qeth_l2_netdev_by_devno(read_dev_no);
1507 if (*dev == NULL)
1508 return -ENODEV;
1509 card = (*dev)->ml_priv;
1510 if (!card)
1511 return -ENODEV;
1512 QETH_CARD_TEXT(card, 2, "osnreg");
1513 if ((assist_cb == NULL) || (data_cb == NULL))
1514 return -EINVAL;
1515 card->osn_info.assist_cb = assist_cb;
1516 card->osn_info.data_cb = data_cb;
1517 return 0;
1518}
1519EXPORT_SYMBOL(qeth_osn_register);
1520
1521void qeth_osn_deregister(struct net_device *dev)
1522{
1523 struct qeth_card *card;
1524
1525 if (!dev)
1526 return;
1527 card = dev->ml_priv;
1528 if (!card)
1529 return;
1530 QETH_CARD_TEXT(card, 2, "osndereg");
1531 card->osn_info.assist_cb = NULL;
1532 card->osn_info.data_cb = NULL;
1533 return;
1534}
1535EXPORT_SYMBOL(qeth_osn_deregister);
1536
1537
1538
1539enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556static void qeth_bridge_emit_host_event(struct qeth_card *card,
1557 enum qeth_an_event_type evtype,
1558 u8 code, struct net_if_token *token, struct mac_addr_lnid *addr_lnid)
1559{
1560 char str[7][32];
1561 char *env[8];
1562 int i = 0;
1563
1564 switch (evtype) {
1565 case anev_reg_unreg:
1566 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
1567 (code & IPA_ADDR_CHANGE_CODE_REMOVAL)
1568 ? "deregister" : "register");
1569 env[i] = str[i]; i++;
1570 if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
1571 snprintf(str[i], sizeof(str[i]), "VLAN=%d",
1572 addr_lnid->lnid);
1573 env[i] = str[i]; i++;
1574 }
1575 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
1576 snprintf(str[i], sizeof(str[i]), "MAC=%pM6",
1577 &addr_lnid->mac);
1578 env[i] = str[i]; i++;
1579 }
1580 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
1581 token->cssid, token->ssid, token->devnum);
1582 env[i] = str[i]; i++;
1583 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
1584 env[i] = str[i]; i++;
1585 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
1586 token->chpid);
1587 env[i] = str[i]; i++;
1588 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
1589 env[i] = str[i]; i++;
1590 break;
1591 case anev_abort:
1592 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
1593 env[i] = str[i]; i++;
1594 break;
1595 case anev_reset:
1596 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
1597 env[i] = str[i]; i++;
1598 break;
1599 }
1600 env[i] = NULL;
1601 kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1602}
1603
1604struct qeth_bridge_state_data {
1605 struct work_struct worker;
1606 struct qeth_card *card;
1607 struct qeth_sbp_state_change qports;
1608};
1609
1610static void qeth_bridge_state_change_worker(struct work_struct *work)
1611{
1612 struct qeth_bridge_state_data *data =
1613 container_of(work, struct qeth_bridge_state_data, worker);
1614
1615 struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
1616 char env_locrem[32];
1617 char env_role[32];
1618 char env_state[32];
1619 char *env[] = {
1620 env_locrem,
1621 env_role,
1622 env_state,
1623 NULL
1624 };
1625
1626
1627
1628 mutex_lock(&data->card->conf_mutex);
1629 data->card->options.sbp.role = entry->role;
1630 mutex_unlock(&data->card->conf_mutex);
1631
1632 snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
1633 snprintf(env_role, sizeof(env_role), "ROLE=%s",
1634 (entry->role == QETH_SBP_ROLE_NONE) ? "none" :
1635 (entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
1636 (entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
1637 "<INVALID>");
1638 snprintf(env_state, sizeof(env_state), "STATE=%s",
1639 (entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
1640 (entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
1641 (entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
1642 "<INVALID>");
1643 kobject_uevent_env(&data->card->gdev->dev.kobj,
1644 KOBJ_CHANGE, env);
1645 kfree(data);
1646}
1647
1648static void qeth_bridge_state_change(struct qeth_card *card,
1649 struct qeth_ipa_cmd *cmd)
1650{
1651 struct qeth_sbp_state_change *qports =
1652 &cmd->data.sbp.data.state_change;
1653 struct qeth_bridge_state_data *data;
1654 int extrasize;
1655
1656 QETH_CARD_TEXT(card, 2, "brstchng");
1657 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1658 QETH_CARD_TEXT_(card, 2, "BPsz%.8d", qports->entry_length);
1659 return;
1660 }
1661 extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
1662 data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
1663 GFP_ATOMIC);
1664 if (!data) {
1665 QETH_CARD_TEXT(card, 2, "BPSalloc");
1666 return;
1667 }
1668 INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
1669 data->card = card;
1670 memcpy(&data->qports, qports,
1671 sizeof(struct qeth_sbp_state_change) + extrasize);
1672 queue_work(card->event_wq, &data->worker);
1673}
1674
1675struct qeth_bridge_host_data {
1676 struct work_struct worker;
1677 struct qeth_card *card;
1678 struct qeth_ipacmd_addr_change hostevs;
1679};
1680
1681static void qeth_bridge_host_event_worker(struct work_struct *work)
1682{
1683 struct qeth_bridge_host_data *data =
1684 container_of(work, struct qeth_bridge_host_data, worker);
1685 int i;
1686
1687 if (data->hostevs.lost_event_mask) {
1688 dev_info(&data->card->gdev->dev,
1689"Address notification from the Bridge Port stopped %s (%s)\n",
1690 data->card->dev->name,
1691 (data->hostevs.lost_event_mask == 0x01)
1692 ? "Overflow"
1693 : (data->hostevs.lost_event_mask == 0x02)
1694 ? "Bridge port state change"
1695 : "Unknown reason");
1696 mutex_lock(&data->card->conf_mutex);
1697 data->card->options.sbp.hostnotification = 0;
1698 mutex_unlock(&data->card->conf_mutex);
1699 qeth_bridge_emit_host_event(data->card, anev_abort,
1700 0, NULL, NULL);
1701 } else
1702 for (i = 0; i < data->hostevs.num_entries; i++) {
1703 struct qeth_ipacmd_addr_change_entry *entry =
1704 &data->hostevs.entry[i];
1705 qeth_bridge_emit_host_event(data->card,
1706 anev_reg_unreg,
1707 entry->change_code,
1708 &entry->token, &entry->addr_lnid);
1709 }
1710 kfree(data);
1711}
1712
1713static void qeth_bridge_host_event(struct qeth_card *card,
1714 struct qeth_ipa_cmd *cmd)
1715{
1716 struct qeth_ipacmd_addr_change *hostevs =
1717 &cmd->data.addrchange;
1718 struct qeth_bridge_host_data *data;
1719 int extrasize;
1720
1721 QETH_CARD_TEXT(card, 2, "brhostev");
1722 if (cmd->hdr.return_code != 0x0000) {
1723 if (cmd->hdr.return_code == 0x0010) {
1724 if (hostevs->lost_event_mask == 0x00)
1725 hostevs->lost_event_mask = 0xff;
1726 } else {
1727 QETH_CARD_TEXT_(card, 2, "BPHe%04x",
1728 cmd->hdr.return_code);
1729 return;
1730 }
1731 }
1732 extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
1733 hostevs->num_entries;
1734 data = kzalloc(sizeof(struct qeth_bridge_host_data) + extrasize,
1735 GFP_ATOMIC);
1736 if (!data) {
1737 QETH_CARD_TEXT(card, 2, "BPHalloc");
1738 return;
1739 }
1740 INIT_WORK(&data->worker, qeth_bridge_host_event_worker);
1741 data->card = card;
1742 memcpy(&data->hostevs, hostevs,
1743 sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1744 queue_work(card->event_wq, &data->worker);
1745}
1746
1747
1748
1749struct _qeth_sbp_cbctl {
1750 u16 ipa_rc;
1751 u16 cmd_rc;
1752 union {
1753 u32 supported;
1754 struct {
1755 enum qeth_sbp_roles *role;
1756 enum qeth_sbp_states *state;
1757 } qports;
1758 } data;
1759};
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769static int qeth_bridgeport_makerc(struct qeth_card *card,
1770 struct _qeth_sbp_cbctl *cbctl, enum qeth_ipa_sbp_cmd setcmd)
1771{
1772 int rc;
1773 int is_iqd = (card->info.type == QETH_CARD_TYPE_IQD);
1774
1775 if ((is_iqd && (cbctl->ipa_rc == IPA_RC_SUCCESS)) ||
1776 (!is_iqd && (cbctl->ipa_rc == cbctl->cmd_rc)))
1777 switch (cbctl->cmd_rc) {
1778 case 0x0000:
1779 rc = 0;
1780 break;
1781 case 0x2B04:
1782 case 0x0004:
1783 rc = -ENOSYS;
1784 break;
1785 case 0x2B0C:
1786 case 0x000C:
1787 rc = -ENODEV;
1788 dev_err(&card->gdev->dev,
1789 "The device is not configured as a Bridge Port\n");
1790 break;
1791 case 0x2B10:
1792 case 0x0010:
1793 rc = -EPERM;
1794 dev_err(&card->gdev->dev,
1795 "A Bridge Port is already configured by a different operating system\n");
1796 break;
1797 case 0x2B14:
1798 case 0x0014:
1799 switch (setcmd) {
1800 case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
1801 rc = -EEXIST;
1802 dev_err(&card->gdev->dev,
1803 "The LAN already has a primary Bridge Port\n");
1804 break;
1805 case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
1806 rc = -EBUSY;
1807 dev_err(&card->gdev->dev,
1808 "The device is already a primary Bridge Port\n");
1809 break;
1810 default:
1811 rc = -EIO;
1812 }
1813 break;
1814 case 0x2B18:
1815 case 0x0018:
1816 rc = -EBUSY;
1817 dev_err(&card->gdev->dev,
1818 "The device is already a secondary Bridge Port\n");
1819 break;
1820 case 0x2B1C:
1821 case 0x001C:
1822 rc = -EEXIST;
1823 dev_err(&card->gdev->dev,
1824 "The LAN cannot have more secondary Bridge Ports\n");
1825 break;
1826 case 0x2B24:
1827 case 0x0024:
1828 rc = -EBUSY;
1829 dev_err(&card->gdev->dev,
1830 "The device is already a primary Bridge Port\n");
1831 break;
1832 case 0x2B20:
1833 case 0x0020:
1834 rc = -EACCES;
1835 dev_err(&card->gdev->dev,
1836 "The device is not authorized to be a Bridge Port\n");
1837 break;
1838 default:
1839 rc = -EIO;
1840 }
1841 else
1842 switch (cbctl->ipa_rc) {
1843 case IPA_RC_NOTSUPP:
1844 rc = -ENOSYS;
1845 break;
1846 case IPA_RC_UNSUPPORTED_COMMAND:
1847 rc = -ENOSYS;
1848 break;
1849 default:
1850 rc = -EIO;
1851 }
1852
1853 if (rc) {
1854 QETH_CARD_TEXT_(card, 2, "SBPi%04x", cbctl->ipa_rc);
1855 QETH_CARD_TEXT_(card, 2, "SBPc%04x", cbctl->cmd_rc);
1856 }
1857 return rc;
1858}
1859
1860static inline int ipa_cmd_sbp(struct qeth_card *card)
1861{
1862 return (card->info.type == QETH_CARD_TYPE_IQD) ?
1863 IPA_CMD_SETBRIDGEPORT_IQD :
1864 IPA_CMD_SETBRIDGEPORT_OSA;
1865}
1866
1867static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1868 struct qeth_reply *reply, unsigned long data)
1869{
1870 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1871 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1872 QETH_CARD_TEXT(card, 2, "brqsupcb");
1873 cbctl->ipa_rc = cmd->hdr.return_code;
1874 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1875 if ((cbctl->ipa_rc == 0) && (cbctl->cmd_rc == 0)) {
1876 cbctl->data.supported =
1877 cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1878 } else {
1879 cbctl->data.supported = 0;
1880 }
1881 return 0;
1882}
1883
1884
1885
1886
1887
1888
1889
1890
1891static void qeth_bridgeport_query_support(struct qeth_card *card)
1892{
1893 struct qeth_cmd_buffer *iob;
1894 struct qeth_ipa_cmd *cmd;
1895 struct _qeth_sbp_cbctl cbctl;
1896
1897 QETH_CARD_TEXT(card, 2, "brqsuppo");
1898 iob = qeth_get_ipacmd_buffer(card, ipa_cmd_sbp(card), 0);
1899 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1900 cmd->data.sbp.hdr.cmdlength =
1901 sizeof(struct qeth_ipacmd_sbp_hdr) +
1902 sizeof(struct qeth_sbp_query_cmds_supp);
1903 cmd->data.sbp.hdr.command_code =
1904 IPA_SBP_QUERY_COMMANDS_SUPPORTED;
1905 cmd->data.sbp.hdr.used_total = 1;
1906 cmd->data.sbp.hdr.seq_no = 1;
1907 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1908 (void *)&cbctl) ||
1909 qeth_bridgeport_makerc(card, &cbctl,
1910 IPA_SBP_QUERY_COMMANDS_SUPPORTED)) {
1911
1912 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1913 return;
1914 }
1915 card->options.sbp.supported_funcs = cbctl.data.supported;
1916}
1917
1918static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1919 struct qeth_reply *reply, unsigned long data)
1920{
1921 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1922 struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
1923 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1924
1925 QETH_CARD_TEXT(card, 2, "brqprtcb");
1926 cbctl->ipa_rc = cmd->hdr.return_code;
1927 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1928 if ((cbctl->ipa_rc != 0) || (cbctl->cmd_rc != 0))
1929 return 0;
1930 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1931 cbctl->cmd_rc = 0xffff;
1932 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1933 return 0;
1934 }
1935
1936 if (qports->num_entries > 0) {
1937 if (cbctl->data.qports.role)
1938 *cbctl->data.qports.role = qports->entry[0].role;
1939 if (cbctl->data.qports.state)
1940 *cbctl->data.qports.state = qports->entry[0].state;
1941 }
1942 return 0;
1943}
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955int qeth_bridgeport_query_ports(struct qeth_card *card,
1956 enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
1957{
1958 int rc = 0;
1959 struct qeth_cmd_buffer *iob;
1960 struct qeth_ipa_cmd *cmd;
1961 struct _qeth_sbp_cbctl cbctl = {
1962 .data = {
1963 .qports = {
1964 .role = role,
1965 .state = state,
1966 },
1967 },
1968 };
1969
1970 QETH_CARD_TEXT(card, 2, "brqports");
1971 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1972 return -EOPNOTSUPP;
1973 iob = qeth_get_ipacmd_buffer(card, ipa_cmd_sbp(card), 0);
1974 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1975 cmd->data.sbp.hdr.cmdlength =
1976 sizeof(struct qeth_ipacmd_sbp_hdr);
1977 cmd->data.sbp.hdr.command_code =
1978 IPA_SBP_QUERY_BRIDGE_PORTS;
1979 cmd->data.sbp.hdr.used_total = 1;
1980 cmd->data.sbp.hdr.seq_no = 1;
1981 rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1982 (void *)&cbctl);
1983 if (rc < 0)
1984 return rc;
1985 return qeth_bridgeport_makerc(card, &cbctl, IPA_SBP_QUERY_BRIDGE_PORTS);
1986}
1987EXPORT_SYMBOL_GPL(qeth_bridgeport_query_ports);
1988
1989static int qeth_bridgeport_set_cb(struct qeth_card *card,
1990 struct qeth_reply *reply, unsigned long data)
1991{
1992 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1993 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1994 QETH_CARD_TEXT(card, 2, "brsetrcb");
1995 cbctl->ipa_rc = cmd->hdr.return_code;
1996 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1997 return 0;
1998}
1999
2000
2001
2002
2003
2004
2005
2006
2007int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
2008{
2009 int rc = 0;
2010 int cmdlength;
2011 struct qeth_cmd_buffer *iob;
2012 struct qeth_ipa_cmd *cmd;
2013 struct _qeth_sbp_cbctl cbctl;
2014 enum qeth_ipa_sbp_cmd setcmd;
2015
2016 QETH_CARD_TEXT(card, 2, "brsetrol");
2017 switch (role) {
2018 case QETH_SBP_ROLE_NONE:
2019 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
2020 cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) +
2021 sizeof(struct qeth_sbp_reset_role);
2022 break;
2023 case QETH_SBP_ROLE_PRIMARY:
2024 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
2025 cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) +
2026 sizeof(struct qeth_sbp_set_primary);
2027 break;
2028 case QETH_SBP_ROLE_SECONDARY:
2029 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
2030 cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) +
2031 sizeof(struct qeth_sbp_set_secondary);
2032 break;
2033 default:
2034 return -EINVAL;
2035 }
2036 if (!(card->options.sbp.supported_funcs & setcmd))
2037 return -EOPNOTSUPP;
2038 iob = qeth_get_ipacmd_buffer(card, ipa_cmd_sbp(card), 0);
2039 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
2040 cmd->data.sbp.hdr.cmdlength = cmdlength;
2041 cmd->data.sbp.hdr.command_code = setcmd;
2042 cmd->data.sbp.hdr.used_total = 1;
2043 cmd->data.sbp.hdr.seq_no = 1;
2044 rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb,
2045 (void *)&cbctl);
2046 if (rc < 0)
2047 return rc;
2048 return qeth_bridgeport_makerc(card, &cbctl, setcmd);
2049}
2050
2051
2052
2053
2054
2055
2056
2057static int qeth_anset_makerc(struct qeth_card *card, int pnso_rc, u16 response)
2058{
2059 int rc;
2060
2061 if (pnso_rc == 0)
2062 switch (response) {
2063 case 0x0001:
2064 rc = 0;
2065 break;
2066 case 0x0004:
2067 case 0x0100:
2068 case 0x0106:
2069 rc = -ENOSYS;
2070 dev_err(&card->gdev->dev,
2071 "Setting address notification failed\n");
2072 break;
2073 case 0x0107:
2074 rc = -EAGAIN;
2075 break;
2076 default:
2077 rc = -EIO;
2078 }
2079 else
2080 rc = -EIO;
2081
2082 if (rc) {
2083 QETH_CARD_TEXT_(card, 2, "SBPp%04x", pnso_rc);
2084 QETH_CARD_TEXT_(card, 2, "SBPr%04x", response);
2085 }
2086 return rc;
2087}
2088
2089static void qeth_bridgeport_an_set_cb(void *priv,
2090 enum qdio_brinfo_entry_type type, void *entry)
2091{
2092 struct qeth_card *card = (struct qeth_card *)priv;
2093 struct qdio_brinfo_entry_l2 *l2entry;
2094 u8 code;
2095
2096 if (type != l2_addr_lnid) {
2097 WARN_ON_ONCE(1);
2098 return;
2099 }
2100
2101 l2entry = (struct qdio_brinfo_entry_l2 *)entry;
2102 code = IPA_ADDR_CHANGE_CODE_MACADDR;
2103 if (l2entry->addr_lnid.lnid)
2104 code |= IPA_ADDR_CHANGE_CODE_VLANID;
2105 qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
2106 (struct net_if_token *)&l2entry->nit,
2107 (struct mac_addr_lnid *)&l2entry->addr_lnid);
2108}
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
2121{
2122 int rc;
2123 u16 response;
2124 struct ccw_device *ddev;
2125 struct subchannel_id schid;
2126
2127 if (!card)
2128 return -EINVAL;
2129 if (!card->options.sbp.supported_funcs)
2130 return -EOPNOTSUPP;
2131 ddev = CARD_DDEV(card);
2132 ccw_device_get_schid(ddev, &schid);
2133
2134 if (enable) {
2135 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
2136 rc = qdio_pnso_brinfo(schid, 1, &response,
2137 qeth_bridgeport_an_set_cb, card);
2138 } else
2139 rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL);
2140 return qeth_anset_makerc(card, rc, response);
2141}
2142EXPORT_SYMBOL_GPL(qeth_bridgeport_an_set);
2143
2144module_init(qeth_l2_init);
2145module_exit(qeth_l2_exit);
2146MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2147MODULE_DESCRIPTION("qeth layer 2 discipline");
2148MODULE_LICENSE("GPL");
2149