/drivers/s390/net/qeth_l3_main.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2 · C · 3759 lines · 3251 code · 394 blank · 114 comment · 725 complexity · 0ac3595442969ea8ec7f05d360378290 MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * drivers/s390/net/qeth_l3_main.c
  3. *
  4. * Copyright IBM Corp. 2007, 2009
  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. #define KMSG_COMPONENT "qeth"
  11. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  12. #include <linux/module.h>
  13. #include <linux/moduleparam.h>
  14. #include <linux/string.h>
  15. #include <linux/errno.h>
  16. #include <linux/kernel.h>
  17. #include <linux/etherdevice.h>
  18. #include <linux/mii.h>
  19. #include <linux/ip.h>
  20. #include <linux/ipv6.h>
  21. #include <linux/inetdevice.h>
  22. #include <linux/igmp.h>
  23. #include <linux/slab.h>
  24. #include <net/ip.h>
  25. #include <net/arp.h>
  26. #include <net/ip6_checksum.h>
  27. #include "qeth_l3.h"
  28. static int qeth_l3_set_offline(struct ccwgroup_device *);
  29. static int qeth_l3_recover(void *);
  30. static int qeth_l3_stop(struct net_device *);
  31. static void qeth_l3_set_multicast_list(struct net_device *);
  32. static int qeth_l3_neigh_setup(struct net_device *, struct neigh_parms *);
  33. static int qeth_l3_register_addr_entry(struct qeth_card *,
  34. struct qeth_ipaddr *);
  35. static int qeth_l3_deregister_addr_entry(struct qeth_card *,
  36. struct qeth_ipaddr *);
  37. static int __qeth_l3_set_online(struct ccwgroup_device *, int);
  38. static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
  39. static int qeth_l3_isxdigit(char *buf)
  40. {
  41. while (*buf) {
  42. if (!isxdigit(*buf++))
  43. return 0;
  44. }
  45. return 1;
  46. }
  47. void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
  48. {
  49. sprintf(buf, "%i.%i.%i.%i", addr[0], addr[1], addr[2], addr[3]);
  50. }
  51. int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
  52. {
  53. int count = 0, rc = 0;
  54. int in[4];
  55. char c;
  56. rc = sscanf(buf, "%u.%u.%u.%u%c",
  57. &in[0], &in[1], &in[2], &in[3], &c);
  58. if (rc != 4 && (rc != 5 || c != '\n'))
  59. return -EINVAL;
  60. for (count = 0; count < 4; count++) {
  61. if (in[count] > 255)
  62. return -EINVAL;
  63. addr[count] = in[count];
  64. }
  65. return 0;
  66. }
  67. void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
  68. {
  69. sprintf(buf, "%pI6", addr);
  70. }
  71. int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
  72. {
  73. const char *end, *end_tmp, *start;
  74. __u16 *in;
  75. char num[5];
  76. int num2, cnt, out, found, save_cnt;
  77. unsigned short in_tmp[8] = {0, };
  78. cnt = out = found = save_cnt = num2 = 0;
  79. end = start = buf;
  80. in = (__u16 *) addr;
  81. memset(in, 0, 16);
  82. while (*end) {
  83. end = strchr(start, ':');
  84. if (end == NULL) {
  85. end = buf + strlen(buf);
  86. end_tmp = strchr(start, '\n');
  87. if (end_tmp != NULL)
  88. end = end_tmp;
  89. out = 1;
  90. }
  91. if ((end - start)) {
  92. memset(num, 0, 5);
  93. if ((end - start) > 4)
  94. return -EINVAL;
  95. memcpy(num, start, end - start);
  96. if (!qeth_l3_isxdigit(num))
  97. return -EINVAL;
  98. sscanf(start, "%x", &num2);
  99. if (found)
  100. in_tmp[save_cnt++] = num2;
  101. else
  102. in[cnt++] = num2;
  103. if (out)
  104. break;
  105. } else {
  106. if (found)
  107. return -EINVAL;
  108. found = 1;
  109. }
  110. start = ++end;
  111. }
  112. if (cnt + save_cnt > 8)
  113. return -EINVAL;
  114. cnt = 7;
  115. while (save_cnt)
  116. in[cnt--] = in_tmp[--save_cnt];
  117. return 0;
  118. }
  119. void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
  120. char *buf)
  121. {
  122. if (proto == QETH_PROT_IPV4)
  123. qeth_l3_ipaddr4_to_string(addr, buf);
  124. else if (proto == QETH_PROT_IPV6)
  125. qeth_l3_ipaddr6_to_string(addr, buf);
  126. }
  127. int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
  128. __u8 *addr)
  129. {
  130. if (proto == QETH_PROT_IPV4)
  131. return qeth_l3_string_to_ipaddr4(buf, addr);
  132. else if (proto == QETH_PROT_IPV6)
  133. return qeth_l3_string_to_ipaddr6(buf, addr);
  134. else
  135. return -EINVAL;
  136. }
  137. static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
  138. {
  139. int i, j;
  140. u8 octet;
  141. for (i = 0; i < len; ++i) {
  142. octet = addr[i];
  143. for (j = 7; j >= 0; --j) {
  144. bits[i*8 + j] = octet & 1;
  145. octet >>= 1;
  146. }
  147. }
  148. }
  149. int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
  150. struct qeth_ipaddr *addr)
  151. {
  152. struct qeth_ipato_entry *ipatoe;
  153. u8 addr_bits[128] = {0, };
  154. u8 ipatoe_bits[128] = {0, };
  155. int rc = 0;
  156. if (!card->ipato.enabled)
  157. return 0;
  158. qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
  159. (addr->proto == QETH_PROT_IPV4)? 4:16);
  160. list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
  161. if (addr->proto != ipatoe->proto)
  162. continue;
  163. qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
  164. (ipatoe->proto == QETH_PROT_IPV4) ?
  165. 4 : 16);
  166. if (addr->proto == QETH_PROT_IPV4)
  167. rc = !memcmp(addr_bits, ipatoe_bits,
  168. min(32, ipatoe->mask_bits));
  169. else
  170. rc = !memcmp(addr_bits, ipatoe_bits,
  171. min(128, ipatoe->mask_bits));
  172. if (rc)
  173. break;
  174. }
  175. /* invert? */
  176. if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
  177. rc = !rc;
  178. else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
  179. rc = !rc;
  180. return rc;
  181. }
  182. /*
  183. * Add IP to be added to todo list. If there is already an "add todo"
  184. * in this list we just incremenent the reference count.
  185. * Returns 0 if we just incremented reference count.
  186. */
  187. static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
  188. struct qeth_ipaddr *addr, int add)
  189. {
  190. struct qeth_ipaddr *tmp, *t;
  191. int found = 0;
  192. if (card->options.sniffer)
  193. return 0;
  194. list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
  195. if ((addr->type == QETH_IP_TYPE_DEL_ALL_MC) &&
  196. (tmp->type == QETH_IP_TYPE_DEL_ALL_MC))
  197. return 0;
  198. if ((tmp->proto == QETH_PROT_IPV4) &&
  199. (addr->proto == QETH_PROT_IPV4) &&
  200. (tmp->type == addr->type) &&
  201. (tmp->is_multicast == addr->is_multicast) &&
  202. (tmp->u.a4.addr == addr->u.a4.addr) &&
  203. (tmp->u.a4.mask == addr->u.a4.mask)) {
  204. found = 1;
  205. break;
  206. }
  207. if ((tmp->proto == QETH_PROT_IPV6) &&
  208. (addr->proto == QETH_PROT_IPV6) &&
  209. (tmp->type == addr->type) &&
  210. (tmp->is_multicast == addr->is_multicast) &&
  211. (tmp->u.a6.pfxlen == addr->u.a6.pfxlen) &&
  212. (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
  213. sizeof(struct in6_addr)) == 0)) {
  214. found = 1;
  215. break;
  216. }
  217. }
  218. if (found) {
  219. if (addr->users != 0)
  220. tmp->users += addr->users;
  221. else
  222. tmp->users += add ? 1 : -1;
  223. if (tmp->users == 0) {
  224. list_del(&tmp->entry);
  225. kfree(tmp);
  226. }
  227. return 0;
  228. } else {
  229. if (addr->type == QETH_IP_TYPE_DEL_ALL_MC)
  230. list_add(&addr->entry, card->ip_tbd_list);
  231. else {
  232. if (addr->users == 0)
  233. addr->users += add ? 1 : -1;
  234. if (add && (addr->type == QETH_IP_TYPE_NORMAL) &&
  235. qeth_l3_is_addr_covered_by_ipato(card, addr)) {
  236. QETH_CARD_TEXT(card, 2, "tkovaddr");
  237. addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
  238. }
  239. list_add_tail(&addr->entry, card->ip_tbd_list);
  240. }
  241. return 1;
  242. }
  243. }
  244. static int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
  245. {
  246. unsigned long flags;
  247. int rc = 0;
  248. QETH_CARD_TEXT(card, 4, "delip");
  249. if (addr->proto == QETH_PROT_IPV4)
  250. QETH_CARD_HEX(card, 4, &addr->u.a4.addr, 4);
  251. else {
  252. QETH_CARD_HEX(card, 4, &addr->u.a6.addr, 8);
  253. QETH_CARD_HEX(card, 4, ((char *)&addr->u.a6.addr) + 8, 8);
  254. }
  255. spin_lock_irqsave(&card->ip_lock, flags);
  256. rc = __qeth_l3_insert_ip_todo(card, addr, 0);
  257. spin_unlock_irqrestore(&card->ip_lock, flags);
  258. return rc;
  259. }
  260. static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
  261. {
  262. unsigned long flags;
  263. int rc = 0;
  264. QETH_CARD_TEXT(card, 4, "addip");
  265. if (addr->proto == QETH_PROT_IPV4)
  266. QETH_CARD_HEX(card, 4, &addr->u.a4.addr, 4);
  267. else {
  268. QETH_CARD_HEX(card, 4, &addr->u.a6.addr, 8);
  269. QETH_CARD_HEX(card, 4, ((char *)&addr->u.a6.addr) + 8, 8);
  270. }
  271. spin_lock_irqsave(&card->ip_lock, flags);
  272. rc = __qeth_l3_insert_ip_todo(card, addr, 1);
  273. spin_unlock_irqrestore(&card->ip_lock, flags);
  274. return rc;
  275. }
  276. static struct qeth_ipaddr *qeth_l3_get_addr_buffer(
  277. enum qeth_prot_versions prot)
  278. {
  279. struct qeth_ipaddr *addr;
  280. addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
  281. if (addr == NULL) {
  282. return NULL;
  283. }
  284. addr->type = QETH_IP_TYPE_NORMAL;
  285. addr->proto = prot;
  286. return addr;
  287. }
  288. static void qeth_l3_delete_mc_addresses(struct qeth_card *card)
  289. {
  290. struct qeth_ipaddr *iptodo;
  291. unsigned long flags;
  292. QETH_CARD_TEXT(card, 4, "delmc");
  293. iptodo = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
  294. if (!iptodo) {
  295. QETH_CARD_TEXT(card, 2, "dmcnomem");
  296. return;
  297. }
  298. iptodo->type = QETH_IP_TYPE_DEL_ALL_MC;
  299. spin_lock_irqsave(&card->ip_lock, flags);
  300. if (!__qeth_l3_insert_ip_todo(card, iptodo, 0))
  301. kfree(iptodo);
  302. spin_unlock_irqrestore(&card->ip_lock, flags);
  303. }
  304. /*
  305. * Add/remove address to/from card's ip list, i.e. try to add or remove
  306. * reference to/from an IP address that is already registered on the card.
  307. * Returns:
  308. * 0 address was on card and its reference count has been adjusted,
  309. * but is still > 0, so nothing has to be done
  310. * also returns 0 if card was not on card and the todo was to delete
  311. * the address -> there is also nothing to be done
  312. * 1 address was not on card and the todo is to add it to the card's ip
  313. * list
  314. * -1 address was on card and its reference count has been decremented
  315. * to <= 0 by the todo -> address must be removed from card
  316. */
  317. static int __qeth_l3_ref_ip_on_card(struct qeth_card *card,
  318. struct qeth_ipaddr *todo, struct qeth_ipaddr **__addr)
  319. {
  320. struct qeth_ipaddr *addr;
  321. int found = 0;
  322. list_for_each_entry(addr, &card->ip_list, entry) {
  323. if ((addr->proto == QETH_PROT_IPV4) &&
  324. (todo->proto == QETH_PROT_IPV4) &&
  325. (addr->type == todo->type) &&
  326. (addr->u.a4.addr == todo->u.a4.addr) &&
  327. (addr->u.a4.mask == todo->u.a4.mask)) {
  328. found = 1;
  329. break;
  330. }
  331. if ((addr->proto == QETH_PROT_IPV6) &&
  332. (todo->proto == QETH_PROT_IPV6) &&
  333. (addr->type == todo->type) &&
  334. (addr->u.a6.pfxlen == todo->u.a6.pfxlen) &&
  335. (memcmp(&addr->u.a6.addr, &todo->u.a6.addr,
  336. sizeof(struct in6_addr)) == 0)) {
  337. found = 1;
  338. break;
  339. }
  340. }
  341. if (found) {
  342. addr->users += todo->users;
  343. if (addr->users <= 0) {
  344. *__addr = addr;
  345. return -1;
  346. } else {
  347. /* for VIPA and RXIP limit refcount to 1 */
  348. if (addr->type != QETH_IP_TYPE_NORMAL)
  349. addr->users = 1;
  350. return 0;
  351. }
  352. }
  353. if (todo->users > 0) {
  354. /* for VIPA and RXIP limit refcount to 1 */
  355. if (todo->type != QETH_IP_TYPE_NORMAL)
  356. todo->users = 1;
  357. return 1;
  358. } else
  359. return 0;
  360. }
  361. static void __qeth_l3_delete_all_mc(struct qeth_card *card,
  362. unsigned long *flags)
  363. {
  364. struct list_head fail_list;
  365. struct qeth_ipaddr *addr, *tmp;
  366. int rc;
  367. INIT_LIST_HEAD(&fail_list);
  368. again:
  369. list_for_each_entry_safe(addr, tmp, &card->ip_list, entry) {
  370. if (addr->is_multicast) {
  371. list_del(&addr->entry);
  372. spin_unlock_irqrestore(&card->ip_lock, *flags);
  373. rc = qeth_l3_deregister_addr_entry(card, addr);
  374. spin_lock_irqsave(&card->ip_lock, *flags);
  375. if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND))
  376. kfree(addr);
  377. else
  378. list_add_tail(&addr->entry, &fail_list);
  379. goto again;
  380. }
  381. }
  382. list_splice(&fail_list, &card->ip_list);
  383. }
  384. static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
  385. {
  386. struct list_head *tbd_list;
  387. struct qeth_ipaddr *todo, *addr;
  388. unsigned long flags;
  389. int rc;
  390. QETH_CARD_TEXT(card, 2, "sdiplist");
  391. QETH_CARD_HEX(card, 2, &card, sizeof(void *));
  392. if ((card->state != CARD_STATE_UP &&
  393. card->state != CARD_STATE_SOFTSETUP) || card->options.sniffer) {
  394. return;
  395. }
  396. spin_lock_irqsave(&card->ip_lock, flags);
  397. tbd_list = card->ip_tbd_list;
  398. card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
  399. if (!card->ip_tbd_list) {
  400. QETH_CARD_TEXT(card, 0, "silnomem");
  401. card->ip_tbd_list = tbd_list;
  402. spin_unlock_irqrestore(&card->ip_lock, flags);
  403. return;
  404. } else
  405. INIT_LIST_HEAD(card->ip_tbd_list);
  406. while (!list_empty(tbd_list)) {
  407. todo = list_entry(tbd_list->next, struct qeth_ipaddr, entry);
  408. list_del(&todo->entry);
  409. if (todo->type == QETH_IP_TYPE_DEL_ALL_MC) {
  410. __qeth_l3_delete_all_mc(card, &flags);
  411. kfree(todo);
  412. continue;
  413. }
  414. rc = __qeth_l3_ref_ip_on_card(card, todo, &addr);
  415. if (rc == 0) {
  416. /* nothing to be done; only adjusted refcount */
  417. kfree(todo);
  418. } else if (rc == 1) {
  419. /* new entry to be added to on-card list */
  420. spin_unlock_irqrestore(&card->ip_lock, flags);
  421. rc = qeth_l3_register_addr_entry(card, todo);
  422. spin_lock_irqsave(&card->ip_lock, flags);
  423. if (!rc || (rc == IPA_RC_LAN_OFFLINE))
  424. list_add_tail(&todo->entry, &card->ip_list);
  425. else
  426. kfree(todo);
  427. } else if (rc == -1) {
  428. /* on-card entry to be removed */
  429. list_del_init(&addr->entry);
  430. spin_unlock_irqrestore(&card->ip_lock, flags);
  431. rc = qeth_l3_deregister_addr_entry(card, addr);
  432. spin_lock_irqsave(&card->ip_lock, flags);
  433. if (!rc || (rc == IPA_RC_IP_ADDRESS_NOT_DEFINED))
  434. kfree(addr);
  435. else
  436. list_add_tail(&addr->entry, &card->ip_list);
  437. kfree(todo);
  438. }
  439. }
  440. spin_unlock_irqrestore(&card->ip_lock, flags);
  441. kfree(tbd_list);
  442. }
  443. static void qeth_l3_clear_ip_list(struct qeth_card *card, int recover)
  444. {
  445. struct qeth_ipaddr *addr, *tmp;
  446. unsigned long flags;
  447. QETH_CARD_TEXT(card, 4, "clearip");
  448. if (recover && card->options.sniffer)
  449. return;
  450. spin_lock_irqsave(&card->ip_lock, flags);
  451. /* clear todo list */
  452. list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
  453. list_del(&addr->entry);
  454. kfree(addr);
  455. }
  456. while (!list_empty(&card->ip_list)) {
  457. addr = list_entry(card->ip_list.next,
  458. struct qeth_ipaddr, entry);
  459. list_del_init(&addr->entry);
  460. if (!recover || addr->is_multicast) {
  461. kfree(addr);
  462. continue;
  463. }
  464. list_add_tail(&addr->entry, card->ip_tbd_list);
  465. }
  466. spin_unlock_irqrestore(&card->ip_lock, flags);
  467. }
  468. static int qeth_l3_address_exists_in_list(struct list_head *list,
  469. struct qeth_ipaddr *addr, int same_type)
  470. {
  471. struct qeth_ipaddr *tmp;
  472. list_for_each_entry(tmp, list, entry) {
  473. if ((tmp->proto == QETH_PROT_IPV4) &&
  474. (addr->proto == QETH_PROT_IPV4) &&
  475. ((same_type && (tmp->type == addr->type)) ||
  476. (!same_type && (tmp->type != addr->type))) &&
  477. (tmp->u.a4.addr == addr->u.a4.addr))
  478. return 1;
  479. if ((tmp->proto == QETH_PROT_IPV6) &&
  480. (addr->proto == QETH_PROT_IPV6) &&
  481. ((same_type && (tmp->type == addr->type)) ||
  482. (!same_type && (tmp->type != addr->type))) &&
  483. (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
  484. sizeof(struct in6_addr)) == 0))
  485. return 1;
  486. }
  487. return 0;
  488. }
  489. static int qeth_l3_send_setdelmc(struct qeth_card *card,
  490. struct qeth_ipaddr *addr, int ipacmd)
  491. {
  492. int rc;
  493. struct qeth_cmd_buffer *iob;
  494. struct qeth_ipa_cmd *cmd;
  495. QETH_CARD_TEXT(card, 4, "setdelmc");
  496. iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
  497. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  498. memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
  499. if (addr->proto == QETH_PROT_IPV6)
  500. memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
  501. sizeof(struct in6_addr));
  502. else
  503. memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
  504. rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
  505. return rc;
  506. }
  507. static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
  508. {
  509. int i, j;
  510. for (i = 0; i < 16; i++) {
  511. j = (len) - (i * 8);
  512. if (j >= 8)
  513. netmask[i] = 0xff;
  514. else if (j > 0)
  515. netmask[i] = (u8)(0xFF00 >> j);
  516. else
  517. netmask[i] = 0;
  518. }
  519. }
  520. static int qeth_l3_send_setdelip(struct qeth_card *card,
  521. struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
  522. {
  523. int rc;
  524. struct qeth_cmd_buffer *iob;
  525. struct qeth_ipa_cmd *cmd;
  526. __u8 netmask[16];
  527. QETH_CARD_TEXT(card, 4, "setdelip");
  528. QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
  529. iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
  530. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  531. if (addr->proto == QETH_PROT_IPV6) {
  532. memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
  533. sizeof(struct in6_addr));
  534. qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
  535. memcpy(cmd->data.setdelip6.mask, netmask,
  536. sizeof(struct in6_addr));
  537. cmd->data.setdelip6.flags = flags;
  538. } else {
  539. memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
  540. memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
  541. cmd->data.setdelip4.flags = flags;
  542. }
  543. rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
  544. return rc;
  545. }
  546. static int qeth_l3_send_setrouting(struct qeth_card *card,
  547. enum qeth_routing_types type, enum qeth_prot_versions prot)
  548. {
  549. int rc;
  550. struct qeth_ipa_cmd *cmd;
  551. struct qeth_cmd_buffer *iob;
  552. QETH_CARD_TEXT(card, 4, "setroutg");
  553. iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
  554. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  555. cmd->data.setrtg.type = (type);
  556. rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
  557. return rc;
  558. }
  559. static void qeth_l3_correct_routing_type(struct qeth_card *card,
  560. enum qeth_routing_types *type, enum qeth_prot_versions prot)
  561. {
  562. if (card->info.type == QETH_CARD_TYPE_IQD) {
  563. switch (*type) {
  564. case NO_ROUTER:
  565. case PRIMARY_CONNECTOR:
  566. case SECONDARY_CONNECTOR:
  567. case MULTICAST_ROUTER:
  568. return;
  569. default:
  570. goto out_inval;
  571. }
  572. } else {
  573. switch (*type) {
  574. case NO_ROUTER:
  575. case PRIMARY_ROUTER:
  576. case SECONDARY_ROUTER:
  577. return;
  578. case MULTICAST_ROUTER:
  579. if (qeth_is_ipafunc_supported(card, prot,
  580. IPA_OSA_MC_ROUTER))
  581. return;
  582. default:
  583. goto out_inval;
  584. }
  585. }
  586. out_inval:
  587. *type = NO_ROUTER;
  588. }
  589. int qeth_l3_setrouting_v4(struct qeth_card *card)
  590. {
  591. int rc;
  592. QETH_CARD_TEXT(card, 3, "setrtg4");
  593. qeth_l3_correct_routing_type(card, &card->options.route4.type,
  594. QETH_PROT_IPV4);
  595. rc = qeth_l3_send_setrouting(card, card->options.route4.type,
  596. QETH_PROT_IPV4);
  597. if (rc) {
  598. card->options.route4.type = NO_ROUTER;
  599. QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
  600. " on %s. Type set to 'no router'.\n", rc,
  601. QETH_CARD_IFNAME(card));
  602. }
  603. return rc;
  604. }
  605. int qeth_l3_setrouting_v6(struct qeth_card *card)
  606. {
  607. int rc = 0;
  608. QETH_CARD_TEXT(card, 3, "setrtg6");
  609. #ifdef CONFIG_QETH_IPV6
  610. if (!qeth_is_supported(card, IPA_IPV6))
  611. return 0;
  612. qeth_l3_correct_routing_type(card, &card->options.route6.type,
  613. QETH_PROT_IPV6);
  614. rc = qeth_l3_send_setrouting(card, card->options.route6.type,
  615. QETH_PROT_IPV6);
  616. if (rc) {
  617. card->options.route6.type = NO_ROUTER;
  618. QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
  619. " on %s. Type set to 'no router'.\n", rc,
  620. QETH_CARD_IFNAME(card));
  621. }
  622. #endif
  623. return rc;
  624. }
  625. /*
  626. * IP address takeover related functions
  627. */
  628. static void qeth_l3_clear_ipato_list(struct qeth_card *card)
  629. {
  630. struct qeth_ipato_entry *ipatoe, *tmp;
  631. unsigned long flags;
  632. spin_lock_irqsave(&card->ip_lock, flags);
  633. list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
  634. list_del(&ipatoe->entry);
  635. kfree(ipatoe);
  636. }
  637. spin_unlock_irqrestore(&card->ip_lock, flags);
  638. }
  639. int qeth_l3_add_ipato_entry(struct qeth_card *card,
  640. struct qeth_ipato_entry *new)
  641. {
  642. struct qeth_ipato_entry *ipatoe;
  643. unsigned long flags;
  644. int rc = 0;
  645. QETH_CARD_TEXT(card, 2, "addipato");
  646. spin_lock_irqsave(&card->ip_lock, flags);
  647. list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
  648. if (ipatoe->proto != new->proto)
  649. continue;
  650. if (!memcmp(ipatoe->addr, new->addr,
  651. (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
  652. (ipatoe->mask_bits == new->mask_bits)) {
  653. rc = -EEXIST;
  654. break;
  655. }
  656. }
  657. if (!rc)
  658. list_add_tail(&new->entry, &card->ipato.entries);
  659. spin_unlock_irqrestore(&card->ip_lock, flags);
  660. return rc;
  661. }
  662. void qeth_l3_del_ipato_entry(struct qeth_card *card,
  663. enum qeth_prot_versions proto, u8 *addr, int mask_bits)
  664. {
  665. struct qeth_ipato_entry *ipatoe, *tmp;
  666. unsigned long flags;
  667. QETH_CARD_TEXT(card, 2, "delipato");
  668. spin_lock_irqsave(&card->ip_lock, flags);
  669. list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
  670. if (ipatoe->proto != proto)
  671. continue;
  672. if (!memcmp(ipatoe->addr, addr,
  673. (proto == QETH_PROT_IPV4)? 4:16) &&
  674. (ipatoe->mask_bits == mask_bits)) {
  675. list_del(&ipatoe->entry);
  676. kfree(ipatoe);
  677. }
  678. }
  679. spin_unlock_irqrestore(&card->ip_lock, flags);
  680. }
  681. /*
  682. * VIPA related functions
  683. */
  684. int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
  685. const u8 *addr)
  686. {
  687. struct qeth_ipaddr *ipaddr;
  688. unsigned long flags;
  689. int rc = 0;
  690. ipaddr = qeth_l3_get_addr_buffer(proto);
  691. if (ipaddr) {
  692. if (proto == QETH_PROT_IPV4) {
  693. QETH_CARD_TEXT(card, 2, "addvipa4");
  694. memcpy(&ipaddr->u.a4.addr, addr, 4);
  695. ipaddr->u.a4.mask = 0;
  696. } else if (proto == QETH_PROT_IPV6) {
  697. QETH_CARD_TEXT(card, 2, "addvipa6");
  698. memcpy(&ipaddr->u.a6.addr, addr, 16);
  699. ipaddr->u.a6.pfxlen = 0;
  700. }
  701. ipaddr->type = QETH_IP_TYPE_VIPA;
  702. ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
  703. ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
  704. } else
  705. return -ENOMEM;
  706. spin_lock_irqsave(&card->ip_lock, flags);
  707. if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
  708. qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
  709. rc = -EEXIST;
  710. spin_unlock_irqrestore(&card->ip_lock, flags);
  711. if (rc) {
  712. return rc;
  713. }
  714. if (!qeth_l3_add_ip(card, ipaddr))
  715. kfree(ipaddr);
  716. qeth_l3_set_ip_addr_list(card);
  717. return rc;
  718. }
  719. void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
  720. const u8 *addr)
  721. {
  722. struct qeth_ipaddr *ipaddr;
  723. ipaddr = qeth_l3_get_addr_buffer(proto);
  724. if (ipaddr) {
  725. if (proto == QETH_PROT_IPV4) {
  726. QETH_CARD_TEXT(card, 2, "delvipa4");
  727. memcpy(&ipaddr->u.a4.addr, addr, 4);
  728. ipaddr->u.a4.mask = 0;
  729. } else if (proto == QETH_PROT_IPV6) {
  730. QETH_CARD_TEXT(card, 2, "delvipa6");
  731. memcpy(&ipaddr->u.a6.addr, addr, 16);
  732. ipaddr->u.a6.pfxlen = 0;
  733. }
  734. ipaddr->type = QETH_IP_TYPE_VIPA;
  735. } else
  736. return;
  737. if (!qeth_l3_delete_ip(card, ipaddr))
  738. kfree(ipaddr);
  739. qeth_l3_set_ip_addr_list(card);
  740. }
  741. /*
  742. * proxy ARP related functions
  743. */
  744. int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
  745. const u8 *addr)
  746. {
  747. struct qeth_ipaddr *ipaddr;
  748. unsigned long flags;
  749. int rc = 0;
  750. ipaddr = qeth_l3_get_addr_buffer(proto);
  751. if (ipaddr) {
  752. if (proto == QETH_PROT_IPV4) {
  753. QETH_CARD_TEXT(card, 2, "addrxip4");
  754. memcpy(&ipaddr->u.a4.addr, addr, 4);
  755. ipaddr->u.a4.mask = 0;
  756. } else if (proto == QETH_PROT_IPV6) {
  757. QETH_CARD_TEXT(card, 2, "addrxip6");
  758. memcpy(&ipaddr->u.a6.addr, addr, 16);
  759. ipaddr->u.a6.pfxlen = 0;
  760. }
  761. ipaddr->type = QETH_IP_TYPE_RXIP;
  762. ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
  763. ipaddr->del_flags = 0;
  764. } else
  765. return -ENOMEM;
  766. spin_lock_irqsave(&card->ip_lock, flags);
  767. if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
  768. qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
  769. rc = -EEXIST;
  770. spin_unlock_irqrestore(&card->ip_lock, flags);
  771. if (rc) {
  772. return rc;
  773. }
  774. if (!qeth_l3_add_ip(card, ipaddr))
  775. kfree(ipaddr);
  776. qeth_l3_set_ip_addr_list(card);
  777. return 0;
  778. }
  779. void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
  780. const u8 *addr)
  781. {
  782. struct qeth_ipaddr *ipaddr;
  783. ipaddr = qeth_l3_get_addr_buffer(proto);
  784. if (ipaddr) {
  785. if (proto == QETH_PROT_IPV4) {
  786. QETH_CARD_TEXT(card, 2, "addrxip4");
  787. memcpy(&ipaddr->u.a4.addr, addr, 4);
  788. ipaddr->u.a4.mask = 0;
  789. } else if (proto == QETH_PROT_IPV6) {
  790. QETH_CARD_TEXT(card, 2, "addrxip6");
  791. memcpy(&ipaddr->u.a6.addr, addr, 16);
  792. ipaddr->u.a6.pfxlen = 0;
  793. }
  794. ipaddr->type = QETH_IP_TYPE_RXIP;
  795. } else
  796. return;
  797. if (!qeth_l3_delete_ip(card, ipaddr))
  798. kfree(ipaddr);
  799. qeth_l3_set_ip_addr_list(card);
  800. }
  801. static int qeth_l3_register_addr_entry(struct qeth_card *card,
  802. struct qeth_ipaddr *addr)
  803. {
  804. char buf[50];
  805. int rc = 0;
  806. int cnt = 3;
  807. if (addr->proto == QETH_PROT_IPV4) {
  808. QETH_CARD_TEXT(card, 2, "setaddr4");
  809. QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
  810. } else if (addr->proto == QETH_PROT_IPV6) {
  811. QETH_CARD_TEXT(card, 2, "setaddr6");
  812. QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
  813. QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
  814. } else {
  815. QETH_CARD_TEXT(card, 2, "setaddr?");
  816. QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
  817. }
  818. do {
  819. if (addr->is_multicast)
  820. rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
  821. else
  822. rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
  823. addr->set_flags);
  824. if (rc)
  825. QETH_CARD_TEXT(card, 2, "failed");
  826. } while ((--cnt > 0) && rc);
  827. if (rc) {
  828. QETH_CARD_TEXT(card, 2, "FAILED");
  829. qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
  830. dev_warn(&card->gdev->dev,
  831. "Registering IP address %s failed\n", buf);
  832. }
  833. return rc;
  834. }
  835. static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
  836. struct qeth_ipaddr *addr)
  837. {
  838. int rc = 0;
  839. if (addr->proto == QETH_PROT_IPV4) {
  840. QETH_CARD_TEXT(card, 2, "deladdr4");
  841. QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
  842. } else if (addr->proto == QETH_PROT_IPV6) {
  843. QETH_CARD_TEXT(card, 2, "deladdr6");
  844. QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
  845. QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
  846. } else {
  847. QETH_CARD_TEXT(card, 2, "deladdr?");
  848. QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
  849. }
  850. if (addr->is_multicast)
  851. rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
  852. else
  853. rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
  854. addr->del_flags);
  855. if (rc)
  856. QETH_CARD_TEXT(card, 2, "failed");
  857. return rc;
  858. }
  859. static inline u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
  860. {
  861. if (cast_type == RTN_MULTICAST)
  862. return QETH_CAST_MULTICAST;
  863. if (cast_type == RTN_BROADCAST)
  864. return QETH_CAST_BROADCAST;
  865. return QETH_CAST_UNICAST;
  866. }
  867. static inline u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
  868. {
  869. u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
  870. if (cast_type == RTN_MULTICAST)
  871. return ct | QETH_CAST_MULTICAST;
  872. if (cast_type == RTN_ANYCAST)
  873. return ct | QETH_CAST_ANYCAST;
  874. if (cast_type == RTN_BROADCAST)
  875. return ct | QETH_CAST_BROADCAST;
  876. return ct | QETH_CAST_UNICAST;
  877. }
  878. static int qeth_l3_send_setadp_mode(struct qeth_card *card, __u32 command,
  879. __u32 mode)
  880. {
  881. int rc;
  882. struct qeth_cmd_buffer *iob;
  883. struct qeth_ipa_cmd *cmd;
  884. QETH_CARD_TEXT(card, 4, "adpmode");
  885. iob = qeth_get_adapter_cmd(card, command,
  886. sizeof(struct qeth_ipacmd_setadpparms));
  887. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  888. cmd->data.setadapterparms.data.mode = mode;
  889. rc = qeth_send_ipa_cmd(card, iob, qeth_default_setadapterparms_cb,
  890. NULL);
  891. return rc;
  892. }
  893. static int qeth_l3_setadapter_hstr(struct qeth_card *card)
  894. {
  895. int rc;
  896. QETH_CARD_TEXT(card, 4, "adphstr");
  897. if (qeth_adp_supported(card, IPA_SETADP_SET_BROADCAST_MODE)) {
  898. rc = qeth_l3_send_setadp_mode(card,
  899. IPA_SETADP_SET_BROADCAST_MODE,
  900. card->options.broadcast_mode);
  901. if (rc)
  902. QETH_DBF_MESSAGE(2, "couldn't set broadcast mode on "
  903. "device %s: x%x\n",
  904. CARD_BUS_ID(card), rc);
  905. rc = qeth_l3_send_setadp_mode(card,
  906. IPA_SETADP_ALTER_MAC_ADDRESS,
  907. card->options.macaddr_mode);
  908. if (rc)
  909. QETH_DBF_MESSAGE(2, "couldn't set macaddr mode on "
  910. "device %s: x%x\n", CARD_BUS_ID(card), rc);
  911. return rc;
  912. }
  913. if (card->options.broadcast_mode == QETH_TR_BROADCAST_LOCAL)
  914. QETH_DBF_MESSAGE(2, "set adapter parameters not available "
  915. "to set broadcast mode, using ALLRINGS "
  916. "on device %s:\n", CARD_BUS_ID(card));
  917. if (card->options.macaddr_mode == QETH_TR_MACADDR_CANONICAL)
  918. QETH_DBF_MESSAGE(2, "set adapter parameters not available "
  919. "to set macaddr mode, using NONCANONICAL "
  920. "on device %s:\n", CARD_BUS_ID(card));
  921. return 0;
  922. }
  923. static int qeth_l3_setadapter_parms(struct qeth_card *card)
  924. {
  925. int rc;
  926. QETH_DBF_TEXT(SETUP, 2, "setadprm");
  927. if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
  928. dev_info(&card->gdev->dev,
  929. "set adapter parameters not supported.\n");
  930. QETH_DBF_TEXT(SETUP, 2, " notsupp");
  931. return 0;
  932. }
  933. rc = qeth_query_setadapterparms(card);
  934. if (rc) {
  935. QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
  936. "0x%x\n", dev_name(&card->gdev->dev), rc);
  937. return rc;
  938. }
  939. if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
  940. rc = qeth_setadpparms_change_macaddr(card);
  941. if (rc)
  942. dev_warn(&card->gdev->dev, "Reading the adapter MAC"
  943. " address failed\n");
  944. }
  945. if ((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
  946. (card->info.link_type == QETH_LINK_TYPE_LANE_TR))
  947. rc = qeth_l3_setadapter_hstr(card);
  948. return rc;
  949. }
  950. static int qeth_l3_default_setassparms_cb(struct qeth_card *card,
  951. struct qeth_reply *reply, unsigned long data)
  952. {
  953. struct qeth_ipa_cmd *cmd;
  954. QETH_CARD_TEXT(card, 4, "defadpcb");
  955. cmd = (struct qeth_ipa_cmd *) data;
  956. if (cmd->hdr.return_code == 0) {
  957. cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
  958. if (cmd->hdr.prot_version == QETH_PROT_IPV4)
  959. card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
  960. if (cmd->hdr.prot_version == QETH_PROT_IPV6)
  961. card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
  962. }
  963. if (cmd->data.setassparms.hdr.assist_no == IPA_INBOUND_CHECKSUM &&
  964. cmd->data.setassparms.hdr.command_code == IPA_CMD_ASS_START) {
  965. card->info.csum_mask = cmd->data.setassparms.data.flags_32bit;
  966. QETH_CARD_TEXT_(card, 3, "csum:%d", card->info.csum_mask);
  967. }
  968. if (cmd->data.setassparms.hdr.assist_no == IPA_OUTBOUND_CHECKSUM &&
  969. cmd->data.setassparms.hdr.command_code == IPA_CMD_ASS_START) {
  970. card->info.tx_csum_mask =
  971. cmd->data.setassparms.data.flags_32bit;
  972. QETH_CARD_TEXT_(card, 3, "tcsu:%d", card->info.tx_csum_mask);
  973. }
  974. return 0;
  975. }
  976. static struct qeth_cmd_buffer *qeth_l3_get_setassparms_cmd(
  977. struct qeth_card *card, enum qeth_ipa_funcs ipa_func, __u16 cmd_code,
  978. __u16 len, enum qeth_prot_versions prot)
  979. {
  980. struct qeth_cmd_buffer *iob;
  981. struct qeth_ipa_cmd *cmd;
  982. QETH_CARD_TEXT(card, 4, "getasscm");
  983. iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETASSPARMS, prot);
  984. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  985. cmd->data.setassparms.hdr.assist_no = ipa_func;
  986. cmd->data.setassparms.hdr.length = 8 + len;
  987. cmd->data.setassparms.hdr.command_code = cmd_code;
  988. cmd->data.setassparms.hdr.return_code = 0;
  989. cmd->data.setassparms.hdr.seq_no = 0;
  990. return iob;
  991. }
  992. static int qeth_l3_send_setassparms(struct qeth_card *card,
  993. struct qeth_cmd_buffer *iob, __u16 len, long data,
  994. int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
  995. unsigned long),
  996. void *reply_param)
  997. {
  998. int rc;
  999. struct qeth_ipa_cmd *cmd;
  1000. QETH_CARD_TEXT(card, 4, "sendassp");
  1001. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  1002. if (len <= sizeof(__u32))
  1003. cmd->data.setassparms.data.flags_32bit = (__u32) data;
  1004. else /* (len > sizeof(__u32)) */
  1005. memcpy(&cmd->data.setassparms.data, (void *) data, len);
  1006. rc = qeth_send_ipa_cmd(card, iob, reply_cb, reply_param);
  1007. return rc;
  1008. }
  1009. #ifdef CONFIG_QETH_IPV6
  1010. static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
  1011. enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
  1012. {
  1013. int rc;
  1014. struct qeth_cmd_buffer *iob;
  1015. QETH_CARD_TEXT(card, 4, "simassp6");
  1016. iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
  1017. 0, QETH_PROT_IPV6);
  1018. rc = qeth_l3_send_setassparms(card, iob, 0, 0,
  1019. qeth_l3_default_setassparms_cb, NULL);
  1020. return rc;
  1021. }
  1022. #endif
  1023. static int qeth_l3_send_simple_setassparms(struct qeth_card *card,
  1024. enum qeth_ipa_funcs ipa_func, __u16 cmd_code, long data)
  1025. {
  1026. int rc;
  1027. int length = 0;
  1028. struct qeth_cmd_buffer *iob;
  1029. QETH_CARD_TEXT(card, 4, "simassp4");
  1030. if (data)
  1031. length = sizeof(__u32);
  1032. iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
  1033. length, QETH_PROT_IPV4);
  1034. rc = qeth_l3_send_setassparms(card, iob, length, data,
  1035. qeth_l3_default_setassparms_cb, NULL);
  1036. return rc;
  1037. }
  1038. static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
  1039. {
  1040. int rc;
  1041. QETH_CARD_TEXT(card, 3, "ipaarp");
  1042. if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
  1043. dev_info(&card->gdev->dev,
  1044. "ARP processing not supported on %s!\n",
  1045. QETH_CARD_IFNAME(card));
  1046. return 0;
  1047. }
  1048. rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
  1049. IPA_CMD_ASS_START, 0);
  1050. if (rc) {
  1051. dev_warn(&card->gdev->dev,
  1052. "Starting ARP processing support for %s failed\n",
  1053. QETH_CARD_IFNAME(card));
  1054. }
  1055. return rc;
  1056. }
  1057. static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card *card)
  1058. {
  1059. int rc;
  1060. QETH_CARD_TEXT(card, 3, "ipaipfrg");
  1061. if (!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) {
  1062. dev_info(&card->gdev->dev,
  1063. "Hardware IP fragmentation not supported on %s\n",
  1064. QETH_CARD_IFNAME(card));
  1065. return -EOPNOTSUPP;
  1066. }
  1067. rc = qeth_l3_send_simple_setassparms(card, IPA_IP_FRAGMENTATION,
  1068. IPA_CMD_ASS_START, 0);
  1069. if (rc) {
  1070. dev_warn(&card->gdev->dev,
  1071. "Starting IP fragmentation support for %s failed\n",
  1072. QETH_CARD_IFNAME(card));
  1073. } else
  1074. dev_info(&card->gdev->dev,
  1075. "Hardware IP fragmentation enabled \n");
  1076. return rc;
  1077. }
  1078. static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
  1079. {
  1080. int rc;
  1081. QETH_CARD_TEXT(card, 3, "stsrcmac");
  1082. if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
  1083. dev_info(&card->gdev->dev,
  1084. "Inbound source MAC-address not supported on %s\n",
  1085. QETH_CARD_IFNAME(card));
  1086. return -EOPNOTSUPP;
  1087. }
  1088. rc = qeth_l3_send_simple_setassparms(card, IPA_SOURCE_MAC,
  1089. IPA_CMD_ASS_START, 0);
  1090. if (rc)
  1091. dev_warn(&card->gdev->dev,
  1092. "Starting source MAC-address support for %s failed\n",
  1093. QETH_CARD_IFNAME(card));
  1094. return rc;
  1095. }
  1096. static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
  1097. {
  1098. int rc = 0;
  1099. QETH_CARD_TEXT(card, 3, "strtvlan");
  1100. if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
  1101. dev_info(&card->gdev->dev,
  1102. "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
  1103. return -EOPNOTSUPP;
  1104. }
  1105. rc = qeth_l3_send_simple_setassparms(card, IPA_VLAN_PRIO,
  1106. IPA_CMD_ASS_START, 0);
  1107. if (rc) {
  1108. dev_warn(&card->gdev->dev,
  1109. "Starting VLAN support for %s failed\n",
  1110. QETH_CARD_IFNAME(card));
  1111. } else {
  1112. dev_info(&card->gdev->dev, "VLAN enabled\n");
  1113. }
  1114. return rc;
  1115. }
  1116. static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
  1117. {
  1118. int rc;
  1119. QETH_CARD_TEXT(card, 3, "stmcast");
  1120. if (!qeth_is_supported(card, IPA_MULTICASTING)) {
  1121. dev_info(&card->gdev->dev,
  1122. "Multicast not supported on %s\n",
  1123. QETH_CARD_IFNAME(card));
  1124. return -EOPNOTSUPP;
  1125. }
  1126. rc = qeth_l3_send_simple_setassparms(card, IPA_MULTICASTING,
  1127. IPA_CMD_ASS_START, 0);
  1128. if (rc) {
  1129. dev_warn(&card->gdev->dev,
  1130. "Starting multicast support for %s failed\n",
  1131. QETH_CARD_IFNAME(card));
  1132. } else {
  1133. dev_info(&card->gdev->dev, "Multicast enabled\n");
  1134. card->dev->flags |= IFF_MULTICAST;
  1135. }
  1136. return rc;
  1137. }
  1138. #ifdef CONFIG_QETH_IPV6
  1139. static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
  1140. {
  1141. int rc;
  1142. QETH_CARD_TEXT(card, 3, "softipv6");
  1143. if (card->info.type == QETH_CARD_TYPE_IQD)
  1144. goto out;
  1145. rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
  1146. if (rc) {
  1147. dev_err(&card->gdev->dev,
  1148. "Activating IPv6 support for %s failed\n",
  1149. QETH_CARD_IFNAME(card));
  1150. return rc;
  1151. }
  1152. rc = qeth_l3_send_simple_setassparms(card, IPA_IPV6,
  1153. IPA_CMD_ASS_START, 3);
  1154. if (rc) {
  1155. dev_err(&card->gdev->dev,
  1156. "Activating IPv6 support for %s failed\n",
  1157. QETH_CARD_IFNAME(card));
  1158. return rc;
  1159. }
  1160. rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
  1161. IPA_CMD_ASS_START);
  1162. if (rc) {
  1163. dev_err(&card->gdev->dev,
  1164. "Activating IPv6 support for %s failed\n",
  1165. QETH_CARD_IFNAME(card));
  1166. return rc;
  1167. }
  1168. rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
  1169. IPA_CMD_ASS_START);
  1170. if (rc) {
  1171. dev_warn(&card->gdev->dev,
  1172. "Enabling the passthrough mode for %s failed\n",
  1173. QETH_CARD_IFNAME(card));
  1174. return rc;
  1175. }
  1176. out:
  1177. dev_info(&card->gdev->dev, "IPV6 enabled\n");
  1178. return 0;
  1179. }
  1180. #endif
  1181. static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
  1182. {
  1183. int rc = 0;
  1184. QETH_CARD_TEXT(card, 3, "strtipv6");
  1185. if (!qeth_is_supported(card, IPA_IPV6)) {
  1186. dev_info(&card->gdev->dev,
  1187. "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
  1188. return 0;
  1189. }
  1190. #ifdef CONFIG_QETH_IPV6
  1191. rc = qeth_l3_softsetup_ipv6(card);
  1192. #endif
  1193. return rc ;
  1194. }
  1195. static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
  1196. {
  1197. int rc;
  1198. QETH_CARD_TEXT(card, 3, "stbrdcst");
  1199. card->info.broadcast_capable = 0;
  1200. if (!qeth_is_supported(card, IPA_FILTERING)) {
  1201. dev_info(&card->gdev->dev,
  1202. "Broadcast not supported on %s\n",
  1203. QETH_CARD_IFNAME(card));
  1204. rc = -EOPNOTSUPP;
  1205. goto out;
  1206. }
  1207. rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
  1208. IPA_CMD_ASS_START, 0);
  1209. if (rc) {
  1210. dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
  1211. "%s failed\n", QETH_CARD_IFNAME(card));
  1212. goto out;
  1213. }
  1214. rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
  1215. IPA_CMD_ASS_CONFIGURE, 1);
  1216. if (rc) {
  1217. dev_warn(&card->gdev->dev,
  1218. "Setting up broadcast filtering for %s failed\n",
  1219. QETH_CARD_IFNAME(card));
  1220. goto out;
  1221. }
  1222. card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
  1223. dev_info(&card->gdev->dev, "Broadcast enabled\n");
  1224. rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
  1225. IPA_CMD_ASS_ENABLE, 1);
  1226. if (rc) {
  1227. dev_warn(&card->gdev->dev, "Setting up broadcast echo "
  1228. "filtering for %s failed\n", QETH_CARD_IFNAME(card));
  1229. goto out;
  1230. }
  1231. card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
  1232. out:
  1233. if (card->info.broadcast_capable)
  1234. card->dev->flags |= IFF_BROADCAST;
  1235. else
  1236. card->dev->flags &= ~IFF_BROADCAST;
  1237. return rc;
  1238. }
  1239. static int qeth_l3_send_checksum_command(struct qeth_card *card)
  1240. {
  1241. int rc;
  1242. rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
  1243. IPA_CMD_ASS_START, 0);
  1244. if (rc) {
  1245. dev_warn(&card->gdev->dev, "Starting HW checksumming for %s "
  1246. "failed, using SW checksumming\n",
  1247. QETH_CARD_IFNAME(card));
  1248. return rc;
  1249. }
  1250. rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
  1251. IPA_CMD_ASS_ENABLE,
  1252. card->info.csum_mask);
  1253. if (rc) {
  1254. dev_warn(&card->gdev->dev, "Enabling HW checksumming for %s "
  1255. "failed, using SW checksumming\n",
  1256. QETH_CARD_IFNAME(card));
  1257. return rc;
  1258. }
  1259. return 0;
  1260. }
  1261. int qeth_l3_set_rx_csum(struct qeth_card *card, int on)
  1262. {
  1263. int rc = 0;
  1264. if (on) {
  1265. rc = qeth_l3_send_checksum_command(card);
  1266. if (rc)
  1267. return -EIO;
  1268. dev_info(&card->gdev->dev,
  1269. "HW Checksumming (inbound) enabled\n");
  1270. } else {
  1271. rc = qeth_l3_send_simple_setassparms(card,
  1272. IPA_INBOUND_CHECKSUM, IPA_CMD_ASS_STOP, 0);
  1273. if (rc)
  1274. return -EIO;
  1275. }
  1276. return 0;
  1277. }
  1278. static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
  1279. {
  1280. QETH_CARD_TEXT(card, 3, "strtcsum");
  1281. if (card->dev->features & NETIF_F_RXCSUM) {
  1282. rtnl_lock();
  1283. /* force set_features call */
  1284. card->dev->features &= ~NETIF_F_RXCSUM;
  1285. netdev_update_features(card->dev);
  1286. rtnl_unlock();
  1287. }
  1288. return 0;
  1289. }
  1290. static int qeth_l3_start_ipa_tx_checksum(struct qeth_card *card)
  1291. {
  1292. int rc = 0;
  1293. if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
  1294. return rc;
  1295. rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_CHECKSUM,
  1296. IPA_CMD_ASS_START, 0);
  1297. if (rc)
  1298. goto err_out;
  1299. rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_CHECKSUM,
  1300. IPA_CMD_ASS_ENABLE, card->info.tx_csum_mask);
  1301. if (rc)
  1302. goto err_out;
  1303. dev_info(&card->gdev->dev, "HW TX Checksumming enabled\n");
  1304. return rc;
  1305. err_out:
  1306. dev_warn(&card->gdev->dev, "Enabling HW TX checksumming for %s "
  1307. "failed, using SW TX checksumming\n", QETH_CARD_IFNAME(card));
  1308. return rc;
  1309. }
  1310. static int qeth_l3_start_ipa_tso(struct qeth_card *card)
  1311. {
  1312. int rc;
  1313. QETH_CARD_TEXT(card, 3, "sttso");
  1314. if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
  1315. dev_info(&card->gdev->dev,
  1316. "Outbound TSO not supported on %s\n",
  1317. QETH_CARD_IFNAME(card));
  1318. rc = -EOPNOTSUPP;
  1319. } else {
  1320. rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_TSO,
  1321. IPA_CMD_ASS_START, 0);
  1322. if (rc)
  1323. dev_warn(&card->gdev->dev, "Starting outbound TCP "
  1324. "segmentation offload for %s failed\n",
  1325. QETH_CARD_IFNAME(card));
  1326. else
  1327. dev_info(&card->gdev->dev,
  1328. "Outbound TSO enabled\n");
  1329. }
  1330. if (rc)
  1331. card->dev->features &= ~NETIF_F_TSO;
  1332. return rc;
  1333. }
  1334. static int qeth_l3_start_ipassists(struct qeth_card *card)
  1335. {
  1336. QETH_CARD_TEXT(card, 3, "strtipas");
  1337. qeth_set_access_ctrl_online(card); /* go on*/
  1338. qeth_l3_start_ipa_arp_processing(card); /* go on*/
  1339. qeth_l3_start_ipa_ip_fragmentation(card); /* go on*/
  1340. qeth_l3_start_ipa_source_mac(card); /* go on*/
  1341. qeth_l3_start_ipa_vlan(card); /* go on*/
  1342. qeth_l3_start_ipa_multicast(card); /* go on*/
  1343. qeth_l3_start_ipa_ipv6(card); /* go on*/
  1344. qeth_l3_start_ipa_broadcast(card); /* go on*/
  1345. qeth_l3_start_ipa_checksum(card); /* go on*/
  1346. qeth_l3_start_ipa_tx_checksum(card);
  1347. qeth_l3_start_ipa_tso(card); /* go on*/
  1348. return 0;
  1349. }
  1350. static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
  1351. struct qeth_reply *reply, unsigned long data)
  1352. {
  1353. struct qeth_ipa_cmd *cmd;
  1354. cmd = (struct qeth_ipa_cmd *) data;
  1355. if (cmd->hdr.return_code == 0)
  1356. memcpy(card->dev->dev_addr,
  1357. cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
  1358. else
  1359. random_ether_addr(card->dev->dev_addr);
  1360. return 0;
  1361. }
  1362. static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
  1363. {
  1364. int rc = 0;
  1365. struct qeth_cmd_buffer *iob;
  1366. struct qeth_ipa_cmd *cmd;
  1367. QETH_DBF_TEXT(SETUP, 2, "hsrmac");
  1368. iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
  1369. QETH_PROT_IPV6);
  1370. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  1371. *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
  1372. card->info.unique_id;
  1373. rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
  1374. NULL);
  1375. return rc;
  1376. }
  1377. static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
  1378. struct qeth_reply *reply, unsigned long data)
  1379. {
  1380. struct qeth_ipa_cmd *cmd;
  1381. cmd = (struct qeth_ipa_cmd *) data;
  1382. if (cmd->hdr.return_code == 0)
  1383. card->info.unique_id = *((__u16 *)
  1384. &cmd->data.create_destroy_addr.unique_id[6]);
  1385. else {
  1386. card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
  1387. UNIQUE_ID_NOT_BY_CARD;
  1388. dev_warn(&card->gdev->dev, "The network adapter failed to "
  1389. "generate a unique ID\n");
  1390. }
  1391. return 0;
  1392. }
  1393. static int qeth_l3_get_unique_id(struct qeth_card *card)
  1394. {
  1395. int rc = 0;
  1396. struct qeth_cmd_buffer *iob;
  1397. struct qeth_ipa_cmd *cmd;
  1398. QETH_DBF_TEXT(SETUP, 2, "guniqeid");
  1399. if (!qeth_is_supported(card, IPA_IPV6)) {
  1400. card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
  1401. UNIQUE_ID_NOT_BY_CARD;
  1402. return 0;
  1403. }
  1404. iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
  1405. QETH_PROT_IPV6);
  1406. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  1407. *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
  1408. card->info.unique_id;
  1409. rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
  1410. return rc;
  1411. }
  1412. static int
  1413. qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
  1414. unsigned long data)
  1415. {
  1416. struct qeth_ipa_cmd *cmd;
  1417. __u16 rc;
  1418. QETH_DBF_TEXT(SETUP, 2, "diastrcb");
  1419. cmd = (struct qeth_ipa_cmd *)data;
  1420. rc = cmd->hdr.return_code;
  1421. if (rc)
  1422. QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
  1423. switch (cmd->data.diagass.action) {
  1424. case QETH_DIAGS_CMD_TRACE_QUERY:
  1425. break;
  1426. case QETH_DIAGS_CMD_TRACE_DISABLE:
  1427. switch (rc) {
  1428. case 0:
  1429. case IPA_RC_INVALID_SUBCMD:
  1430. card->info.promisc_mode = SET_PROMISC_MODE_OFF;
  1431. dev_info(&card->gdev->dev, "The HiperSockets network "
  1432. "traffic analyzer is deactivated\n");
  1433. break;
  1434. default:
  1435. break;
  1436. }
  1437. break;
  1438. case QETH_DIAGS_CMD_TRACE_ENABLE:
  1439. switch (rc) {
  1440. case 0:
  1441. card->info.promisc_mode = SET_PROMISC_MODE_ON;
  1442. dev_info(&card->gdev->dev, "The HiperSockets network "
  1443. "traffic analyzer is activated\n");
  1444. break;
  1445. case IPA_RC_HARDWARE_AUTH_ERROR:
  1446. dev_warn(&card->gdev->dev, "The device is not "
  1447. "authorized to run as a HiperSockets network "
  1448. "traffic analyzer\n");
  1449. break;
  1450. case IPA_RC_TRACE_ALREADY_ACTIVE:
  1451. dev_warn(&card->gdev->dev, "A HiperSockets "
  1452. "network traffic analyzer is already "
  1453. "active in the HiperSockets LAN\n");
  1454. break;
  1455. default:
  1456. break;
  1457. }
  1458. break;
  1459. default:
  1460. QETH_DBF_MESSAGE(2, "Unknown sniffer action (0x%04x) on %s\n",
  1461. cmd->data.diagass.action, QETH_CARD_IFNAME(card));
  1462. }
  1463. return 0;
  1464. }
  1465. static int
  1466. qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
  1467. {
  1468. struct qeth_cmd_buffer *iob;
  1469. struct qeth_ipa_cmd *cmd;
  1470. QETH_DBF_TEXT(SETUP, 2, "diagtrac");
  1471. iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
  1472. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  1473. cmd->data.diagass.subcmd_len = 16;
  1474. cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
  1475. cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
  1476. cmd->data.diagass.action = diags_cmd;
  1477. return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
  1478. }
  1479. static void qeth_l3_get_mac_for_ipm(__u32 ipm, char *mac,
  1480. struct net_device *dev)
  1481. {
  1482. if (dev->type == ARPHRD_IEEE802_TR)
  1483. ip_tr_mc_map(ipm, mac);
  1484. else
  1485. ip_eth_mc_map(ipm, mac);
  1486. }
  1487. static void qeth_l3_add_mc(struct qeth_card *card, struct in_device *in4_dev)
  1488. {
  1489. struct qeth_ipaddr *ipm;
  1490. struct ip_mc_list *im4;
  1491. char buf[MAX_ADDR_LEN];
  1492. QETH_CARD_TEXT(card, 4, "addmc");
  1493. for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
  1494. im4 = rcu_dereference(im4->next_rcu)) {
  1495. qeth_l3_get_mac_for_ipm(im4->multiaddr, buf, in4_dev->dev);
  1496. ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
  1497. if (!ipm)
  1498. continue;
  1499. ipm->u.a4.addr = im4->multiaddr;
  1500. memcpy(ipm->mac, buf, OSA_ADDR_LEN);
  1501. ipm->is_multicast = 1;
  1502. if (!qeth_l3_add_ip(card, ipm))
  1503. kfree(ipm);
  1504. }
  1505. }
  1506. static void qeth_l3_add_vlan_mc(struct qeth_card *card)
  1507. {
  1508. struct in_device *in_dev;
  1509. struct vlan_group *vg;
  1510. int i;
  1511. QETH_CARD_TEXT(card, 4, "addmcvl");
  1512. if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
  1513. return;
  1514. vg = card->vlangrp;
  1515. for (i = 0; i < VLAN_N_VID; i++) {
  1516. struct net_device *netdev = vlan_group_get_device(vg, i);
  1517. if (netdev == NULL ||
  1518. !(netdev->flags & IFF_UP))
  1519. continue;
  1520. in_dev = in_dev_get(netdev);
  1521. if (!in_dev)
  1522. continue;
  1523. rcu_read_lock();
  1524. qeth_l3_add_mc(card, in_dev);
  1525. rcu_read_unlock();
  1526. in_dev_put(in_dev);
  1527. }
  1528. }
  1529. static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
  1530. {
  1531. struct in_device *in4_dev;
  1532. QETH_CARD_TEXT(card, 4, "chkmcv4");
  1533. in4_dev = in_dev_get(card->dev);
  1534. if (in4_dev == NULL)
  1535. return;
  1536. rcu_read_lock();
  1537. qeth_l3_add_mc(card, in4_dev);
  1538. qeth_l3_add_vlan_mc(card);
  1539. rcu_read_unlock();
  1540. in_dev_put(in4_dev);
  1541. }
  1542. #ifdef CONFIG_QETH_IPV6
  1543. static void qeth_l3_add_mc6(struct qeth_card *card, struct inet6_dev *in6_dev)
  1544. {
  1545. struct qeth_ipaddr *ipm;
  1546. struct ifmcaddr6 *im6;
  1547. char buf[MAX_ADDR_LEN];
  1548. QETH_CARD_TEXT(card, 4, "addmc6");
  1549. for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
  1550. ndisc_mc_map(&im6->mca_addr, buf, in6_dev->dev, 0);
  1551. ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
  1552. if (!ipm)
  1553. continue;
  1554. ipm->is_multicast = 1;
  1555. memcpy(ipm->mac, buf, OSA_ADDR_LEN);
  1556. memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
  1557. sizeof(struct in6_addr));
  1558. if (!qeth_l3_add_ip(card, ipm))
  1559. kfree(ipm);
  1560. }
  1561. }
  1562. static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
  1563. {
  1564. struct inet6_dev *in_dev;
  1565. struct vlan_group *vg;
  1566. int i;
  1567. QETH_CARD_TEXT(card, 4, "admc6vl");
  1568. if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
  1569. return;
  1570. vg = card->vlangrp;
  1571. for (i = 0; i < VLAN_N_VID; i++) {
  1572. struct net_device *netdev = vlan_group_get_device(vg, i);
  1573. if (netdev == NULL ||
  1574. !(netdev->flags & IFF_UP))
  1575. continue;
  1576. in_dev = in6_dev_get(netdev);
  1577. if (!in_dev)
  1578. continue;
  1579. read_lock_bh(&in_dev->lock);
  1580. qeth_l3_add_mc6(card, in_dev);
  1581. read_unlock_bh(&in_dev->lock);
  1582. in6_dev_put(in_dev);
  1583. }
  1584. }
  1585. static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
  1586. {
  1587. struct inet6_dev *in6_dev;
  1588. QETH_CARD_TEXT(card, 4, "chkmcv6");
  1589. if (!qeth_is_supported(card, IPA_IPV6))
  1590. return ;
  1591. in6_dev = in6_dev_get(card->dev);
  1592. if (in6_dev == NULL)
  1593. return;
  1594. read_lock_bh(&in6_dev->lock);
  1595. qeth_l3_add_mc6(card, in6_dev);
  1596. qeth_l3_add_vlan_mc6(card);
  1597. read_unlock_bh(&in6_dev->lock);
  1598. in6_dev_put(in6_dev);
  1599. }
  1600. #endif /* CONFIG_QETH_IPV6 */
  1601. static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
  1602. unsigned short vid)
  1603. {
  1604. struct in_device *in_dev;
  1605. struct in_ifaddr *ifa;
  1606. struct qeth_ipaddr *addr;
  1607. QETH_CARD_TEXT(card, 4, "frvaddr4");
  1608. in_dev = in_dev_get(vlan_group_get_device(card->vlangrp, vid));
  1609. if (!in_dev)
  1610. return;
  1611. for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
  1612. addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
  1613. if (addr) {
  1614. addr->u.a4.addr = ifa->ifa_address;
  1615. addr->u.a4.mask = ifa->ifa_mask;
  1616. addr->type = QETH_IP_TYPE_NORMAL;
  1617. if (!qeth_l3_delete_ip(card, addr))
  1618. kfree(addr);
  1619. }
  1620. }
  1621. in_dev_put(in_dev);
  1622. }
  1623. static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
  1624. unsigned short vid)
  1625. {
  1626. #ifdef CONFIG_QETH_IPV6
  1627. struct inet6_dev *in6_dev;
  1628. struct inet6_ifaddr *ifa;
  1629. struct qeth_ipaddr *addr;
  1630. QETH_CARD_TEXT(card, 4, "frvaddr6");
  1631. in6_dev = in6_dev_get(vlan_group_get_device(card->vlangrp, vid));
  1632. if (!in6_dev)
  1633. return;
  1634. list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
  1635. addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
  1636. if (addr) {
  1637. memcpy(&addr->u.a6.addr, &ifa->addr,
  1638. sizeof(struct in6_addr));
  1639. addr->u.a6.pfxlen = ifa->prefix_len;
  1640. addr->type = QETH_IP_TYPE_NORMAL;
  1641. if (!qeth_l3_delete_ip(card, addr))
  1642. kfree(addr);
  1643. }
  1644. }
  1645. in6_dev_put(in6_dev);
  1646. #endif /* CONFIG_QETH_IPV6 */
  1647. }
  1648. static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
  1649. unsigned short vid)
  1650. {
  1651. if (!card->vlangrp)
  1652. return;
  1653. qeth_l3_free_vlan_addresses4(card, vid);
  1654. qeth_l3_free_vlan_addresses6(card, vid);
  1655. }
  1656. static void qeth_l3_vlan_rx_register(struct net_device *dev,
  1657. struct vlan_group *grp)
  1658. {
  1659. struct qeth_card *card = dev->ml_priv;
  1660. unsigned long flags;
  1661. QETH_CARD_TEXT(card, 4, "vlanreg");
  1662. spin_lock_irqsave(&card->vlanlock, flags);
  1663. card->vlangrp = grp;
  1664. spin_unlock_irqrestore(&card->vlanlock, flags);
  1665. }
  1666. static void qeth_l3_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
  1667. {
  1668. return;
  1669. }
  1670. static void qeth_l3_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
  1671. {
  1672. struct qeth_card *card = dev->ml_priv;
  1673. unsigned long flags;
  1674. QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
  1675. if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
  1676. QETH_CARD_TEXT(card, 3, "kidREC");
  1677. return;
  1678. }
  1679. spin_lock_irqsave(&card->vlanlock, flags);
  1680. /* unregister IP addresses of vlan device */
  1681. qeth_l3_free_vlan_addresses(card, vid);
  1682. vlan_group_set_device(card->vlangrp, vid, NULL);
  1683. spin_unlock_irqrestore(&card->vlanlock, flags);
  1684. qeth_l3_set_multicast_list(card->dev);
  1685. }
  1686. static inline int qeth_l3_rebuild_skb(struct qeth_card *card,
  1687. struct sk_buff *skb, struct qeth_hdr *hdr,
  1688. unsigned short *vlan_id)
  1689. {
  1690. __be16 prot;
  1691. str