?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
firmware: use memory_read_from_buffer()
[linux-2.6/mini2440.git] / drivers / s390 / net / qeth_l3_main.c
blob38de31b557082cbe006f227bb3f6e88603ed3dc4
1 /*
2 * drivers/s390/net/qeth_l3_main.c
3 *
4 * Copyright IBM Corp. 2007
5 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
6 * Frank Pavlic <fpavlic@de.ibm.com>,
7 * Thomas Spatzier <tspat@de.ibm.com>,
8 * Frank Blaschka <frank.blaschka@de.ibm.com>
9 */
10
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/string.h>
14 #include <linux/errno.h>
15 #include <linux/kernel.h>
16 #include <linux/etherdevice.h>
17 #include <linux/mii.h>
18 #include <linux/ip.h>
19 #include <linux/reboot.h>
20 #include <linux/inetdevice.h>
21 #include <linux/igmp.h>
22
23 #include <net/ip.h>
24 #include <net/arp.h>
25
26 #include <asm/s390_rdev.h>
27
28 #include "qeth_l3.h"
29 #include "qeth_core_offl.h"
30
31 static int qeth_l3_set_offline(struct ccwgroup_device *);
32 static int qeth_l3_recover(void *);
33 static int qeth_l3_stop(struct net_device *);
34 static void qeth_l3_set_multicast_list(struct net_device *);
35 static int qeth_l3_neigh_setup(struct net_device *, struct neigh_parms *);
36 static int qeth_l3_register_addr_entry(struct qeth_card *,
37 struct qeth_ipaddr *);
38 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
39 struct qeth_ipaddr *);
40 static int __qeth_l3_set_online(struct ccwgroup_device *, int);
41 static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
42
43
44 static int qeth_l3_isxdigit(char *buf)
45 {
46 while (*buf) {
47 if (!isxdigit(*buf++))
48 return 0;
49 }
50 return 1;
51 }
52
53 void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
54 {
55 sprintf(buf, "%i.%i.%i.%i", addr[0], addr[1], addr[2], addr[3]);
56 }
57
58 int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
59 {
60 int count = 0, rc = 0;
61 int in[4];
62 char c;
63
64 rc = sscanf(buf, "%u.%u.%u.%u%c",
65 &in[0], &in[1], &in[2], &in[3], &c);
66 if (rc != 4 && (rc != 5 || c != '\n'))
67 return -EINVAL;
68 for (count = 0; count < 4; count++) {
69 if (in[count] > 255)
70 return -EINVAL;
71 addr[count] = in[count];
72 }
73 return 0;
74 }
75
76 void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
77 {
78 sprintf(buf, "%02x%02x:%02x%02x:%02x%02x:%02x%02x"
79 ":%02x%02x:%02x%02x:%02x%02x:%02x%02x",
80 addr[0], addr[1], addr[2], addr[3],
81 addr[4], addr[5], addr[6], addr[7],
82 addr[8], addr[9], addr[10], addr[11],
83 addr[12], addr[13], addr[14], addr[15]);
84 }
85
86 int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
87 {
88 const char *end, *end_tmp, *start;
89 __u16 *in;
90 char num[5];
91 int num2, cnt, out, found, save_cnt;
92 unsigned short in_tmp[8] = {0, };
93
94 cnt = out = found = save_cnt = num2 = 0;
95 end = start = buf;
96 in = (__u16 *) addr;
97 memset(in, 0, 16);
98 while (*end) {
99 end = strchr(start, ':');
100 if (end == NULL) {
101 end = buf + strlen(buf);
102 end_tmp = strchr(start, '\n');
103 if (end_tmp != NULL)
104 end = end_tmp;
105 out = 1;
106 }
107 if ((end - start)) {
108 memset(num, 0, 5);
109 if ((end - start) > 4)
110 return -EINVAL;
111 memcpy(num, start, end - start);
112 if (!qeth_l3_isxdigit(num))
113 return -EINVAL;
114 sscanf(start, "%x", &num2);
115 if (found)
116 in_tmp[save_cnt++] = num2;
117 else
118 in[cnt++] = num2;
119 if (out)
120 break;
121 } else {
122 if (found)
123 return -EINVAL;
124 found = 1;
125 }
126 start = ++end;
127 }
128 if (cnt + save_cnt > 8)
129 return -EINVAL;
130 cnt = 7;
131 while (save_cnt)
132 in[cnt--] = in_tmp[--save_cnt];
133 return 0;
134 }
135
136 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
137 char *buf)
138 {
139 if (proto == QETH_PROT_IPV4)
140 qeth_l3_ipaddr4_to_string(addr, buf);
141 else if (proto == QETH_PROT_IPV6)
142 qeth_l3_ipaddr6_to_string(addr, buf);
143 }
144
145 int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
146 __u8 *addr)
147 {
148 if (proto == QETH_PROT_IPV4)
149 return qeth_l3_string_to_ipaddr4(buf, addr);
150 else if (proto == QETH_PROT_IPV6)
151 return qeth_l3_string_to_ipaddr6(buf, addr);
152 else
153 return -EINVAL;
154 }
155
156 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
157 {
158 int i, j;
159 u8 octet;
160
161 for (i = 0; i < len; ++i) {
162 octet = addr[i];
163 for (j = 7; j >= 0; --j) {
164 bits[i*8 + j] = octet & 1;
165 octet >>= 1;
166 }
167 }
168 }
169
170 static int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
171 struct qeth_ipaddr *addr)
172 {
173 struct qeth_ipato_entry *ipatoe;
174 u8 addr_bits[128] = {0, };
175 u8 ipatoe_bits[128] = {0, };
176 int rc = 0;
177
178 if (!card->ipato.enabled)
179 return 0;
180
181 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
182 (addr->proto == QETH_PROT_IPV4)? 4:16);
183 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
184 if (addr->proto != ipatoe->proto)
185 continue;
186 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
187 (ipatoe->proto == QETH_PROT_IPV4) ?
188 4 : 16);
189 if (addr->proto == QETH_PROT_IPV4)
190 rc = !memcmp(addr_bits, ipatoe_bits,
191 min(32, ipatoe->mask_bits));
192 else
193 rc = !memcmp(addr_bits, ipatoe_bits,
194 min(128, ipatoe->mask_bits));
195 if (rc)
196 break;
197 }
198 /* invert? */
199 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
200 rc = !rc;
201 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
202 rc = !rc;
203
204 return rc;
205 }
206
207 /*
208 * Add IP to be added to todo list. If there is already an "add todo"
209 * in this list we just incremenent the reference count.
210 * Returns 0 if we just incremented reference count.
211 */
212 static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
213 struct qeth_ipaddr *addr, int add)
214 {
215 struct qeth_ipaddr *tmp, *t;
216 int found = 0;
217
218 list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
219 if ((addr->type == QETH_IP_TYPE_DEL_ALL_MC) &&
220 (tmp->type == QETH_IP_TYPE_DEL_ALL_MC))
221 return 0;
222 if ((tmp->proto == QETH_PROT_IPV4) &&
223 (addr->proto == QETH_PROT_IPV4) &&
224 (tmp->type == addr->type) &&
225 (tmp->is_multicast == addr->is_multicast) &&
226 (tmp->u.a4.addr == addr->u.a4.addr) &&
227 (tmp->u.a4.mask == addr->u.a4.mask)) {
228 found = 1;
229 break;
230 }
231 if ((tmp->proto == QETH_PROT_IPV6) &&
232 (addr->proto == QETH_PROT_IPV6) &&
233 (tmp->type == addr->type) &&
234 (tmp->is_multicast == addr->is_multicast) &&
235 (tmp->u.a6.pfxlen == addr->u.a6.pfxlen) &&
236 (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
237 sizeof(struct in6_addr)) == 0)) {
238 found = 1;
239 break;
240 }
241 }
242 if (found) {
243 if (addr->users != 0)
244 tmp->users += addr->users;
245 else
246 tmp->users += add ? 1 : -1;
247 if (tmp->users == 0) {
248 list_del(&tmp->entry);
249 kfree(tmp);
250 }
251 return 0;
252 } else {
253 if (addr->type == QETH_IP_TYPE_DEL_ALL_MC)
254 list_add(&addr->entry, card->ip_tbd_list);
255 else {
256 if (addr->users == 0)
257 addr->users += add ? 1 : -1;
258 if (add && (addr->type == QETH_IP_TYPE_NORMAL) &&
259 qeth_l3_is_addr_covered_by_ipato(card, addr)) {
260 QETH_DBF_TEXT(TRACE, 2, "tkovaddr");
261 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
262 }
263 list_add_tail(&addr->entry, card->ip_tbd_list);
264 }
265 return 1;
266 }
267 }
268
269 static int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
270 {
271 unsigned long flags;
272 int rc = 0;
273
274 QETH_DBF_TEXT(TRACE, 4, "delip");
275
276 if (addr->proto == QETH_PROT_IPV4)
277 QETH_DBF_HEX(TRACE, 4, &addr->u.a4.addr, 4);
278 else {
279 QETH_DBF_HEX(TRACE, 4, &addr->u.a6.addr, 8);
280 QETH_DBF_HEX(TRACE, 4, ((char *)&addr->u.a6.addr) + 8, 8);
281 }
282 spin_lock_irqsave(&card->ip_lock, flags);
283 rc = __qeth_l3_insert_ip_todo(card, addr, 0);
284 spin_unlock_irqrestore(&card->ip_lock, flags);
285 return rc;
286 }
287
288 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
289 {
290 unsigned long flags;
291 int rc = 0;
292
293 QETH_DBF_TEXT(TRACE, 4, "addip");
294 if (addr->proto == QETH_PROT_IPV4)
295 QETH_DBF_HEX(TRACE, 4, &addr->u.a4.addr, 4);
296 else {
297 QETH_DBF_HEX(TRACE, 4, &addr->u.a6.addr, 8);
298 QETH_DBF_HEX(TRACE, 4, ((char *)&addr->u.a6.addr) + 8, 8);
299 }
300 spin_lock_irqsave(&card->ip_lock, flags);
301 rc = __qeth_l3_insert_ip_todo(card, addr, 1);
302 spin_unlock_irqrestore(&card->ip_lock, flags);
303 return rc;
304 }
305
306
307 static struct qeth_ipaddr *qeth_l3_get_addr_buffer(
308 enum qeth_prot_versions prot)
309 {
310 struct qeth_ipaddr *addr;
311
312 addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
313 if (addr == NULL) {
314 return NULL;
315 }
316 addr->type = QETH_IP_TYPE_NORMAL;
317 addr->proto = prot;
318 return addr;
319 }
320
321 static void qeth_l3_delete_mc_addresses(struct qeth_card *card)
322 {
323 struct qeth_ipaddr *iptodo;
324 unsigned long flags;
325
326 QETH_DBF_TEXT(TRACE, 4, "delmc");
327 iptodo = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
328 if (!iptodo) {
329 QETH_DBF_TEXT(TRACE, 2, "dmcnomem");
330 return;
331 }
332 iptodo->type = QETH_IP_TYPE_DEL_ALL_MC;
333 spin_lock_irqsave(&card->ip_lock, flags);
334 if (!__qeth_l3_insert_ip_todo(card, iptodo, 0))
335 kfree(iptodo);
336 spin_unlock_irqrestore(&card->ip_lock, flags);
337 }
338
339 /*
340 * Add/remove address to/from card's ip list, i.e. try to add or remove
341 * reference to/from an IP address that is already registered on the card.
342 * Returns:
343 * 0 address was on card and its reference count has been adjusted,
344 * but is still > 0, so nothing has to be done
345 * also returns 0 if card was not on card and the todo was to delete
346 * the address -> there is also nothing to be done
347 * 1 address was not on card and the todo is to add it to the card's ip
348 * list
349 * -1 address was on card and its reference count has been decremented
350 * to <= 0 by the todo -> address must be removed from card
351 */
352 static int __qeth_l3_ref_ip_on_card(struct qeth_card *card,
353 struct qeth_ipaddr *todo, struct qeth_ipaddr **__addr)
354 {
355 struct qeth_ipaddr *addr;
356 int found = 0;
357
358 list_for_each_entry(addr, &card->ip_list, entry) {
359 if ((addr->proto == QETH_PROT_IPV4) &&
360 (todo->proto == QETH_PROT_IPV4) &&
361 (addr->type == todo->type) &&
362 (addr->u.a4.addr == todo->u.a4.addr) &&
363 (addr->u.a4.mask == todo->u.a4.mask)) {
364 found = 1;
365 break;
366 }
367 if ((addr->proto == QETH_PROT_IPV6) &&
368 (todo->proto == QETH_PROT_IPV6) &&
369 (addr->type == todo->type) &&
370 (addr->u.a6.pfxlen == todo->u.a6.pfxlen) &&
371 (memcmp(&addr->u.a6.addr, &todo->u.a6.addr,
372 sizeof(struct in6_addr)) == 0)) {
373 found = 1;
374 break;
375 }
376 }
377 if (found) {
378 addr->users += todo->users;
379 if (addr->users <= 0) {
380 *__addr = addr;
381 return -1;
382 } else {
383 /* for VIPA and RXIP limit refcount to 1 */
384 if (addr->type != QETH_IP_TYPE_NORMAL)
385 addr->users = 1;
386 return 0;
387 }
388 }
389 if (todo->users > 0) {
390 /* for VIPA and RXIP limit refcount to 1 */
391 if (todo->type != QETH_IP_TYPE_NORMAL)
392 todo->users = 1;
393 return 1;
394 } else
395 return 0;
396 }
397
398 static void __qeth_l3_delete_all_mc(struct qeth_card *card,
399 unsigned long *flags)
400 {
401 struct list_head fail_list;
402 struct qeth_ipaddr *addr, *tmp;
403 int rc;
404
405 INIT_LIST_HEAD(&fail_list);
406 again:
407 list_for_each_entry_safe(addr, tmp, &card->ip_list, entry) {
408 if (addr->is_multicast) {
409 list_del(&addr->entry);
410 spin_unlock_irqrestore(&card->ip_lock, *flags);
411 rc = qeth_l3_deregister_addr_entry(card, addr);
412 spin_lock_irqsave(&card->ip_lock, *flags);
413 if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND))
414 kfree(addr);
415 else
416 list_add_tail(&addr->entry, &fail_list);
417 goto again;
418 }
419 }
420 list_splice(&fail_list, &card->ip_list);
421 }
422
423 static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
424 {
425 struct list_head *tbd_list;
426 struct qeth_ipaddr *todo, *addr;
427 unsigned long flags;
428 int rc;
429
430 QETH_DBF_TEXT(TRACE, 2, "sdiplist");
431 QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
432
433 spin_lock_irqsave(&card->ip_lock, flags);
434 tbd_list = card->ip_tbd_list;
435 card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
436 if (!card->ip_tbd_list) {
437 QETH_DBF_TEXT(TRACE, 0, "silnomem");
438 card->ip_tbd_list = tbd_list;
439 spin_unlock_irqrestore(&card->ip_lock, flags);
440 return;
441 } else
442 INIT_LIST_HEAD(card->ip_tbd_list);
443
444 while (!list_empty(tbd_list)) {
445 todo = list_entry(tbd_list->next, struct qeth_ipaddr, entry);
446 list_del(&todo->entry);
447 if (todo->type == QETH_IP_TYPE_DEL_ALL_MC) {
448 __qeth_l3_delete_all_mc(card, &flags);
449 kfree(todo);
450 continue;
451 }
452 rc = __qeth_l3_ref_ip_on_card(card, todo, &addr);
453 if (rc == 0) {
454 /* nothing to be done; only adjusted refcount */
455 kfree(todo);
456 } else if (rc == 1) {
457 /* new entry to be added to on-card list */
458 spin_unlock_irqrestore(&card->ip_lock, flags);
459 rc = qeth_l3_register_addr_entry(card, todo);
460 spin_lock_irqsave(&card->ip_lock, flags);
461 if (!rc || (rc == IPA_RC_LAN_OFFLINE))
462 list_add_tail(&todo->entry, &card->ip_list);
463 else
464 kfree(todo);
465 } else if (rc == -1) {
466 /* on-card entry to be removed */
467 list_del_init(&addr->entry);
468 spin_unlock_irqrestore(&card->ip_lock, flags);
469 rc = qeth_l3_deregister_addr_entry(card, addr);
470 spin_lock_irqsave(&card->ip_lock, flags);
471 if (!rc || (rc == IPA_RC_PRIMARY_ALREADY_DEFINED))
472 kfree(addr);
473 else
474 list_add_tail(&addr->entry, &card->ip_list);
475 kfree(todo);
476 }
477 }
478 spin_unlock_irqrestore(&card->ip_lock, flags);
479 kfree(tbd_list);
480 }
481
482 static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
483 int recover)
484 {
485 struct qeth_ipaddr *addr, *tmp;
486 unsigned long flags;
487
488 QETH_DBF_TEXT(TRACE, 4, "clearip");
489 spin_lock_irqsave(&card->ip_lock, flags);
490 /* clear todo list */
491 list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
492 list_del(&addr->entry);
493 kfree(addr);
494 }
495
496 while (!list_empty(&card->ip_list)) {
497 addr = list_entry(card->ip_list.next,
498 struct qeth_ipaddr, entry);
499 list_del_init(&addr->entry);
500 if (clean) {
501 spin_unlock_irqrestore(&card->ip_lock, flags);
502 qeth_l3_deregister_addr_entry(card, addr);
503 spin_lock_irqsave(&card->ip_lock, flags);
504 }
505 if (!recover || addr->is_multicast) {
506 kfree(addr);
507 continue;
508 }
509 list_add_tail(&addr->entry, card->ip_tbd_list);
510 }
511 spin_unlock_irqrestore(&card->ip_lock, flags);
512 }
513
514 static int qeth_l3_address_exists_in_list(struct list_head *list,
515 struct qeth_ipaddr *addr, int same_type)
516 {
517 struct qeth_ipaddr *tmp;
518
519 list_for_each_entry(tmp, list, entry) {
520 if ((tmp->proto == QETH_PROT_IPV4) &&
521 (addr->proto == QETH_PROT_IPV4) &&
522 ((same_type && (tmp->type == addr->type)) ||
523 (!same_type && (tmp->type != addr->type))) &&
524 (tmp->u.a4.addr == addr->u.a4.addr))
525 return 1;
526
527 if ((tmp->proto == QETH_PROT_IPV6) &&
528 (addr->proto == QETH_PROT_IPV6) &&
529 ((same_type && (tmp->type == addr->type)) ||
530 (!same_type && (tmp->type != addr->type))) &&
531 (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
532 sizeof(struct in6_addr)) == 0))
533 return 1;
534
535 }
536 return 0;
537 }
538
539 static int qeth_l3_send_setdelmc(struct qeth_card *card,
540 struct qeth_ipaddr *addr, int ipacmd)
541 {
542 int rc;
543 struct qeth_cmd_buffer *iob;
544 struct qeth_ipa_cmd *cmd;
545
546 QETH_DBF_TEXT(TRACE, 4, "setdelmc");
547
548 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
549 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
550 memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
551 if (addr->proto == QETH_PROT_IPV6)
552 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
553 sizeof(struct in6_addr));
554 else
555 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
556
557 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
558
559 return rc;
560 }
561
562 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
563 {
564 int i, j;
565 for (i = 0; i < 16; i++) {
566 j = (len) - (i * 8);
567 if (j >= 8)
568 netmask[i] = 0xff;
569 else if (j > 0)
570 netmask[i] = (u8)(0xFF00 >> j);
571 else
572 netmask[i] = 0;
573 }
574 }
575
576 static int qeth_l3_send_setdelip(struct qeth_card *card,
577 struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
578 {
579 int rc;
580 struct qeth_cmd_buffer *iob;
581 struct qeth_ipa_cmd *cmd;
582 __u8 netmask[16];
583
584 QETH_DBF_TEXT(TRACE, 4, "setdelip");
585 QETH_DBF_TEXT_(TRACE, 4, "flags%02X", flags);
586
587 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
588 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
589 if (addr->proto == QETH_PROT_IPV6) {
590 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
591 sizeof(struct in6_addr));
592 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
593 memcpy(cmd->data.setdelip6.mask, netmask,
594 sizeof(struct in6_addr));
595 cmd->data.setdelip6.flags = flags;
596 } else {
597 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
598 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
599 cmd->data.setdelip4.flags = flags;
600 }
601
602 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
603
604 return rc;
605 }
606
607 static int qeth_l3_send_setrouting(struct qeth_card *card,
608 enum qeth_routing_types type, enum qeth_prot_versions prot)
609 {
610 int rc;
611 struct qeth_ipa_cmd *cmd;
612 struct qeth_cmd_buffer *iob;
613
614 QETH_DBF_TEXT(TRACE, 4, "setroutg");
615 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
616 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
617 cmd->data.setrtg.type = (type);
618 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
619
620 return rc;
621 }
622
623 static void qeth_l3_correct_routing_type(struct qeth_card *card,
624 enum qeth_routing_types *type, enum qeth_prot_versions prot)
625 {
626 if (card->info.type == QETH_CARD_TYPE_IQD) {
627 switch (*type) {
628 case NO_ROUTER:
629 case PRIMARY_CONNECTOR:
630 case SECONDARY_CONNECTOR:
631 case MULTICAST_ROUTER:
632 return;
633 default:
634 goto out_inval;
635 }
636 } else {
637 switch (*type) {
638 case NO_ROUTER:
639 case PRIMARY_ROUTER:
640 case SECONDARY_ROUTER:
641 return;
642 case MULTICAST_ROUTER:
643 if (qeth_is_ipafunc_supported(card, prot,
644 IPA_OSA_MC_ROUTER))
645 return;
646 default:
647 goto out_inval;
648 }
649 }
650 out_inval:
651 *type = NO_ROUTER;
652 }
653
654 int qeth_l3_setrouting_v4(struct qeth_card *card)
655 {
656 int rc;
657
658 QETH_DBF_TEXT(TRACE, 3, "setrtg4");
659
660 qeth_l3_correct_routing_type(card, &card->options.route4.type,
661 QETH_PROT_IPV4);
662
663 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
664 QETH_PROT_IPV4);
665 if (rc) {
666 card->options.route4.type = NO_ROUTER;
667 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
668 " on %s. Type set to 'no router'.\n", rc,
669 QETH_CARD_IFNAME(card));
670 }
671 return rc;
672 }
673
674 int qeth_l3_setrouting_v6(struct qeth_card *card)
675 {
676 int rc = 0;
677
678 QETH_DBF_TEXT(TRACE, 3, "setrtg6");
679 #ifdef CONFIG_QETH_IPV6
680
681 if (!qeth_is_supported(card, IPA_IPV6))
682 return 0;
683 qeth_l3_correct_routing_type(card, &card->options.route6.type,
684 QETH_PROT_IPV6);
685
686 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
687 QETH_PROT_IPV6);
688 if (rc) {
689 card->options.route6.type = NO_ROUTER;
690 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
691 " on %s. Type set to 'no router'.\n", rc,
692 QETH_CARD_IFNAME(card));
693 }
694 #endif
695 return rc;
696 }
697
698 /*
699 * IP address takeover related functions
700 */
701 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
702 {
703
704 struct qeth_ipato_entry *ipatoe, *tmp;
705 unsigned long flags;
706
707 spin_lock_irqsave(&card->ip_lock, flags);
708 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
709 list_del(&ipatoe->entry);
710 kfree(ipatoe);
711 }
712 spin_unlock_irqrestore(&card->ip_lock, flags);
713 }
714
715 int qeth_l3_add_ipato_entry(struct qeth_card *card,
716 struct qeth_ipato_entry *new)
717 {
718 struct qeth_ipato_entry *ipatoe;
719 unsigned long flags;
720 int rc = 0;
721
722 QETH_DBF_TEXT(TRACE, 2, "addipato");
723 spin_lock_irqsave(&card->ip_lock, flags);
724 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
725 if (ipatoe->proto != new->proto)
726 continue;
727 if (!memcmp(ipatoe->addr, new->addr,
728 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
729 (ipatoe->mask_bits == new->mask_bits)) {
730 rc = -EEXIST;
731 break;
732 }
733 }
734 if (!rc)
735 list_add_tail(&new->entry, &card->ipato.entries);
736
737 spin_unlock_irqrestore(&card->ip_lock, flags);
738 return rc;
739 }
740
741 void qeth_l3_del_ipato_entry(struct qeth_card *card,
742 enum qeth_prot_versions proto, u8 *addr, int mask_bits)
743 {
744 struct qeth_ipato_entry *ipatoe, *tmp;
745 unsigned long flags;
746
747 QETH_DBF_TEXT(TRACE, 2, "delipato");
748 spin_lock_irqsave(&card->ip_lock, flags);
749 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
750 if (ipatoe->proto != proto)
751 continue;
752 if (!memcmp(ipatoe->addr, addr,
753 (proto == QETH_PROT_IPV4)? 4:16) &&
754 (ipatoe->mask_bits == mask_bits)) {
755 list_del(&ipatoe->entry);
756 kfree(ipatoe);
757 }
758 }
759 spin_unlock_irqrestore(&card->ip_lock, flags);
760 }
761
762 /*
763 * VIPA related functions
764 */
765 int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
766 const u8 *addr)
767 {
768 struct qeth_ipaddr *ipaddr;
769 unsigned long flags;
770 int rc = 0;
771
772 ipaddr = qeth_l3_get_addr_buffer(proto);
773 if (ipaddr) {
774 if (proto == QETH_PROT_IPV4) {
775 QETH_DBF_TEXT(TRACE, 2, "addvipa4");
776 memcpy(&ipaddr->u.a4.addr, addr, 4);
777 ipaddr->u.a4.mask = 0;
778 } else if (proto == QETH_PROT_IPV6) {
779 QETH_DBF_TEXT(TRACE, 2, "addvipa6");
780 memcpy(&ipaddr->u.a6.addr, addr, 16);
781 ipaddr->u.a6.pfxlen = 0;
782 }
783 ipaddr->type = QETH_IP_TYPE_VIPA;
784 ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
785 ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
786 } else
787 return -ENOMEM;
788 spin_lock_irqsave(&card->ip_lock, flags);
789 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
790 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
791 rc = -EEXIST;
792 spin_unlock_irqrestore(&card->ip_lock, flags);
793 if (rc) {
794 return rc;
795 }
796 if (!qeth_l3_add_ip(card, ipaddr))
797 kfree(ipaddr);
798 qeth_l3_set_ip_addr_list(card);
799 return rc;
800 }
801
802 void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
803 const u8 *addr)
804 {
805 struct qeth_ipaddr *ipaddr;
806
807 ipaddr = qeth_l3_get_addr_buffer(proto);
808 if (ipaddr) {
809 if (proto == QETH_PROT_IPV4) {
810 QETH_DBF_TEXT(TRACE, 2, "delvipa4");
811 memcpy(&ipaddr->u.a4.addr, addr, 4);
812 ipaddr->u.a4.mask = 0;
813 } else if (proto == QETH_PROT_IPV6) {
814 QETH_DBF_TEXT(TRACE, 2, "delvipa6");
815 memcpy(&ipaddr->u.a6.addr, addr, 16);
816 ipaddr->u.a6.pfxlen = 0;
817 }
818 ipaddr->type = QETH_IP_TYPE_VIPA;
819 } else
820 return;
821 if (!qeth_l3_delete_ip(card, ipaddr))
822 kfree(ipaddr);
823 qeth_l3_set_ip_addr_list(card);
824 }
825
826 /*
827 * proxy ARP related functions
828 */
829 int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
830 const u8 *addr)
831 {
832 struct qeth_ipaddr *ipaddr;
833 unsigned long flags;
834 int rc = 0;
835
836 ipaddr = qeth_l3_get_addr_buffer(proto);
837 if (ipaddr) {
838 if (proto == QETH_PROT_IPV4) {
839 QETH_DBF_TEXT(TRACE, 2, "addrxip4");
840 memcpy(&ipaddr->u.a4.addr, addr, 4);
841 ipaddr->u.a4.mask = 0;
842 } else if (proto == QETH_PROT_IPV6) {
843 QETH_DBF_TEXT(TRACE, 2, "addrxip6");
844 memcpy(&ipaddr->u.a6.addr, addr, 16);
845 ipaddr->u.a6.pfxlen = 0;
846 }
847 ipaddr->type = QETH_IP_TYPE_RXIP;
848 ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
849 ipaddr->del_flags = 0;
850 } else
851 return -ENOMEM;
852 spin_lock_irqsave(&card->ip_lock, flags);
853 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
854 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
855 rc = -EEXIST;
856 spin_unlock_irqrestore(&card->ip_lock, flags);
857 if (rc) {
858 return rc;
859 }
860 if (!qeth_l3_add_ip(card, ipaddr))
861 kfree(ipaddr);
862 qeth_l3_set_ip_addr_list(card);
863 return 0;
864 }
865
866 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
867 const u8 *addr)
868 {
869 struct qeth_ipaddr *ipaddr;
870
871 ipaddr = qeth_l3_get_addr_buffer(proto);
872 if (ipaddr) {
873 if (proto == QETH_PROT_IPV4) {
874 QETH_DBF_TEXT(TRACE, 2, "addrxip4");
875 memcpy(&ipaddr->u.a4.addr, addr, 4);
876 ipaddr->u.a4.mask = 0;
877 } else if (proto == QETH_PROT_IPV6) {
878 QETH_DBF_TEXT(TRACE, 2, "addrxip6");
879 memcpy(&ipaddr->u.a6.addr, addr, 16);
880 ipaddr->u.a6.pfxlen = 0;
881 }
882 ipaddr->type = QETH_IP_TYPE_RXIP;
883 } else
884 return;
885 if (!qeth_l3_delete_ip(card, ipaddr))
886 kfree(ipaddr);
887 qeth_l3_set_ip_addr_list(card);
888 }
889
890 static int qeth_l3_register_addr_entry(struct qeth_card *card,
891 struct qeth_ipaddr *addr)
892 {
893 char buf[50];
894 int rc = 0;
895 int cnt = 3;
896
897 if (addr->proto == QETH_PROT_IPV4) {
898 QETH_DBF_TEXT(TRACE, 2, "setaddr4");
899 QETH_DBF_HEX(TRACE, 3, &addr->u.a4.addr, sizeof(int));
900 } else if (addr->proto == QETH_PROT_IPV6) {
901 QETH_DBF_TEXT(TRACE, 2, "setaddr6");
902 QETH_DBF_HEX(TRACE, 3, &addr->u.a6.addr, 8);
903 QETH_DBF_HEX(TRACE, 3, ((char *)&addr->u.a6.addr) + 8, 8);
904 } else {
905 QETH_DBF_TEXT(TRACE, 2, "setaddr?");
906 QETH_DBF_HEX(TRACE, 3, addr, sizeof(struct qeth_ipaddr));
907 }
908 do {
909 if (addr->is_multicast)
910 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
911 else
912 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
913 addr->set_flags);
914 if (rc)
915 QETH_DBF_TEXT(TRACE, 2, "failed");
916 } while ((--cnt > 0) && rc);
917 if (rc) {
918 QETH_DBF_TEXT(TRACE, 2, "FAILED");
919 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
920 PRINT_WARN("Could not register IP address %s (rc=0x%x/%d)\n",
921 buf, rc, rc);
922 }
923 return rc;
924 }
925
926 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
927 struct qeth_ipaddr *addr)
928 {
929 int rc = 0;
930
931 if (addr->proto == QETH_PROT_IPV4) {
932 QETH_DBF_TEXT(TRACE, 2, "deladdr4");
933 QETH_DBF_HEX(TRACE, 3, &addr->u.a4.addr, sizeof(int));
934 } else if (addr->proto == QETH_PROT_IPV6) {
935 QETH_DBF_TEXT(TRACE, 2, "deladdr6");
936 QETH_DBF_HEX(TRACE, 3, &addr->u.a6.addr, 8);
937 QETH_DBF_HEX(TRACE, 3, ((char *)&addr->u.a6.addr) + 8, 8);
938 } else {
939 QETH_DBF_TEXT(TRACE, 2, "deladdr?");
940 QETH_DBF_HEX(TRACE, 3, addr, sizeof(struct qeth_ipaddr));
941 }
942 if (addr->is_multicast)
943 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
944 else
945 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
946 addr->del_flags);
947 if (rc)
948 QETH_DBF_TEXT(TRACE, 2, "failed");
949
950 return rc;
951 }
952
953 static inline u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
954 {
955 if (cast_type == RTN_MULTICAST)
956 return QETH_CAST_MULTICAST;
957 if (cast_type == RTN_BROADCAST)
958 return QETH_CAST_BROADCAST;
959 return QETH_CAST_UNICAST;
960 }
961
962 static inline u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
963 {
964 u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
965 if (cast_type == RTN_MULTICAST)
966 return ct | QETH_CAST_MULTICAST;
967 if (cast_type == RTN_ANYCAST)
968 return ct | QETH_CAST_ANYCAST;
969 if (cast_type == RTN_BROADCAST)
970 return ct | QETH_CAST_BROADCAST;
971 return ct | QETH_CAST_UNICAST;
972 }
973
974 static int qeth_l3_send_setadp_mode(struct qeth_card *card, __u32 command,
975 __u32 mode)
976 {
977 int rc;
978 struct qeth_cmd_buffer *iob;
979 struct qeth_ipa_cmd *cmd;
980
981 QETH_DBF_TEXT(TRACE, 4, "adpmode");
982
983 iob = qeth_get_adapter_cmd(card, command,
984 sizeof(struct qeth_ipacmd_setadpparms));
985 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
986 cmd->data.setadapterparms.data.mode = mode;
987 rc = qeth_send_ipa_cmd(card, iob, qeth_default_setadapterparms_cb,
988 NULL);
989 return rc;
990 }
991
992 static int qeth_l3_setadapter_hstr(struct qeth_card *card)
993 {
994 int rc;
995
996 QETH_DBF_TEXT(TRACE, 4, "adphstr");
997
998 if (qeth_adp_supported(card, IPA_SETADP_SET_BROADCAST_MODE)) {
999 rc = qeth_l3_send_setadp_mode(card,
1000 IPA_SETADP_SET_BROADCAST_MODE,
1001 card->options.broadcast_mode);
1002 if (rc)
1003 QETH_DBF_MESSAGE(2, "couldn't set broadcast mode on "
1004 "device %s: x%x\n",
1005 CARD_BUS_ID(card), rc);
1006 rc = qeth_l3_send_setadp_mode(card,
1007 IPA_SETADP_ALTER_MAC_ADDRESS,
1008 card->options.macaddr_mode);
1009 if (rc)
1010 QETH_DBF_MESSAGE(2, "couldn't set macaddr mode on "
1011 "device %s: x%x\n", CARD_BUS_ID(card), rc);
1012 return rc;
1013 }
1014 if (card->options.broadcast_mode == QETH_TR_BROADCAST_LOCAL)
1015 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1016 "to set broadcast mode, using ALLRINGS "
1017 "on device %s:\n", CARD_BUS_ID(card));
1018 if (card->options.macaddr_mode == QETH_TR_MACADDR_CANONICAL)
1019 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1020 "to set macaddr mode, using NONCANONICAL "
1021 "on device %s:\n", CARD_BUS_ID(card));
1022 return 0;
1023 }
1024
1025 static int qeth_l3_setadapter_parms(struct qeth_card *card)
1026 {
1027 int rc;
1028
1029 QETH_DBF_TEXT(SETUP, 2, "setadprm");
1030
1031 if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
1032 PRINT_WARN("set adapter parameters not supported "
1033 "on device %s.\n",
1034 CARD_BUS_ID(card));
1035 QETH_DBF_TEXT(SETUP, 2, " notsupp");
1036 return 0;
1037 }
1038 rc = qeth_query_setadapterparms(card);
1039 if (rc) {
1040 PRINT_WARN("couldn't set adapter parameters on device %s: "
1041 "x%x\n", CARD_BUS_ID(card), rc);
1042 return rc;
1043 }
1044 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
1045 rc = qeth_setadpparms_change_macaddr(card);
1046 if (rc)
1047 PRINT_WARN("couldn't get MAC address on "
1048 "device %s: x%x\n",
1049 CARD_BUS_ID(card), rc);
1050 }
1051
1052 if ((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
1053 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))
1054 rc = qeth_l3_setadapter_hstr(card);
1055
1056 return rc;
1057 }
1058
1059 static int qeth_l3_default_setassparms_cb(struct qeth_card *card,
1060 struct qeth_reply *reply, unsigned long data)
1061 {
1062 struct qeth_ipa_cmd *cmd;
1063
1064 QETH_DBF_TEXT(TRACE, 4, "defadpcb");
1065
1066 cmd = (struct qeth_ipa_cmd *) data;
1067 if (cmd->hdr.return_code == 0) {
1068 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1069 if (cmd->hdr.prot_version == QETH_PROT_IPV4)
1070 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1071 if (cmd->hdr.prot_version == QETH_PROT_IPV6)
1072 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1073 }
1074 if (cmd->data.setassparms.hdr.assist_no == IPA_INBOUND_CHECKSUM &&
1075 cmd->data.setassparms.hdr.command_code == IPA_CMD_ASS_START) {
1076 card->info.csum_mask = cmd->data.setassparms.data.flags_32bit;
1077 QETH_DBF_TEXT_(TRACE, 3, "csum:%d", card->info.csum_mask);
1078 }
1079 return 0;
1080 }
1081
1082 static struct qeth_cmd_buffer *qeth_l3_get_setassparms_cmd(
1083 struct qeth_card *card, enum qeth_ipa_funcs ipa_func, __u16 cmd_code,
1084 __u16 len, enum qeth_prot_versions prot)
1085 {
1086 struct qeth_cmd_buffer *iob;
1087 struct qeth_ipa_cmd *cmd;
1088
1089 QETH_DBF_TEXT(TRACE, 4, "getasscm");
1090 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETASSPARMS, prot);
1091
1092 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1093 cmd->data.setassparms.hdr.assist_no = ipa_func;
1094 cmd->data.setassparms.hdr.length = 8 + len;
1095 cmd->data.setassparms.hdr.command_code = cmd_code;
1096 cmd->data.setassparms.hdr.return_code = 0;
1097 cmd->data.setassparms.hdr.seq_no = 0;
1098
1099 return iob;
1100 }
1101
1102 static int qeth_l3_send_setassparms(struct qeth_card *card,
1103 struct qeth_cmd_buffer *iob, __u16 len, long data,
1104 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
1105 unsigned long),
1106 void *reply_param)
1107 {
1108 int rc;
1109 struct qeth_ipa_cmd *cmd;
1110
1111 QETH_DBF_TEXT(TRACE, 4, "sendassp");
1112
1113 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1114 if (len <= sizeof(__u32))
1115 cmd->data.setassparms.data.flags_32bit = (__u32) data;
1116 else /* (len > sizeof(__u32)) */
1117 memcpy(&cmd->data.setassparms.data, (void *) data, len);
1118
1119 rc = qeth_send_ipa_cmd(card, iob, reply_cb, reply_param);
1120 return rc;
1121 }
1122
1123 #ifdef CONFIG_QETH_IPV6
1124 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
1125 enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
1126 {
1127 int rc;
1128 struct qeth_cmd_buffer *iob;
1129
1130 QETH_DBF_TEXT(TRACE, 4, "simassp6");
1131 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1132 0, QETH_PROT_IPV6);
1133 rc = qeth_l3_send_setassparms(card, iob, 0, 0,
1134 qeth_l3_default_setassparms_cb, NULL);
1135 return rc;
1136 }
1137 #endif
1138
1139 static int qeth_l3_send_simple_setassparms(struct qeth_card *card,
1140 enum qeth_ipa_funcs ipa_func, __u16 cmd_code, long data)
1141 {
1142 int rc;
1143 int length = 0;
1144 struct qeth_cmd_buffer *iob;
1145
1146 QETH_DBF_TEXT(TRACE, 4, "simassp4");
1147 if (data)
1148 length = sizeof(__u32);
1149 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1150 length, QETH_PROT_IPV4);
1151 rc = qeth_l3_send_setassparms(card, iob, length, data,
1152 qeth_l3_default_setassparms_cb, NULL);
1153 return rc;
1154 }
1155
1156 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
1157 {
1158 int rc;
1159
1160 QETH_DBF_TEXT(TRACE, 3, "ipaarp");
1161
1162 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1163 PRINT_WARN("ARP processing not supported "
1164 "on %s!\n", QETH_CARD_IFNAME(card));
1165 return 0;
1166 }
1167 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
1168 IPA_CMD_ASS_START, 0);
1169 if (rc) {
1170 PRINT_WARN("Could not start ARP processing "
1171 "assist on %s: 0x%x\n",
1172 QETH_CARD_IFNAME(card), rc);
1173 }
1174 return rc;
1175 }
1176
1177 static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card *card)
1178 {
1179 int rc;
1180
1181 QETH_DBF_TEXT(TRACE, 3, "ipaipfrg");
1182
1183 if (!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) {
1184 PRINT_INFO("Hardware IP fragmentation not supported on %s\n",
1185 QETH_CARD_IFNAME(card));
1186 return -EOPNOTSUPP;
1187 }
1188
1189 rc = qeth_l3_send_simple_setassparms(card, IPA_IP_FRAGMENTATION,
1190 IPA_CMD_ASS_START, 0);
1191 if (rc) {
1192 PRINT_WARN("Could not start Hardware IP fragmentation "
1193 "assist on %s: 0x%x\n",
1194 QETH_CARD_IFNAME(card), rc);
1195 } else
1196 PRINT_INFO("Hardware IP fragmentation enabled \n");
1197 return rc;
1198 }
1199
1200 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
1201 {
1202 int rc;
1203
1204 QETH_DBF_TEXT(TRACE, 3, "stsrcmac");
1205
1206 if (!card->options.fake_ll)
1207 return -EOPNOTSUPP;
1208
1209 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
1210 PRINT_INFO("Inbound source address not "
1211 "supported on %s\n", QETH_CARD_IFNAME(card));
1212 return -EOPNOTSUPP;
1213 }
1214
1215 rc = qeth_l3_send_simple_setassparms(card, IPA_SOURCE_MAC,
1216 IPA_CMD_ASS_START, 0);
1217 if (rc)
1218 PRINT_WARN("Could not start inbound source "
1219 "assist on %s: 0x%x\n",
1220 QETH_CARD_IFNAME(card), rc);
1221 return rc;
1222 }
1223
1224 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
1225 {
1226 int rc = 0;
1227
1228 QETH_DBF_TEXT(TRACE, 3, "strtvlan");
1229
1230 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
1231 PRINT_WARN("VLAN not supported on %s\n",
1232 QETH_CARD_IFNAME(card));
1233 return -EOPNOTSUPP;
1234 }
1235
1236 rc = qeth_l3_send_simple_setassparms(card, IPA_VLAN_PRIO,
1237 IPA_CMD_ASS_START, 0);
1238 if (rc) {
1239 PRINT_WARN("Could not start vlan "
1240 "assist on %s: 0x%x\n",
1241 QETH_CARD_IFNAME(card), rc);
1242 } else {
1243 PRINT_INFO("VLAN enabled \n");
1244 }
1245 return rc;
1246 }
1247
1248 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
1249 {
1250 int rc;
1251
1252 QETH_DBF_TEXT(TRACE, 3, "stmcast");
1253
1254 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1255 PRINT_WARN("Multicast not supported on %s\n",
1256 QETH_CARD_IFNAME(card));
1257 return -EOPNOTSUPP;
1258 }
1259
1260 rc = qeth_l3_send_simple_setassparms(card, IPA_MULTICASTING,
1261 IPA_CMD_ASS_START, 0);
1262 if (rc) {
1263 PRINT_WARN("Could not start multicast "
1264 "assist on %s: rc=%i\n",
1265 QETH_CARD_IFNAME(card), rc);
1266 } else {
1267 PRINT_INFO("Multicast enabled\n");
1268 card->dev->flags |= IFF_MULTICAST;
1269 }
1270 return rc;
1271 }
1272
1273 static int qeth_l3_query_ipassists_cb(struct qeth_card *card,
1274 struct qeth_reply *reply, unsigned long data)
1275 {
1276 struct qeth_ipa_cmd *cmd;
1277
1278 QETH_DBF_TEXT(SETUP, 2, "qipasscb");
1279
1280 cmd = (struct qeth_ipa_cmd *) data;
1281 if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
1282 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
1283 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1284 } else {
1285 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
1286 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1287 }
1288 QETH_DBF_TEXT(SETUP, 2, "suppenbl");
1289 QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
1290 QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
1291 return 0;
1292 }
1293
1294 static int qeth_l3_query_ipassists(struct qeth_card *card,
1295 enum qeth_prot_versions prot)
1296 {
1297 int rc;
1298 struct qeth_cmd_buffer *iob;
1299
1300 QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
1301 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
1302 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_query_ipassists_cb, NULL);
1303 return rc;
1304 }
1305
1306 #ifdef CONFIG_QETH_IPV6
1307 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1308 {
1309 int rc;
1310
1311 QETH_DBF_TEXT(TRACE, 3, "softipv6");
1312
1313 if (card->info.type == QETH_CARD_TYPE_IQD)
1314 goto out;
1315
1316 rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
1317 if (rc) {
1318 PRINT_ERR("IPv6 query ipassist failed on %s\n",
1319 QETH_CARD_IFNAME(card));
1320 return rc;
1321 }
1322 rc = qeth_l3_send_simple_setassparms(card, IPA_IPV6,
1323 IPA_CMD_ASS_START, 3);
1324 if (rc) {
1325 PRINT_WARN("IPv6 start assist (version 4) failed "
1326 "on %s: 0x%x\n",
1327 QETH_CARD_IFNAME(card), rc);
1328 return rc;
1329 }
1330 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
1331 IPA_CMD_ASS_START);
1332 if (rc) {
1333 PRINT_WARN("IPV6 start assist (version 6) failed "
1334 "on %s: 0x%x\n",
1335 QETH_CARD_IFNAME(card), rc);
1336 return rc;
1337 }
1338 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1339 IPA_CMD_ASS_START);
1340 if (rc) {
1341 PRINT_WARN("Could not enable passthrough "
1342 "on %s: 0x%x\n",
1343 QETH_CARD_IFNAME(card), rc);
1344 return rc;
1345 }
1346 out:
1347 PRINT_INFO("IPV6 enabled \n");
1348 return 0;
1349 }
1350 #endif
1351
1352 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1353 {
1354 int rc = 0;
1355
1356 QETH_DBF_TEXT(TRACE, 3, "strtipv6");
1357
1358 if (!qeth_is_supported(card, IPA_IPV6)) {
1359 PRINT_WARN("IPv6 not supported on %s\n",
1360 QETH_CARD_IFNAME(card));
1361 return 0;
1362 }
1363 #ifdef CONFIG_QETH_IPV6
1364 rc = qeth_l3_softsetup_ipv6(card);
1365 #endif
1366 return rc ;
1367 }
1368
1369 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
1370 {
1371 int rc;
1372
1373 QETH_DBF_TEXT(TRACE, 3, "stbrdcst");
1374 card->info.broadcast_capable = 0;
1375 if (!qeth_is_supported(card, IPA_FILTERING)) {
1376 PRINT_WARN("Broadcast not supported on %s\n",
1377 QETH_CARD_IFNAME(card));
1378 rc = -EOPNOTSUPP;
1379 goto out;
1380 }
1381 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1382 IPA_CMD_ASS_START, 0);
1383 if (rc) {
1384 PRINT_WARN("Could not enable broadcasting filtering "
1385 "on %s: 0x%x\n",
1386 QETH_CARD_IFNAME(card), rc);
1387 goto out;
1388 }
1389
1390 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1391 IPA_CMD_ASS_CONFIGURE, 1);
1392 if (rc) {
1393 PRINT_WARN("Could not set up broadcast filtering on %s: 0x%x\n",
1394 QETH_CARD_IFNAME(card), rc);
1395 goto out;
1396 }
1397 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1398 PRINT_INFO("Broadcast enabled \n");
1399 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1400 IPA_CMD_ASS_ENABLE, 1);
1401 if (rc) {
1402 PRINT_WARN("Could not set up broadcast echo filtering on "
1403 "%s: 0x%x\n", QETH_CARD_IFNAME(card), rc);
1404 goto out;
1405 }
1406 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
1407 out:
1408 if (card->info.broadcast_capable)
1409 card->dev->flags |= IFF_BROADCAST;
1410 else
1411 card->dev->flags &= ~IFF_BROADCAST;
1412 return rc;
1413 }
1414
1415 static int qeth_l3_send_checksum_command(struct qeth_card *card)
1416 {
1417 int rc;
1418
1419 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1420 IPA_CMD_ASS_START, 0);
1421 if (rc) {
1422 PRINT_WARN("Starting Inbound HW Checksumming failed on %s: "
1423 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
1424 QETH_CARD_IFNAME(card), rc);
1425 return rc;
1426 }
1427 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1428 IPA_CMD_ASS_ENABLE,
1429 card->info.csum_mask);
1430 if (rc) {
1431 PRINT_WARN("Enabling Inbound HW Checksumming failed on %s: "
1432 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
1433 QETH_CARD_IFNAME(card), rc);
1434 return rc;
1435 }
1436 return 0;
1437 }
1438
1439 static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
1440 {
1441 int rc = 0;
1442
1443 QETH_DBF_TEXT(TRACE, 3, "strtcsum");
1444
1445 if (card->options.checksum_type == NO_CHECKSUMMING) {
1446 PRINT_WARN("Using no checksumming on %s.\n",
1447 QETH_CARD_IFNAME(card));
1448 return 0;
1449 }
1450 if (card->options.checksum_type == SW_CHECKSUMMING) {
1451 PRINT_WARN("Using SW checksumming on %s.\n",
1452 QETH_CARD_IFNAME(card));
1453 return 0;
1454 }
1455 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
1456 PRINT_WARN("Inbound HW Checksumming not "
1457 "supported on %s,\ncontinuing "
1458 "using Inbound SW Checksumming\n",
1459 QETH_CARD_IFNAME(card));
1460 card->options.checksum_type = SW_CHECKSUMMING;
1461 return 0;
1462 }
1463 rc = qeth_l3_send_checksum_command(card);
1464 if (!rc)
1465 PRINT_INFO("HW Checksumming (inbound) enabled \n");
1466
1467 return rc;
1468 }
1469
1470 static int qeth_l3_start_ipa_tso(struct qeth_card *card)
1471 {
1472 int rc;
1473
1474 QETH_DBF_TEXT(TRACE, 3, "sttso");
1475
1476 if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
1477 PRINT_WARN("Outbound TSO not supported on %s\n",
1478 QETH_CARD_IFNAME(card));
1479 rc = -EOPNOTSUPP;
1480 } else {
1481 rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_TSO,
1482 IPA_CMD_ASS_START, 0);
1483 if (rc)
1484 PRINT_WARN("Could not start outbound TSO "
1485 "assist on %s: rc=%i\n",
1486 QETH_CARD_IFNAME(card), rc);
1487 else
1488 PRINT_INFO("Outbound TSO enabled\n");
1489 }
1490 if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
1491 card->options.large_send = QETH_LARGE_SEND_NO;
1492 card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
1493 }
1494 return rc;
1495 }
1496
1497 static int qeth_l3_start_ipassists(struct qeth_card *card)
1498 {
1499 QETH_DBF_TEXT(TRACE, 3, "strtipas");
1500 qeth_l3_start_ipa_arp_processing(card); /* go on*/
1501 qeth_l3_start_ipa_ip_fragmentation(card); /* go on*/
1502 qeth_l3_start_ipa_source_mac(card); /* go on*/
1503 qeth_l3_start_ipa_vlan(card); /* go on*/
1504 qeth_l3_start_ipa_multicast(card); /* go on*/
1505 qeth_l3_start_ipa_ipv6(card); /* go on*/
1506 qeth_l3_start_ipa_broadcast(card); /* go on*/
1507 qeth_l3_start_ipa_checksum(card); /* go on*/
1508 qeth_l3_start_ipa_tso(card); /* go on*/
1509 return 0;
1510 }
1511
1512 static int qeth_l3_put_unique_id(struct qeth_card *card)
1513 {
1514
1515 int rc = 0;
1516 struct qeth_cmd_buffer *iob;
1517 struct qeth_ipa_cmd *cmd;
1518
1519 QETH_DBF_TEXT(TRACE, 2, "puniqeid");
1520
1521 if ((card->info.unique_id & UNIQUE_ID_NOT_BY_CARD) ==
1522 UNIQUE_ID_NOT_BY_CARD)
1523 return -1;
1524 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_DESTROY_ADDR,
1525 QETH_PROT_IPV6);
1526 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1527 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1528 card->info.unique_id;
1529 memcpy(&cmd->data.create_destroy_addr.unique_id[0],
1530 card->dev->dev_addr, OSA_ADDR_LEN);
1531 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
1532 return rc;
1533 }
1534
1535 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1536 struct qeth_reply *reply, unsigned long data)
1537 {
1538 struct qeth_ipa_cmd *cmd;
1539
1540 cmd = (struct qeth_ipa_cmd *) data;
1541 if (cmd->hdr.return_code == 0)
1542 memcpy(card->dev->dev_addr,
1543 cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
1544 else
1545 random_ether_addr(card->dev->dev_addr);
1546
1547 return 0;
1548 }
1549
1550 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
1551 {
1552 int rc = 0;
1553 struct qeth_cmd_buffer *iob;
1554 struct qeth_ipa_cmd *cmd;
1555
1556 QETH_DBF_TEXT(SETUP, 2, "hsrmac");
1557
1558 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1559 QETH_PROT_IPV6);
1560 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1561 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1562 card->info.unique_id;
1563
1564 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1565 NULL);
1566 return rc;
1567 }
1568
1569 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1570 struct qeth_reply *reply, unsigned long data)
1571 {
1572 struct qeth_ipa_cmd *cmd;
1573
1574 cmd = (struct qeth_ipa_cmd *) data;
1575 if (cmd->hdr.return_code == 0)
1576 card->info.unique_id = *((__u16 *)
1577 &cmd->data.create_destroy_addr.unique_id[6]);
1578 else {
1579 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1580 UNIQUE_ID_NOT_BY_CARD;
1581 PRINT_WARN("couldn't get a unique id from the card on device "
1582 "%s (result=x%x), using default id. ipv6 "
1583 "autoconfig on other lpars may lead to duplicate "
1584 "ip addresses. please use manually "
1585 "configured ones.\n",
1586 CARD_BUS_ID(card), cmd->hdr.return_code);
1587 }
1588 return 0;
1589 }
1590
1591 static int qeth_l3_get_unique_id(struct qeth_card *card)
1592 {
1593 int rc = 0;
1594 struct qeth_cmd_buffer *iob;
1595 struct qeth_ipa_cmd *cmd;
1596
1597 QETH_DBF_TEXT(SETUP, 2, "guniqeid");
1598
1599 if (!qeth_is_supported(card, IPA_IPV6)) {
1600 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1601 UNIQUE_ID_NOT_BY_CARD;
1602 return 0;
1603 }
1604
1605 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1606 QETH_PROT_IPV6);
1607 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1608 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1609 card->info.unique_id;
1610
1611 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1612 return rc;
1613 }
1614
1615 static void qeth_l3_get_mac_for_ipm(__u32 ipm, char *mac,
1616 struct net_device *dev)
1617 {
1618 if (dev->type == ARPHRD_IEEE802_TR)
1619 ip_tr_mc_map(ipm, mac);
1620 else
1621 ip_eth_mc_map(ipm, mac);
1622 }
1623
1624 static void qeth_l3_add_mc(struct qeth_card *card, struct in_device *in4_dev)
1625 {
1626 struct qeth_ipaddr *ipm;
1627 struct ip_mc_list *im4;
1628 char buf[MAX_ADDR_LEN];
1629
1630 QETH_DBF_TEXT(TRACE, 4, "addmc");
1631 for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
1632 qeth_l3_get_mac_for_ipm(im4->multiaddr, buf, in4_dev->dev);
1633 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1634 if (!ipm)
1635 continue;
1636 ipm->u.a4.addr = im4->multiaddr;
1637 memcpy(ipm->mac, buf, OSA_ADDR_LEN);
1638 ipm->is_multicast = 1;
1639 if (!qeth_l3_add_ip(card, ipm))
1640 kfree(ipm);
1641 }
1642 }
1643
1644 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1645 {
1646 struct in_device *in_dev;
1647 struct vlan_group *vg;
1648 int i;
1649
1650 QETH_DBF_TEXT(TRACE, 4, "addmcvl");
1651 if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
1652 return;
1653
1654 vg = card->vlangrp;
1655 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
1656 struct net_device *netdev = vlan_group_get_device(vg, i);
1657 if (netdev == NULL ||
1658 !(netdev->flags & IFF_UP))
1659 continue;
1660 in_dev = in_dev_get(netdev);
1661 if (!in_dev)
1662 continue;
1663 read_lock(&in_dev->mc_list_lock);
1664 qeth_l3_add_mc(card, in_dev);
1665 read_unlock(&in_dev->mc_list_lock);
1666 in_dev_put(in_dev);
1667 }
1668 }
1669
1670 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1671 {
1672 struct in_device *in4_dev;
1673
1674 QETH_DBF_TEXT(TRACE, 4, "chkmcv4");
1675 in4_dev = in_dev_get(card->dev);
1676 if (in4_dev == NULL)
1677 return;
1678 read_lock(&in4_dev->mc_list_lock);
1679 qeth_l3_add_mc(card, in4_dev);
1680 qeth_l3_add_vlan_mc(card);
1681 read_unlock(&in4_dev->mc_list_lock);
1682 in_dev_put(in4_dev);
1683 }
1684
1685 #ifdef CONFIG_QETH_IPV6
1686 static void qeth_l3_add_mc6(struct qeth_card *card, struct inet6_dev *in6_dev)
1687 {
1688 struct qeth_ipaddr *ipm;
1689 struct ifmcaddr6 *im6;
1690 char buf[MAX_ADDR_LEN];
1691
1692 QETH_DBF_TEXT(TRACE, 4, "addmc6");
1693 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1694 ndisc_mc_map(&im6->mca_addr, buf, in6_dev->dev, 0);
1695 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1696 if (!ipm)
1697 continue;
1698 ipm->is_multicast = 1;
1699 memcpy(ipm->mac, buf, OSA_ADDR_LEN);
1700 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1701 sizeof(struct in6_addr));
1702 if (!qeth_l3_add_ip(card, ipm))
1703 kfree(ipm);
1704 }
1705 }
1706
1707 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1708 {
1709 struct inet6_dev *in_dev;
1710 struct vlan_group *vg;
1711 int i;
1712
1713 QETH_DBF_TEXT(TRACE, 4, "admc6vl");
1714 if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
1715 return;
1716
1717 vg = card->vlangrp;
1718 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
1719 struct net_device *netdev = vlan_group_get_device(vg, i);
1720 if (netdev == NULL ||
1721 !(netdev->flags & IFF_UP))
1722 continue;
1723 in_dev = in6_dev_get(netdev);
1724 if (!in_dev)
1725 continue;
1726 read_lock_bh(&in_dev->lock);
1727 qeth_l3_add_mc6(card, in_dev);
1728 read_unlock_bh(&in_dev->lock);
1729 in6_dev_put(in_dev);
1730 }
1731 }
1732
1733 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1734 {
1735 struct inet6_dev *in6_dev;
1736
1737 QETH_DBF_TEXT(TRACE, 4, "chkmcv6");
1738 if (!qeth_is_supported(card, IPA_IPV6))
1739 return ;
1740 in6_dev = in6_dev_get(card->dev);
1741 if (in6_dev == NULL)
1742 return;
1743 read_lock_bh(&in6_dev->lock);
1744 qeth_l3_add_mc6(card, in6_dev);
1745 qeth_l3_add_vlan_mc6(card);
1746 read_unlock_bh(&in6_dev->lock);
1747 in6_dev_put(in6_dev);
1748 }
1749 #endif /* CONFIG_QETH_IPV6 */
1750
1751 static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
1752 unsigned short vid)
1753 {
1754 struct in_device *in_dev;
1755 struct in_ifaddr *ifa;
1756 struct qeth_ipaddr *addr;
1757
1758 QETH_DBF_TEXT(TRACE, 4, "frvaddr4");
1759
1760 in_dev = in_dev_get(vlan_group_get_device(card->vlangrp, vid));
1761 if (!in_dev)
1762 return;
1763 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1764 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1765 if (addr) {
1766 addr->u.a4.addr = ifa->ifa_address;
1767 addr->u.a4.mask = ifa->ifa_mask;
1768 addr->type = QETH_IP_TYPE_NORMAL;
1769 if (!qeth_l3_delete_ip(card, addr))
1770 kfree(addr);
1771 }
1772 }
1773 in_dev_put(in_dev);
1774 }
1775
1776 static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
1777 unsigned short vid)
1778 {
1779 #ifdef CONFIG_QETH_IPV6
1780 struct inet6_dev *in6_dev;
1781 struct inet6_ifaddr *ifa;
1782 struct qeth_ipaddr *addr;
1783
1784 QETH_DBF_TEXT(TRACE, 4, "frvaddr6");
1785
1786 in6_dev = in6_dev_get(vlan_group_get_device(card->vlangrp, vid));
1787 if (!in6_dev)
1788 return;
1789 for (ifa = in6_dev->addr_list; ifa; ifa = ifa->lst_next) {
1790 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1791 if (addr) {
1792 memcpy(&addr->u.a6.addr, &ifa->addr,
1793 sizeof(struct in6_addr));
1794 addr->u.a6.pfxlen = ifa->prefix_len;
1795 addr->type = QETH_IP_TYPE_NORMAL;
1796 if (!qeth_l3_delete_ip(card, addr))
1797 kfree(addr);
1798 }
1799 }
1800 in6_dev_put(in6_dev);
1801 #endif /* CONFIG_QETH_IPV6 */
1802 }
1803
1804 static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
1805 unsigned short vid)
1806 {
1807 if (!card->vlangrp)
1808 return;
1809 qeth_l3_free_vlan_addresses4(card, vid);
1810 qeth_l3_free_vlan_addresses6(card, vid);
1811 }
1812
1813 static void qeth_l3_vlan_rx_register(struct net_device *dev,
1814 struct vlan_group *grp)
1815 {
1816 struct qeth_card *card = netdev_priv(dev);
1817 unsigned long flags;
1818
1819 QETH_DBF_TEXT(TRACE, 4, "vlanreg");
1820 spin_lock_irqsave(&card->vlanlock, flags);
1821 card->vlangrp = grp;
1822 spin_unlock_irqrestore(&card->vlanlock, flags);
1823 }
1824
1825 static void qeth_l3_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
1826 {
1827 struct net_device *vlandev;
1828 struct qeth_card *card = (struct qeth_card *) dev->priv;
1829 struct in_device *in_dev;
1830
1831 if (card->info.type == QETH_CARD_TYPE_IQD)
1832 return;
1833
1834 vlandev = vlan_group_get_device(card->vlangrp, vid);
1835 vlandev->neigh_setup = qeth_l3_neigh_setup;
1836
1837 in_dev = in_dev_get(vlandev);
1838 #ifdef CONFIG_SYSCTL
1839 neigh_sysctl_unregister(in_dev->arp_parms);
1840 #endif
1841 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
1842
1843 in_dev->arp_parms = neigh_parms_alloc(vlandev, &arp_tbl);
1844 #ifdef CONFIG_SYSCTL
1845 neigh_sysctl_register(vlandev, in_dev->arp_parms, NET_IPV4,
1846 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1847 #endif
1848 in_dev_put(in_dev);
1849 return;
1850 }
1851
1852 static void qeth_l3_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
1853 {
1854 struct qeth_card *card = netdev_priv(dev);
1855 unsigned long flags;
1856
1857 QETH_DBF_TEXT_(TRACE, 4, "kid:%d", vid);
1858 spin_lock_irqsave(&card->vlanlock, flags);
1859 /* unregister IP addresses of vlan device */
1860 qeth_l3_free_vlan_addresses(card, vid);
1861 vlan_group_set_device(card->vlangrp, vid, NULL);
1862 spin_unlock_irqrestore(&card->vlanlock, flags);
1863 qeth_l3_set_multicast_list(card->dev);
1864 }
1865
1866 static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
1867 struct sk_buff *skb, struct qeth_hdr *hdr)
1868 {
1869 unsigned short vlan_id = 0;
1870 __be16 prot;
1871 struct iphdr *ip_hdr;
1872 unsigned char tg_addr[MAX_ADDR_LEN];
1873
1874 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1875 prot = htons((hdr->hdr.l3.flags & QETH_HDR_IPV6)? ETH_P_IPV6 :
1876 ETH_P_IP);
1877 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1878 case QETH_CAST_MULTICAST:
1879 switch (prot) {
1880 #ifdef CONFIG_QETH_IPV6
1881 case __constant_htons(ETH_P_IPV6):
1882 ndisc_mc_map((struct in6_addr *)
1883 skb->data + 24,
1884 tg_addr, card->dev, 0);
1885 break;
1886 #endif
1887 case __constant_htons(ETH_P_IP):
1888 ip_hdr = (struct iphdr *)skb->data;
1889 (card->dev->type == ARPHRD_IEEE802_TR) ?
1890 ip_tr_mc_map(ip_hdr->daddr, tg_addr):
1891 ip_eth_mc_map(ip_hdr->daddr, tg_addr);
1892 break;
1893 default:
1894 memcpy(tg_addr, card->dev->broadcast,
1895 card->dev->addr_len);
1896 }
1897 card->stats.multicast++;
1898 skb->pkt_type = PACKET_MULTICAST;
1899 break;
1900 case QETH_CAST_BROADCAST:
1901 memcpy(tg_addr, card->dev->broadcast,
1902 card->dev->addr_len);
1903 card->stats.multicast++;
1904 skb->pkt_type = PACKET_BROADCAST;
1905 break;
1906 case QETH_CAST_UNICAST:
1907 case QETH_CAST_ANYCAST:
1908 case QETH_CAST_NOCAST:
1909 default:
1910 skb->pkt_type = PACKET_HOST;
1911 memcpy(tg_addr, card->dev->dev_addr,
1912 card->dev->addr_len);
1913 }
1914 card->dev->header_ops->create(skb, card->dev, prot, tg_addr,
1915 "FAKELL", card->dev->addr_len);
1916 }
1917
1918 #ifdef CONFIG_TR
1919 if (card->dev->type == ARPHRD_IEEE802_TR)
1920 skb->protocol = tr_type_trans(skb, card->dev);
1921 else
1922 #endif
1923 skb->protocol = eth_type_trans(skb, card->dev);
1924
1925 if (hdr->hdr.l3.ext_flags &
1926 (QETH_HDR_EXT_VLAN_FRAME | QETH_HDR_EXT_INCLUDE_VLAN_TAG)) {
1927 vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME)?
1928 hdr->hdr.l3.vlan_id : *((u16 *)&hdr->hdr.l3.dest_addr[12]);
1929 }
1930
1931 skb->ip_summed = card->options.checksum_type;
1932 if (card->options.checksum_type == HW_CHECKSUMMING) {
1933 if ((hdr->hdr.l3.ext_flags &
1934 (QETH_HDR_EXT_CSUM_HDR_REQ |
1935 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
1936 (QETH_HDR_EXT_CSUM_HDR_REQ |
1937 QETH_HDR_EXT_CSUM_TRANSP_REQ))
1938 skb->ip_summed = CHECKSUM_UNNECESSARY;
1939 else
1940 skb->ip_summed = SW_CHECKSUMMING;
1941 }
1942
1943 return vlan_id;
1944 }
1945
1946 static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
1947 struct qeth_qdio_buffer *buf, int index)
1948 {
1949 struct qdio_buffer_element *element;
1950 struct sk_buff *skb;
1951 struct qeth_hdr *hdr;
1952 int offset;
1953 __u16 vlan_tag = 0;
1954 unsigned int len;
1955
1956 /* get first element of current buffer */
1957 element = (struct qdio_buffer_element *)&buf->buffer->element[0];
1958 offset = 0;
1959 if (card->options.performance_stats)
1960 card->perf_stats.bufs_rec++;
1961 while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
1962 &offset, &hdr))) {
1963 skb->dev = card->dev;
1964 /* is device UP ? */
1965 if (!(card->dev->flags & IFF_UP)) {
1966 dev_kfree_skb_any(skb);
1967 continue;
1968 }
1969
1970 switch (hdr->hdr.l3.id) {
1971 case QETH_HEADER_TYPE_LAYER3:
1972 vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
1973 len = skb->len;
1974 if (vlan_tag)
1975 if (card->vlangrp)
1976 vlan_hwaccel_rx(skb, card->vlangrp,
1977 vlan_tag);
1978 else {
1979 dev_kfree_skb_any(skb);
1980 continue;
1981 }
1982 else
1983 netif_rx(skb);
1984 break;
1985 default:
1986 dev_kfree_skb_any(skb);
1987 QETH_DBF_TEXT(TRACE, 3, "inbunkno");
1988 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
1989 continue;
1990 }
1991
1992 card->dev->last_rx = jiffies;
1993 card->stats.rx_packets++;
1994 card->stats.rx_bytes += len;
1995 }
1996 }
1997
1998 static int qeth_l3_verify_vlan_dev(struct net_device *dev,
1999 struct qeth_card *card)
2000 {
2001 int rc = 0;
2002 struct vlan_group *vg;
2003 int i;
2004
2005 vg = card->vlangrp;
2006 if (!vg)
2007 return rc;
2008
2009 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
2010 if (vlan_group_get_device(vg, i) == dev) {
2011 rc = QETH_VLAN_CARD;
2012 break;
2013 }
2014 }
2015
2016 if (rc && !(netdev_priv(vlan_dev_real_dev(dev)) == (void *)card))
2017 return 0;
2018
2019 return rc;
2020 }
2021
2022 static int qeth_l3_verify_dev(struct net_device *dev)
2023 {
2024 struct qeth_card *card;
2025 unsigned long flags;
2026 int rc = 0;
2027
2028 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
2029 list_for_each_entry(card, &qeth_core_card_list.list, list) {
2030 if (card->dev == dev) {
2031 rc = QETH_REAL_CARD;
2032 break;
2033 }
2034 rc = qeth_l3_verify_vlan_dev(dev, card);
2035 if (rc)
2036 break;
2037 }
2038 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
2039
2040 return rc;
2041 }
2042
2043 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2044 {
2045 struct qeth_card *card = NULL;
2046 int rc;
2047
2048 rc = qeth_l3_verify_dev(dev);
2049 if (rc == QETH_REAL_CARD)
2050 card = netdev_priv(dev);
2051 else if (rc == QETH_VLAN_CARD)
2052 card = netdev_priv(vlan_dev_real_dev(dev));
2053 if (card && card->options.layer2)
2054 card = NULL;
2055 QETH_DBF_TEXT_(TRACE, 4, "%d", rc);
2056 return card ;
2057 }
2058
2059 static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
2060 {
2061 int rc = 0;
2062
2063 QETH_DBF_TEXT(SETUP, 2, "stopcard");
2064 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
2065
2066 qeth_set_allowed_threads(card, 0, 1);
2067 if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD))
2068 return -ERESTARTSYS;
2069 if (card->read.state == CH_STATE_UP &&
2070 card->write.state == CH_STATE_UP &&
2071 (card->state == CARD_STATE_UP)) {
2072 if (recovery_mode)
2073 qeth_l3_stop(card->dev);
2074 else {
2075 rtnl_lock();
2076 dev_close(card->dev);
2077 rtnl_unlock();
2078 }
2079 if (!card->use_hard_stop) {
2080 rc = qeth_send_stoplan(card);
2081 if (rc)
2082 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
2083 }
2084 card->state = CARD_STATE_SOFTSETUP;
2085 }
2086 if (card->state == CARD_STATE_SOFTSETUP) {
2087 qeth_l3_clear_ip_list(card, !card->use_hard_stop, 1);
2088 qeth_clear_ipacmd_list(card);
2089 card->state = CARD_STATE_HARDSETUP;
2090 }
2091 if (card->state == CARD_STATE_HARDSETUP) {
2092 if (!card->use_hard_stop &&
2093 (card->info.type != QETH_CARD_TYPE_IQD)) {
2094 rc = qeth_l3_put_unique_id(card);
2095 if (rc)
2096 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
2097 }
2098 qeth_qdio_clear_card(card, 0);
2099 qeth_clear_qdio_buffers(card);
2100 qeth_clear_working_pool_list(card);
2101 card->state = CARD_STATE_DOWN;
2102 }
2103 if (card->state == CARD_STATE_DOWN) {
2104 qeth_clear_cmd_buffers(&card->read);
2105 qeth_clear_cmd_buffers(&card->write);
2106 }
2107 card->use_hard_stop = 0;
2108 return rc;
2109 }
2110
2111 static void qeth_l3_set_multicast_list(struct net_device *dev)
2112 {
2113 struct qeth_card *card = netdev_priv(dev);
2114
2115 QETH_DBF_TEXT(TRACE, 3, "setmulti");
2116 qeth_l3_delete_mc_addresses(card);
2117 qeth_l3_add_multicast_ipv4(card);
2118 #ifdef CONFIG_QETH_IPV6
2119 qeth_l3_add_multicast_ipv6(card);
2120 #endif
2121 qeth_l3_set_ip_addr_list(card);
2122 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
2123 return;
2124 qeth_setadp_promisc_mode(card);
2125 }
2126
2127 static const char *qeth_l3_arp_get_error_cause(int *rc)
2128 {
2129 switch (*rc) {
2130 case QETH_IPA_ARP_RC_FAILED:
2131 *rc = -EIO;
2132 return "operation failed";
2133 case QETH_IPA_ARP_RC_NOTSUPP:
2134 *rc = -EOPNOTSUPP;
2135 return "operation not supported";
2136 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
2137 *rc = -EINVAL;
2138 return "argument out of range";
2139 case QETH_IPA_ARP_RC_Q_NOTSUPP:
2140 *rc = -EOPNOTSUPP;
2141 return "query operation not supported";
2142 case QETH_IPA_ARP_RC_Q_NO_DATA:
2143 *rc = -ENOENT;
2144 return "no query data available";
2145 default:
2146 return "unknown error";
2147 }
2148 }
2149
2150 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
2151 {
2152 int tmp;
2153 int rc;
2154
2155 QETH_DBF_TEXT(TRACE, 3, "arpstnoe");
2156
2157 /*
2158 * currently GuestLAN only supports the ARP assist function
2159 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
2160 * thus we say EOPNOTSUPP for this ARP function
2161 */
2162 if (card->info.guestlan)
2163 return -EOPNOTSUPP;
2164 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2165 return -EOPNOTSUPP;
2166 }
2167 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2168 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
2169 no_entries);
2170 if (rc) {
2171 tmp = rc;
2172 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
2173 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
2174 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2175 }
2176 return rc;
2177 }
2178
2179 static void qeth_l3_copy_arp_entries_stripped(struct qeth_arp_query_info *qinfo,
2180 struct qeth_arp_query_data *qdata, int entry_size,
2181 int uentry_size)
2182 {
2183 char *entry_ptr;
2184 char *uentry_ptr;
2185 int i;
2186
2187 entry_ptr = (char *)&qdata->data;
2188 uentry_ptr = (char *)(qinfo->udata + qinfo->udata_offset);
2189 for (i = 0; i < qdata->no_entries; ++i) {
2190 /* strip off 32 bytes "media specific information" */
2191 memcpy(uentry_ptr, (entry_ptr + 32), entry_size - 32);
2192 entry_ptr += entry_size;
2193 uentry_ptr += uentry_size;
2194 }
2195 }
2196
2197 static int qeth_l3_arp_query_cb(struct qeth_card *card,
2198 struct qeth_reply *reply, unsigned long data)
2199 {
2200 struct qeth_ipa_cmd *cmd;
2201 struct qeth_arp_query_data *qdata;
2202 struct qeth_arp_query_info *qinfo;
2203 int entry_size;
2204 int uentry_size;
2205 int i;
2206
2207 QETH_DBF_TEXT(TRACE, 4, "arpquecb");
2208
2209 qinfo = (struct qeth_arp_query_info *) reply->param;
2210 cmd = (struct qeth_ipa_cmd *) data;
2211 if (cmd->hdr.return_code) {
2212 QETH_DBF_TEXT_(TRACE, 4, "qaer1%i", cmd->hdr.return_code);
2213 return 0;
2214 }
2215 if (cmd->data.setassparms.hdr.return_code) {
2216 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
2217 QETH_DBF_TEXT_(TRACE, 4, "qaer2%i", cmd->hdr.return_code);
2218 return 0;
2219 }
2220 qdata = &cmd->data.setassparms.data.query_arp;
2221 switch (qdata->reply_bits) {
2222 case 5:
2223 uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry5);
2224 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2225 uentry_size = sizeof(struct qeth_arp_qi_entry5_short);
2226 break;
2227 case 7:
2228 /* fall through to default */
2229 default:
2230 /* tr is the same as eth -> entry7 */
2231 uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry7);
2232 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2233 uentry_size = sizeof(struct qeth_arp_qi_entry7_short);
2234 break;
2235 }
2236 /* check if there is enough room in userspace */
2237 if ((qinfo->udata_len - qinfo->udata_offset) <
2238 qdata->no_entries * uentry_size){
2239 QETH_DBF_TEXT_(TRACE, 4, "qaer3%i", -ENOMEM);
2240 cmd->hdr.return_code = -ENOMEM;
2241 goto out_error;
2242 }
2243 QETH_DBF_TEXT_(TRACE, 4, "anore%i",
2244 cmd->data.setassparms.hdr.number_of_replies);
2245 QETH_DBF_TEXT_(TRACE, 4, "aseqn%i", cmd->data.setassparms.hdr.seq_no);
2246 QETH_DBF_TEXT_(TRACE, 4, "anoen%i", qdata->no_entries);
2247
2248 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) {
2249 /* strip off "media specific information" */
2250 qeth_l3_copy_arp_entries_stripped(qinfo, qdata, entry_size,
2251 uentry_size);
2252 } else
2253 /*copy entries to user buffer*/
2254 memcpy(qinfo->udata + qinfo->udata_offset,
2255 (char *)&qdata->data, qdata->no_entries*uentry_size);
2256
2257 qinfo->no_entries += qdata->no_entries;
2258 qinfo->udata_offset += (qdata->no_entries*uentry_size);
2259 /* check if all replies received ... */
2260 if (cmd->data.setassparms.hdr.seq_no <
2261 cmd->data.setassparms.hdr.number_of_replies)
2262 return 1;
2263 memcpy(qinfo->udata, &qinfo->no_entries, 4);
2264 /* keep STRIP_ENTRIES flag so the user program can distinguish
2265 * stripped entries from normal ones */
2266 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2267 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
2268 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2269 return 0;
2270 out_error:
2271 i = 0;
2272 memcpy(qinfo->udata, &i, 4);
2273 return 0;
2274 }
2275
2276 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2277 struct qeth_cmd_buffer *iob, int len,
2278 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
2279 unsigned long),
2280 void *reply_param)
2281 {
2282 QETH_DBF_TEXT(TRACE, 4, "sendarp");
2283
2284 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
2285 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
2286 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2287 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2288 reply_cb, reply_param);
2289 }
2290
2291 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2292 {
2293 struct qeth_cmd_buffer *iob;
2294 struct qeth_arp_query_info qinfo = {0, };
2295 int tmp;
2296 int rc;
2297
2298 QETH_DBF_TEXT(TRACE, 3, "arpquery");
2299
2300 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2301 IPA_ARP_PROCESSING)) {
2302 return -EOPNOTSUPP;
2303 }
2304 /* get size of userspace buffer and mask_bits -> 6 bytes */
2305 if (copy_from_user(&qinfo, udata, 6))
2306 return -EFAULT;
2307 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2308 if (!qinfo.udata)
2309 return -ENOMEM;
2310 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2311 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2312 IPA_CMD_ASS_ARP_QUERY_INFO,
2313 sizeof(int), QETH_PROT_IPV4);
2314
2315 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2316 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
2317 qeth_l3_arp_query_cb, (void *)&qinfo);
2318 if (rc) {
2319 tmp = rc;
2320 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on %s: %s "
2321 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2322 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2323 if (copy_to_user(udata, qinfo.udata, 4))
2324 rc = -EFAULT;
2325 } else {
2326 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len))
2327 rc = -EFAULT;
2328 }
2329 kfree(qinfo.udata);
2330 return rc;
2331 }
2332
2333 static int qeth_l3_arp_add_entry(struct qeth_card *card,
2334 struct qeth_arp_cache_entry *entry)
2335 {
2336 struct qeth_cmd_buffer *iob;
2337 char buf[16];
2338 int tmp;
2339 int rc;
2340
2341 QETH_DBF_TEXT(TRACE, 3, "arpadent");
2342
2343 /*
2344 * currently GuestLAN only supports the ARP assist function
2345 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2346 * thus we say EOPNOTSUPP for this ARP function
2347 */
2348 if (card->info.guestlan)
2349 return -EOPNOTSUPP;
2350 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2351 return -EOPNOTSUPP;
2352 }
2353
2354 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2355 IPA_CMD_ASS_ARP_ADD_ENTRY,
2356 sizeof(struct qeth_arp_cache_entry),
2357 QETH_PROT_IPV4);
2358 rc = qeth_l3_send_setassparms(card, iob,
2359 sizeof(struct qeth_arp_cache_entry),
2360 (unsigned long) entry,
2361 qeth_l3_default_setassparms_cb, NULL);
2362 if (rc) {
2363 tmp = rc;
2364 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2365 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2366 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2367 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2368 }
2369 return rc;
2370 }
2371
2372 static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2373 struct qeth_arp_cache_entry *entry)
2374 {
2375 struct qeth_cmd_buffer *iob;
2376 char buf[16] = {0, };
2377 int tmp;
2378 int rc;
2379
2380 QETH_DBF_TEXT(TRACE, 3, "arprment");
2381
2382 /*
2383 * currently GuestLAN only supports the ARP assist function
2384 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2385 * thus we say EOPNOTSUPP for this ARP function
2386 */
2387 if (card->info.guestlan)
2388 return -EOPNOTSUPP;
2389 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2390 return -EOPNOTSUPP;
2391 }
2392 memcpy(buf, entry, 12);
2393 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2394 IPA_CMD_ASS_ARP_REMOVE_ENTRY,
2395 12,
2396 QETH_PROT_IPV4);
2397 rc = qeth_l3_send_setassparms(card, iob,
2398 12, (unsigned long)buf,
2399 qeth_l3_default_setassparms_cb, NULL);
2400 if (rc) {
2401 tmp = rc;
2402 memset(buf, 0, 16);
2403 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2404 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2405 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2406 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2407 }
2408 return rc;
2409 }
2410
2411 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2412 {
2413 int rc;
2414 int tmp;
2415
2416 QETH_DBF_TEXT(TRACE, 3, "arpflush");
2417
2418 /*
2419 * currently GuestLAN only supports the ARP assist function
2420 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2421 * thus we say EOPNOTSUPP for this ARP function
2422 */
2423 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2424 return -EOPNOTSUPP;
2425 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2426 return -EOPNOTSUPP;
2427 }
2428 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2429 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
2430 if (rc) {
2431 tmp = rc;
2432 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2433 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2434 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2435 }
2436 return rc;
2437 }
2438
2439 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2440 {
2441 struct qeth_card *card = netdev_priv(dev);
2442 struct qeth_arp_cache_entry arp_entry;
2443 struct mii_ioctl_data *mii_data;
2444 int rc = 0;
2445
2446 if (!card)
2447 return -ENODEV;
2448
2449 if ((card->state != CARD_STATE_UP) &&
2450 (card->state != CARD_STATE_SOFTSETUP))
2451 return -ENODEV;
2452
2453 switch (cmd) {
2454 case SIOC_QETH_ARP_SET_NO_ENTRIES:
2455 if (!capable(CAP_NET_ADMIN)) {
2456 rc = -EPERM;
2457 break;
2458 }
2459 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2460 break;
2461 case SIOC_QETH_ARP_QUERY_INFO:
2462 if (!capable(CAP_NET_ADMIN)) {
2463 rc = -EPERM;
2464 break;
2465 }
2466 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2467 break;
2468 case SIOC_QETH_ARP_ADD_ENTRY:
2469 if (!capable(CAP_NET_ADMIN)) {
2470 rc = -EPERM;
2471 break;
2472 }
2473 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2474 sizeof(struct qeth_arp_cache_entry)))
2475 rc = -EFAULT;
2476 else
2477 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2478 break;
2479 case SIOC_QETH_ARP_REMOVE_ENTRY:
2480 if (!capable(CAP_NET_ADMIN)) {
2481 rc = -EPERM;
2482 break;
2483 }
2484 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2485 sizeof(struct qeth_arp_cache_entry)))
2486 rc = -EFAULT;
2487 else
2488 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2489 break;
2490 case SIOC_QETH_ARP_FLUSH_CACHE:
2491 if (!capable(CAP_NET_ADMIN)) {
2492 rc = -EPERM;
2493 break;
2494 }
2495 rc = qeth_l3_arp_flush_cache(card);
2496 break;
2497 case SIOC_QETH_ADP_SET_SNMP_CONTROL:
2498 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);
2499 break;
2500 case SIOC_QETH_GET_CARD_TYPE:
2501 if ((card->info.type == QETH_CARD_TYPE_OSAE) &&
2502 !card->info.guestlan)
2503 return 1;
2504 return 0;
2505 break;
2506 case SIOCGMIIPHY:
2507 mii_data = if_mii(rq);
2508 mii_data->phy_id = 0;
2509 break;
2510 case SIOCGMIIREG:
2511 mii_data = if_mii(rq);
2512 if (mii_data->phy_id != 0)
2513 rc = -EINVAL;
2514 else
2515 mii_data->val_out = qeth_mdio_read(dev,
2516 mii_data->phy_id,
2517 mii_data->reg_num);
2518 break;
2519 default:
2520 rc = -EOPNOTSUPP;
2521 }
2522 if (rc)
2523 QETH_DBF_TEXT_(TRACE, 2, "ioce%d", rc);
2524 return rc;
2525 }
2526
2527 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2528 struct sk_buff *skb, int ipv, int cast_type)
2529 {
2530 memset(hdr, 0, sizeof(struct qeth_hdr));
2531 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2532 hdr->hdr.l3.ext_flags = 0;
2533
2534 /*
2535 * before we're going to overwrite this location with next hop ip.
2536 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2537 */
2538 if (card->vlangrp && vlan_tx_tag_present(skb)) {
2539 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2540 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
2541 else
2542 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
2543 hdr->hdr.l3.vlan_id = vlan_tx_tag_get(skb);
2544 }
2545
2546 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2547 if (ipv == 4) {
2548 /* IPv4 */
2549 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type);
2550 memset(hdr->hdr.l3.dest_addr, 0, 12);
2551 if ((skb->dst) && (skb->dst->neighbour)) {
2552 *((u32 *) (&hdr->hdr.l3.dest_addr[12])) =
2553 *((u32 *) skb->dst->neighbour->primary_key);
2554 } else {
2555 /* fill in destination address used in ip header */
2556 *((u32 *) (&hdr->hdr.l3.dest_addr[12])) =
2557 ip_hdr(skb)->daddr;
2558 }
2559 } else if (ipv == 6) {
2560 /* IPv6 */
2561 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type);
2562 if (card->info.type == QETH_CARD_TYPE_IQD)
2563 hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU;
2564 if ((skb->dst) && (skb->dst->neighbour)) {
2565 memcpy(hdr->hdr.l3.dest_addr,
2566 skb->dst->neighbour->primary_key, 16);
2567 } else {
2568 /* fill in destination address used in ip header */
2569 memcpy(hdr->hdr.l3.dest_addr,
2570 &ipv6_hdr(skb)->daddr, 16);
2571 }
2572 } else {
2573 /* passthrough */
2574 if ((skb->dev->type == ARPHRD_IEEE802_TR) &&
2575 !memcmp(skb->data + sizeof(struct qeth_hdr) +
2576 sizeof(__u16), skb->dev->broadcast, 6)) {
2577 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2578 QETH_HDR_PASSTHRU;
2579 } else if (!memcmp(skb->data + sizeof(struct qeth_hdr),
2580 skb->dev->broadcast, 6)) {
2581 /* broadcast? */
2582 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2583 QETH_HDR_PASSTHRU;
2584 } else {
2585 hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
2586 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
2587 QETH_CAST_UNICAST | QETH_HDR_PASSTHRU;
2588 }
2589 }
2590 }
2591
2592 static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
2593 {
2594 int rc;
2595 u16 *tag;
2596 struct qeth_hdr *hdr = NULL;
2597 int elements_needed = 0;
2598 struct qeth_card *card = netdev_priv(dev);
2599 struct sk_buff *new_skb = NULL;
2600 int ipv = qeth_get_ip_version(skb);
2601 int cast_type = qeth_get_cast_type(card, skb);
2602 struct qeth_qdio_out_q *queue = card->qdio.out_qs
2603 [qeth_get_priority_queue(card, skb, ipv, cast_type)];
2604 int tx_bytes = skb->len;
2605 enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
2606 struct qeth_eddp_context *ctx = NULL;
2607
2608 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
2609 (skb->protocol != htons(ETH_P_IPV6)) &&
2610 (skb->protocol != htons(ETH_P_IP)))
2611 goto tx_drop;
2612
2613 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2614 card->stats.tx_carrier_errors++;
2615 goto tx_drop;
2616 }
2617
2618 if ((cast_type == RTN_BROADCAST) &&
2619 (card->info.broadcast_capable == 0))
2620 goto tx_drop;
2621
2622 if (card->options.performance_stats) {
2623 card->perf_stats.outbound_cnt++;
2624 card->perf_stats.outbound_start_time = qeth_get_micros();
2625 }
2626
2627 /* create a clone with writeable headroom */
2628 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso) +
2629 VLAN_HLEN);
2630 if (!new_skb)
2631 goto tx_drop;
2632
2633 if (card->info.type == QETH_CARD_TYPE_IQD) {
2634 skb_pull(new_skb, ETH_HLEN);
2635 } else {
2636 if (new_skb->protocol == htons(ETH_P_IP)) {
2637 if (card->dev->type == ARPHRD_IEEE802_TR)
2638 skb_pull(new_skb, TR_HLEN);
2639 else
2640 skb_pull(new_skb, ETH_HLEN);
2641 }
2642
2643 if (new_skb->protocol == ETH_P_IPV6 && card->vlangrp &&
2644 vlan_tx_tag_present(new_skb)) {
2645 skb_push(new_skb, VLAN_HLEN);
2646 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
2647 skb_copy_to_linear_data_offset(new_skb, 4,
2648 new_skb->data + 8, 4);
2649 skb_copy_to_linear_data_offset(new_skb, 8,
2650 new_skb->data + 12, 4);
2651 tag = (u16 *)(new_skb->data + 12);
2652 *tag = __constant_htons(ETH_P_8021Q);
2653 *(tag + 1) = htons(vlan_tx_tag_get(new_skb));
2654 new_skb->vlan_tci = 0;
2655 }
2656 }
2657
2658 netif_stop_queue(dev);
2659
2660 if (skb_is_gso(new_skb))
2661 large_send = card->options.large_send;
2662
2663 /* fix hardware limitation: as long as we do not have sbal
2664 * chaining we can not send long frag lists so we temporary
2665 * switch to EDDP
2666 */
2667 if ((large_send == QETH_LARGE_SEND_TSO) &&
2668 ((skb_shinfo(new_skb)->nr_frags + 2) > 16))
2669 large_send = QETH_LARGE_SEND_EDDP;
2670
2671 if ((large_send == QETH_LARGE_SEND_TSO) &&
2672 (cast_type == RTN_UNSPEC)) {
2673 hdr = (struct qeth_hdr *)skb_push(new_skb,
2674 sizeof(struct qeth_hdr_tso));
2675 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
2676 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2677 qeth_tso_fill_header(card, hdr, new_skb);
2678 elements_needed++;
2679 } else {
2680 hdr = (struct qeth_hdr *)skb_push(new_skb,
2681 sizeof(struct qeth_hdr));
2682 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2683 }
2684
2685 if (large_send == QETH_LARGE_SEND_EDDP) {
2686 /* new_skb is not owned by a socket so we use skb to get
2687 * the protocol
2688 */
2689 ctx = qeth_eddp_create_context(card, new_skb, hdr,
2690 skb->sk->sk_protocol);
2691 if (ctx == NULL) {
2692 QETH_DBF_MESSAGE(2, "could not create eddp context\n");
2693 goto tx_drop;
2694 }
2695 } else {
2696 int elems = qeth_get_elements_no(card, (void *)hdr, new_skb,
2697 elements_needed);
2698 if (!elems)
2699 goto tx_drop;
2700 elements_needed += elems;
2701 }
2702
2703 if ((large_send == QETH_LARGE_SEND_NO) &&
2704 (new_skb->ip_summed == CHECKSUM_PARTIAL))
2705 qeth_tx_csum(new_skb);
2706
2707 if (card->info.type != QETH_CARD_TYPE_IQD)
2708 rc = qeth_do_send_packet(card, queue, new_skb, hdr,
2709 elements_needed, ctx);
2710 else
2711 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
2712 elements_needed, ctx);
2713
2714 if (!rc) {
2715 card->stats.tx_packets++;
2716 card->stats.tx_bytes += tx_bytes;
2717 if (new_skb != skb)
2718 dev_kfree_skb_any(skb);
2719 if (card->options.performance_stats) {
2720 if (large_send != QETH_LARGE_SEND_NO) {
2721 card->perf_stats.large_send_bytes += tx_bytes;
2722 card->perf_stats.large_send_cnt++;
2723 }
2724 if (skb_shinfo(new_skb)->nr_frags > 0) {
2725 card->perf_stats.sg_skbs_sent++;
2726 /* nr_frags + skb->data */
2727 card->perf_stats.sg_frags_sent +=
2728 skb_shinfo(new_skb)->nr_frags + 1;
2729 }
2730 }
2731
2732 if (ctx != NULL) {
2733 qeth_eddp_put_context(ctx);
2734 dev_kfree_skb_any(new_skb);
2735 }
2736 } else {
2737 if (ctx != NULL)
2738 qeth_eddp_put_context(ctx);
2739
2740 if (rc == -EBUSY) {
2741 if (new_skb != skb)
2742 dev_kfree_skb_any(new_skb);
2743 return NETDEV_TX_BUSY;
2744 } else
2745 goto tx_drop;
2746 }
2747
2748 netif_wake_queue(dev);
2749 if (card->options.performance_stats)
2750 card->perf_stats.outbound_time += qeth_get_micros() -
2751 card->perf_stats.outbound_start_time;
2752 return rc;
2753
2754 tx_drop:
2755 card->stats.tx_dropped++;
2756 card->stats.tx_errors++;
2757 if ((new_skb != skb) && new_skb)
2758 dev_kfree_skb_any(new_skb);
2759 dev_kfree_skb_any(skb);
2760 netif_wake_queue(dev);
2761 return NETDEV_TX_OK;
2762 }
2763
2764 static int qeth_l3_open(struct net_device *dev)
2765 {
2766 struct qeth_card *card = netdev_priv(dev);
2767
2768 QETH_DBF_TEXT(TRACE, 4, "qethopen");
2769 if (card->state != CARD_STATE_SOFTSETUP)
2770 return -ENODEV;
2771 card->data.state = CH_STATE_UP;
2772 card->state = CARD_STATE_UP;
2773 card->dev->flags |= IFF_UP;
2774 netif_start_queue(dev);
2775
2776 if (!card->lan_online && netif_carrier_ok(dev))
2777 netif_carrier_off(dev);
2778 return 0;
2779 }
2780
2781 static int qeth_l3_stop(struct net_device *dev)
2782 {
2783 struct qeth_card *card = netdev_priv(dev);
2784
2785 QETH_DBF_TEXT(TRACE, 4, "qethstop");
2786 netif_tx_disable(dev);
2787 card->dev->flags &= ~IFF_UP;
2788 if (card->state == CARD_STATE_UP)
2789 card->state = CARD_STATE_SOFTSETUP;
2790 return 0;
2791 }
2792
2793 static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
2794 {
2795 struct qeth_card *card = netdev_priv(dev);
2796
2797 return (card->options.checksum_type == HW_CHECKSUMMING);
2798 }
2799
2800 static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
2801 {
2802 struct qeth_card *card = netdev_priv(dev);
2803 enum qeth_card_states old_state;
2804 enum qeth_checksum_types csum_type;
2805
2806 if ((card->state != CARD_STATE_UP) &&
2807 (card->state != CARD_STATE_DOWN))
2808 return -EPERM;
2809
2810 if (data)
2811 csum_type = HW_CHECKSUMMING;
2812 else
2813 csum_type = SW_CHECKSUMMING;
2814
2815 if (card->options.checksum_type != csum_type) {
2816 old_state = card->state;
2817 if (card->state == CARD_STATE_UP)
2818 __qeth_l3_set_offline(card->gdev, 1);
2819 card->options.checksum_type = csum_type;
2820 if (old_state == CARD_STATE_UP)
2821 __qeth_l3_set_online(card->gdev, 1);
2822 }
2823 return 0;
2824 }
2825
2826 static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
2827 {
2828 struct qeth_card *card = netdev_priv(dev);
2829
2830 if (data) {
2831 if (card->options.large_send == QETH_LARGE_SEND_NO) {
2832 if (card->info.type == QETH_CARD_TYPE_IQD)
2833 card->options.large_send = QETH_LARGE_SEND_EDDP;
2834 else
2835 card->options.large_send = QETH_LARGE_SEND_TSO;
2836 dev->features |= NETIF_F_TSO;
2837 }
2838 } else {
2839 dev->features &= ~NETIF_F_TSO;
2840 card->options.large_send = QETH_LARGE_SEND_NO;
2841 }
2842 return 0;
2843 }
2844
2845 static struct ethtool_ops qeth_l3_ethtool_ops = {
2846 .get_link = ethtool_op_get_link,
2847 .get_tx_csum = ethtool_op_get_tx_csum,
2848 .set_tx_csum = ethtool_op_set_tx_hw_csum,
2849 .get_rx_csum = qeth_l3_ethtool_get_rx_csum,
2850 .set_rx_csum = qeth_l3_ethtool_set_rx_csum,
2851 .get_sg = ethtool_op_get_sg,
2852 .set_sg = ethtool_op_set_sg,
2853 .get_tso = ethtool_op_get_tso,
2854 .set_tso = qeth_l3_ethtool_set_tso,
2855 .get_strings = qeth_core_get_strings,
2856 .get_ethtool_stats = qeth_core_get_ethtool_stats,
2857 .get_stats_count = qeth_core_get_stats_count,
2858 .get_drvinfo = qeth_core_get_drvinfo,
2859 .get_settings = qeth_core_ethtool_get_settings,
2860 };
2861
2862 /*
2863 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2864 * NOARP on the netdevice is no option because it also turns off neighbor
2865 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2866 * arp resolution but we want the hard header (packet socket will work
2867 * e.g. tcpdump)
2868 */
2869 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2870 {
2871 n->nud_state = NUD_NOARP;
2872 memcpy(n->ha, "FAKELL", 6);
2873 n->output = n->ops->connected_output;
2874 return 0;
2875 }
2876
2877 static int
2878 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2879 {
2880 if (np->tbl->family == AF_INET)
2881 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2882
2883 return 0;
2884 }
2885
2886 static int qeth_l3_setup_netdev(struct qeth_card *card)
2887 {
2888 if (card->info.type == QETH_CARD_TYPE_OSAE) {
2889 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2890 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2891 #ifdef CONFIG_TR
2892 card->dev = alloc_trdev(0);
2893 #endif
2894 if (!card->dev)
2895 return -ENODEV;
2896 } else {
2897 card->dev = alloc_etherdev(0);
2898 if (!card->dev)
2899 return -ENODEV;
2900 card->dev->neigh_setup = qeth_l3_neigh_setup;
2901
2902 /*IPv6 address autoconfiguration stuff*/
2903 qeth_l3_get_unique_id(card);
2904 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2905 card->dev->dev_id = card->info.unique_id &
2906 0xffff;
2907 }
2908 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2909 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
2910 if (!card->dev)
2911 return -ENODEV;
2912 card->dev->flags |= IFF_NOARP;
2913 qeth_l3_iqd_read_initial_mac(card);
2914 } else
2915 return -ENODEV;
2916
2917 card->dev->hard_start_xmit = qeth_l3_hard_start_xmit;
2918 card->dev->priv = card;
2919 card->dev->tx_timeout = &qeth_tx_timeout;
2920 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
2921 card->dev->open = qeth_l3_open;
2922 card->dev->stop = qeth_l3_stop;
2923 card->dev->do_ioctl = qeth_l3_do_ioctl;
2924 card->dev->get_stats = qeth_get_stats;
2925 card->dev->change_mtu = qeth_change_mtu;
2926 card->dev->set_multicast_list = qeth_l3_set_multicast_list;
2927 card->dev->vlan_rx_register = qeth_l3_vlan_rx_register;
2928 card->dev->vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid;
2929 card->dev->vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid;
2930 card->dev->mtu = card->info.initial_mtu;
2931 card->dev->set_mac_address = NULL;
2932 SET_ETHTOOL_OPS(card->dev, &qeth_l3_ethtool_ops);
2933 card->dev->features |= NETIF_F_HW_VLAN_TX |
2934 NETIF_F_HW_VLAN_RX |
2935 NETIF_F_HW_VLAN_FILTER;
2936
2937 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
2938 return register_netdev(card->dev);
2939 }
2940
2941 static void qeth_l3_qdio_input_handler(struct ccw_device *ccwdev,
2942 unsigned int qdio_err, unsigned int queue, int first_element,
2943 int count, unsigned long card_ptr)
2944 {
2945 struct net_device *net_dev;
2946 struct qeth_card *card;
2947 struct qeth_qdio_buffer *buffer;
2948 int index;
2949 int i;
2950
2951 card = (struct qeth_card *) card_ptr;
2952 net_dev = card->dev;
2953 if (card->options.performance_stats) {
2954 card->perf_stats.inbound_cnt++;
2955 card->perf_stats.inbound_start_time = qeth_get_micros();
2956 }
2957 if (qdio_err & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {
2958 QETH_DBF_TEXT(TRACE, 1, "qdinchk");
2959 QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card));
2960 QETH_DBF_TEXT_(TRACE, 1, "%04X%04X",
2961 first_element, count);
2962 QETH_DBF_TEXT_(TRACE, 1, "%04X", queue);
2963 qeth_schedule_recovery(card);
2964 return;
2965 }
2966 for (i = first_element; i < (first_element + count); ++i) {
2967 index = i % QDIO_MAX_BUFFERS_PER_Q;
2968 buffer = &card->qdio.in_q->bufs[index];
2969 if (!(qdio_err &&
2970 qeth_check_qdio_errors(buffer->buffer,
2971 qdio_err, "qinerr")))
2972 qeth_l3_process_inbound_buffer(card, buffer, index);
2973 /* clear buffer and give back to hardware */
2974 qeth_put_buffer_pool_entry(card, buffer->pool_entry);
2975 qeth_queue_input_buffer(card, index);
2976 }
2977 if (card->options.performance_stats)
2978 card->perf_stats.inbound_time += qeth_get_micros() -
2979 card->perf_stats.inbound_start_time;
2980 }
2981
2982 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
2983 {
2984 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2985
2986 qeth_l3_create_device_attributes(&gdev->dev);
2987 card->options.layer2 = 0;
2988 card->discipline.input_handler = (qdio_handler_t *)
2989 qeth_l3_qdio_input_handler;
2990 card->discipline.output_handler = (qdio_handler_t *)
2991 qeth_qdio_output_handler;
2992 card->discipline.recover = qeth_l3_recover;
2993 return 0;
2994 }
2995
2996 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
2997 {
2998 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2999
3000 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3001
3002 if (cgdev->state == CCWGROUP_ONLINE) {
3003 card->use_hard_stop = 1;
3004 qeth_l3_set_offline(cgdev);
3005 }
3006
3007 if (card->dev) {
3008 unregister_netdev(card->dev);
3009 card->dev = NULL;
3010 }
3011
3012 qeth_l3_remove_device_attributes(&cgdev->dev);
3013 qeth_l3_clear_ip_list(card, 0, 0);
3014 qeth_l3_clear_ipato_list(card);
3015 return;
3016 }
3017
3018 static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
3019 {
3020 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3021 int rc = 0;
3022 enum qeth_card_states recover_flag;
3023
3024 BUG_ON(!card);
3025 QETH_DBF_TEXT(SETUP, 2, "setonlin");
3026 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
3027
3028 qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
3029 if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD)) {
3030 PRINT_WARN("set_online of card %s interrupted by user!\n",
3031 CARD_BUS_ID(card));
3032 return -ERESTARTSYS;
3033 }
3034
3035 recover_flag = card->state;
3036 rc = ccw_device_set_online(CARD_RDEV(card));
3037 if (rc) {
3038 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3039 return -EIO;
3040 }
3041 rc = ccw_device_set_online(CARD_WDEV(card));
3042 if (rc) {
3043 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3044 return -EIO;
3045 }
3046 rc = ccw_device_set_online(CARD_DDEV(card));
3047 if (rc) {
3048 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3049 return -EIO;
3050 }
3051
3052 rc = qeth_core_hardsetup_card(card);
3053 if (rc) {
3054 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
3055 goto out_remove;
3056 }
3057
3058 qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
3059
3060 if (!card->dev && qeth_l3_setup_netdev(card))
3061 goto out_remove;
3062
3063 card->state = CARD_STATE_HARDSETUP;
3064 qeth_print_status_message(card);
3065
3066 /* softsetup */
3067 QETH_DBF_TEXT(SETUP, 2, "softsetp");
3068
3069 rc = qeth_send_startlan(card);
3070 if (rc) {
3071 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3072 if (rc == 0xe080) {
3073 PRINT_WARN("LAN on card %s if offline! "
3074 "Waiting for STARTLAN from card.\n",
3075 CARD_BUS_ID(card));
3076 card->lan_online = 0;
3077 }
3078 return rc;
3079 } else
3080 card->lan_online = 1;
3081 qeth_set_large_send(card, card->options.large_send);
3082
3083 rc = qeth_l3_setadapter_parms(card);
3084 if (rc)
3085 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
3086 rc = qeth_l3_start_ipassists(card);
3087 if (rc)
3088 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
3089 rc = qeth_l3_setrouting_v4(card);
3090 if (rc)
3091 QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
3092 rc = qeth_l3_setrouting_v6(card);
3093 if (rc)
3094 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
3095 netif_tx_disable(card->dev);
3096
3097 rc = qeth_init_qdio_queues(card);
3098 if (rc) {
3099 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
3100 goto out_remove;
3101 }
3102 card->state = CARD_STATE_SOFTSETUP;
3103 netif_carrier_on(card->dev);
3104
3105 qeth_set_allowed_threads(card, 0xffffffff, 0);
3106 if (recover_flag == CARD_STATE_RECOVER) {
3107 if (recovery_mode)
3108 qeth_l3_open(card->dev);
3109 else {
3110 rtnl_lock();
3111 dev_open(card->dev);
3112 rtnl_unlock();
3113 }
3114 qeth_l3_set_multicast_list(card->dev);
3115 }
3116 /* let user_space know that device is online */
3117 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
3118 return 0;
3119 out_remove:
3120 card->use_hard_stop = 1;
3121 qeth_l3_stop_card(card, 0);
3122 ccw_device_set_offline(CARD_DDEV(card));
3123 ccw_device_set_offline(CARD_WDEV(card));
3124 ccw_device_set_offline(CARD_RDEV(card));
3125 if (recover_flag == CARD_STATE_RECOVER)
3126 card->state = CARD_STATE_RECOVER;
3127 else
3128 card->state = CARD_STATE_DOWN;
3129 return -ENODEV;
3130 }
3131
3132 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
3133 {
3134 return __qeth_l3_set_online(gdev, 0);
3135 }
3136
3137 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
3138 int recovery_mode)
3139 {
3140 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3141 int rc = 0, rc2 = 0, rc3 = 0;
3142 enum qeth_card_states recover_flag;
3143
3144 QETH_DBF_TEXT(SETUP, 3, "setoffl");
3145 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
3146
3147 if (card->dev && netif_carrier_ok(card->dev))
3148 netif_carrier_off(card->dev);
3149 recover_flag = card->state;
3150 if (qeth_l3_stop_card(card, recovery_mode) == -ERESTARTSYS) {
3151 PRINT_WARN("Stopping card %s interrupted by user!\n",
3152 CARD_BUS_ID(card));
3153 return -ERESTARTSYS;
3154 }
3155 rc = ccw_device_set_offline(CARD_DDEV(card));
3156 rc2 = ccw_device_set_offline(CARD_WDEV(card));
3157 rc3 = ccw_device_set_offline(CARD_RDEV(card));
3158 if (!rc)
3159 rc = (rc2) ? rc2 : rc3;
3160 if (rc)
3161 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3162 if (recover_flag == CARD_STATE_UP)
3163 card->state = CARD_STATE_RECOVER;
3164 /* let user_space know that device is offline */
3165 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
3166 return 0;
3167 }
3168
3169 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
3170 {
3171 return __qeth_l3_set_offline(cgdev, 0);
3172 }
3173
3174 static int qeth_l3_recover(void *ptr)
3175 {
3176 struct qeth_card *card;
3177 int rc = 0;
3178
3179 card = (struct qeth_card *) ptr;
3180 QETH_DBF_TEXT(TRACE, 2, "recover1");
3181 QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
3182 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
3183 return 0;
3184 QETH_DBF_TEXT(TRACE, 2, "recover2");
3185 PRINT_WARN("Recovery of device %s started ...\n",
3186 CARD_BUS_ID(card));
3187 card->use_hard_stop = 1;
3188 __qeth_l3_set_offline(card->gdev, 1);
3189 rc = __qeth_l3_set_online(card->gdev, 1);
3190 /* don't run another scheduled recovery */
3191 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
3192 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3193 if (!rc)
3194 PRINT_INFO("Device %s successfully recovered!\n",
3195 CARD_BUS_ID(card));
3196 else
3197 PRINT_INFO("Device %s could not be recovered!\n",
3198 CARD_BUS_ID(card));
3199 return 0;
3200 }
3201
3202 static void qeth_l3_shutdown(struct ccwgroup_device *gdev)
3203 {
3204 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3205 qeth_l3_clear_ip_list(card, 0, 0);
3206 qeth_qdio_clear_card(card, 0);
3207 qeth_clear_qdio_buffers(card);
3208 }
3209
3210 struct ccwgroup_driver qeth_l3_ccwgroup_driver = {
3211 .probe = qeth_l3_probe_device,
3212 .remove = qeth_l3_remove_device,
3213 .set_online = qeth_l3_set_online,
3214 .set_offline = qeth_l3_set_offline,
3215 .shutdown = qeth_l3_shutdown,
3216 };
3217 EXPORT_SYMBOL_GPL(qeth_l3_ccwgroup_driver);
3218
3219 static int qeth_l3_ip_event(struct notifier_block *this,
3220 unsigned long event, void *ptr)
3221 {
3222 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3223 struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev;
3224 struct qeth_ipaddr *addr;
3225 struct qeth_card *card;
3226
3227 if (dev_net(dev) != &init_net)
3228 return NOTIFY_DONE;
3229
3230 QETH_DBF_TEXT(TRACE, 3, "ipevent");
3231 card = qeth_l3_get_card_from_dev(dev);
3232 if (!card)
3233 return NOTIFY_DONE;
3234
3235 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
3236 if (addr != NULL) {
3237 addr->u.a4.addr = ifa->ifa_address;
3238 addr->u.a4.mask = ifa->ifa_mask;
3239 addr->type = QETH_IP_TYPE_NORMAL;
3240 } else
3241 goto out;
3242
3243 switch (event) {
3244 case NETDEV_UP:
3245 if (!qeth_l3_add_ip(card, addr))
3246 kfree(addr);
3247 break;
3248 case NETDEV_DOWN:
3249 if (!qeth_l3_delete_ip(card, addr))
3250 kfree(addr);
3251 break;
3252 default:
3253 break;
3254 }
3255 qeth_l3_set_ip_addr_list(card);
3256 out:
3257 return NOTIFY_DONE;
3258 }
3259
3260 static struct notifier_block qeth_l3_ip_notifier = {
3261 qeth_l3_ip_event,
3262 NULL,
3263 };
3264
3265 #ifdef CONFIG_QETH_IPV6
3266 /**
3267 * IPv6 event handler
3268 */
3269 static int qeth_l3_ip6_event(struct notifier_block *this,
3270 unsigned long event, void *ptr)
3271 {
3272 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
3273 struct net_device *dev = (struct net_device *)ifa->idev->dev;
3274 struct qeth_ipaddr *addr;
3275 struct qeth_card *card;
3276
3277 QETH_DBF_TEXT(TRACE, 3, "ip6event");
3278
3279 card = qeth_l3_get_card_from_dev(dev);
3280 if (!card)
3281 return NOTIFY_DONE;
3282 if (!qeth_is_supported(card, IPA_IPV6))
3283 return NOTIFY_DONE;
3284
3285 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
3286 if (addr != NULL) {
3287 memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr));
3288 addr->u.a6.pfxlen = ifa->prefix_len;
3289 addr->type = QETH_IP_TYPE_NORMAL;
3290 } else
3291 goto out;
3292
3293 switch (event) {
3294 case NETDEV_UP:
3295 if (!qeth_l3_add_ip(card, addr))
3296 kfree(addr);
3297 break;
3298 case NETDEV_DOWN:
3299 if (!qeth_l3_delete_ip(card, addr))
3300 kfree(addr);
3301 break;
3302 default:
3303 break;
3304 }
3305 qeth_l3_set_ip_addr_list(card);
3306 out:
3307 return NOTIFY_DONE;
3308 }
3309
3310 static struct notifier_block qeth_l3_ip6_notifier = {
3311 qeth_l3_ip6_event,
3312 NULL,
3313 };
3314 #endif
3315
3316 static int qeth_l3_register_notifiers(void)
3317 {
3318 int rc;
3319
3320 QETH_DBF_TEXT(TRACE, 5, "regnotif");
3321 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
3322 if (rc)
3323 return rc;
3324 #ifdef CONFIG_QETH_IPV6
3325 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
3326 if (rc) {
3327 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
3328 return rc;
3329 }
3330 #else
3331 PRINT_WARN("layer 3 discipline no IPv6 support\n");
3332 #endif
3333 return 0;
3334 }
3335
3336 static void qeth_l3_unregister_notifiers(void)
3337 {
3338
3339 QETH_DBF_TEXT(TRACE, 5, "unregnot");
3340 BUG_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
3341 #ifdef CONFIG_QETH_IPV6
3342 BUG_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
3343 #endif /* QETH_IPV6 */
3344 }
3345
3346 static int __init qeth_l3_init(void)
3347 {
3348 int rc = 0;
3349
3350 PRINT_INFO("register layer 3 discipline\n");
3351 rc = qeth_l3_register_notifiers();
3352 return rc;
3353 }
3354
3355 static void __exit qeth_l3_exit(void)
3356 {
3357 qeth_l3_unregister_notifiers();
3358 PRINT_INFO("unregister layer 3 discipline\n");
3359 }
3360
3361 module_init(qeth_l3_init);
3362 module_exit(qeth_l3_exit);
3363 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3364 MODULE_DESCRIPTION("qeth layer 3 discipline");
3365 MODULE_LICENSE("GPL");
Support for the Chinese Samsung S3C2440 based development boards