viohs.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* viohs.c: LDOM Virtual I/O handshake helper layer.
  3. *
  4. * Copyright (C) 2007 David S. Miller <[email protected]>
  5. */
  6. #include <linux/kernel.h>
  7. #include <linux/export.h>
  8. #include <linux/string.h>
  9. #include <linux/delay.h>
  10. #include <linux/sched.h>
  11. #include <linux/sched/clock.h>
  12. #include <linux/slab.h>
  13. #include <asm/ldc.h>
  14. #include <asm/vio.h>
  15. int vio_ldc_send(struct vio_driver_state *vio, void *data, int len)
  16. {
  17. int err, limit = 1000;
  18. err = -EINVAL;
  19. while (limit-- > 0) {
  20. err = ldc_write(vio->lp, data, len);
  21. if (!err || (err != -EAGAIN))
  22. break;
  23. udelay(1);
  24. }
  25. return err;
  26. }
  27. EXPORT_SYMBOL(vio_ldc_send);
  28. static int send_ctrl(struct vio_driver_state *vio,
  29. struct vio_msg_tag *tag, int len)
  30. {
  31. tag->sid = vio_send_sid(vio);
  32. return vio_ldc_send(vio, tag, len);
  33. }
  34. static void init_tag(struct vio_msg_tag *tag, u8 type, u8 stype, u16 stype_env)
  35. {
  36. tag->type = type;
  37. tag->stype = stype;
  38. tag->stype_env = stype_env;
  39. }
  40. static int send_version(struct vio_driver_state *vio, u16 major, u16 minor)
  41. {
  42. struct vio_ver_info pkt;
  43. vio->_local_sid = (u32) sched_clock();
  44. memset(&pkt, 0, sizeof(pkt));
  45. init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_VER_INFO);
  46. pkt.major = major;
  47. pkt.minor = minor;
  48. pkt.dev_class = vio->dev_class;
  49. viodbg(HS, "SEND VERSION INFO maj[%u] min[%u] devclass[%u]\n",
  50. major, minor, vio->dev_class);
  51. return send_ctrl(vio, &pkt.tag, sizeof(pkt));
  52. }
  53. static int start_handshake(struct vio_driver_state *vio)
  54. {
  55. int err;
  56. viodbg(HS, "START HANDSHAKE\n");
  57. vio->hs_state = VIO_HS_INVALID;
  58. err = send_version(vio,
  59. vio->ver_table[0].major,
  60. vio->ver_table[0].minor);
  61. if (err < 0)
  62. return err;
  63. return 0;
  64. }
  65. static void flush_rx_dring(struct vio_driver_state *vio)
  66. {
  67. struct vio_dring_state *dr;
  68. u64 ident;
  69. BUG_ON(!(vio->dr_state & VIO_DR_STATE_RXREG));
  70. dr = &vio->drings[VIO_DRIVER_RX_RING];
  71. ident = dr->ident;
  72. BUG_ON(!vio->desc_buf);
  73. kfree(vio->desc_buf);
  74. vio->desc_buf = NULL;
  75. memset(dr, 0, sizeof(*dr));
  76. dr->ident = ident;
  77. }
  78. void vio_link_state_change(struct vio_driver_state *vio, int event)
  79. {
  80. if (event == LDC_EVENT_UP) {
  81. vio->hs_state = VIO_HS_INVALID;
  82. switch (vio->dev_class) {
  83. case VDEV_NETWORK:
  84. case VDEV_NETWORK_SWITCH:
  85. vio->dr_state = (VIO_DR_STATE_TXREQ |
  86. VIO_DR_STATE_RXREQ);
  87. break;
  88. case VDEV_DISK:
  89. vio->dr_state = VIO_DR_STATE_TXREQ;
  90. break;
  91. case VDEV_DISK_SERVER:
  92. vio->dr_state = VIO_DR_STATE_RXREQ;
  93. break;
  94. }
  95. start_handshake(vio);
  96. } else if (event == LDC_EVENT_RESET) {
  97. vio->hs_state = VIO_HS_INVALID;
  98. if (vio->dr_state & VIO_DR_STATE_RXREG)
  99. flush_rx_dring(vio);
  100. vio->dr_state = 0x00;
  101. memset(&vio->ver, 0, sizeof(vio->ver));
  102. ldc_disconnect(vio->lp);
  103. }
  104. }
  105. EXPORT_SYMBOL(vio_link_state_change);
  106. static int handshake_failure(struct vio_driver_state *vio)
  107. {
  108. struct vio_dring_state *dr;
  109. /* XXX Put policy here... Perhaps start a timer to fire
  110. * XXX in 100 ms, which will bring the link up and retry
  111. * XXX the handshake.
  112. */
  113. viodbg(HS, "HANDSHAKE FAILURE\n");
  114. vio->dr_state &= ~(VIO_DR_STATE_TXREG |
  115. VIO_DR_STATE_RXREG);
  116. dr = &vio->drings[VIO_DRIVER_RX_RING];
  117. memset(dr, 0, sizeof(*dr));
  118. kfree(vio->desc_buf);
  119. vio->desc_buf = NULL;
  120. vio->desc_buf_len = 0;
  121. vio->hs_state = VIO_HS_INVALID;
  122. return -ECONNRESET;
  123. }
  124. static int process_unknown(struct vio_driver_state *vio, void *arg)
  125. {
  126. struct vio_msg_tag *pkt = arg;
  127. viodbg(HS, "UNKNOWN CONTROL [%02x:%02x:%04x:%08x]\n",
  128. pkt->type, pkt->stype, pkt->stype_env, pkt->sid);
  129. printk(KERN_ERR "vio: ID[%lu] Resetting connection.\n",
  130. vio->vdev->channel_id);
  131. ldc_disconnect(vio->lp);
  132. return -ECONNRESET;
  133. }
  134. static int send_dreg(struct vio_driver_state *vio)
  135. {
  136. struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_TX_RING];
  137. union {
  138. struct vio_dring_register pkt;
  139. char all[sizeof(struct vio_dring_register) +
  140. (sizeof(struct ldc_trans_cookie) *
  141. VIO_MAX_RING_COOKIES)];
  142. } u;
  143. size_t bytes = sizeof(struct vio_dring_register) +
  144. (sizeof(struct ldc_trans_cookie) *
  145. dr->ncookies);
  146. int i;
  147. if (WARN_ON(bytes > sizeof(u)))
  148. return -EINVAL;
  149. memset(&u, 0, bytes);
  150. init_tag(&u.pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_DRING_REG);
  151. u.pkt.dring_ident = 0;
  152. u.pkt.num_descr = dr->num_entries;
  153. u.pkt.descr_size = dr->entry_size;
  154. u.pkt.options = VIO_TX_DRING;
  155. u.pkt.num_cookies = dr->ncookies;
  156. viodbg(HS, "SEND DRING_REG INFO ndesc[%u] dsz[%u] opt[0x%x] "
  157. "ncookies[%u]\n",
  158. u.pkt.num_descr, u.pkt.descr_size, u.pkt.options,
  159. u.pkt.num_cookies);
  160. for (i = 0; i < dr->ncookies; i++) {
  161. u.pkt.cookies[i] = dr->cookies[i];
  162. viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
  163. i,
  164. (unsigned long long) u.pkt.cookies[i].cookie_addr,
  165. (unsigned long long) u.pkt.cookies[i].cookie_size);
  166. }
  167. return send_ctrl(vio, &u.pkt.tag, bytes);
  168. }
  169. static int send_rdx(struct vio_driver_state *vio)
  170. {
  171. struct vio_rdx pkt;
  172. memset(&pkt, 0, sizeof(pkt));
  173. init_tag(&pkt.tag, VIO_TYPE_CTRL, VIO_SUBTYPE_INFO, VIO_RDX);
  174. viodbg(HS, "SEND RDX INFO\n");
  175. return send_ctrl(vio, &pkt.tag, sizeof(pkt));
  176. }
  177. static int send_attr(struct vio_driver_state *vio)
  178. {
  179. if (!vio->ops)
  180. return -EINVAL;
  181. return vio->ops->send_attr(vio);
  182. }
  183. static struct vio_version *find_by_major(struct vio_driver_state *vio,
  184. u16 major)
  185. {
  186. struct vio_version *ret = NULL;
  187. int i;
  188. for (i = 0; i < vio->ver_table_entries; i++) {
  189. struct vio_version *v = &vio->ver_table[i];
  190. if (v->major <= major) {
  191. ret = v;
  192. break;
  193. }
  194. }
  195. return ret;
  196. }
  197. static int process_ver_info(struct vio_driver_state *vio,
  198. struct vio_ver_info *pkt)
  199. {
  200. struct vio_version *vap;
  201. int err;
  202. viodbg(HS, "GOT VERSION INFO maj[%u] min[%u] devclass[%u]\n",
  203. pkt->major, pkt->minor, pkt->dev_class);
  204. if (vio->hs_state != VIO_HS_INVALID) {
  205. /* XXX Perhaps invoke start_handshake? XXX */
  206. memset(&vio->ver, 0, sizeof(vio->ver));
  207. vio->hs_state = VIO_HS_INVALID;
  208. }
  209. vap = find_by_major(vio, pkt->major);
  210. vio->_peer_sid = pkt->tag.sid;
  211. if (!vap) {
  212. pkt->tag.stype = VIO_SUBTYPE_NACK;
  213. pkt->major = 0;
  214. pkt->minor = 0;
  215. viodbg(HS, "SEND VERSION NACK maj[0] min[0]\n");
  216. err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
  217. } else if (vap->major != pkt->major) {
  218. pkt->tag.stype = VIO_SUBTYPE_NACK;
  219. pkt->major = vap->major;
  220. pkt->minor = vap->minor;
  221. viodbg(HS, "SEND VERSION NACK maj[%u] min[%u]\n",
  222. pkt->major, pkt->minor);
  223. err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
  224. } else {
  225. struct vio_version ver = {
  226. .major = pkt->major,
  227. .minor = pkt->minor,
  228. };
  229. if (ver.minor > vap->minor)
  230. ver.minor = vap->minor;
  231. pkt->minor = ver.minor;
  232. pkt->tag.stype = VIO_SUBTYPE_ACK;
  233. pkt->dev_class = vio->dev_class;
  234. viodbg(HS, "SEND VERSION ACK maj[%u] min[%u]\n",
  235. pkt->major, pkt->minor);
  236. err = send_ctrl(vio, &pkt->tag, sizeof(*pkt));
  237. if (err > 0) {
  238. vio->ver = ver;
  239. vio->hs_state = VIO_HS_GOTVERS;
  240. }
  241. }
  242. if (err < 0)
  243. return handshake_failure(vio);
  244. return 0;
  245. }
  246. static int process_ver_ack(struct vio_driver_state *vio,
  247. struct vio_ver_info *pkt)
  248. {
  249. viodbg(HS, "GOT VERSION ACK maj[%u] min[%u] devclass[%u]\n",
  250. pkt->major, pkt->minor, pkt->dev_class);
  251. if (vio->hs_state & VIO_HS_GOTVERS) {
  252. if (vio->ver.major != pkt->major ||
  253. vio->ver.minor != pkt->minor) {
  254. pkt->tag.stype = VIO_SUBTYPE_NACK;
  255. (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
  256. return handshake_failure(vio);
  257. }
  258. } else {
  259. vio->ver.major = pkt->major;
  260. vio->ver.minor = pkt->minor;
  261. vio->hs_state = VIO_HS_GOTVERS;
  262. }
  263. switch (vio->dev_class) {
  264. case VDEV_NETWORK:
  265. case VDEV_DISK:
  266. if (send_attr(vio) < 0)
  267. return handshake_failure(vio);
  268. break;
  269. default:
  270. break;
  271. }
  272. return 0;
  273. }
  274. static int process_ver_nack(struct vio_driver_state *vio,
  275. struct vio_ver_info *pkt)
  276. {
  277. struct vio_version *nver;
  278. viodbg(HS, "GOT VERSION NACK maj[%u] min[%u] devclass[%u]\n",
  279. pkt->major, pkt->minor, pkt->dev_class);
  280. if (pkt->major == 0 && pkt->minor == 0)
  281. return handshake_failure(vio);
  282. nver = find_by_major(vio, pkt->major);
  283. if (!nver)
  284. return handshake_failure(vio);
  285. if (send_version(vio, nver->major, nver->minor) < 0)
  286. return handshake_failure(vio);
  287. return 0;
  288. }
  289. static int process_ver(struct vio_driver_state *vio, struct vio_ver_info *pkt)
  290. {
  291. switch (pkt->tag.stype) {
  292. case VIO_SUBTYPE_INFO:
  293. return process_ver_info(vio, pkt);
  294. case VIO_SUBTYPE_ACK:
  295. return process_ver_ack(vio, pkt);
  296. case VIO_SUBTYPE_NACK:
  297. return process_ver_nack(vio, pkt);
  298. default:
  299. return handshake_failure(vio);
  300. }
  301. }
  302. static int process_attr(struct vio_driver_state *vio, void *pkt)
  303. {
  304. int err;
  305. if (!(vio->hs_state & VIO_HS_GOTVERS))
  306. return handshake_failure(vio);
  307. if (!vio->ops)
  308. return 0;
  309. err = vio->ops->handle_attr(vio, pkt);
  310. if (err < 0) {
  311. return handshake_failure(vio);
  312. } else {
  313. vio->hs_state |= VIO_HS_GOT_ATTR;
  314. if ((vio->dr_state & VIO_DR_STATE_TXREQ) &&
  315. !(vio->hs_state & VIO_HS_SENT_DREG)) {
  316. if (send_dreg(vio) < 0)
  317. return handshake_failure(vio);
  318. vio->hs_state |= VIO_HS_SENT_DREG;
  319. }
  320. }
  321. return 0;
  322. }
  323. static int all_drings_registered(struct vio_driver_state *vio)
  324. {
  325. int need_rx, need_tx;
  326. need_rx = (vio->dr_state & VIO_DR_STATE_RXREQ);
  327. need_tx = (vio->dr_state & VIO_DR_STATE_TXREQ);
  328. if (need_rx &&
  329. !(vio->dr_state & VIO_DR_STATE_RXREG))
  330. return 0;
  331. if (need_tx &&
  332. !(vio->dr_state & VIO_DR_STATE_TXREG))
  333. return 0;
  334. return 1;
  335. }
  336. static int process_dreg_info(struct vio_driver_state *vio,
  337. struct vio_dring_register *pkt)
  338. {
  339. struct vio_dring_state *dr;
  340. int i;
  341. viodbg(HS, "GOT DRING_REG INFO ident[%llx] "
  342. "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
  343. (unsigned long long) pkt->dring_ident,
  344. pkt->num_descr, pkt->descr_size, pkt->options,
  345. pkt->num_cookies);
  346. if (!(vio->dr_state & VIO_DR_STATE_RXREQ))
  347. goto send_nack;
  348. if (vio->dr_state & VIO_DR_STATE_RXREG)
  349. goto send_nack;
  350. /* v1.6 and higher, ACK with desired, supported mode, or NACK */
  351. if (vio_version_after_eq(vio, 1, 6)) {
  352. if (!(pkt->options & VIO_TX_DRING))
  353. goto send_nack;
  354. pkt->options = VIO_TX_DRING;
  355. }
  356. BUG_ON(vio->desc_buf);
  357. vio->desc_buf = kzalloc(pkt->descr_size, GFP_ATOMIC);
  358. if (!vio->desc_buf)
  359. goto send_nack;
  360. vio->desc_buf_len = pkt->descr_size;
  361. dr = &vio->drings[VIO_DRIVER_RX_RING];
  362. dr->num_entries = pkt->num_descr;
  363. dr->entry_size = pkt->descr_size;
  364. dr->ncookies = pkt->num_cookies;
  365. for (i = 0; i < dr->ncookies; i++) {
  366. dr->cookies[i] = pkt->cookies[i];
  367. viodbg(HS, "DRING COOKIE(%d) [%016llx:%016llx]\n",
  368. i,
  369. (unsigned long long)
  370. pkt->cookies[i].cookie_addr,
  371. (unsigned long long)
  372. pkt->cookies[i].cookie_size);
  373. }
  374. pkt->tag.stype = VIO_SUBTYPE_ACK;
  375. pkt->dring_ident = ++dr->ident;
  376. viodbg(HS, "SEND DRING_REG ACK ident[%llx] "
  377. "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
  378. (unsigned long long) pkt->dring_ident,
  379. pkt->num_descr, pkt->descr_size, pkt->options,
  380. pkt->num_cookies);
  381. if (send_ctrl(vio, &pkt->tag, struct_size(pkt, cookies, dr->ncookies)) < 0)
  382. goto send_nack;
  383. vio->dr_state |= VIO_DR_STATE_RXREG;
  384. return 0;
  385. send_nack:
  386. pkt->tag.stype = VIO_SUBTYPE_NACK;
  387. viodbg(HS, "SEND DRING_REG NACK\n");
  388. (void) send_ctrl(vio, &pkt->tag, sizeof(*pkt));
  389. return handshake_failure(vio);
  390. }
  391. static int process_dreg_ack(struct vio_driver_state *vio,
  392. struct vio_dring_register *pkt)
  393. {
  394. struct vio_dring_state *dr;
  395. viodbg(HS, "GOT DRING_REG ACK ident[%llx] "
  396. "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
  397. (unsigned long long) pkt->dring_ident,
  398. pkt->num_descr, pkt->descr_size, pkt->options,
  399. pkt->num_cookies);
  400. dr = &vio->drings[VIO_DRIVER_TX_RING];
  401. if (!(vio->dr_state & VIO_DR_STATE_TXREQ))
  402. return handshake_failure(vio);
  403. dr->ident = pkt->dring_ident;
  404. vio->dr_state |= VIO_DR_STATE_TXREG;
  405. if (all_drings_registered(vio)) {
  406. if (send_rdx(vio) < 0)
  407. return handshake_failure(vio);
  408. vio->hs_state = VIO_HS_SENT_RDX;
  409. }
  410. return 0;
  411. }
  412. static int process_dreg_nack(struct vio_driver_state *vio,
  413. struct vio_dring_register *pkt)
  414. {
  415. viodbg(HS, "GOT DRING_REG NACK ident[%llx] "
  416. "ndesc[%u] dsz[%u] opt[0x%x] ncookies[%u]\n",
  417. (unsigned long long) pkt->dring_ident,
  418. pkt->num_descr, pkt->descr_size, pkt->options,
  419. pkt->num_cookies);
  420. return handshake_failure(vio);
  421. }
  422. static int process_dreg(struct vio_driver_state *vio,
  423. struct vio_dring_register *pkt)
  424. {
  425. if (!(vio->hs_state & VIO_HS_GOTVERS))
  426. return handshake_failure(vio);
  427. switch (pkt->tag.stype) {
  428. case VIO_SUBTYPE_INFO:
  429. return process_dreg_info(vio, pkt);
  430. case VIO_SUBTYPE_ACK:
  431. return process_dreg_ack(vio, pkt);
  432. case VIO_SUBTYPE_NACK:
  433. return process_dreg_nack(vio, pkt);
  434. default:
  435. return handshake_failure(vio);
  436. }
  437. }
  438. static int process_dunreg(struct vio_driver_state *vio,
  439. struct vio_dring_unregister *pkt)
  440. {
  441. struct vio_dring_state *dr = &vio->drings[VIO_DRIVER_RX_RING];
  442. viodbg(HS, "GOT DRING_UNREG\n");
  443. if (pkt->dring_ident != dr->ident)
  444. return 0;
  445. vio->dr_state &= ~VIO_DR_STATE_RXREG;
  446. memset(dr, 0, sizeof(*dr));
  447. kfree(vio->desc_buf);
  448. vio->desc_buf = NULL;
  449. vio->desc_buf_len = 0;
  450. return 0;
  451. }
  452. static int process_rdx_info(struct vio_driver_state *vio, struct vio_rdx *pkt)
  453. {
  454. viodbg(HS, "GOT RDX INFO\n");
  455. pkt->tag.stype = VIO_SUBTYPE_ACK;
  456. viodbg(HS, "SEND RDX ACK\n");
  457. if (send_ctrl(vio, &pkt->tag, sizeof(*pkt)) < 0)
  458. return handshake_failure(vio);
  459. vio->hs_state |= VIO_HS_SENT_RDX_ACK;
  460. return 0;
  461. }
  462. static int process_rdx_ack(struct vio_driver_state *vio, struct vio_rdx *pkt)
  463. {
  464. viodbg(HS, "GOT RDX ACK\n");
  465. if (!(vio->hs_state & VIO_HS_SENT_RDX))
  466. return handshake_failure(vio);
  467. vio->hs_state |= VIO_HS_GOT_RDX_ACK;
  468. return 0;
  469. }
  470. static int process_rdx_nack(struct vio_driver_state *vio, struct vio_rdx *pkt)
  471. {
  472. viodbg(HS, "GOT RDX NACK\n");
  473. return handshake_failure(vio);
  474. }
  475. static int process_rdx(struct vio_driver_state *vio, struct vio_rdx *pkt)
  476. {
  477. if (!all_drings_registered(vio))
  478. handshake_failure(vio);
  479. switch (pkt->tag.stype) {
  480. case VIO_SUBTYPE_INFO:
  481. return process_rdx_info(vio, pkt);
  482. case VIO_SUBTYPE_ACK:
  483. return process_rdx_ack(vio, pkt);
  484. case VIO_SUBTYPE_NACK:
  485. return process_rdx_nack(vio, pkt);
  486. default:
  487. return handshake_failure(vio);
  488. }
  489. }
  490. int vio_control_pkt_engine(struct vio_driver_state *vio, void *pkt)
  491. {
  492. struct vio_msg_tag *tag = pkt;
  493. u8 prev_state = vio->hs_state;
  494. int err;
  495. switch (tag->stype_env) {
  496. case VIO_VER_INFO:
  497. err = process_ver(vio, pkt);
  498. break;
  499. case VIO_ATTR_INFO:
  500. err = process_attr(vio, pkt);
  501. break;
  502. case VIO_DRING_REG:
  503. err = process_dreg(vio, pkt);
  504. break;
  505. case VIO_DRING_UNREG:
  506. err = process_dunreg(vio, pkt);
  507. break;
  508. case VIO_RDX:
  509. err = process_rdx(vio, pkt);
  510. break;
  511. default:
  512. err = process_unknown(vio, pkt);
  513. break;
  514. }
  515. if (!err &&
  516. vio->hs_state != prev_state &&
  517. (vio->hs_state & VIO_HS_COMPLETE)) {
  518. if (vio->ops)
  519. vio->ops->handshake_complete(vio);
  520. }
  521. return err;
  522. }
  523. EXPORT_SYMBOL(vio_control_pkt_engine);
  524. void vio_conn_reset(struct vio_driver_state *vio)
  525. {
  526. }
  527. EXPORT_SYMBOL(vio_conn_reset);
  528. /* The issue is that the Solaris virtual disk server just mirrors the
  529. * SID values it gets from the client peer. So we work around that
  530. * here in vio_{validate,send}_sid() so that the drivers don't need
  531. * to be aware of this crap.
  532. */
  533. int vio_validate_sid(struct vio_driver_state *vio, struct vio_msg_tag *tp)
  534. {
  535. u32 sid;
  536. /* Always let VERSION+INFO packets through unchecked, they
  537. * define the new SID.
  538. */
  539. if (tp->type == VIO_TYPE_CTRL &&
  540. tp->stype == VIO_SUBTYPE_INFO &&
  541. tp->stype_env == VIO_VER_INFO)
  542. return 0;
  543. /* Ok, now figure out which SID to use. */
  544. switch (vio->dev_class) {
  545. case VDEV_NETWORK:
  546. case VDEV_NETWORK_SWITCH:
  547. case VDEV_DISK_SERVER:
  548. default:
  549. sid = vio->_peer_sid;
  550. break;
  551. case VDEV_DISK:
  552. sid = vio->_local_sid;
  553. break;
  554. }
  555. if (sid == tp->sid)
  556. return 0;
  557. viodbg(DATA, "BAD SID tag->sid[%08x] peer_sid[%08x] local_sid[%08x]\n",
  558. tp->sid, vio->_peer_sid, vio->_local_sid);
  559. return -EINVAL;
  560. }
  561. EXPORT_SYMBOL(vio_validate_sid);
  562. u32 vio_send_sid(struct vio_driver_state *vio)
  563. {
  564. switch (vio->dev_class) {
  565. case VDEV_NETWORK:
  566. case VDEV_NETWORK_SWITCH:
  567. case VDEV_DISK:
  568. default:
  569. return vio->_local_sid;
  570. case VDEV_DISK_SERVER:
  571. return vio->_peer_sid;
  572. }
  573. }
  574. EXPORT_SYMBOL(vio_send_sid);
  575. int vio_ldc_alloc(struct vio_driver_state *vio,
  576. struct ldc_channel_config *base_cfg,
  577. void *event_arg)
  578. {
  579. struct ldc_channel_config cfg = *base_cfg;
  580. struct ldc_channel *lp;
  581. cfg.tx_irq = vio->vdev->tx_irq;
  582. cfg.rx_irq = vio->vdev->rx_irq;
  583. lp = ldc_alloc(vio->vdev->channel_id, &cfg, event_arg, vio->name);
  584. if (IS_ERR(lp))
  585. return PTR_ERR(lp);
  586. vio->lp = lp;
  587. return 0;
  588. }
  589. EXPORT_SYMBOL(vio_ldc_alloc);
  590. void vio_ldc_free(struct vio_driver_state *vio)
  591. {
  592. ldc_free(vio->lp);
  593. vio->lp = NULL;
  594. kfree(vio->desc_buf);
  595. vio->desc_buf = NULL;
  596. vio->desc_buf_len = 0;
  597. }
  598. EXPORT_SYMBOL(vio_ldc_free);
  599. void vio_port_up(struct vio_driver_state *vio)
  600. {
  601. unsigned long flags;
  602. int err, state;
  603. spin_lock_irqsave(&vio->lock, flags);
  604. state = ldc_state(vio->lp);
  605. err = 0;
  606. if (state == LDC_STATE_INIT) {
  607. err = ldc_bind(vio->lp);
  608. if (err)
  609. printk(KERN_WARNING "%s: Port %lu bind failed, "
  610. "err=%d\n",
  611. vio->name, vio->vdev->channel_id, err);
  612. }
  613. if (!err) {
  614. if (ldc_mode(vio->lp) == LDC_MODE_RAW)
  615. ldc_set_state(vio->lp, LDC_STATE_CONNECTED);
  616. else
  617. err = ldc_connect(vio->lp);
  618. if (err)
  619. printk(KERN_WARNING "%s: Port %lu connect failed, "
  620. "err=%d\n",
  621. vio->name, vio->vdev->channel_id, err);
  622. }
  623. if (err) {
  624. unsigned long expires = jiffies + HZ;
  625. expires = round_jiffies(expires);
  626. mod_timer(&vio->timer, expires);
  627. }
  628. spin_unlock_irqrestore(&vio->lock, flags);
  629. }
  630. EXPORT_SYMBOL(vio_port_up);
  631. static void vio_port_timer(struct timer_list *t)
  632. {
  633. struct vio_driver_state *vio = from_timer(vio, t, timer);
  634. vio_port_up(vio);
  635. }
  636. int vio_driver_init(struct vio_driver_state *vio, struct vio_dev *vdev,
  637. u8 dev_class, struct vio_version *ver_table,
  638. int ver_table_size, struct vio_driver_ops *ops,
  639. char *name)
  640. {
  641. switch (dev_class) {
  642. case VDEV_NETWORK:
  643. case VDEV_NETWORK_SWITCH:
  644. case VDEV_DISK:
  645. case VDEV_DISK_SERVER:
  646. case VDEV_CONSOLE_CON:
  647. break;
  648. default:
  649. return -EINVAL;
  650. }
  651. if (dev_class == VDEV_NETWORK ||
  652. dev_class == VDEV_NETWORK_SWITCH ||
  653. dev_class == VDEV_DISK ||
  654. dev_class == VDEV_DISK_SERVER) {
  655. if (!ops || !ops->send_attr || !ops->handle_attr ||
  656. !ops->handshake_complete)
  657. return -EINVAL;
  658. }
  659. if (!ver_table || ver_table_size < 0)
  660. return -EINVAL;
  661. if (!name)
  662. return -EINVAL;
  663. spin_lock_init(&vio->lock);
  664. vio->name = name;
  665. vio->dev_class = dev_class;
  666. vio->vdev = vdev;
  667. vio->ver_table = ver_table;
  668. vio->ver_table_entries = ver_table_size;
  669. vio->ops = ops;
  670. timer_setup(&vio->timer, vio_port_timer, 0);
  671. return 0;
  672. }
  673. EXPORT_SYMBOL(vio_driver_init);