qib_mad.c 61 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177
  1. /*
  2. * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
  3. * All rights reserved.
  4. * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
  5. *
  6. * This software is available to you under a choice of one of two
  7. * licenses. You may choose to be licensed under the terms of the GNU
  8. * General Public License (GPL) Version 2, available from the file
  9. * COPYING in the main directory of this source tree, or the
  10. * OpenIB.org BSD license below:
  11. *
  12. * Redistribution and use in source and binary forms, with or
  13. * without modification, are permitted provided that the following
  14. * conditions are met:
  15. *
  16. * - Redistributions of source code must retain the above
  17. * copyright notice, this list of conditions and the following
  18. * disclaimer.
  19. *
  20. * - Redistributions in binary form must reproduce the above
  21. * copyright notice, this list of conditions and the following
  22. * disclaimer in the documentation and/or other materials
  23. * provided with the distribution.
  24. *
  25. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29. * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30. * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31. * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32. * SOFTWARE.
  33. */
  34. #include <rdma/ib_smi.h>
  35. #include "qib.h"
  36. #include "qib_mad.h"
  37. static int reply(struct ib_smp *smp)
  38. {
  39. /*
  40. * The verbs framework will handle the directed/LID route
  41. * packet changes.
  42. */
  43. smp->method = IB_MGMT_METHOD_GET_RESP;
  44. if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
  45. smp->status |= IB_SMP_DIRECTION;
  46. return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY;
  47. }
  48. static void qib_send_trap(struct qib_ibport *ibp, void *data, unsigned len)
  49. {
  50. struct ib_mad_send_buf *send_buf;
  51. struct ib_mad_agent *agent;
  52. struct ib_smp *smp;
  53. int ret;
  54. unsigned long flags;
  55. unsigned long timeout;
  56. agent = ibp->send_agent;
  57. if (!agent)
  58. return;
  59. /* o14-3.2.1 */
  60. if (!(ppd_from_ibp(ibp)->lflags & QIBL_LINKACTIVE))
  61. return;
  62. /* o14-2 */
  63. if (ibp->trap_timeout && time_before(jiffies, ibp->trap_timeout))
  64. return;
  65. send_buf = ib_create_send_mad(agent, 0, 0, 0, IB_MGMT_MAD_HDR,
  66. IB_MGMT_MAD_DATA, GFP_ATOMIC);
  67. if (IS_ERR(send_buf))
  68. return;
  69. smp = send_buf->mad;
  70. smp->base_version = IB_MGMT_BASE_VERSION;
  71. smp->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
  72. smp->class_version = 1;
  73. smp->method = IB_MGMT_METHOD_TRAP;
  74. ibp->tid++;
  75. smp->tid = cpu_to_be64(ibp->tid);
  76. smp->attr_id = IB_SMP_ATTR_NOTICE;
  77. /* o14-1: smp->mkey = 0; */
  78. memcpy(smp->data, data, len);
  79. spin_lock_irqsave(&ibp->lock, flags);
  80. if (!ibp->sm_ah) {
  81. if (ibp->sm_lid != be16_to_cpu(IB_LID_PERMISSIVE)) {
  82. struct ib_ah *ah;
  83. struct ib_ah_attr attr;
  84. memset(&attr, 0, sizeof attr);
  85. attr.dlid = ibp->sm_lid;
  86. attr.port_num = ppd_from_ibp(ibp)->port;
  87. ah = ib_create_ah(ibp->qp0->ibqp.pd, &attr);
  88. if (IS_ERR(ah))
  89. ret = -EINVAL;
  90. else {
  91. send_buf->ah = ah;
  92. ibp->sm_ah = to_iah(ah);
  93. ret = 0;
  94. }
  95. } else
  96. ret = -EINVAL;
  97. } else {
  98. send_buf->ah = &ibp->sm_ah->ibah;
  99. ret = 0;
  100. }
  101. spin_unlock_irqrestore(&ibp->lock, flags);
  102. if (!ret)
  103. ret = ib_post_send_mad(send_buf, NULL);
  104. if (!ret) {
  105. /* 4.096 usec. */
  106. timeout = (4096 * (1UL << ibp->subnet_timeout)) / 1000;
  107. ibp->trap_timeout = jiffies + usecs_to_jiffies(timeout);
  108. } else {
  109. ib_free_send_mad(send_buf);
  110. ibp->trap_timeout = 0;
  111. }
  112. }
  113. /*
  114. * Send a bad [PQ]_Key trap (ch. 14.3.8).
  115. */
  116. void qib_bad_pqkey(struct qib_ibport *ibp, __be16 trap_num, u32 key, u32 sl,
  117. u32 qp1, u32 qp2, __be16 lid1, __be16 lid2)
  118. {
  119. struct ib_mad_notice_attr data;
  120. if (trap_num == IB_NOTICE_TRAP_BAD_PKEY)
  121. ibp->pkey_violations++;
  122. else
  123. ibp->qkey_violations++;
  124. ibp->n_pkt_drops++;
  125. /* Send violation trap */
  126. data.generic_type = IB_NOTICE_TYPE_SECURITY;
  127. data.prod_type_msb = 0;
  128. data.prod_type_lsb = IB_NOTICE_PROD_CA;
  129. data.trap_num = trap_num;
  130. data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
  131. data.toggle_count = 0;
  132. memset(&data.details, 0, sizeof data.details);
  133. data.details.ntc_257_258.lid1 = lid1;
  134. data.details.ntc_257_258.lid2 = lid2;
  135. data.details.ntc_257_258.key = cpu_to_be32(key);
  136. data.details.ntc_257_258.sl_qp1 = cpu_to_be32((sl << 28) | qp1);
  137. data.details.ntc_257_258.qp2 = cpu_to_be32(qp2);
  138. qib_send_trap(ibp, &data, sizeof data);
  139. }
  140. /*
  141. * Send a bad M_Key trap (ch. 14.3.9).
  142. */
  143. static void qib_bad_mkey(struct qib_ibport *ibp, struct ib_smp *smp)
  144. {
  145. struct ib_mad_notice_attr data;
  146. /* Send violation trap */
  147. data.generic_type = IB_NOTICE_TYPE_SECURITY;
  148. data.prod_type_msb = 0;
  149. data.prod_type_lsb = IB_NOTICE_PROD_CA;
  150. data.trap_num = IB_NOTICE_TRAP_BAD_MKEY;
  151. data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
  152. data.toggle_count = 0;
  153. memset(&data.details, 0, sizeof data.details);
  154. data.details.ntc_256.lid = data.issuer_lid;
  155. data.details.ntc_256.method = smp->method;
  156. data.details.ntc_256.attr_id = smp->attr_id;
  157. data.details.ntc_256.attr_mod = smp->attr_mod;
  158. data.details.ntc_256.mkey = smp->mkey;
  159. if (smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) {
  160. u8 hop_cnt;
  161. data.details.ntc_256.dr_slid = smp->dr_slid;
  162. data.details.ntc_256.dr_trunc_hop = IB_NOTICE_TRAP_DR_NOTICE;
  163. hop_cnt = smp->hop_cnt;
  164. if (hop_cnt > ARRAY_SIZE(data.details.ntc_256.dr_rtn_path)) {
  165. data.details.ntc_256.dr_trunc_hop |=
  166. IB_NOTICE_TRAP_DR_TRUNC;
  167. hop_cnt = ARRAY_SIZE(data.details.ntc_256.dr_rtn_path);
  168. }
  169. data.details.ntc_256.dr_trunc_hop |= hop_cnt;
  170. memcpy(data.details.ntc_256.dr_rtn_path, smp->return_path,
  171. hop_cnt);
  172. }
  173. qib_send_trap(ibp, &data, sizeof data);
  174. }
  175. /*
  176. * Send a Port Capability Mask Changed trap (ch. 14.3.11).
  177. */
  178. void qib_cap_mask_chg(struct qib_ibport *ibp)
  179. {
  180. struct ib_mad_notice_attr data;
  181. data.generic_type = IB_NOTICE_TYPE_INFO;
  182. data.prod_type_msb = 0;
  183. data.prod_type_lsb = IB_NOTICE_PROD_CA;
  184. data.trap_num = IB_NOTICE_TRAP_CAP_MASK_CHG;
  185. data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
  186. data.toggle_count = 0;
  187. memset(&data.details, 0, sizeof data.details);
  188. data.details.ntc_144.lid = data.issuer_lid;
  189. data.details.ntc_144.new_cap_mask = cpu_to_be32(ibp->port_cap_flags);
  190. qib_send_trap(ibp, &data, sizeof data);
  191. }
  192. /*
  193. * Send a System Image GUID Changed trap (ch. 14.3.12).
  194. */
  195. void qib_sys_guid_chg(struct qib_ibport *ibp)
  196. {
  197. struct ib_mad_notice_attr data;
  198. data.generic_type = IB_NOTICE_TYPE_INFO;
  199. data.prod_type_msb = 0;
  200. data.prod_type_lsb = IB_NOTICE_PROD_CA;
  201. data.trap_num = IB_NOTICE_TRAP_SYS_GUID_CHG;
  202. data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
  203. data.toggle_count = 0;
  204. memset(&data.details, 0, sizeof data.details);
  205. data.details.ntc_145.lid = data.issuer_lid;
  206. data.details.ntc_145.new_sys_guid = ib_qib_sys_image_guid;
  207. qib_send_trap(ibp, &data, sizeof data);
  208. }
  209. /*
  210. * Send a Node Description Changed trap (ch. 14.3.13).
  211. */
  212. void qib_node_desc_chg(struct qib_ibport *ibp)
  213. {
  214. struct ib_mad_notice_attr data;
  215. data.generic_type = IB_NOTICE_TYPE_INFO;
  216. data.prod_type_msb = 0;
  217. data.prod_type_lsb = IB_NOTICE_PROD_CA;
  218. data.trap_num = IB_NOTICE_TRAP_CAP_MASK_CHG;
  219. data.issuer_lid = cpu_to_be16(ppd_from_ibp(ibp)->lid);
  220. data.toggle_count = 0;
  221. memset(&data.details, 0, sizeof data.details);
  222. data.details.ntc_144.lid = data.issuer_lid;
  223. data.details.ntc_144.local_changes = 1;
  224. data.details.ntc_144.change_flags = IB_NOTICE_TRAP_NODE_DESC_CHG;
  225. qib_send_trap(ibp, &data, sizeof data);
  226. }
  227. static int subn_get_nodedescription(struct ib_smp *smp,
  228. struct ib_device *ibdev)
  229. {
  230. if (smp->attr_mod)
  231. smp->status |= IB_SMP_INVALID_FIELD;
  232. memcpy(smp->data, ibdev->node_desc, sizeof(smp->data));
  233. return reply(smp);
  234. }
  235. static int subn_get_nodeinfo(struct ib_smp *smp, struct ib_device *ibdev,
  236. u8 port)
  237. {
  238. struct ib_node_info *nip = (struct ib_node_info *)&smp->data;
  239. struct qib_devdata *dd = dd_from_ibdev(ibdev);
  240. u32 vendor, majrev, minrev;
  241. unsigned pidx = port - 1; /* IB number port from 1, hdw from 0 */
  242. /* GUID 0 is illegal */
  243. if (smp->attr_mod || pidx >= dd->num_pports ||
  244. dd->pport[pidx].guid == 0)
  245. smp->status |= IB_SMP_INVALID_FIELD;
  246. else
  247. nip->port_guid = dd->pport[pidx].guid;
  248. nip->base_version = 1;
  249. nip->class_version = 1;
  250. nip->node_type = 1; /* channel adapter */
  251. nip->num_ports = ibdev->phys_port_cnt;
  252. /* This is already in network order */
  253. nip->sys_guid = ib_qib_sys_image_guid;
  254. nip->node_guid = dd->pport->guid; /* Use first-port GUID as node */
  255. nip->partition_cap = cpu_to_be16(qib_get_npkeys(dd));
  256. nip->device_id = cpu_to_be16(dd->deviceid);
  257. majrev = dd->majrev;
  258. minrev = dd->minrev;
  259. nip->revision = cpu_to_be32((majrev << 16) | minrev);
  260. nip->local_port_num = port;
  261. vendor = dd->vendorid;
  262. nip->vendor_id[0] = QIB_SRC_OUI_1;
  263. nip->vendor_id[1] = QIB_SRC_OUI_2;
  264. nip->vendor_id[2] = QIB_SRC_OUI_3;
  265. return reply(smp);
  266. }
  267. static int subn_get_guidinfo(struct ib_smp *smp, struct ib_device *ibdev,
  268. u8 port)
  269. {
  270. struct qib_devdata *dd = dd_from_ibdev(ibdev);
  271. u32 startgx = 8 * be32_to_cpu(smp->attr_mod);
  272. __be64 *p = (__be64 *) smp->data;
  273. unsigned pidx = port - 1; /* IB number port from 1, hdw from 0 */
  274. /* 32 blocks of 8 64-bit GUIDs per block */
  275. memset(smp->data, 0, sizeof(smp->data));
  276. if (startgx == 0 && pidx < dd->num_pports) {
  277. struct qib_pportdata *ppd = dd->pport + pidx;
  278. struct qib_ibport *ibp = &ppd->ibport_data;
  279. __be64 g = ppd->guid;
  280. unsigned i;
  281. /* GUID 0 is illegal */
  282. if (g == 0)
  283. smp->status |= IB_SMP_INVALID_FIELD;
  284. else {
  285. /* The first is a copy of the read-only HW GUID. */
  286. p[0] = g;
  287. for (i = 1; i < QIB_GUIDS_PER_PORT; i++)
  288. p[i] = ibp->guids[i - 1];
  289. }
  290. } else
  291. smp->status |= IB_SMP_INVALID_FIELD;
  292. return reply(smp);
  293. }
  294. static void set_link_width_enabled(struct qib_pportdata *ppd, u32 w)
  295. {
  296. (void) ppd->dd->f_set_ib_cfg(ppd, QIB_IB_CFG_LWID_ENB, w);
  297. }
  298. static void set_link_speed_enabled(struct qib_pportdata *ppd, u32 s)
  299. {
  300. (void) ppd->dd->f_set_ib_cfg(ppd, QIB_IB_CFG_SPD_ENB, s);
  301. }
  302. static int get_overrunthreshold(struct qib_pportdata *ppd)
  303. {
  304. return ppd->dd->f_get_ib_cfg(ppd, QIB_IB_CFG_OVERRUN_THRESH);
  305. }
  306. /**
  307. * set_overrunthreshold - set the overrun threshold
  308. * @ppd: the physical port data
  309. * @n: the new threshold
  310. *
  311. * Note that this will only take effect when the link state changes.
  312. */
  313. static int set_overrunthreshold(struct qib_pportdata *ppd, unsigned n)
  314. {
  315. (void) ppd->dd->f_set_ib_cfg(ppd, QIB_IB_CFG_OVERRUN_THRESH,
  316. (u32)n);
  317. return 0;
  318. }
  319. static int get_phyerrthreshold(struct qib_pportdata *ppd)
  320. {
  321. return ppd->dd->f_get_ib_cfg(ppd, QIB_IB_CFG_PHYERR_THRESH);
  322. }
  323. /**
  324. * set_phyerrthreshold - set the physical error threshold
  325. * @ppd: the physical port data
  326. * @n: the new threshold
  327. *
  328. * Note that this will only take effect when the link state changes.
  329. */
  330. static int set_phyerrthreshold(struct qib_pportdata *ppd, unsigned n)
  331. {
  332. (void) ppd->dd->f_set_ib_cfg(ppd, QIB_IB_CFG_PHYERR_THRESH,
  333. (u32)n);
  334. return 0;
  335. }
  336. /**
  337. * get_linkdowndefaultstate - get the default linkdown state
  338. * @ppd: the physical port data
  339. *
  340. * Returns zero if the default is POLL, 1 if the default is SLEEP.
  341. */
  342. static int get_linkdowndefaultstate(struct qib_pportdata *ppd)
  343. {
  344. return ppd->dd->f_get_ib_cfg(ppd, QIB_IB_CFG_LINKDEFAULT) ==
  345. IB_LINKINITCMD_SLEEP;
  346. }
  347. static int check_mkey(struct qib_ibport *ibp, struct ib_smp *smp, int mad_flags)
  348. {
  349. int ret = 0;
  350. /* Is the mkey in the process of expiring? */
  351. if (ibp->mkey_lease_timeout &&
  352. time_after_eq(jiffies, ibp->mkey_lease_timeout)) {
  353. /* Clear timeout and mkey protection field. */
  354. ibp->mkey_lease_timeout = 0;
  355. ibp->mkeyprot = 0;
  356. }
  357. /* M_Key checking depends on Portinfo:M_Key_protect_bits */
  358. if ((mad_flags & IB_MAD_IGNORE_MKEY) == 0 && ibp->mkey != 0 &&
  359. ibp->mkey != smp->mkey &&
  360. (smp->method == IB_MGMT_METHOD_SET ||
  361. smp->method == IB_MGMT_METHOD_TRAP_REPRESS ||
  362. (smp->method == IB_MGMT_METHOD_GET && ibp->mkeyprot >= 2))) {
  363. if (ibp->mkey_violations != 0xFFFF)
  364. ++ibp->mkey_violations;
  365. if (!ibp->mkey_lease_timeout && ibp->mkey_lease_period)
  366. ibp->mkey_lease_timeout = jiffies +
  367. ibp->mkey_lease_period * HZ;
  368. /* Generate a trap notice. */
  369. qib_bad_mkey(ibp, smp);
  370. ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
  371. } else if (ibp->mkey_lease_timeout)
  372. ibp->mkey_lease_timeout = 0;
  373. return ret;
  374. }
  375. static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
  376. u8 port)
  377. {
  378. struct qib_devdata *dd;
  379. struct qib_pportdata *ppd;
  380. struct qib_ibport *ibp;
  381. struct ib_port_info *pip = (struct ib_port_info *)smp->data;
  382. u8 mtu;
  383. int ret;
  384. u32 state;
  385. u32 port_num = be32_to_cpu(smp->attr_mod);
  386. if (port_num == 0)
  387. port_num = port;
  388. else {
  389. if (port_num > ibdev->phys_port_cnt) {
  390. smp->status |= IB_SMP_INVALID_FIELD;
  391. ret = reply(smp);
  392. goto bail;
  393. }
  394. if (port_num != port) {
  395. ibp = to_iport(ibdev, port_num);
  396. ret = check_mkey(ibp, smp, 0);
  397. if (ret)
  398. goto bail;
  399. }
  400. }
  401. dd = dd_from_ibdev(ibdev);
  402. /* IB numbers ports from 1, hdw from 0 */
  403. ppd = dd->pport + (port_num - 1);
  404. ibp = &ppd->ibport_data;
  405. /* Clear all fields. Only set the non-zero fields. */
  406. memset(smp->data, 0, sizeof(smp->data));
  407. /* Only return the mkey if the protection field allows it. */
  408. if (!(smp->method == IB_MGMT_METHOD_GET &&
  409. ibp->mkey != smp->mkey &&
  410. ibp->mkeyprot == 1))
  411. pip->mkey = ibp->mkey;
  412. pip->gid_prefix = ibp->gid_prefix;
  413. pip->lid = cpu_to_be16(ppd->lid);
  414. pip->sm_lid = cpu_to_be16(ibp->sm_lid);
  415. pip->cap_mask = cpu_to_be32(ibp->port_cap_flags);
  416. /* pip->diag_code; */
  417. pip->mkey_lease_period = cpu_to_be16(ibp->mkey_lease_period);
  418. pip->local_port_num = port;
  419. pip->link_width_enabled = ppd->link_width_enabled;
  420. pip->link_width_supported = ppd->link_width_supported;
  421. pip->link_width_active = ppd->link_width_active;
  422. state = dd->f_iblink_state(ppd->lastibcstat);
  423. pip->linkspeed_portstate = ppd->link_speed_supported << 4 | state;
  424. pip->portphysstate_linkdown =
  425. (dd->f_ibphys_portstate(ppd->lastibcstat) << 4) |
  426. (get_linkdowndefaultstate(ppd) ? 1 : 2);
  427. pip->mkeyprot_resv_lmc = (ibp->mkeyprot << 6) | ppd->lmc;
  428. pip->linkspeedactive_enabled = (ppd->link_speed_active << 4) |
  429. ppd->link_speed_enabled;
  430. switch (ppd->ibmtu) {
  431. default: /* something is wrong; fall through */
  432. case 4096:
  433. mtu = IB_MTU_4096;
  434. break;
  435. case 2048:
  436. mtu = IB_MTU_2048;
  437. break;
  438. case 1024:
  439. mtu = IB_MTU_1024;
  440. break;
  441. case 512:
  442. mtu = IB_MTU_512;
  443. break;
  444. case 256:
  445. mtu = IB_MTU_256;
  446. break;
  447. }
  448. pip->neighbormtu_mastersmsl = (mtu << 4) | ibp->sm_sl;
  449. pip->vlcap_inittype = ppd->vls_supported << 4; /* InitType = 0 */
  450. pip->vl_high_limit = ibp->vl_high_limit;
  451. pip->vl_arb_high_cap =
  452. dd->f_get_ib_cfg(ppd, QIB_IB_CFG_VL_HIGH_CAP);
  453. pip->vl_arb_low_cap =
  454. dd->f_get_ib_cfg(ppd, QIB_IB_CFG_VL_LOW_CAP);
  455. /* InitTypeReply = 0 */
  456. pip->inittypereply_mtucap = qib_ibmtu ? qib_ibmtu : IB_MTU_4096;
  457. /* HCAs ignore VLStallCount and HOQLife */
  458. /* pip->vlstallcnt_hoqlife; */
  459. pip->operationalvl_pei_peo_fpi_fpo =
  460. dd->f_get_ib_cfg(ppd, QIB_IB_CFG_OP_VLS) << 4;
  461. pip->mkey_violations = cpu_to_be16(ibp->mkey_violations);
  462. /* P_KeyViolations are counted by hardware. */
  463. pip->pkey_violations = cpu_to_be16(ibp->pkey_violations);
  464. pip->qkey_violations = cpu_to_be16(ibp->qkey_violations);
  465. /* Only the hardware GUID is supported for now */
  466. pip->guid_cap = QIB_GUIDS_PER_PORT;
  467. pip->clientrereg_resv_subnetto = ibp->subnet_timeout;
  468. /* 32.768 usec. response time (guessing) */
  469. pip->resv_resptimevalue = 3;
  470. pip->localphyerrors_overrunerrors =
  471. (get_phyerrthreshold(ppd) << 4) |
  472. get_overrunthreshold(ppd);
  473. /* pip->max_credit_hint; */
  474. if (ibp->port_cap_flags & IB_PORT_LINK_LATENCY_SUP) {
  475. u32 v;
  476. v = dd->f_get_ib_cfg(ppd, QIB_IB_CFG_LINKLATENCY);
  477. pip->link_roundtrip_latency[0] = v >> 16;
  478. pip->link_roundtrip_latency[1] = v >> 8;
  479. pip->link_roundtrip_latency[2] = v;
  480. }
  481. ret = reply(smp);
  482. bail:
  483. return ret;
  484. }
  485. /**
  486. * get_pkeys - return the PKEY table
  487. * @dd: the qlogic_ib device
  488. * @port: the IB port number
  489. * @pkeys: the pkey table is placed here
  490. */
  491. static int get_pkeys(struct qib_devdata *dd, u8 port, u16 *pkeys)
  492. {
  493. struct qib_pportdata *ppd = dd->pport + port - 1;
  494. /*
  495. * always a kernel context, no locking needed.
  496. * If we get here with ppd setup, no need to check
  497. * that pd is valid.
  498. */
  499. struct qib_ctxtdata *rcd = dd->rcd[ppd->hw_pidx];
  500. memcpy(pkeys, rcd->pkeys, sizeof(rcd->pkeys));
  501. return 0;
  502. }
  503. static int subn_get_pkeytable(struct ib_smp *smp, struct ib_device *ibdev,
  504. u8 port)
  505. {
  506. u32 startpx = 32 * (be32_to_cpu(smp->attr_mod) & 0xffff);
  507. u16 *p = (u16 *) smp->data;
  508. __be16 *q = (__be16 *) smp->data;
  509. /* 64 blocks of 32 16-bit P_Key entries */
  510. memset(smp->data, 0, sizeof(smp->data));
  511. if (startpx == 0) {
  512. struct qib_devdata *dd = dd_from_ibdev(ibdev);
  513. unsigned i, n = qib_get_npkeys(dd);
  514. get_pkeys(dd, port, p);
  515. for (i = 0; i < n; i++)
  516. q[i] = cpu_to_be16(p[i]);
  517. } else
  518. smp->status |= IB_SMP_INVALID_FIELD;
  519. return reply(smp);
  520. }
  521. static int subn_set_guidinfo(struct ib_smp *smp, struct ib_device *ibdev,
  522. u8 port)
  523. {
  524. struct qib_devdata *dd = dd_from_ibdev(ibdev);
  525. u32 startgx = 8 * be32_to_cpu(smp->attr_mod);
  526. __be64 *p = (__be64 *) smp->data;
  527. unsigned pidx = port - 1; /* IB number port from 1, hdw from 0 */
  528. /* 32 blocks of 8 64-bit GUIDs per block */
  529. if (startgx == 0 && pidx < dd->num_pports) {
  530. struct qib_pportdata *ppd = dd->pport + pidx;
  531. struct qib_ibport *ibp = &ppd->ibport_data;
  532. unsigned i;
  533. /* The first entry is read-only. */
  534. for (i = 1; i < QIB_GUIDS_PER_PORT; i++)
  535. ibp->guids[i - 1] = p[i];
  536. } else
  537. smp->status |= IB_SMP_INVALID_FIELD;
  538. /* The only GUID we support is the first read-only entry. */
  539. return subn_get_guidinfo(smp, ibdev, port);
  540. }
  541. /**
  542. * subn_set_portinfo - set port information
  543. * @smp: the incoming SM packet
  544. * @ibdev: the infiniband device
  545. * @port: the port on the device
  546. *
  547. * Set Portinfo (see ch. 14.2.5.6).
  548. */
  549. static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
  550. u8 port)
  551. {
  552. struct ib_port_info *pip = (struct ib_port_info *)smp->data;
  553. struct ib_event event;
  554. struct qib_devdata *dd;
  555. struct qib_pportdata *ppd;
  556. struct qib_ibport *ibp;
  557. u8 clientrereg = (pip->clientrereg_resv_subnetto & 0x80);
  558. unsigned long flags;
  559. u16 lid, smlid;
  560. u8 lwe;
  561. u8 lse;
  562. u8 state;
  563. u8 vls;
  564. u8 msl;
  565. u16 lstate;
  566. int ret, ore, mtu;
  567. u32 port_num = be32_to_cpu(smp->attr_mod);
  568. if (port_num == 0)
  569. port_num = port;
  570. else {
  571. if (port_num > ibdev->phys_port_cnt)
  572. goto err;
  573. /* Port attributes can only be set on the receiving port */
  574. if (port_num != port)
  575. goto get_only;
  576. }
  577. dd = dd_from_ibdev(ibdev);
  578. /* IB numbers ports from 1, hdw from 0 */
  579. ppd = dd->pport + (port_num - 1);
  580. ibp = &ppd->ibport_data;
  581. event.device = ibdev;
  582. event.element.port_num = port;
  583. ibp->mkey = pip->mkey;
  584. ibp->gid_prefix = pip->gid_prefix;
  585. ibp->mkey_lease_period = be16_to_cpu(pip->mkey_lease_period);
  586. lid = be16_to_cpu(pip->lid);
  587. /* Must be a valid unicast LID address. */
  588. if (lid == 0 || lid >= QIB_MULTICAST_LID_BASE)
  589. smp->status |= IB_SMP_INVALID_FIELD;
  590. else if (ppd->lid != lid || ppd->lmc != (pip->mkeyprot_resv_lmc & 7)) {
  591. if (ppd->lid != lid)
  592. qib_set_uevent_bits(ppd, _QIB_EVENT_LID_CHANGE_BIT);
  593. if (ppd->lmc != (pip->mkeyprot_resv_lmc & 7))
  594. qib_set_uevent_bits(ppd, _QIB_EVENT_LMC_CHANGE_BIT);
  595. qib_set_lid(ppd, lid, pip->mkeyprot_resv_lmc & 7);
  596. event.event = IB_EVENT_LID_CHANGE;
  597. ib_dispatch_event(&event);
  598. }
  599. smlid = be16_to_cpu(pip->sm_lid);
  600. msl = pip->neighbormtu_mastersmsl & 0xF;
  601. /* Must be a valid unicast LID address. */
  602. if (smlid == 0 || smlid >= QIB_MULTICAST_LID_BASE)
  603. smp->status |= IB_SMP_INVALID_FIELD;
  604. else if (smlid != ibp->sm_lid || msl != ibp->sm_sl) {
  605. spin_lock_irqsave(&ibp->lock, flags);
  606. if (ibp->sm_ah) {
  607. if (smlid != ibp->sm_lid)
  608. ibp->sm_ah->attr.dlid = smlid;
  609. if (msl != ibp->sm_sl)
  610. ibp->sm_ah->attr.sl = msl;
  611. }
  612. spin_unlock_irqrestore(&ibp->lock, flags);
  613. if (smlid != ibp->sm_lid)
  614. ibp->sm_lid = smlid;
  615. if (msl != ibp->sm_sl)
  616. ibp->sm_sl = msl;
  617. event.event = IB_EVENT_SM_CHANGE;
  618. ib_dispatch_event(&event);
  619. }
  620. /* Allow 1x or 4x to be set (see 14.2.6.6). */
  621. lwe = pip->link_width_enabled;
  622. if (lwe) {
  623. if (lwe == 0xFF)
  624. set_link_width_enabled(ppd, ppd->link_width_supported);
  625. else if (lwe >= 16 || (lwe & ~ppd->link_width_supported))
  626. smp->status |= IB_SMP_INVALID_FIELD;
  627. else if (lwe != ppd->link_width_enabled)
  628. set_link_width_enabled(ppd, lwe);
  629. }
  630. lse = pip->linkspeedactive_enabled & 0xF;
  631. if (lse) {
  632. /*
  633. * The IB 1.2 spec. only allows link speed values
  634. * 1, 3, 5, 7, 15. 1.2.1 extended to allow specific
  635. * speeds.
  636. */
  637. if (lse == 15)
  638. set_link_speed_enabled(ppd,
  639. ppd->link_speed_supported);
  640. else if (lse >= 8 || (lse & ~ppd->link_speed_supported))
  641. smp->status |= IB_SMP_INVALID_FIELD;
  642. else if (lse != ppd->link_speed_enabled)
  643. set_link_speed_enabled(ppd, lse);
  644. }
  645. /* Set link down default state. */
  646. switch (pip->portphysstate_linkdown & 0xF) {
  647. case 0: /* NOP */
  648. break;
  649. case 1: /* SLEEP */
  650. (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_LINKDEFAULT,
  651. IB_LINKINITCMD_SLEEP);
  652. break;
  653. case 2: /* POLL */
  654. (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_LINKDEFAULT,
  655. IB_LINKINITCMD_POLL);
  656. break;
  657. default:
  658. smp->status |= IB_SMP_INVALID_FIELD;
  659. }
  660. ibp->mkeyprot = pip->mkeyprot_resv_lmc >> 6;
  661. ibp->vl_high_limit = pip->vl_high_limit;
  662. (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_VL_HIGH_LIMIT,
  663. ibp->vl_high_limit);
  664. mtu = ib_mtu_enum_to_int((pip->neighbormtu_mastersmsl >> 4) & 0xF);
  665. if (mtu == -1)
  666. smp->status |= IB_SMP_INVALID_FIELD;
  667. else
  668. qib_set_mtu(ppd, mtu);
  669. /* Set operational VLs */
  670. vls = (pip->operationalvl_pei_peo_fpi_fpo >> 4) & 0xF;
  671. if (vls) {
  672. if (vls > ppd->vls_supported)
  673. smp->status |= IB_SMP_INVALID_FIELD;
  674. else
  675. (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_OP_VLS, vls);
  676. }
  677. if (pip->mkey_violations == 0)
  678. ibp->mkey_violations = 0;
  679. if (pip->pkey_violations == 0)
  680. ibp->pkey_violations = 0;
  681. if (pip->qkey_violations == 0)
  682. ibp->qkey_violations = 0;
  683. ore = pip->localphyerrors_overrunerrors;
  684. if (set_phyerrthreshold(ppd, (ore >> 4) & 0xF))
  685. smp->status |= IB_SMP_INVALID_FIELD;
  686. if (set_overrunthreshold(ppd, (ore & 0xF)))
  687. smp->status |= IB_SMP_INVALID_FIELD;
  688. ibp->subnet_timeout = pip->clientrereg_resv_subnetto & 0x1F;
  689. /*
  690. * Do the port state change now that the other link parameters
  691. * have been set.
  692. * Changing the port physical state only makes sense if the link
  693. * is down or is being set to down.
  694. */
  695. state = pip->linkspeed_portstate & 0xF;
  696. lstate = (pip->portphysstate_linkdown >> 4) & 0xF;
  697. if (lstate && !(state == IB_PORT_DOWN || state == IB_PORT_NOP))
  698. smp->status |= IB_SMP_INVALID_FIELD;
  699. /*
  700. * Only state changes of DOWN, ARM, and ACTIVE are valid
  701. * and must be in the correct state to take effect (see 7.2.6).
  702. */
  703. switch (state) {
  704. case IB_PORT_NOP:
  705. if (lstate == 0)
  706. break;
  707. /* FALLTHROUGH */
  708. case IB_PORT_DOWN:
  709. if (lstate == 0)
  710. lstate = QIB_IB_LINKDOWN_ONLY;
  711. else if (lstate == 1)
  712. lstate = QIB_IB_LINKDOWN_SLEEP;
  713. else if (lstate == 2)
  714. lstate = QIB_IB_LINKDOWN;
  715. else if (lstate == 3)
  716. lstate = QIB_IB_LINKDOWN_DISABLE;
  717. else {
  718. smp->status |= IB_SMP_INVALID_FIELD;
  719. break;
  720. }
  721. spin_lock_irqsave(&ppd->lflags_lock, flags);
  722. ppd->lflags &= ~QIBL_LINKV;
  723. spin_unlock_irqrestore(&ppd->lflags_lock, flags);
  724. qib_set_linkstate(ppd, lstate);
  725. /*
  726. * Don't send a reply if the response would be sent
  727. * through the disabled port.
  728. */
  729. if (lstate == QIB_IB_LINKDOWN_DISABLE && smp->hop_cnt) {
  730. ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
  731. goto done;
  732. }
  733. qib_wait_linkstate(ppd, QIBL_LINKV, 10);
  734. break;
  735. case IB_PORT_ARMED:
  736. qib_set_linkstate(ppd, QIB_IB_LINKARM);
  737. break;
  738. case IB_PORT_ACTIVE:
  739. qib_set_linkstate(ppd, QIB_IB_LINKACTIVE);
  740. break;
  741. default:
  742. smp->status |= IB_SMP_INVALID_FIELD;
  743. }
  744. if (clientrereg) {
  745. event.event = IB_EVENT_CLIENT_REREGISTER;
  746. ib_dispatch_event(&event);
  747. }
  748. ret = subn_get_portinfo(smp, ibdev, port);
  749. /* restore re-reg bit per o14-12.2.1 */
  750. pip->clientrereg_resv_subnetto |= clientrereg;
  751. goto get_only;
  752. err:
  753. smp->status |= IB_SMP_INVALID_FIELD;
  754. get_only:
  755. ret = subn_get_portinfo(smp, ibdev, port);
  756. done:
  757. return ret;
  758. }
  759. /**
  760. * rm_pkey - decrecment the reference count for the given PKEY
  761. * @dd: the qlogic_ib device
  762. * @key: the PKEY index
  763. *
  764. * Return true if this was the last reference and the hardware table entry
  765. * needs to be changed.
  766. */
  767. static int rm_pkey(struct qib_pportdata *ppd, u16 key)
  768. {
  769. int i;
  770. int ret;
  771. for (i = 0; i < ARRAY_SIZE(ppd->pkeys); i++) {
  772. if (ppd->pkeys[i] != key)
  773. continue;
  774. if (atomic_dec_and_test(&ppd->pkeyrefs[i])) {
  775. ppd->pkeys[i] = 0;
  776. ret = 1;
  777. goto bail;
  778. }
  779. break;
  780. }
  781. ret = 0;
  782. bail:
  783. return ret;
  784. }
  785. /**
  786. * add_pkey - add the given PKEY to the hardware table
  787. * @dd: the qlogic_ib device
  788. * @key: the PKEY
  789. *
  790. * Return an error code if unable to add the entry, zero if no change,
  791. * or 1 if the hardware PKEY register needs to be updated.
  792. */
  793. static int add_pkey(struct qib_pportdata *ppd, u16 key)
  794. {
  795. int i;
  796. u16 lkey = key & 0x7FFF;
  797. int any = 0;
  798. int ret;
  799. if (lkey == 0x7FFF) {
  800. ret = 0;
  801. goto bail;
  802. }
  803. /* Look for an empty slot or a matching PKEY. */
  804. for (i = 0; i < ARRAY_SIZE(ppd->pkeys); i++) {
  805. if (!ppd->pkeys[i]) {
  806. any++;
  807. continue;
  808. }
  809. /* If it matches exactly, try to increment the ref count */
  810. if (ppd->pkeys[i] == key) {
  811. if (atomic_inc_return(&ppd->pkeyrefs[i]) > 1) {
  812. ret = 0;
  813. goto bail;
  814. }
  815. /* Lost the race. Look for an empty slot below. */
  816. atomic_dec(&ppd->pkeyrefs[i]);
  817. any++;
  818. }
  819. /*
  820. * It makes no sense to have both the limited and unlimited
  821. * PKEY set at the same time since the unlimited one will
  822. * disable the limited one.
  823. */
  824. if ((ppd->pkeys[i] & 0x7FFF) == lkey) {
  825. ret = -EEXIST;
  826. goto bail;
  827. }
  828. }
  829. if (!any) {
  830. ret = -EBUSY;
  831. goto bail;
  832. }
  833. for (i = 0; i < ARRAY_SIZE(ppd->pkeys); i++) {
  834. if (!ppd->pkeys[i] &&
  835. atomic_inc_return(&ppd->pkeyrefs[i]) == 1) {
  836. /* for qibstats, etc. */
  837. ppd->pkeys[i] = key;
  838. ret = 1;
  839. goto bail;
  840. }
  841. }
  842. ret = -EBUSY;
  843. bail:
  844. return ret;
  845. }
  846. /**
  847. * set_pkeys - set the PKEY table for ctxt 0
  848. * @dd: the qlogic_ib device
  849. * @port: the IB port number
  850. * @pkeys: the PKEY table
  851. */
  852. static int set_pkeys(struct qib_devdata *dd, u8 port, u16 *pkeys)
  853. {
  854. struct qib_pportdata *ppd;
  855. struct qib_ctxtdata *rcd;
  856. int i;
  857. int changed = 0;
  858. /*
  859. * IB port one/two always maps to context zero/one,
  860. * always a kernel context, no locking needed
  861. * If we get here with ppd setup, no need to check
  862. * that rcd is valid.
  863. */
  864. ppd = dd->pport + (port - 1);
  865. rcd = dd->rcd[ppd->hw_pidx];
  866. for (i = 0; i < ARRAY_SIZE(rcd->pkeys); i++) {
  867. u16 key = pkeys[i];
  868. u16 okey = rcd->pkeys[i];
  869. if (key == okey)
  870. continue;
  871. /*
  872. * The value of this PKEY table entry is changing.
  873. * Remove the old entry in the hardware's array of PKEYs.
  874. */
  875. if (okey & 0x7FFF)
  876. changed |= rm_pkey(ppd, okey);
  877. if (key & 0x7FFF) {
  878. int ret = add_pkey(ppd, key);
  879. if (ret < 0)
  880. key = 0;
  881. else
  882. changed |= ret;
  883. }
  884. rcd->pkeys[i] = key;
  885. }
  886. if (changed) {
  887. struct ib_event event;
  888. (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_PKEYS, 0);
  889. event.event = IB_EVENT_PKEY_CHANGE;
  890. event.device = &dd->verbs_dev.ibdev;
  891. event.element.port_num = 1;
  892. ib_dispatch_event(&event);
  893. }
  894. return 0;
  895. }
  896. static int subn_set_pkeytable(struct ib_smp *smp, struct ib_device *ibdev,
  897. u8 port)
  898. {
  899. u32 startpx = 32 * (be32_to_cpu(smp->attr_mod) & 0xffff);
  900. __be16 *p = (__be16 *) smp->data;
  901. u16 *q = (u16 *) smp->data;
  902. struct qib_devdata *dd = dd_from_ibdev(ibdev);
  903. unsigned i, n = qib_get_npkeys(dd);
  904. for (i = 0; i < n; i++)
  905. q[i] = be16_to_cpu(p[i]);
  906. if (startpx != 0 || set_pkeys(dd, port, q) != 0)
  907. smp->status |= IB_SMP_INVALID_FIELD;
  908. return subn_get_pkeytable(smp, ibdev, port);
  909. }
  910. static int subn_get_sl_to_vl(struct ib_smp *smp, struct ib_device *ibdev,
  911. u8 port)
  912. {
  913. struct qib_ibport *ibp = to_iport(ibdev, port);
  914. u8 *p = (u8 *) smp->data;
  915. unsigned i;
  916. memset(smp->data, 0, sizeof(smp->data));
  917. if (!(ibp->port_cap_flags & IB_PORT_SL_MAP_SUP))
  918. smp->status |= IB_SMP_UNSUP_METHOD;
  919. else
  920. for (i = 0; i < ARRAY_SIZE(ibp->sl_to_vl); i += 2)
  921. *p++ = (ibp->sl_to_vl[i] << 4) | ibp->sl_to_vl[i + 1];
  922. return reply(smp);
  923. }
  924. static int subn_set_sl_to_vl(struct ib_smp *smp, struct ib_device *ibdev,
  925. u8 port)
  926. {
  927. struct qib_ibport *ibp = to_iport(ibdev, port);
  928. u8 *p = (u8 *) smp->data;
  929. unsigned i;
  930. if (!(ibp->port_cap_flags & IB_PORT_SL_MAP_SUP)) {
  931. smp->status |= IB_SMP_UNSUP_METHOD;
  932. return reply(smp);
  933. }
  934. for (i = 0; i < ARRAY_SIZE(ibp->sl_to_vl); i += 2, p++) {
  935. ibp->sl_to_vl[i] = *p >> 4;
  936. ibp->sl_to_vl[i + 1] = *p & 0xF;
  937. }
  938. qib_set_uevent_bits(ppd_from_ibp(to_iport(ibdev, port)),
  939. _QIB_EVENT_SL2VL_CHANGE_BIT);
  940. return subn_get_sl_to_vl(smp, ibdev, port);
  941. }
  942. static int subn_get_vl_arb(struct ib_smp *smp, struct ib_device *ibdev,
  943. u8 port)
  944. {
  945. unsigned which = be32_to_cpu(smp->attr_mod) >> 16;
  946. struct qib_pportdata *ppd = ppd_from_ibp(to_iport(ibdev, port));
  947. memset(smp->data, 0, sizeof(smp->data));
  948. if (ppd->vls_supported == IB_VL_VL0)
  949. smp->status |= IB_SMP_UNSUP_METHOD;
  950. else if (which == IB_VLARB_LOWPRI_0_31)
  951. (void) ppd->dd->f_get_ib_table(ppd, QIB_IB_TBL_VL_LOW_ARB,
  952. smp->data);
  953. else if (which == IB_VLARB_HIGHPRI_0_31)
  954. (void) ppd->dd->f_get_ib_table(ppd, QIB_IB_TBL_VL_HIGH_ARB,
  955. smp->data);
  956. else
  957. smp->status |= IB_SMP_INVALID_FIELD;
  958. return reply(smp);
  959. }
  960. static int subn_set_vl_arb(struct ib_smp *smp, struct ib_device *ibdev,
  961. u8 port)
  962. {
  963. unsigned which = be32_to_cpu(smp->attr_mod) >> 16;
  964. struct qib_pportdata *ppd = ppd_from_ibp(to_iport(ibdev, port));
  965. if (ppd->vls_supported == IB_VL_VL0)
  966. smp->status |= IB_SMP_UNSUP_METHOD;
  967. else if (which == IB_VLARB_LOWPRI_0_31)
  968. (void) ppd->dd->f_set_ib_table(ppd, QIB_IB_TBL_VL_LOW_ARB,
  969. smp->data);
  970. else if (which == IB_VLARB_HIGHPRI_0_31)
  971. (void) ppd->dd->f_set_ib_table(ppd, QIB_IB_TBL_VL_HIGH_ARB,
  972. smp->data);
  973. else
  974. smp->status |= IB_SMP_INVALID_FIELD;
  975. return subn_get_vl_arb(smp, ibdev, port);
  976. }
  977. static int subn_trap_repress(struct ib_smp *smp, struct ib_device *ibdev,
  978. u8 port)
  979. {
  980. /*
  981. * For now, we only send the trap once so no need to process this.
  982. * o13-6, o13-7,
  983. * o14-3.a4 The SMA shall not send any message in response to a valid
  984. * SubnTrapRepress() message.
  985. */
  986. return IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
  987. }
  988. static int pma_get_classportinfo(struct ib_pma_mad *pmp,
  989. struct ib_device *ibdev)
  990. {
  991. struct ib_class_port_info *p =
  992. (struct ib_class_port_info *)pmp->data;
  993. struct qib_devdata *dd = dd_from_ibdev(ibdev);
  994. memset(pmp->data, 0, sizeof(pmp->data));
  995. if (pmp->mad_hdr.attr_mod != 0)
  996. pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
  997. /* Note that AllPortSelect is not valid */
  998. p->base_version = 1;
  999. p->class_version = 1;
  1000. p->capability_mask = IB_PMA_CLASS_CAP_EXT_WIDTH;
  1001. /*
  1002. * Set the most significant bit of CM2 to indicate support for
  1003. * congestion statistics
  1004. */
  1005. p->reserved[0] = dd->psxmitwait_supported << 7;
  1006. /*
  1007. * Expected response time is 4.096 usec. * 2^18 == 1.073741824 sec.
  1008. */
  1009. p->resp_time_value = 18;
  1010. return reply((struct ib_smp *) pmp);
  1011. }
  1012. static int pma_get_portsamplescontrol(struct ib_pma_mad *pmp,
  1013. struct ib_device *ibdev, u8 port)
  1014. {
  1015. struct ib_pma_portsamplescontrol *p =
  1016. (struct ib_pma_portsamplescontrol *)pmp->data;
  1017. struct qib_ibdev *dev = to_idev(ibdev);
  1018. struct qib_devdata *dd = dd_from_dev(dev);
  1019. struct qib_ibport *ibp = to_iport(ibdev, port);
  1020. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1021. unsigned long flags;
  1022. u8 port_select = p->port_select;
  1023. memset(pmp->data, 0, sizeof(pmp->data));
  1024. p->port_select = port_select;
  1025. if (pmp->mad_hdr.attr_mod != 0 || port_select != port) {
  1026. pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
  1027. goto bail;
  1028. }
  1029. spin_lock_irqsave(&ibp->lock, flags);
  1030. p->tick = dd->f_get_ib_cfg(ppd, QIB_IB_CFG_PMA_TICKS);
  1031. p->sample_status = dd->f_portcntr(ppd, QIBPORTCNTR_PSSTAT);
  1032. p->counter_width = 4; /* 32 bit counters */
  1033. p->counter_mask0_9 = COUNTER_MASK0_9;
  1034. p->sample_start = cpu_to_be32(ibp->pma_sample_start);
  1035. p->sample_interval = cpu_to_be32(ibp->pma_sample_interval);
  1036. p->tag = cpu_to_be16(ibp->pma_tag);
  1037. p->counter_select[0] = ibp->pma_counter_select[0];
  1038. p->counter_select[1] = ibp->pma_counter_select[1];
  1039. p->counter_select[2] = ibp->pma_counter_select[2];
  1040. p->counter_select[3] = ibp->pma_counter_select[3];
  1041. p->counter_select[4] = ibp->pma_counter_select[4];
  1042. spin_unlock_irqrestore(&ibp->lock, flags);
  1043. bail:
  1044. return reply((struct ib_smp *) pmp);
  1045. }
  1046. static int pma_set_portsamplescontrol(struct ib_pma_mad *pmp,
  1047. struct ib_device *ibdev, u8 port)
  1048. {
  1049. struct ib_pma_portsamplescontrol *p =
  1050. (struct ib_pma_portsamplescontrol *)pmp->data;
  1051. struct qib_ibdev *dev = to_idev(ibdev);
  1052. struct qib_devdata *dd = dd_from_dev(dev);
  1053. struct qib_ibport *ibp = to_iport(ibdev, port);
  1054. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1055. unsigned long flags;
  1056. u8 status, xmit_flags;
  1057. int ret;
  1058. if (pmp->mad_hdr.attr_mod != 0 || p->port_select != port) {
  1059. pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
  1060. ret = reply((struct ib_smp *) pmp);
  1061. goto bail;
  1062. }
  1063. spin_lock_irqsave(&ibp->lock, flags);
  1064. /* Port Sampling code owns the PS* HW counters */
  1065. xmit_flags = ppd->cong_stats.flags;
  1066. ppd->cong_stats.flags = IB_PMA_CONG_HW_CONTROL_SAMPLE;
  1067. status = dd->f_portcntr(ppd, QIBPORTCNTR_PSSTAT);
  1068. if (status == IB_PMA_SAMPLE_STATUS_DONE ||
  1069. (status == IB_PMA_SAMPLE_STATUS_RUNNING &&
  1070. xmit_flags == IB_PMA_CONG_HW_CONTROL_TIMER)) {
  1071. ibp->pma_sample_start = be32_to_cpu(p->sample_start);
  1072. ibp->pma_sample_interval = be32_to_cpu(p->sample_interval);
  1073. ibp->pma_tag = be16_to_cpu(p->tag);
  1074. ibp->pma_counter_select[0] = p->counter_select[0];
  1075. ibp->pma_counter_select[1] = p->counter_select[1];
  1076. ibp->pma_counter_select[2] = p->counter_select[2];
  1077. ibp->pma_counter_select[3] = p->counter_select[3];
  1078. ibp->pma_counter_select[4] = p->counter_select[4];
  1079. dd->f_set_cntr_sample(ppd, ibp->pma_sample_interval,
  1080. ibp->pma_sample_start);
  1081. }
  1082. spin_unlock_irqrestore(&ibp->lock, flags);
  1083. ret = pma_get_portsamplescontrol(pmp, ibdev, port);
  1084. bail:
  1085. return ret;
  1086. }
  1087. static u64 get_counter(struct qib_ibport *ibp, struct qib_pportdata *ppd,
  1088. __be16 sel)
  1089. {
  1090. u64 ret;
  1091. switch (sel) {
  1092. case IB_PMA_PORT_XMIT_DATA:
  1093. ret = ppd->dd->f_portcntr(ppd, QIBPORTCNTR_PSXMITDATA);
  1094. break;
  1095. case IB_PMA_PORT_RCV_DATA:
  1096. ret = ppd->dd->f_portcntr(ppd, QIBPORTCNTR_PSRCVDATA);
  1097. break;
  1098. case IB_PMA_PORT_XMIT_PKTS:
  1099. ret = ppd->dd->f_portcntr(ppd, QIBPORTCNTR_PSXMITPKTS);
  1100. break;
  1101. case IB_PMA_PORT_RCV_PKTS:
  1102. ret = ppd->dd->f_portcntr(ppd, QIBPORTCNTR_PSRCVPKTS);
  1103. break;
  1104. case IB_PMA_PORT_XMIT_WAIT:
  1105. ret = ppd->dd->f_portcntr(ppd, QIBPORTCNTR_PSXMITWAIT);
  1106. break;
  1107. default:
  1108. ret = 0;
  1109. }
  1110. return ret;
  1111. }
  1112. /* This function assumes that the xmit_wait lock is already held */
  1113. static u64 xmit_wait_get_value_delta(struct qib_pportdata *ppd)
  1114. {
  1115. u32 delta;
  1116. delta = get_counter(&ppd->ibport_data, ppd,
  1117. IB_PMA_PORT_XMIT_WAIT);
  1118. return ppd->cong_stats.counter + delta;
  1119. }
  1120. static void cache_hw_sample_counters(struct qib_pportdata *ppd)
  1121. {
  1122. struct qib_ibport *ibp = &ppd->ibport_data;
  1123. ppd->cong_stats.counter_cache.psxmitdata =
  1124. get_counter(ibp, ppd, IB_PMA_PORT_XMIT_DATA);
  1125. ppd->cong_stats.counter_cache.psrcvdata =
  1126. get_counter(ibp, ppd, IB_PMA_PORT_RCV_DATA);
  1127. ppd->cong_stats.counter_cache.psxmitpkts =
  1128. get_counter(ibp, ppd, IB_PMA_PORT_XMIT_PKTS);
  1129. ppd->cong_stats.counter_cache.psrcvpkts =
  1130. get_counter(ibp, ppd, IB_PMA_PORT_RCV_PKTS);
  1131. ppd->cong_stats.counter_cache.psxmitwait =
  1132. get_counter(ibp, ppd, IB_PMA_PORT_XMIT_WAIT);
  1133. }
  1134. static u64 get_cache_hw_sample_counters(struct qib_pportdata *ppd,
  1135. __be16 sel)
  1136. {
  1137. u64 ret;
  1138. switch (sel) {
  1139. case IB_PMA_PORT_XMIT_DATA:
  1140. ret = ppd->cong_stats.counter_cache.psxmitdata;
  1141. break;
  1142. case IB_PMA_PORT_RCV_DATA:
  1143. ret = ppd->cong_stats.counter_cache.psrcvdata;
  1144. break;
  1145. case IB_PMA_PORT_XMIT_PKTS:
  1146. ret = ppd->cong_stats.counter_cache.psxmitpkts;
  1147. break;
  1148. case IB_PMA_PORT_RCV_PKTS:
  1149. ret = ppd->cong_stats.counter_cache.psrcvpkts;
  1150. break;
  1151. case IB_PMA_PORT_XMIT_WAIT:
  1152. ret = ppd->cong_stats.counter_cache.psxmitwait;
  1153. break;
  1154. default:
  1155. ret = 0;
  1156. }
  1157. return ret;
  1158. }
  1159. static int pma_get_portsamplesresult(struct ib_pma_mad *pmp,
  1160. struct ib_device *ibdev, u8 port)
  1161. {
  1162. struct ib_pma_portsamplesresult *p =
  1163. (struct ib_pma_portsamplesresult *)pmp->data;
  1164. struct qib_ibdev *dev = to_idev(ibdev);
  1165. struct qib_devdata *dd = dd_from_dev(dev);
  1166. struct qib_ibport *ibp = to_iport(ibdev, port);
  1167. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1168. unsigned long flags;
  1169. u8 status;
  1170. int i;
  1171. memset(pmp->data, 0, sizeof(pmp->data));
  1172. spin_lock_irqsave(&ibp->lock, flags);
  1173. p->tag = cpu_to_be16(ibp->pma_tag);
  1174. if (ppd->cong_stats.flags == IB_PMA_CONG_HW_CONTROL_TIMER)
  1175. p->sample_status = IB_PMA_SAMPLE_STATUS_DONE;
  1176. else {
  1177. status = dd->f_portcntr(ppd, QIBPORTCNTR_PSSTAT);
  1178. p->sample_status = cpu_to_be16(status);
  1179. if (status == IB_PMA_SAMPLE_STATUS_DONE) {
  1180. cache_hw_sample_counters(ppd);
  1181. ppd->cong_stats.counter =
  1182. xmit_wait_get_value_delta(ppd);
  1183. dd->f_set_cntr_sample(ppd,
  1184. QIB_CONG_TIMER_PSINTERVAL, 0);
  1185. ppd->cong_stats.flags = IB_PMA_CONG_HW_CONTROL_TIMER;
  1186. }
  1187. }
  1188. for (i = 0; i < ARRAY_SIZE(ibp->pma_counter_select); i++)
  1189. p->counter[i] = cpu_to_be32(
  1190. get_cache_hw_sample_counters(
  1191. ppd, ibp->pma_counter_select[i]));
  1192. spin_unlock_irqrestore(&ibp->lock, flags);
  1193. return reply((struct ib_smp *) pmp);
  1194. }
  1195. static int pma_get_portsamplesresult_ext(struct ib_pma_mad *pmp,
  1196. struct ib_device *ibdev, u8 port)
  1197. {
  1198. struct ib_pma_portsamplesresult_ext *p =
  1199. (struct ib_pma_portsamplesresult_ext *)pmp->data;
  1200. struct qib_ibdev *dev = to_idev(ibdev);
  1201. struct qib_devdata *dd = dd_from_dev(dev);
  1202. struct qib_ibport *ibp = to_iport(ibdev, port);
  1203. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1204. unsigned long flags;
  1205. u8 status;
  1206. int i;
  1207. /* Port Sampling code owns the PS* HW counters */
  1208. memset(pmp->data, 0, sizeof(pmp->data));
  1209. spin_lock_irqsave(&ibp->lock, flags);
  1210. p->tag = cpu_to_be16(ibp->pma_tag);
  1211. if (ppd->cong_stats.flags == IB_PMA_CONG_HW_CONTROL_TIMER)
  1212. p->sample_status = IB_PMA_SAMPLE_STATUS_DONE;
  1213. else {
  1214. status = dd->f_portcntr(ppd, QIBPORTCNTR_PSSTAT);
  1215. p->sample_status = cpu_to_be16(status);
  1216. /* 64 bits */
  1217. p->extended_width = cpu_to_be32(0x80000000);
  1218. if (status == IB_PMA_SAMPLE_STATUS_DONE) {
  1219. cache_hw_sample_counters(ppd);
  1220. ppd->cong_stats.counter =
  1221. xmit_wait_get_value_delta(ppd);
  1222. dd->f_set_cntr_sample(ppd,
  1223. QIB_CONG_TIMER_PSINTERVAL, 0);
  1224. ppd->cong_stats.flags = IB_PMA_CONG_HW_CONTROL_TIMER;
  1225. }
  1226. }
  1227. for (i = 0; i < ARRAY_SIZE(ibp->pma_counter_select); i++)
  1228. p->counter[i] = cpu_to_be64(
  1229. get_cache_hw_sample_counters(
  1230. ppd, ibp->pma_counter_select[i]));
  1231. spin_unlock_irqrestore(&ibp->lock, flags);
  1232. return reply((struct ib_smp *) pmp);
  1233. }
  1234. static int pma_get_portcounters(struct ib_pma_mad *pmp,
  1235. struct ib_device *ibdev, u8 port)
  1236. {
  1237. struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
  1238. pmp->data;
  1239. struct qib_ibport *ibp = to_iport(ibdev, port);
  1240. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1241. struct qib_verbs_counters cntrs;
  1242. u8 port_select = p->port_select;
  1243. qib_get_counters(ppd, &cntrs);
  1244. /* Adjust counters for any resets done. */
  1245. cntrs.symbol_error_counter -= ibp->z_symbol_error_counter;
  1246. cntrs.link_error_recovery_counter -=
  1247. ibp->z_link_error_recovery_counter;
  1248. cntrs.link_downed_counter -= ibp->z_link_downed_counter;
  1249. cntrs.port_rcv_errors -= ibp->z_port_rcv_errors;
  1250. cntrs.port_rcv_remphys_errors -= ibp->z_port_rcv_remphys_errors;
  1251. cntrs.port_xmit_discards -= ibp->z_port_xmit_discards;
  1252. cntrs.port_xmit_data -= ibp->z_port_xmit_data;
  1253. cntrs.port_rcv_data -= ibp->z_port_rcv_data;
  1254. cntrs.port_xmit_packets -= ibp->z_port_xmit_packets;
  1255. cntrs.port_rcv_packets -= ibp->z_port_rcv_packets;
  1256. cntrs.local_link_integrity_errors -=
  1257. ibp->z_local_link_integrity_errors;
  1258. cntrs.excessive_buffer_overrun_errors -=
  1259. ibp->z_excessive_buffer_overrun_errors;
  1260. cntrs.vl15_dropped -= ibp->z_vl15_dropped;
  1261. cntrs.vl15_dropped += ibp->n_vl15_dropped;
  1262. memset(pmp->data, 0, sizeof(pmp->data));
  1263. p->port_select = port_select;
  1264. if (pmp->mad_hdr.attr_mod != 0 || port_select != port)
  1265. pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
  1266. if (cntrs.symbol_error_counter > 0xFFFFUL)
  1267. p->symbol_error_counter = cpu_to_be16(0xFFFF);
  1268. else
  1269. p->symbol_error_counter =
  1270. cpu_to_be16((u16)cntrs.symbol_error_counter);
  1271. if (cntrs.link_error_recovery_counter > 0xFFUL)
  1272. p->link_error_recovery_counter = 0xFF;
  1273. else
  1274. p->link_error_recovery_counter =
  1275. (u8)cntrs.link_error_recovery_counter;
  1276. if (cntrs.link_downed_counter > 0xFFUL)
  1277. p->link_downed_counter = 0xFF;
  1278. else
  1279. p->link_downed_counter = (u8)cntrs.link_downed_counter;
  1280. if (cntrs.port_rcv_errors > 0xFFFFUL)
  1281. p->port_rcv_errors = cpu_to_be16(0xFFFF);
  1282. else
  1283. p->port_rcv_errors =
  1284. cpu_to_be16((u16) cntrs.port_rcv_errors);
  1285. if (cntrs.port_rcv_remphys_errors > 0xFFFFUL)
  1286. p->port_rcv_remphys_errors = cpu_to_be16(0xFFFF);
  1287. else
  1288. p->port_rcv_remphys_errors =
  1289. cpu_to_be16((u16)cntrs.port_rcv_remphys_errors);
  1290. if (cntrs.port_xmit_discards > 0xFFFFUL)
  1291. p->port_xmit_discards = cpu_to_be16(0xFFFF);
  1292. else
  1293. p->port_xmit_discards =
  1294. cpu_to_be16((u16)cntrs.port_xmit_discards);
  1295. if (cntrs.local_link_integrity_errors > 0xFUL)
  1296. cntrs.local_link_integrity_errors = 0xFUL;
  1297. if (cntrs.excessive_buffer_overrun_errors > 0xFUL)
  1298. cntrs.excessive_buffer_overrun_errors = 0xFUL;
  1299. p->link_overrun_errors = (cntrs.local_link_integrity_errors << 4) |
  1300. cntrs.excessive_buffer_overrun_errors;
  1301. if (cntrs.vl15_dropped > 0xFFFFUL)
  1302. p->vl15_dropped = cpu_to_be16(0xFFFF);
  1303. else
  1304. p->vl15_dropped = cpu_to_be16((u16)cntrs.vl15_dropped);
  1305. if (cntrs.port_xmit_data > 0xFFFFFFFFUL)
  1306. p->port_xmit_data = cpu_to_be32(0xFFFFFFFF);
  1307. else
  1308. p->port_xmit_data = cpu_to_be32((u32)cntrs.port_xmit_data);
  1309. if (cntrs.port_rcv_data > 0xFFFFFFFFUL)
  1310. p->port_rcv_data = cpu_to_be32(0xFFFFFFFF);
  1311. else
  1312. p->port_rcv_data = cpu_to_be32((u32)cntrs.port_rcv_data);
  1313. if (cntrs.port_xmit_packets > 0xFFFFFFFFUL)
  1314. p->port_xmit_packets = cpu_to_be32(0xFFFFFFFF);
  1315. else
  1316. p->port_xmit_packets =
  1317. cpu_to_be32((u32)cntrs.port_xmit_packets);
  1318. if (cntrs.port_rcv_packets > 0xFFFFFFFFUL)
  1319. p->port_rcv_packets = cpu_to_be32(0xFFFFFFFF);
  1320. else
  1321. p->port_rcv_packets =
  1322. cpu_to_be32((u32) cntrs.port_rcv_packets);
  1323. return reply((struct ib_smp *) pmp);
  1324. }
  1325. static int pma_get_portcounters_cong(struct ib_pma_mad *pmp,
  1326. struct ib_device *ibdev, u8 port)
  1327. {
  1328. /* Congestion PMA packets start at offset 24 not 64 */
  1329. struct ib_pma_portcounters_cong *p =
  1330. (struct ib_pma_portcounters_cong *)pmp->reserved;
  1331. struct qib_verbs_counters cntrs;
  1332. struct qib_ibport *ibp = to_iport(ibdev, port);
  1333. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1334. struct qib_devdata *dd = dd_from_ppd(ppd);
  1335. u32 port_select = be32_to_cpu(pmp->mad_hdr.attr_mod) & 0xFF;
  1336. u64 xmit_wait_counter;
  1337. unsigned long flags;
  1338. /*
  1339. * This check is performed only in the GET method because the
  1340. * SET method ends up calling this anyway.
  1341. */
  1342. if (!dd->psxmitwait_supported)
  1343. pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
  1344. if (port_select != port)
  1345. pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
  1346. qib_get_counters(ppd, &cntrs);
  1347. spin_lock_irqsave(&ppd->ibport_data.lock, flags);
  1348. xmit_wait_counter = xmit_wait_get_value_delta(ppd);
  1349. spin_unlock_irqrestore(&ppd->ibport_data.lock, flags);
  1350. /* Adjust counters for any resets done. */
  1351. cntrs.symbol_error_counter -= ibp->z_symbol_error_counter;
  1352. cntrs.link_error_recovery_counter -=
  1353. ibp->z_link_error_recovery_counter;
  1354. cntrs.link_downed_counter -= ibp->z_link_downed_counter;
  1355. cntrs.port_rcv_errors -= ibp->z_port_rcv_errors;
  1356. cntrs.port_rcv_remphys_errors -=
  1357. ibp->z_port_rcv_remphys_errors;
  1358. cntrs.port_xmit_discards -= ibp->z_port_xmit_discards;
  1359. cntrs.local_link_integrity_errors -=
  1360. ibp->z_local_link_integrity_errors;
  1361. cntrs.excessive_buffer_overrun_errors -=
  1362. ibp->z_excessive_buffer_overrun_errors;
  1363. cntrs.vl15_dropped -= ibp->z_vl15_dropped;
  1364. cntrs.vl15_dropped += ibp->n_vl15_dropped;
  1365. cntrs.port_xmit_data -= ibp->z_port_xmit_data;
  1366. cntrs.port_rcv_data -= ibp->z_port_rcv_data;
  1367. cntrs.port_xmit_packets -= ibp->z_port_xmit_packets;
  1368. cntrs.port_rcv_packets -= ibp->z_port_rcv_packets;
  1369. memset(pmp->reserved, 0, sizeof(pmp->reserved) +
  1370. sizeof(pmp->data));
  1371. /*
  1372. * Set top 3 bits to indicate interval in picoseconds in
  1373. * remaining bits.
  1374. */
  1375. p->port_check_rate =
  1376. cpu_to_be16((QIB_XMIT_RATE_PICO << 13) |
  1377. (dd->psxmitwait_check_rate &
  1378. ~(QIB_XMIT_RATE_PICO << 13)));
  1379. p->port_adr_events = cpu_to_be64(0);
  1380. p->port_xmit_wait = cpu_to_be64(xmit_wait_counter);
  1381. p->port_xmit_data = cpu_to_be64(cntrs.port_xmit_data);
  1382. p->port_rcv_data = cpu_to_be64(cntrs.port_rcv_data);
  1383. p->port_xmit_packets =
  1384. cpu_to_be64(cntrs.port_xmit_packets);
  1385. p->port_rcv_packets =
  1386. cpu_to_be64(cntrs.port_rcv_packets);
  1387. if (cntrs.symbol_error_counter > 0xFFFFUL)
  1388. p->symbol_error_counter = cpu_to_be16(0xFFFF);
  1389. else
  1390. p->symbol_error_counter =
  1391. cpu_to_be16(
  1392. (u16)cntrs.symbol_error_counter);
  1393. if (cntrs.link_error_recovery_counter > 0xFFUL)
  1394. p->link_error_recovery_counter = 0xFF;
  1395. else
  1396. p->link_error_recovery_counter =
  1397. (u8)cntrs.link_error_recovery_counter;
  1398. if (cntrs.link_downed_counter > 0xFFUL)
  1399. p->link_downed_counter = 0xFF;
  1400. else
  1401. p->link_downed_counter =
  1402. (u8)cntrs.link_downed_counter;
  1403. if (cntrs.port_rcv_errors > 0xFFFFUL)
  1404. p->port_rcv_errors = cpu_to_be16(0xFFFF);
  1405. else
  1406. p->port_rcv_errors =
  1407. cpu_to_be16((u16) cntrs.port_rcv_errors);
  1408. if (cntrs.port_rcv_remphys_errors > 0xFFFFUL)
  1409. p->port_rcv_remphys_errors = cpu_to_be16(0xFFFF);
  1410. else
  1411. p->port_rcv_remphys_errors =
  1412. cpu_to_be16(
  1413. (u16)cntrs.port_rcv_remphys_errors);
  1414. if (cntrs.port_xmit_discards > 0xFFFFUL)
  1415. p->port_xmit_discards = cpu_to_be16(0xFFFF);
  1416. else
  1417. p->port_xmit_discards =
  1418. cpu_to_be16((u16)cntrs.port_xmit_discards);
  1419. if (cntrs.local_link_integrity_errors > 0xFUL)
  1420. cntrs.local_link_integrity_errors = 0xFUL;
  1421. if (cntrs.excessive_buffer_overrun_errors > 0xFUL)
  1422. cntrs.excessive_buffer_overrun_errors = 0xFUL;
  1423. p->link_overrun_errors = (cntrs.local_link_integrity_errors << 4) |
  1424. cntrs.excessive_buffer_overrun_errors;
  1425. if (cntrs.vl15_dropped > 0xFFFFUL)
  1426. p->vl15_dropped = cpu_to_be16(0xFFFF);
  1427. else
  1428. p->vl15_dropped = cpu_to_be16((u16)cntrs.vl15_dropped);
  1429. return reply((struct ib_smp *)pmp);
  1430. }
  1431. static int pma_get_portcounters_ext(struct ib_pma_mad *pmp,
  1432. struct ib_device *ibdev, u8 port)
  1433. {
  1434. struct ib_pma_portcounters_ext *p =
  1435. (struct ib_pma_portcounters_ext *)pmp->data;
  1436. struct qib_ibport *ibp = to_iport(ibdev, port);
  1437. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1438. u64 swords, rwords, spkts, rpkts, xwait;
  1439. u8 port_select = p->port_select;
  1440. memset(pmp->data, 0, sizeof(pmp->data));
  1441. p->port_select = port_select;
  1442. if (pmp->mad_hdr.attr_mod != 0 || port_select != port) {
  1443. pmp->mad_hdr.status |= IB_SMP_INVALID_FIELD;
  1444. goto bail;
  1445. }
  1446. qib_snapshot_counters(ppd, &swords, &rwords, &spkts, &rpkts, &xwait);
  1447. /* Adjust counters for any resets done. */
  1448. swords -= ibp->z_port_xmit_data;
  1449. rwords -= ibp->z_port_rcv_data;
  1450. spkts -= ibp->z_port_xmit_packets;
  1451. rpkts -= ibp->z_port_rcv_packets;
  1452. p->port_xmit_data = cpu_to_be64(swords);
  1453. p->port_rcv_data = cpu_to_be64(rwords);
  1454. p->port_xmit_packets = cpu_to_be64(spkts);
  1455. p->port_rcv_packets = cpu_to_be64(rpkts);
  1456. p->port_unicast_xmit_packets = cpu_to_be64(ibp->n_unicast_xmit);
  1457. p->port_unicast_rcv_packets = cpu_to_be64(ibp->n_unicast_rcv);
  1458. p->port_multicast_xmit_packets = cpu_to_be64(ibp->n_multicast_xmit);
  1459. p->port_multicast_rcv_packets = cpu_to_be64(ibp->n_multicast_rcv);
  1460. bail:
  1461. return reply((struct ib_smp *) pmp);
  1462. }
  1463. static int pma_set_portcounters(struct ib_pma_mad *pmp,
  1464. struct ib_device *ibdev, u8 port)
  1465. {
  1466. struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
  1467. pmp->data;
  1468. struct qib_ibport *ibp = to_iport(ibdev, port);
  1469. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1470. struct qib_verbs_counters cntrs;
  1471. /*
  1472. * Since the HW doesn't support clearing counters, we save the
  1473. * current count and subtract it from future responses.
  1474. */
  1475. qib_get_counters(ppd, &cntrs);
  1476. if (p->counter_select & IB_PMA_SEL_SYMBOL_ERROR)
  1477. ibp->z_symbol_error_counter = cntrs.symbol_error_counter;
  1478. if (p->counter_select & IB_PMA_SEL_LINK_ERROR_RECOVERY)
  1479. ibp->z_link_error_recovery_counter =
  1480. cntrs.link_error_recovery_counter;
  1481. if (p->counter_select & IB_PMA_SEL_LINK_DOWNED)
  1482. ibp->z_link_downed_counter = cntrs.link_downed_counter;
  1483. if (p->counter_select & IB_PMA_SEL_PORT_RCV_ERRORS)
  1484. ibp->z_port_rcv_errors = cntrs.port_rcv_errors;
  1485. if (p->counter_select & IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS)
  1486. ibp->z_port_rcv_remphys_errors =
  1487. cntrs.port_rcv_remphys_errors;
  1488. if (p->counter_select & IB_PMA_SEL_PORT_XMIT_DISCARDS)
  1489. ibp->z_port_xmit_discards = cntrs.port_xmit_discards;
  1490. if (p->counter_select & IB_PMA_SEL_LOCAL_LINK_INTEGRITY_ERRORS)
  1491. ibp->z_local_link_integrity_errors =
  1492. cntrs.local_link_integrity_errors;
  1493. if (p->counter_select & IB_PMA_SEL_EXCESSIVE_BUFFER_OVERRUNS)
  1494. ibp->z_excessive_buffer_overrun_errors =
  1495. cntrs.excessive_buffer_overrun_errors;
  1496. if (p->counter_select & IB_PMA_SEL_PORT_VL15_DROPPED) {
  1497. ibp->n_vl15_dropped = 0;
  1498. ibp->z_vl15_dropped = cntrs.vl15_dropped;
  1499. }
  1500. if (p->counter_select & IB_PMA_SEL_PORT_XMIT_DATA)
  1501. ibp->z_port_xmit_data = cntrs.port_xmit_data;
  1502. if (p->counter_select & IB_PMA_SEL_PORT_RCV_DATA)
  1503. ibp->z_port_rcv_data = cntrs.port_rcv_data;
  1504. if (p->counter_select & IB_PMA_SEL_PORT_XMIT_PACKETS)
  1505. ibp->z_port_xmit_packets = cntrs.port_xmit_packets;
  1506. if (p->counter_select & IB_PMA_SEL_PORT_RCV_PACKETS)
  1507. ibp->z_port_rcv_packets = cntrs.port_rcv_packets;
  1508. return pma_get_portcounters(pmp, ibdev, port);
  1509. }
  1510. static int pma_set_portcounters_cong(struct ib_pma_mad *pmp,
  1511. struct ib_device *ibdev, u8 port)
  1512. {
  1513. struct qib_ibport *ibp = to_iport(ibdev, port);
  1514. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1515. struct qib_devdata *dd = dd_from_ppd(ppd);
  1516. struct qib_verbs_counters cntrs;
  1517. u32 counter_select = (be32_to_cpu(pmp->mad_hdr.attr_mod) >> 24) & 0xFF;
  1518. int ret = 0;
  1519. unsigned long flags;
  1520. qib_get_counters(ppd, &cntrs);
  1521. /* Get counter values before we save them */
  1522. ret = pma_get_portcounters_cong(pmp, ibdev, port);
  1523. if (counter_select & IB_PMA_SEL_CONG_XMIT) {
  1524. spin_lock_irqsave(&ppd->ibport_data.lock, flags);
  1525. ppd->cong_stats.counter = 0;
  1526. dd->f_set_cntr_sample(ppd, QIB_CONG_TIMER_PSINTERVAL,
  1527. 0x0);
  1528. spin_unlock_irqrestore(&ppd->ibport_data.lock, flags);
  1529. }
  1530. if (counter_select & IB_PMA_SEL_CONG_PORT_DATA) {
  1531. ibp->z_port_xmit_data = cntrs.port_xmit_data;
  1532. ibp->z_port_rcv_data = cntrs.port_rcv_data;
  1533. ibp->z_port_xmit_packets = cntrs.port_xmit_packets;
  1534. ibp->z_port_rcv_packets = cntrs.port_rcv_packets;
  1535. }
  1536. if (counter_select & IB_PMA_SEL_CONG_ALL) {
  1537. ibp->z_symbol_error_counter =
  1538. cntrs.symbol_error_counter;
  1539. ibp->z_link_error_recovery_counter =
  1540. cntrs.link_error_recovery_counter;
  1541. ibp->z_link_downed_counter =
  1542. cntrs.link_downed_counter;
  1543. ibp->z_port_rcv_errors = cntrs.port_rcv_errors;
  1544. ibp->z_port_rcv_remphys_errors =
  1545. cntrs.port_rcv_remphys_errors;
  1546. ibp->z_port_xmit_discards =
  1547. cntrs.port_xmit_discards;
  1548. ibp->z_local_link_integrity_errors =
  1549. cntrs.local_link_integrity_errors;
  1550. ibp->z_excessive_buffer_overrun_errors =
  1551. cntrs.excessive_buffer_overrun_errors;
  1552. ibp->n_vl15_dropped = 0;
  1553. ibp->z_vl15_dropped = cntrs.vl15_dropped;
  1554. }
  1555. return ret;
  1556. }
  1557. static int pma_set_portcounters_ext(struct ib_pma_mad *pmp,
  1558. struct ib_device *ibdev, u8 port)
  1559. {
  1560. struct ib_pma_portcounters *p = (struct ib_pma_portcounters *)
  1561. pmp->data;
  1562. struct qib_ibport *ibp = to_iport(ibdev, port);
  1563. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1564. u64 swords, rwords, spkts, rpkts, xwait;
  1565. qib_snapshot_counters(ppd, &swords, &rwords, &spkts, &rpkts, &xwait);
  1566. if (p->counter_select & IB_PMA_SELX_PORT_XMIT_DATA)
  1567. ibp->z_port_xmit_data = swords;
  1568. if (p->counter_select & IB_PMA_SELX_PORT_RCV_DATA)
  1569. ibp->z_port_rcv_data = rwords;
  1570. if (p->counter_select & IB_PMA_SELX_PORT_XMIT_PACKETS)
  1571. ibp->z_port_xmit_packets = spkts;
  1572. if (p->counter_select & IB_PMA_SELX_PORT_RCV_PACKETS)
  1573. ibp->z_port_rcv_packets = rpkts;
  1574. if (p->counter_select & IB_PMA_SELX_PORT_UNI_XMIT_PACKETS)
  1575. ibp->n_unicast_xmit = 0;
  1576. if (p->counter_select & IB_PMA_SELX_PORT_UNI_RCV_PACKETS)
  1577. ibp->n_unicast_rcv = 0;
  1578. if (p->counter_select & IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS)
  1579. ibp->n_multicast_xmit = 0;
  1580. if (p->counter_select & IB_PMA_SELX_PORT_MULTI_RCV_PACKETS)
  1581. ibp->n_multicast_rcv = 0;
  1582. return pma_get_portcounters_ext(pmp, ibdev, port);
  1583. }
  1584. static int process_subn(struct ib_device *ibdev, int mad_flags,
  1585. u8 port, struct ib_mad *in_mad,
  1586. struct ib_mad *out_mad)
  1587. {
  1588. struct ib_smp *smp = (struct ib_smp *)out_mad;
  1589. struct qib_ibport *ibp = to_iport(ibdev, port);
  1590. struct qib_pportdata *ppd = ppd_from_ibp(ibp);
  1591. int ret;
  1592. *out_mad = *in_mad;
  1593. if (smp->class_version != 1) {
  1594. smp->status |= IB_SMP_UNSUP_VERSION;
  1595. ret = reply(smp);
  1596. goto bail;
  1597. }
  1598. ret = check_mkey(ibp, smp, mad_flags);
  1599. if (ret) {
  1600. u32 port_num = be32_to_cpu(smp->attr_mod);
  1601. /*
  1602. * If this is a get/set portinfo, we already check the
  1603. * M_Key if the MAD is for another port and the M_Key
  1604. * is OK on the receiving port. This check is needed
  1605. * to increment the error counters when the M_Key
  1606. * fails to match on *both* ports.
  1607. */
  1608. if (in_mad->mad_hdr.attr_id == IB_SMP_ATTR_PORT_INFO &&
  1609. (smp->method == IB_MGMT_METHOD_GET ||
  1610. smp->method == IB_MGMT_METHOD_SET) &&
  1611. port_num && port_num <= ibdev->phys_port_cnt &&
  1612. port != port_num)
  1613. (void) check_mkey(to_iport(ibdev, port_num), smp, 0);
  1614. goto bail;
  1615. }
  1616. switch (smp->method) {
  1617. case IB_MGMT_METHOD_GET:
  1618. switch (smp->attr_id) {
  1619. case IB_SMP_ATTR_NODE_DESC:
  1620. ret = subn_get_nodedescription(smp, ibdev);
  1621. goto bail;
  1622. case IB_SMP_ATTR_NODE_INFO:
  1623. ret = subn_get_nodeinfo(smp, ibdev, port);
  1624. goto bail;
  1625. case IB_SMP_ATTR_GUID_INFO:
  1626. ret = subn_get_guidinfo(smp, ibdev, port);
  1627. goto bail;
  1628. case IB_SMP_ATTR_PORT_INFO:
  1629. ret = subn_get_portinfo(smp, ibdev, port);
  1630. goto bail;
  1631. case IB_SMP_ATTR_PKEY_TABLE:
  1632. ret = subn_get_pkeytable(smp, ibdev, port);
  1633. goto bail;
  1634. case IB_SMP_ATTR_SL_TO_VL_TABLE:
  1635. ret = subn_get_sl_to_vl(smp, ibdev, port);
  1636. goto bail;
  1637. case IB_SMP_ATTR_VL_ARB_TABLE:
  1638. ret = subn_get_vl_arb(smp, ibdev, port);
  1639. goto bail;
  1640. case IB_SMP_ATTR_SM_INFO:
  1641. if (ibp->port_cap_flags & IB_PORT_SM_DISABLED) {
  1642. ret = IB_MAD_RESULT_SUCCESS |
  1643. IB_MAD_RESULT_CONSUMED;
  1644. goto bail;
  1645. }
  1646. if (ibp->port_cap_flags & IB_PORT_SM) {
  1647. ret = IB_MAD_RESULT_SUCCESS;
  1648. goto bail;
  1649. }
  1650. /* FALLTHROUGH */
  1651. default:
  1652. smp->status |= IB_SMP_UNSUP_METH_ATTR;
  1653. ret = reply(smp);
  1654. goto bail;
  1655. }
  1656. case IB_MGMT_METHOD_SET:
  1657. switch (smp->attr_id) {
  1658. case IB_SMP_ATTR_GUID_INFO:
  1659. ret = subn_set_guidinfo(smp, ibdev, port);
  1660. goto bail;
  1661. case IB_SMP_ATTR_PORT_INFO:
  1662. ret = subn_set_portinfo(smp, ibdev, port);
  1663. goto bail;
  1664. case IB_SMP_ATTR_PKEY_TABLE:
  1665. ret = subn_set_pkeytable(smp, ibdev, port);
  1666. goto bail;
  1667. case IB_SMP_ATTR_SL_TO_VL_TABLE:
  1668. ret = subn_set_sl_to_vl(smp, ibdev, port);
  1669. goto bail;
  1670. case IB_SMP_ATTR_VL_ARB_TABLE:
  1671. ret = subn_set_vl_arb(smp, ibdev, port);
  1672. goto bail;
  1673. case IB_SMP_ATTR_SM_INFO:
  1674. if (ibp->port_cap_flags & IB_PORT_SM_DISABLED) {
  1675. ret = IB_MAD_RESULT_SUCCESS |
  1676. IB_MAD_RESULT_CONSUMED;
  1677. goto bail;
  1678. }
  1679. if (ibp->port_cap_flags & IB_PORT_SM) {
  1680. ret = IB_MAD_RESULT_SUCCESS;
  1681. goto bail;
  1682. }
  1683. /* FALLTHROUGH */
  1684. default:
  1685. smp->status |= IB_SMP_UNSUP_METH_ATTR;
  1686. ret = reply(smp);
  1687. goto bail;
  1688. }
  1689. case IB_MGMT_METHOD_TRAP_REPRESS:
  1690. if (smp->attr_id == IB_SMP_ATTR_NOTICE)
  1691. ret = subn_trap_repress(smp, ibdev, port);
  1692. else {
  1693. smp->status |= IB_SMP_UNSUP_METH_ATTR;
  1694. ret = reply(smp);
  1695. }
  1696. goto bail;
  1697. case IB_MGMT_METHOD_TRAP:
  1698. case IB_MGMT_METHOD_REPORT:
  1699. case IB_MGMT_METHOD_REPORT_RESP:
  1700. case IB_MGMT_METHOD_GET_RESP:
  1701. /*
  1702. * The ib_mad module will call us to process responses
  1703. * before checking for other consumers.
  1704. * Just tell the caller to process it normally.
  1705. */
  1706. ret = IB_MAD_RESULT_SUCCESS;
  1707. goto bail;
  1708. case IB_MGMT_METHOD_SEND:
  1709. if (ib_get_smp_direction(smp) &&
  1710. smp->attr_id == QIB_VENDOR_IPG) {
  1711. ppd->dd->f_set_ib_cfg(ppd, QIB_IB_CFG_PORT,
  1712. smp->data[0]);
  1713. ret = IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED;
  1714. } else
  1715. ret = IB_MAD_RESULT_SUCCESS;
  1716. goto bail;
  1717. default:
  1718. smp->status |= IB_SMP_UNSUP_METHOD;
  1719. ret = reply(smp);
  1720. }
  1721. bail:
  1722. return ret;
  1723. }
  1724. static int process_perf(struct ib_device *ibdev, u8 port,
  1725. struct ib_mad *in_mad,
  1726. struct ib_mad *out_mad)
  1727. {
  1728. struct ib_pma_mad *pmp = (struct ib_pma_mad *)out_mad;
  1729. int ret;
  1730. *out_mad = *in_mad;
  1731. if (pmp->mad_hdr.class_version != 1) {
  1732. pmp->mad_hdr.status |= IB_SMP_UNSUP_VERSION;
  1733. ret = reply((struct ib_smp *) pmp);
  1734. goto bail;
  1735. }
  1736. switch (pmp->mad_hdr.method) {
  1737. case IB_MGMT_METHOD_GET:
  1738. switch (pmp->mad_hdr.attr_id) {
  1739. case IB_PMA_CLASS_PORT_INFO:
  1740. ret = pma_get_classportinfo(pmp, ibdev);
  1741. goto bail;
  1742. case IB_PMA_PORT_SAMPLES_CONTROL:
  1743. ret = pma_get_portsamplescontrol(pmp, ibdev, port);
  1744. goto bail;
  1745. case IB_PMA_PORT_SAMPLES_RESULT:
  1746. ret = pma_get_portsamplesresult(pmp, ibdev, port);
  1747. goto bail;
  1748. case IB_PMA_PORT_SAMPLES_RESULT_EXT:
  1749. ret = pma_get_portsamplesresult_ext(pmp, ibdev, port);
  1750. goto bail;
  1751. case IB_PMA_PORT_COUNTERS:
  1752. ret = pma_get_portcounters(pmp, ibdev, port);
  1753. goto bail;
  1754. case IB_PMA_PORT_COUNTERS_EXT:
  1755. ret = pma_get_portcounters_ext(pmp, ibdev, port);
  1756. goto bail;
  1757. case IB_PMA_PORT_COUNTERS_CONG:
  1758. ret = pma_get_portcounters_cong(pmp, ibdev, port);
  1759. goto bail;
  1760. default:
  1761. pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
  1762. ret = reply((struct ib_smp *) pmp);
  1763. goto bail;
  1764. }
  1765. case IB_MGMT_METHOD_SET:
  1766. switch (pmp->mad_hdr.attr_id) {
  1767. case IB_PMA_PORT_SAMPLES_CONTROL:
  1768. ret = pma_set_portsamplescontrol(pmp, ibdev, port);
  1769. goto bail;
  1770. case IB_PMA_PORT_COUNTERS:
  1771. ret = pma_set_portcounters(pmp, ibdev, port);
  1772. goto bail;
  1773. case IB_PMA_PORT_COUNTERS_EXT:
  1774. ret = pma_set_portcounters_ext(pmp, ibdev, port);
  1775. goto bail;
  1776. case IB_PMA_PORT_COUNTERS_CONG:
  1777. ret = pma_set_portcounters_cong(pmp, ibdev, port);
  1778. goto bail;
  1779. default:
  1780. pmp->mad_hdr.status |= IB_SMP_UNSUP_METH_ATTR;
  1781. ret = reply((struct ib_smp *) pmp);
  1782. goto bail;
  1783. }
  1784. case IB_MGMT_METHOD_TRAP:
  1785. case IB_MGMT_METHOD_GET_RESP:
  1786. /*
  1787. * The ib_mad module will call us to process responses
  1788. * before checking for other consumers.
  1789. * Just tell the caller to process it normally.
  1790. */
  1791. ret = IB_MAD_RESULT_SUCCESS;
  1792. goto bail;
  1793. default:
  1794. pmp->mad_hdr.status |= IB_SMP_UNSUP_METHOD;
  1795. ret = reply((struct ib_smp *) pmp);
  1796. }
  1797. bail:
  1798. return ret;
  1799. }
  1800. /**
  1801. * qib_process_mad - process an incoming MAD packet
  1802. * @ibdev: the infiniband device this packet came in on
  1803. * @mad_flags: MAD flags
  1804. * @port: the port number this packet came in on
  1805. * @in_wc: the work completion entry for this packet
  1806. * @in_grh: the global route header for this packet
  1807. * @in_mad: the incoming MAD
  1808. * @out_mad: any outgoing MAD reply
  1809. *
  1810. * Returns IB_MAD_RESULT_SUCCESS if this is a MAD that we are not
  1811. * interested in processing.
  1812. *
  1813. * Note that the verbs framework has already done the MAD sanity checks,
  1814. * and hop count/pointer updating for IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE
  1815. * MADs.
  1816. *
  1817. * This is called by the ib_mad module.
  1818. */
  1819. int qib_process_mad(struct ib_device *ibdev, int mad_flags, u8 port,
  1820. struct ib_wc *in_wc, struct ib_grh *in_grh,
  1821. struct ib_mad *in_mad, struct ib_mad *out_mad)
  1822. {
  1823. int ret;
  1824. switch (in_mad->mad_hdr.mgmt_class) {
  1825. case IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE:
  1826. case IB_MGMT_CLASS_SUBN_LID_ROUTED:
  1827. ret = process_subn(ibdev, mad_flags, port, in_mad, out_mad);
  1828. goto bail;
  1829. case IB_MGMT_CLASS_PERF_MGMT:
  1830. ret = process_perf(ibdev, port, in_mad, out_mad);
  1831. goto bail;
  1832. default:
  1833. ret = IB_MAD_RESULT_SUCCESS;
  1834. }
  1835. bail:
  1836. return ret;
  1837. }
  1838. static void send_handler(struct ib_mad_agent *agent,
  1839. struct ib_mad_send_wc *mad_send_wc)
  1840. {
  1841. ib_free_send_mad(mad_send_wc->send_buf);
  1842. }
  1843. static void xmit_wait_timer_func(unsigned long opaque)
  1844. {
  1845. struct qib_pportdata *ppd = (struct qib_pportdata *)opaque;
  1846. struct qib_devdata *dd = dd_from_ppd(ppd);
  1847. unsigned long flags;
  1848. u8 status;
  1849. spin_lock_irqsave(&ppd->ibport_data.lock, flags);
  1850. if (ppd->cong_stats.flags == IB_PMA_CONG_HW_CONTROL_SAMPLE) {
  1851. status = dd->f_portcntr(ppd, QIBPORTCNTR_PSSTAT);
  1852. if (status == IB_PMA_SAMPLE_STATUS_DONE) {
  1853. /* save counter cache */
  1854. cache_hw_sample_counters(ppd);
  1855. ppd->cong_stats.flags = IB_PMA_CONG_HW_CONTROL_TIMER;
  1856. } else
  1857. goto done;
  1858. }
  1859. ppd->cong_stats.counter = xmit_wait_get_value_delta(ppd);
  1860. dd->f_set_cntr_sample(ppd, QIB_CONG_TIMER_PSINTERVAL, 0x0);
  1861. done:
  1862. spin_unlock_irqrestore(&ppd->ibport_data.lock, flags);
  1863. mod_timer(&ppd->cong_stats.timer, jiffies + HZ);
  1864. }
  1865. int qib_create_agents(struct qib_ibdev *dev)
  1866. {
  1867. struct qib_devdata *dd = dd_from_dev(dev);
  1868. struct ib_mad_agent *agent;
  1869. struct qib_ibport *ibp;
  1870. int p;
  1871. int ret;
  1872. for (p = 0; p < dd->num_pports; p++) {
  1873. ibp = &dd->pport[p].ibport_data;
  1874. agent = ib_register_mad_agent(&dev->ibdev, p + 1, IB_QPT_SMI,
  1875. NULL, 0, send_handler,
  1876. NULL, NULL);
  1877. if (IS_ERR(agent)) {
  1878. ret = PTR_ERR(agent);
  1879. goto err;
  1880. }
  1881. /* Initialize xmit_wait structure */
  1882. dd->pport[p].cong_stats.counter = 0;
  1883. init_timer(&dd->pport[p].cong_stats.timer);
  1884. dd->pport[p].cong_stats.timer.function = xmit_wait_timer_func;
  1885. dd->pport[p].cong_stats.timer.data =
  1886. (unsigned long)(&dd->pport[p]);
  1887. dd->pport[p].cong_stats.timer.expires = 0;
  1888. add_timer(&dd->pport[p].cong_stats.timer);
  1889. ibp->send_agent = agent;
  1890. }
  1891. return 0;
  1892. err:
  1893. for (p = 0; p < dd->num_pports; p++) {
  1894. ibp = &dd->pport[p].ibport_data;
  1895. if (ibp->send_agent) {
  1896. agent = ibp->send_agent;
  1897. ibp->send_agent = NULL;
  1898. ib_unregister_mad_agent(agent);
  1899. }
  1900. }
  1901. return ret;
  1902. }
  1903. void qib_free_agents(struct qib_ibdev *dev)
  1904. {
  1905. struct qib_devdata *dd = dd_from_dev(dev);
  1906. struct ib_mad_agent *agent;
  1907. struct qib_ibport *ibp;
  1908. int p;
  1909. for (p = 0; p < dd->num_pports; p++) {
  1910. ibp = &dd->pport[p].ibport_data;
  1911. if (ibp->send_agent) {
  1912. agent = ibp->send_agent;
  1913. ibp->send_agent = NULL;
  1914. ib_unregister_mad_agent(agent);
  1915. }
  1916. if (ibp->sm_ah) {
  1917. ib_destroy_ah(&ibp->sm_ah->ibah);
  1918. ibp->sm_ah = NULL;
  1919. }
  1920. if (dd->pport[p].cong_stats.timer.data)
  1921. del_timer_sync(&dd->pport[p].cong_stats.timer);
  1922. }
  1923. }