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