spapr_llan.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886
  1. /*
  2. * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
  3. *
  4. * PAPR Inter-VM Logical Lan, aka ibmveth
  5. *
  6. * Copyright (c) 2010,2011 David Gibson, IBM Corporation.
  7. *
  8. * Permission is hereby granted, free of charge, to any person obtaining a copy
  9. * of this software and associated documentation files (the "Software"), to deal
  10. * in the Software without restriction, including without limitation the rights
  11. * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12. * copies of the Software, and to permit persons to whom the Software is
  13. * furnished to do so, subject to the following conditions:
  14. *
  15. * The above copyright notice and this permission notice shall be included in
  16. * all copies or substantial portions of the Software.
  17. *
  18. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23. * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24. * THE SOFTWARE.
  25. *
  26. */
  27. #include "qemu/osdep.h"
  28. #include "cpu.h"
  29. #include "qemu/log.h"
  30. #include "qemu/module.h"
  31. #include "net/net.h"
  32. #include "migration/vmstate.h"
  33. #include "hw/ppc/spapr.h"
  34. #include "hw/ppc/spapr_vio.h"
  35. #include "hw/qdev-properties.h"
  36. #include "sysemu/sysemu.h"
  37. #include "trace.h"
  38. #include <libfdt.h>
  39. #include "qom/object.h"
  40. #define ETH_ALEN 6
  41. #define MAX_PACKET_SIZE 65536
  42. /* Compatibility flags for migration */
  43. #define SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT 0
  44. #define SPAPRVLAN_FLAG_RX_BUF_POOLS (1 << SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT)
  45. /*
  46. * Virtual LAN device
  47. */
  48. typedef uint64_t vlan_bd_t;
  49. #define VLAN_BD_VALID 0x8000000000000000ULL
  50. #define VLAN_BD_TOGGLE 0x4000000000000000ULL
  51. #define VLAN_BD_NO_CSUM 0x0200000000000000ULL
  52. #define VLAN_BD_CSUM_GOOD 0x0100000000000000ULL
  53. #define VLAN_BD_LEN_MASK 0x00ffffff00000000ULL
  54. #define VLAN_BD_LEN(bd) (((bd) & VLAN_BD_LEN_MASK) >> 32)
  55. #define VLAN_BD_ADDR_MASK 0x00000000ffffffffULL
  56. #define VLAN_BD_ADDR(bd) ((bd) & VLAN_BD_ADDR_MASK)
  57. #define VLAN_VALID_BD(addr, len) (VLAN_BD_VALID | \
  58. (((len) << 32) & VLAN_BD_LEN_MASK) | \
  59. (addr & VLAN_BD_ADDR_MASK))
  60. #define VLAN_RXQC_TOGGLE 0x80
  61. #define VLAN_RXQC_VALID 0x40
  62. #define VLAN_RXQC_NO_CSUM 0x02
  63. #define VLAN_RXQC_CSUM_GOOD 0x01
  64. #define VLAN_RQ_ALIGNMENT 16
  65. #define VLAN_RXQ_BD_OFF 0
  66. #define VLAN_FILTER_BD_OFF 8
  67. #define VLAN_RX_BDS_OFF 16
  68. /*
  69. * The final 8 bytes of the buffer list is a counter of frames dropped
  70. * because there was not a buffer in the buffer list capable of holding
  71. * the frame. We must avoid it, or the operating system will report garbage
  72. * for this statistic.
  73. */
  74. #define VLAN_RX_BDS_LEN (SPAPR_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF - 8)
  75. #define VLAN_MAX_BUFS (VLAN_RX_BDS_LEN / 8)
  76. #define TYPE_VIO_SPAPR_VLAN_DEVICE "spapr-vlan"
  77. OBJECT_DECLARE_SIMPLE_TYPE(SpaprVioVlan, VIO_SPAPR_VLAN_DEVICE)
  78. #define RX_POOL_MAX_BDS 4096
  79. #define RX_MAX_POOLS 5
  80. typedef struct {
  81. int32_t bufsize;
  82. int32_t count;
  83. vlan_bd_t bds[RX_POOL_MAX_BDS];
  84. } RxBufPool;
  85. struct SpaprVioVlan {
  86. SpaprVioDevice sdev;
  87. NICConf nicconf;
  88. NICState *nic;
  89. MACAddr perm_mac;
  90. bool isopen;
  91. hwaddr buf_list;
  92. uint32_t add_buf_ptr, use_buf_ptr, rx_bufs;
  93. hwaddr rxq_ptr;
  94. QEMUTimer *rxp_timer;
  95. uint32_t compat_flags; /* Compatibility flags for migration */
  96. RxBufPool *rx_pool[RX_MAX_POOLS]; /* Receive buffer descriptor pools */
  97. };
  98. static bool spapr_vlan_can_receive(NetClientState *nc)
  99. {
  100. SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
  101. return dev->isopen && dev->rx_bufs > 0;
  102. }
  103. /**
  104. * The last 8 bytes of the receive buffer list page (that has been
  105. * supplied by the guest with the H_REGISTER_LOGICAL_LAN call) contain
  106. * a counter for frames that have been dropped because there was no
  107. * suitable receive buffer available. This function is used to increase
  108. * this counter by one.
  109. */
  110. static void spapr_vlan_record_dropped_rx_frame(SpaprVioVlan *dev)
  111. {
  112. uint64_t cnt;
  113. cnt = vio_ldq(&dev->sdev, dev->buf_list + 4096 - 8);
  114. vio_stq(&dev->sdev, dev->buf_list + 4096 - 8, cnt + 1);
  115. }
  116. /**
  117. * Get buffer descriptor from one of our receive buffer pools
  118. */
  119. static vlan_bd_t spapr_vlan_get_rx_bd_from_pool(SpaprVioVlan *dev,
  120. size_t size)
  121. {
  122. vlan_bd_t bd;
  123. int pool;
  124. for (pool = 0; pool < RX_MAX_POOLS; pool++) {
  125. if (dev->rx_pool[pool]->count > 0 &&
  126. dev->rx_pool[pool]->bufsize >= size + 8) {
  127. break;
  128. }
  129. }
  130. if (pool == RX_MAX_POOLS) {
  131. /* Failed to find a suitable buffer */
  132. return 0;
  133. }
  134. trace_spapr_vlan_get_rx_bd_from_pool_found(pool,
  135. dev->rx_pool[pool]->count,
  136. dev->rx_bufs);
  137. /* Remove the buffer from the pool */
  138. dev->rx_pool[pool]->count--;
  139. bd = dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count];
  140. dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count] = 0;
  141. return bd;
  142. }
  143. /**
  144. * Get buffer descriptor from the receive buffer list page that has been
  145. * supplied by the guest with the H_REGISTER_LOGICAL_LAN call
  146. */
  147. static vlan_bd_t spapr_vlan_get_rx_bd_from_page(SpaprVioVlan *dev,
  148. size_t size)
  149. {
  150. int buf_ptr = dev->use_buf_ptr;
  151. vlan_bd_t bd;
  152. do {
  153. buf_ptr += 8;
  154. if (buf_ptr >= VLAN_RX_BDS_LEN + VLAN_RX_BDS_OFF) {
  155. buf_ptr = VLAN_RX_BDS_OFF;
  156. }
  157. bd = vio_ldq(&dev->sdev, dev->buf_list + buf_ptr);
  158. trace_spapr_vlan_get_rx_bd_from_page(buf_ptr, (uint64_t)bd);
  159. } while ((!(bd & VLAN_BD_VALID) || VLAN_BD_LEN(bd) < size + 8)
  160. && buf_ptr != dev->use_buf_ptr);
  161. if (!(bd & VLAN_BD_VALID) || VLAN_BD_LEN(bd) < size + 8) {
  162. /* Failed to find a suitable buffer */
  163. return 0;
  164. }
  165. /* Remove the buffer from the pool */
  166. dev->use_buf_ptr = buf_ptr;
  167. vio_stq(&dev->sdev, dev->buf_list + dev->use_buf_ptr, 0);
  168. trace_spapr_vlan_get_rx_bd_from_page_found(dev->use_buf_ptr, dev->rx_bufs);
  169. return bd;
  170. }
  171. static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf,
  172. size_t size)
  173. {
  174. SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
  175. SpaprVioDevice *sdev = VIO_SPAPR_DEVICE(dev);
  176. vlan_bd_t rxq_bd = vio_ldq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF);
  177. vlan_bd_t bd;
  178. uint64_t handle;
  179. uint8_t control;
  180. trace_spapr_vlan_receive(sdev->qdev.id, dev->rx_bufs);
  181. if (!dev->isopen) {
  182. return -1;
  183. }
  184. if (!dev->rx_bufs) {
  185. spapr_vlan_record_dropped_rx_frame(dev);
  186. return 0;
  187. }
  188. if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
  189. bd = spapr_vlan_get_rx_bd_from_pool(dev, size);
  190. } else {
  191. bd = spapr_vlan_get_rx_bd_from_page(dev, size);
  192. }
  193. if (!bd) {
  194. spapr_vlan_record_dropped_rx_frame(dev);
  195. return 0;
  196. }
  197. dev->rx_bufs--;
  198. /* Transfer the packet data */
  199. if (spapr_vio_dma_write(sdev, VLAN_BD_ADDR(bd) + 8, buf, size) < 0) {
  200. return -1;
  201. }
  202. trace_spapr_vlan_receive_dma_completed();
  203. /* Update the receive queue */
  204. control = VLAN_RXQC_TOGGLE | VLAN_RXQC_VALID;
  205. if (rxq_bd & VLAN_BD_TOGGLE) {
  206. control ^= VLAN_RXQC_TOGGLE;
  207. }
  208. handle = vio_ldq(sdev, VLAN_BD_ADDR(bd));
  209. vio_stq(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 8, handle);
  210. vio_stl(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 4, size);
  211. vio_sth(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8);
  212. vio_stb(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr, control);
  213. trace_spapr_vlan_receive_wrote(dev->rxq_ptr,
  214. vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +
  215. dev->rxq_ptr),
  216. vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +
  217. dev->rxq_ptr + 8));
  218. dev->rxq_ptr += 16;
  219. if (dev->rxq_ptr >= VLAN_BD_LEN(rxq_bd)) {
  220. dev->rxq_ptr = 0;
  221. vio_stq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF, rxq_bd ^ VLAN_BD_TOGGLE);
  222. }
  223. if (sdev->signal_state & 1) {
  224. spapr_vio_irq_pulse(sdev);
  225. }
  226. return size;
  227. }
  228. static NetClientInfo net_spapr_vlan_info = {
  229. .type = NET_CLIENT_DRIVER_NIC,
  230. .size = sizeof(NICState),
  231. .can_receive = spapr_vlan_can_receive,
  232. .receive = spapr_vlan_receive,
  233. };
  234. static void spapr_vlan_flush_rx_queue(void *opaque)
  235. {
  236. SpaprVioVlan *dev = opaque;
  237. qemu_flush_queued_packets(qemu_get_queue(dev->nic));
  238. }
  239. static void spapr_vlan_reset_rx_pool(RxBufPool *rxp)
  240. {
  241. /*
  242. * Use INT_MAX as bufsize so that unused buffers are moved to the end
  243. * of the list during the qsort in spapr_vlan_add_rxbuf_to_pool() later.
  244. */
  245. rxp->bufsize = INT_MAX;
  246. rxp->count = 0;
  247. memset(rxp->bds, 0, sizeof(rxp->bds));
  248. }
  249. static void spapr_vlan_reset(SpaprVioDevice *sdev)
  250. {
  251. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  252. int i;
  253. dev->buf_list = 0;
  254. dev->rx_bufs = 0;
  255. dev->isopen = 0;
  256. if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
  257. for (i = 0; i < RX_MAX_POOLS; i++) {
  258. spapr_vlan_reset_rx_pool(dev->rx_pool[i]);
  259. }
  260. }
  261. memcpy(&dev->nicconf.macaddr.a, &dev->perm_mac.a,
  262. sizeof(dev->nicconf.macaddr.a));
  263. qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
  264. }
  265. static void spapr_vlan_realize(SpaprVioDevice *sdev, Error **errp)
  266. {
  267. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  268. qemu_macaddr_default_if_unset(&dev->nicconf.macaddr);
  269. memcpy(&dev->perm_mac.a, &dev->nicconf.macaddr.a, sizeof(dev->perm_mac.a));
  270. dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf,
  271. object_get_typename(OBJECT(sdev)), sdev->qdev.id, dev);
  272. qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
  273. dev->rxp_timer = timer_new_us(QEMU_CLOCK_VIRTUAL, spapr_vlan_flush_rx_queue,
  274. dev);
  275. }
  276. static void spapr_vlan_instance_init(Object *obj)
  277. {
  278. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(obj);
  279. int i;
  280. device_add_bootindex_property(obj, &dev->nicconf.bootindex,
  281. "bootindex", "",
  282. DEVICE(dev));
  283. if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
  284. for (i = 0; i < RX_MAX_POOLS; i++) {
  285. dev->rx_pool[i] = g_new(RxBufPool, 1);
  286. spapr_vlan_reset_rx_pool(dev->rx_pool[i]);
  287. }
  288. }
  289. }
  290. static void spapr_vlan_instance_finalize(Object *obj)
  291. {
  292. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(obj);
  293. int i;
  294. if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
  295. for (i = 0; i < RX_MAX_POOLS; i++) {
  296. g_free(dev->rx_pool[i]);
  297. dev->rx_pool[i] = NULL;
  298. }
  299. }
  300. if (dev->rxp_timer) {
  301. timer_del(dev->rxp_timer);
  302. timer_free(dev->rxp_timer);
  303. }
  304. }
  305. void spapr_vlan_create(SpaprVioBus *bus, NICInfo *nd)
  306. {
  307. DeviceState *dev;
  308. dev = qdev_new("spapr-vlan");
  309. qdev_set_nic_properties(dev, nd);
  310. qdev_realize_and_unref(dev, &bus->bus, &error_fatal);
  311. }
  312. static int spapr_vlan_devnode(SpaprVioDevice *dev, void *fdt, int node_off)
  313. {
  314. SpaprVioVlan *vdev = VIO_SPAPR_VLAN_DEVICE(dev);
  315. uint8_t padded_mac[8] = {0, 0};
  316. int ret;
  317. /* Some old phyp versions give the mac address in an 8-byte
  318. * property. The kernel driver (before 3.10) has an insane workaround;
  319. * rather than doing the obvious thing and checking the property
  320. * length, it checks whether the first byte has 0b10 in the low
  321. * bits. If a correct 6-byte property has a different first byte
  322. * the kernel will get the wrong mac address, overrunning its
  323. * buffer in the process (read only, thank goodness).
  324. *
  325. * Here we return a 6-byte address unless that would break a pre-3.10
  326. * driver. In that case we return a padded 8-byte address to allow the old
  327. * workaround to succeed. */
  328. if ((vdev->nicconf.macaddr.a[0] & 0x3) == 0x2) {
  329. ret = fdt_setprop(fdt, node_off, "local-mac-address",
  330. &vdev->nicconf.macaddr, ETH_ALEN);
  331. } else {
  332. memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);
  333. ret = fdt_setprop(fdt, node_off, "local-mac-address",
  334. padded_mac, sizeof(padded_mac));
  335. }
  336. if (ret < 0) {
  337. return ret;
  338. }
  339. ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0);
  340. if (ret < 0) {
  341. return ret;
  342. }
  343. return 0;
  344. }
  345. static int check_bd(SpaprVioVlan *dev, vlan_bd_t bd,
  346. target_ulong alignment)
  347. {
  348. if ((VLAN_BD_ADDR(bd) % alignment)
  349. || (VLAN_BD_LEN(bd) % alignment)) {
  350. return -1;
  351. }
  352. if (!spapr_vio_dma_valid(&dev->sdev, VLAN_BD_ADDR(bd),
  353. VLAN_BD_LEN(bd), DMA_DIRECTION_FROM_DEVICE)
  354. || !spapr_vio_dma_valid(&dev->sdev, VLAN_BD_ADDR(bd),
  355. VLAN_BD_LEN(bd), DMA_DIRECTION_TO_DEVICE)) {
  356. return -1;
  357. }
  358. return 0;
  359. }
  360. static target_ulong h_register_logical_lan(PowerPCCPU *cpu,
  361. SpaprMachineState *spapr,
  362. target_ulong opcode,
  363. target_ulong *args)
  364. {
  365. target_ulong reg = args[0];
  366. target_ulong buf_list = args[1];
  367. target_ulong rec_queue = args[2];
  368. target_ulong filter_list = args[3];
  369. SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
  370. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  371. vlan_bd_t filter_list_bd;
  372. if (!dev) {
  373. return H_PARAMETER;
  374. }
  375. if (dev->isopen) {
  376. hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
  377. "H_FREE_LOGICAL_LAN\n");
  378. return H_RESOURCE;
  379. }
  380. if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_TCE_PAGE_SIZE),
  381. SPAPR_TCE_PAGE_SIZE) < 0) {
  382. hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx "\n", buf_list);
  383. return H_PARAMETER;
  384. }
  385. filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_TCE_PAGE_SIZE);
  386. if (check_bd(dev, filter_list_bd, SPAPR_TCE_PAGE_SIZE) < 0) {
  387. hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx "\n", filter_list);
  388. return H_PARAMETER;
  389. }
  390. if (!(rec_queue & VLAN_BD_VALID)
  391. || (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) {
  392. hcall_dprintf("Bad receive queue\n");
  393. return H_PARAMETER;
  394. }
  395. dev->buf_list = buf_list;
  396. sdev->signal_state = 0;
  397. rec_queue &= ~VLAN_BD_TOGGLE;
  398. /* Initialize the buffer list */
  399. vio_stq(sdev, buf_list, rec_queue);
  400. vio_stq(sdev, buf_list + 8, filter_list_bd);
  401. spapr_vio_dma_set(sdev, buf_list + VLAN_RX_BDS_OFF, 0,
  402. SPAPR_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF);
  403. dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8;
  404. dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8;
  405. dev->rx_bufs = 0;
  406. dev->rxq_ptr = 0;
  407. /* Initialize the receive queue */
  408. spapr_vio_dma_set(sdev, VLAN_BD_ADDR(rec_queue), 0, VLAN_BD_LEN(rec_queue));
  409. dev->isopen = 1;
  410. qemu_flush_queued_packets(qemu_get_queue(dev->nic));
  411. return H_SUCCESS;
  412. }
  413. static target_ulong h_free_logical_lan(PowerPCCPU *cpu,
  414. SpaprMachineState *spapr,
  415. target_ulong opcode, target_ulong *args)
  416. {
  417. target_ulong reg = args[0];
  418. SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
  419. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  420. if (!dev) {
  421. return H_PARAMETER;
  422. }
  423. if (!dev->isopen) {
  424. hcall_dprintf("H_FREE_LOGICAL_LAN called without "
  425. "H_REGISTER_LOGICAL_LAN\n");
  426. return H_RESOURCE;
  427. }
  428. spapr_vlan_reset(sdev);
  429. return H_SUCCESS;
  430. }
  431. /**
  432. * Used for qsort, this function compares two RxBufPools by size.
  433. */
  434. static int rx_pool_size_compare(const void *p1, const void *p2)
  435. {
  436. const RxBufPool *pool1 = *(RxBufPool **)p1;
  437. const RxBufPool *pool2 = *(RxBufPool **)p2;
  438. if (pool1->bufsize < pool2->bufsize) {
  439. return -1;
  440. }
  441. return pool1->bufsize > pool2->bufsize;
  442. }
  443. /**
  444. * Search for a matching buffer pool with exact matching size,
  445. * or return -1 if no matching pool has been found.
  446. */
  447. static int spapr_vlan_get_rx_pool_id(SpaprVioVlan *dev, int size)
  448. {
  449. int pool;
  450. for (pool = 0; pool < RX_MAX_POOLS; pool++) {
  451. if (dev->rx_pool[pool]->bufsize == size) {
  452. return pool;
  453. }
  454. }
  455. return -1;
  456. }
  457. /**
  458. * Enqueuing receive buffer by adding it to one of our receive buffer pools
  459. */
  460. static target_long spapr_vlan_add_rxbuf_to_pool(SpaprVioVlan *dev,
  461. target_ulong buf)
  462. {
  463. int size = VLAN_BD_LEN(buf);
  464. int pool;
  465. pool = spapr_vlan_get_rx_pool_id(dev, size);
  466. if (pool < 0) {
  467. /*
  468. * No matching pool found? Try to use a new one. If the guest used all
  469. * pools before, but changed the size of one pool in the meantime, we might
  470. * need to recycle that pool here (if it's empty already). Thus scan
  471. * all buffer pools now, starting with the last (likely empty) one.
  472. */
  473. for (pool = RX_MAX_POOLS - 1; pool >= 0 ; pool--) {
  474. if (dev->rx_pool[pool]->count == 0) {
  475. dev->rx_pool[pool]->bufsize = size;
  476. /*
  477. * Sort pools by size so that spapr_vlan_receive()
  478. * can later find the smallest buffer pool easily.
  479. */
  480. qsort(dev->rx_pool, RX_MAX_POOLS, sizeof(dev->rx_pool[0]),
  481. rx_pool_size_compare);
  482. pool = spapr_vlan_get_rx_pool_id(dev, size);
  483. trace_spapr_vlan_add_rxbuf_to_pool_create(pool,
  484. VLAN_BD_LEN(buf));
  485. break;
  486. }
  487. }
  488. }
  489. /* Still no usable pool? Give up */
  490. if (pool < 0 || dev->rx_pool[pool]->count >= RX_POOL_MAX_BDS) {
  491. return H_RESOURCE;
  492. }
  493. trace_spapr_vlan_add_rxbuf_to_pool(pool, VLAN_BD_LEN(buf),
  494. dev->rx_pool[pool]->count);
  495. dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count++] = buf;
  496. return 0;
  497. }
  498. /**
  499. * This is the old way of enqueuing receive buffers: Add it to the rx queue
  500. * page that has been supplied by the guest (which is quite limited in size).
  501. */
  502. static target_long spapr_vlan_add_rxbuf_to_page(SpaprVioVlan *dev,
  503. target_ulong buf)
  504. {
  505. vlan_bd_t bd;
  506. if (dev->rx_bufs >= VLAN_MAX_BUFS) {
  507. return H_RESOURCE;
  508. }
  509. do {
  510. dev->add_buf_ptr += 8;
  511. if (dev->add_buf_ptr >= VLAN_RX_BDS_LEN + VLAN_RX_BDS_OFF) {
  512. dev->add_buf_ptr = VLAN_RX_BDS_OFF;
  513. }
  514. bd = vio_ldq(&dev->sdev, dev->buf_list + dev->add_buf_ptr);
  515. } while (bd & VLAN_BD_VALID);
  516. vio_stq(&dev->sdev, dev->buf_list + dev->add_buf_ptr, buf);
  517. trace_spapr_vlan_add_rxbuf_to_page(dev->add_buf_ptr, dev->rx_bufs, buf);
  518. return 0;
  519. }
  520. static target_ulong h_add_logical_lan_buffer(PowerPCCPU *cpu,
  521. SpaprMachineState *spapr,
  522. target_ulong opcode,
  523. target_ulong *args)
  524. {
  525. target_ulong reg = args[0];
  526. target_ulong buf = args[1];
  527. SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
  528. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  529. target_long ret;
  530. trace_spapr_vlan_h_add_logical_lan_buffer(reg, buf);
  531. if (!sdev) {
  532. hcall_dprintf("Bad device\n");
  533. return H_PARAMETER;
  534. }
  535. if ((check_bd(dev, buf, 4) < 0)
  536. || (VLAN_BD_LEN(buf) < 16)) {
  537. hcall_dprintf("Bad buffer enqueued\n");
  538. return H_PARAMETER;
  539. }
  540. if (!dev->isopen) {
  541. return H_RESOURCE;
  542. }
  543. if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
  544. ret = spapr_vlan_add_rxbuf_to_pool(dev, buf);
  545. } else {
  546. ret = spapr_vlan_add_rxbuf_to_page(dev, buf);
  547. }
  548. if (ret) {
  549. return ret;
  550. }
  551. dev->rx_bufs++;
  552. /*
  553. * Give guest some more time to add additional RX buffers before we
  554. * flush the receive queue, so that e.g. fragmented IP packets can
  555. * be passed to the guest in one go later (instead of passing single
  556. * fragments if there is only one receive buffer available).
  557. */
  558. timer_mod(dev->rxp_timer, qemu_clock_get_us(QEMU_CLOCK_VIRTUAL) + 500);
  559. return H_SUCCESS;
  560. }
  561. static target_ulong h_send_logical_lan(PowerPCCPU *cpu,
  562. SpaprMachineState *spapr,
  563. target_ulong opcode, target_ulong *args)
  564. {
  565. target_ulong reg = args[0];
  566. target_ulong *bufs = args + 1;
  567. target_ulong continue_token = args[7];
  568. SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
  569. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  570. unsigned total_len;
  571. uint8_t *lbuf, *p;
  572. int i, nbufs;
  573. int ret;
  574. trace_spapr_vlan_h_send_logical_lan(reg, continue_token);
  575. if (!sdev) {
  576. return H_PARAMETER;
  577. }
  578. trace_spapr_vlan_h_send_logical_lan_rxbufs(dev->rx_bufs);
  579. if (!dev->isopen) {
  580. return H_DROPPED;
  581. }
  582. if (continue_token) {
  583. return H_HARDWARE; /* FIXME actually handle this */
  584. }
  585. total_len = 0;
  586. for (i = 0; i < 6; i++) {
  587. trace_spapr_vlan_h_send_logical_lan_buf_desc(bufs[i]);
  588. if (!(bufs[i] & VLAN_BD_VALID)) {
  589. break;
  590. }
  591. total_len += VLAN_BD_LEN(bufs[i]);
  592. }
  593. nbufs = i;
  594. trace_spapr_vlan_h_send_logical_lan_total(nbufs, total_len);
  595. if (total_len == 0) {
  596. return H_SUCCESS;
  597. }
  598. if (total_len > MAX_PACKET_SIZE) {
  599. /* Don't let the guest force too large an allocation */
  600. return H_RESOURCE;
  601. }
  602. lbuf = alloca(total_len);
  603. p = lbuf;
  604. for (i = 0; i < nbufs; i++) {
  605. ret = spapr_vio_dma_read(sdev, VLAN_BD_ADDR(bufs[i]),
  606. p, VLAN_BD_LEN(bufs[i]));
  607. if (ret < 0) {
  608. return ret;
  609. }
  610. p += VLAN_BD_LEN(bufs[i]);
  611. }
  612. qemu_send_packet(qemu_get_queue(dev->nic), lbuf, total_len);
  613. return H_SUCCESS;
  614. }
  615. static target_ulong h_multicast_ctrl(PowerPCCPU *cpu, SpaprMachineState *spapr,
  616. target_ulong opcode, target_ulong *args)
  617. {
  618. target_ulong reg = args[0];
  619. SpaprVioDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
  620. if (!dev) {
  621. return H_PARAMETER;
  622. }
  623. return H_SUCCESS;
  624. }
  625. static target_ulong h_change_logical_lan_mac(PowerPCCPU *cpu,
  626. SpaprMachineState *spapr,
  627. target_ulong opcode,
  628. target_ulong *args)
  629. {
  630. target_ulong reg = args[0];
  631. target_ulong macaddr = args[1];
  632. SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
  633. SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
  634. int i;
  635. for (i = 0; i < ETH_ALEN; i++) {
  636. dev->nicconf.macaddr.a[ETH_ALEN - i - 1] = macaddr & 0xff;
  637. macaddr >>= 8;
  638. }
  639. qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
  640. return H_SUCCESS;
  641. }
  642. static Property spapr_vlan_properties[] = {
  643. DEFINE_SPAPR_PROPERTIES(SpaprVioVlan, sdev),
  644. DEFINE_NIC_PROPERTIES(SpaprVioVlan, nicconf),
  645. DEFINE_PROP_BIT("use-rx-buffer-pools", SpaprVioVlan,
  646. compat_flags, SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT, true),
  647. DEFINE_PROP_END_OF_LIST(),
  648. };
  649. static bool spapr_vlan_rx_buffer_pools_needed(void *opaque)
  650. {
  651. SpaprVioVlan *dev = opaque;
  652. return (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) != 0;
  653. }
  654. static const VMStateDescription vmstate_rx_buffer_pool = {
  655. .name = "spapr_llan/rx_buffer_pool",
  656. .version_id = 1,
  657. .minimum_version_id = 1,
  658. .needed = spapr_vlan_rx_buffer_pools_needed,
  659. .fields = (VMStateField[]) {
  660. VMSTATE_INT32(bufsize, RxBufPool),
  661. VMSTATE_INT32(count, RxBufPool),
  662. VMSTATE_UINT64_ARRAY(bds, RxBufPool, RX_POOL_MAX_BDS),
  663. VMSTATE_END_OF_LIST()
  664. }
  665. };
  666. static const VMStateDescription vmstate_rx_pools = {
  667. .name = "spapr_llan/rx_pools",
  668. .version_id = 1,
  669. .minimum_version_id = 1,
  670. .needed = spapr_vlan_rx_buffer_pools_needed,
  671. .fields = (VMStateField[]) {
  672. VMSTATE_ARRAY_OF_POINTER_TO_STRUCT(rx_pool, SpaprVioVlan,
  673. RX_MAX_POOLS, 1,
  674. vmstate_rx_buffer_pool, RxBufPool),
  675. VMSTATE_END_OF_LIST()
  676. }
  677. };
  678. static const VMStateDescription vmstate_spapr_llan = {
  679. .name = "spapr_llan",
  680. .version_id = 1,
  681. .minimum_version_id = 1,
  682. .fields = (VMStateField[]) {
  683. VMSTATE_SPAPR_VIO(sdev, SpaprVioVlan),
  684. /* LLAN state */
  685. VMSTATE_BOOL(isopen, SpaprVioVlan),
  686. VMSTATE_UINT64(buf_list, SpaprVioVlan),
  687. VMSTATE_UINT32(add_buf_ptr, SpaprVioVlan),
  688. VMSTATE_UINT32(use_buf_ptr, SpaprVioVlan),
  689. VMSTATE_UINT32(rx_bufs, SpaprVioVlan),
  690. VMSTATE_UINT64(rxq_ptr, SpaprVioVlan),
  691. VMSTATE_END_OF_LIST()
  692. },
  693. .subsections = (const VMStateDescription * []) {
  694. &vmstate_rx_pools,
  695. NULL
  696. }
  697. };
  698. static void spapr_vlan_class_init(ObjectClass *klass, void *data)
  699. {
  700. DeviceClass *dc = DEVICE_CLASS(klass);
  701. SpaprVioDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);
  702. k->realize = spapr_vlan_realize;
  703. k->reset = spapr_vlan_reset;
  704. k->devnode = spapr_vlan_devnode;
  705. k->dt_name = "l-lan";
  706. k->dt_type = "network";
  707. k->dt_compatible = "IBM,l-lan";
  708. k->signal_mask = 0x1;
  709. set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
  710. device_class_set_props(dc, spapr_vlan_properties);
  711. k->rtce_window_size = 0x10000000;
  712. dc->vmsd = &vmstate_spapr_llan;
  713. }
  714. static const TypeInfo spapr_vlan_info = {
  715. .name = TYPE_VIO_SPAPR_VLAN_DEVICE,
  716. .parent = TYPE_VIO_SPAPR_DEVICE,
  717. .instance_size = sizeof(SpaprVioVlan),
  718. .class_init = spapr_vlan_class_init,
  719. .instance_init = spapr_vlan_instance_init,
  720. .instance_finalize = spapr_vlan_instance_finalize,
  721. };
  722. static void spapr_vlan_register_types(void)
  723. {
  724. spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan);
  725. spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan);
  726. spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan);
  727. spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
  728. h_add_logical_lan_buffer);
  729. spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
  730. spapr_register_hypercall(H_CHANGE_LOGICAL_LAN_MAC,
  731. h_change_logical_lan_mac);
  732. type_register_static(&spapr_vlan_info);
  733. }
  734. type_init(spapr_vlan_register_types)