qeth_l3_main.c 89 KB

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