qeth_l3_main.c 98 KB

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