[qemu.git] / hw / spapr_llan.c

/*
 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
 *
 * PAPR Inter-VM Logical Lan, aka ibmveth
 *
 * Copyright (c) 2010,2011 David Gibson, IBM Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
#include "hw.h"
#include "net.h"
#include "hw/qdev.h"
#include "hw/spapr.h"
#include "hw/spapr_vio.h"

#include <libfdt.h>

#define ETH_ALEN        6
#define MAX_PACKET_SIZE 65536

/*#define DEBUG*/

#ifdef DEBUG
#define dprintf(fmt...) do { fprintf(stderr, fmt); } while (0)
#else
#define dprintf(fmt...)
#endif

/*
 * Virtual LAN device
 */

typedef uint64_t vlan_bd_t;

#define VLAN_BD_VALID        0x8000000000000000ULL
#define VLAN_BD_TOGGLE       0x4000000000000000ULL
#define VLAN_BD_NO_CSUM      0x0200000000000000ULL
#define VLAN_BD_CSUM_GOOD    0x0100000000000000ULL
#define VLAN_BD_LEN_MASK     0x00ffffff00000000ULL
#define VLAN_BD_LEN(bd)      (((bd) & VLAN_BD_LEN_MASK) >> 32)
#define VLAN_BD_ADDR_MASK    0x00000000ffffffffULL
#define VLAN_BD_ADDR(bd)     ((bd) & VLAN_BD_ADDR_MASK)

#define VLAN_VALID_BD(addr, len) (VLAN_BD_VALID | \
                                  (((len) << 32) & VLAN_BD_LEN_MASK) |  \
                                  (addr & VLAN_BD_ADDR_MASK))

#define VLAN_RXQC_TOGGLE     0x80
#define VLAN_RXQC_VALID      0x40
#define VLAN_RXQC_NO_CSUM    0x02
#define VLAN_RXQC_CSUM_GOOD  0x01

#define VLAN_RQ_ALIGNMENT    16
#define VLAN_RXQ_BD_OFF      0
#define VLAN_FILTER_BD_OFF   8
#define VLAN_RX_BDS_OFF      16
#define VLAN_MAX_BUFS        ((SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF) / 8)

typedef struct VIOsPAPRVLANDevice {
    VIOsPAPRDevice sdev;
    NICConf nicconf;
    NICState *nic;
    int isopen;
    target_ulong buf_list;
    int add_buf_ptr, use_buf_ptr, rx_bufs;
    target_ulong rxq_ptr;
} VIOsPAPRVLANDevice;

static int spapr_vlan_can_receive(VLANClientState *nc)
{
    VIOsPAPRVLANDevice *dev = DO_UPCAST(NICState, nc, nc)->opaque;

    return (dev->isopen && dev->rx_bufs > 0);
}

static ssize_t spapr_vlan_receive(VLANClientState *nc, const uint8_t *buf,
                                  size_t size)
{
    VIOsPAPRDevice *sdev = DO_UPCAST(NICState, nc, nc)->opaque;
    VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
    vlan_bd_t rxq_bd = ldq_tce(sdev, dev->buf_list + VLAN_RXQ_BD_OFF);
    vlan_bd_t bd;
    int buf_ptr = dev->use_buf_ptr;
    uint64_t handle;
    uint8_t control;

    dprintf("spapr_vlan_receive() [%s] rx_bufs=%d\n", sdev->qdev.id,
            dev->rx_bufs);

    if (!dev->isopen) {
        return -1;
    }

    if (!dev->rx_bufs) {
        return -1;
    }

    do {
        buf_ptr += 8;
        if (buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
            buf_ptr = VLAN_RX_BDS_OFF;
        }

        bd = ldq_tce(sdev, dev->buf_list + buf_ptr);
        dprintf("use_buf_ptr=%d bd=0x%016llx\n",
                buf_ptr, (unsigned long long)bd);
    } while ((!(bd & VLAN_BD_VALID) || (VLAN_BD_LEN(bd) < (size + 8)))
             && (buf_ptr != dev->use_buf_ptr));

    if (!(bd & VLAN_BD_VALID) || (VLAN_BD_LEN(bd) < (size + 8))) {
        /* Failed to find a suitable buffer */
        return -1;
    }

    /* Remove the buffer from the pool */
    dev->rx_bufs--;
    dev->use_buf_ptr = buf_ptr;
    stq_tce(sdev, dev->buf_list + dev->use_buf_ptr, 0);

    dprintf("Found buffer: ptr=%d num=%d\n", dev->use_buf_ptr, dev->rx_bufs);

    /* Transfer the packet data */
    if (spapr_tce_dma_write(sdev, VLAN_BD_ADDR(bd) + 8, buf, size) < 0) {
        return -1;
    }

    dprintf("spapr_vlan_receive: DMA write completed\n");

    /* Update the receive queue */
    control = VLAN_RXQC_TOGGLE | VLAN_RXQC_VALID;
    if (rxq_bd & VLAN_BD_TOGGLE) {
        control ^= VLAN_RXQC_TOGGLE;
    }

    handle = ldq_tce(sdev, VLAN_BD_ADDR(bd));
    stq_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 8, handle);
    stw_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 4, size);
    sth_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8);
    stb_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr, control);

    dprintf("wrote rxq entry (ptr=0x%llx): 0x%016llx 0x%016llx\n",
            (unsigned long long)dev->rxq_ptr,
            (unsigned long long)ldq_tce(sdev, VLAN_BD_ADDR(rxq_bd) +
                                        dev->rxq_ptr),
            (unsigned long long)ldq_tce(sdev, VLAN_BD_ADDR(rxq_bd) +
                                        dev->rxq_ptr + 8));

    dev->rxq_ptr += 16;
    if (dev->rxq_ptr >= VLAN_BD_LEN(rxq_bd)) {
        dev->rxq_ptr = 0;
        stq_tce(sdev, dev->buf_list + VLAN_RXQ_BD_OFF, rxq_bd ^ VLAN_BD_TOGGLE);
    }

    if (sdev->signal_state & 1) {
        qemu_irq_pulse(sdev->qirq);
    }

    return size;
}

static NetClientInfo net_spapr_vlan_info = {
    .type = NET_CLIENT_TYPE_NIC,
    .size = sizeof(NICState),
    .can_receive = spapr_vlan_can_receive,
    .receive = spapr_vlan_receive,
};

static int spapr_vlan_init(VIOsPAPRDevice *sdev)
{
    VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
    VIOsPAPRBus *bus;

    bus = DO_UPCAST(VIOsPAPRBus, bus, sdev->qdev.parent_bus);

    qemu_macaddr_default_if_unset(&dev->nicconf.macaddr);

    dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf,
                            sdev->qdev.info->name, sdev->qdev.id, dev);
    qemu_format_nic_info_str(&dev->nic->nc, dev->nicconf.macaddr.a);

    return 0;
}

void spapr_vlan_create(VIOsPAPRBus *bus, uint32_t reg, NICInfo *nd,
                       qemu_irq qirq, uint32_t vio_irq_num)
{
    DeviceState *dev;
    VIOsPAPRDevice *sdev;

    dev = qdev_create(&bus->bus, "spapr-vlan");
    qdev_prop_set_uint32(dev, "reg", reg);

    qdev_set_nic_properties(dev, nd);

    qdev_init_nofail(dev);
    sdev = (VIOsPAPRDevice *)dev;
    sdev->qirq = qirq;
    sdev->vio_irq_num = vio_irq_num;
}

static int spapr_vlan_devnode(VIOsPAPRDevice *dev, void *fdt, int node_off)
{
    VIOsPAPRVLANDevice *vdev = (VIOsPAPRVLANDevice *)dev;
    uint8_t padded_mac[8] = {0, 0};
    int ret;

    /* Some old phyp versions give the mac address in an 8-byte
     * property.  The kernel driver has an insane workaround for this;
     * rather than doing the obvious thing and checking the property
     * length, it checks whether the first byte has 0b10 in the low
     * bits.  If a correct 6-byte property has a different first byte
     * the kernel will get the wrong mac address, overrunning its
     * buffer in the process (read only, thank goodness).
     *
     * Here we workaround the kernel workaround by always supplying an
     * 8-byte property, with the mac address in the last six bytes */
    memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);
    ret = fdt_setprop(fdt, node_off, "local-mac-address",
                      padded_mac, sizeof(padded_mac));
    if (ret < 0) {
        return ret;
    }

    ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0);
    if (ret < 0) {
        return ret;
    }

    return 0;
}

static int check_bd(VIOsPAPRVLANDevice *dev, vlan_bd_t bd,
                    target_ulong alignment)
{
    if ((VLAN_BD_ADDR(bd) % alignment)
        || (VLAN_BD_LEN(bd) % alignment)) {
        return -1;
    }

    if (spapr_vio_check_tces(&dev->sdev, VLAN_BD_ADDR(bd),
                             VLAN_BD_LEN(bd), SPAPR_TCE_RW) != 0) {
        return -1;
    }

    return 0;
}

static target_ulong h_register_logical_lan(CPUState *env,
                                           sPAPREnvironment *spapr,
                                           target_ulong opcode,
                                           target_ulong *args)
{
    target_ulong reg = args[0];
    target_ulong buf_list = args[1];
    target_ulong rec_queue = args[2];
    target_ulong filter_list = args[3];
    VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
    VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
    vlan_bd_t filter_list_bd;
#ifdef DEBUG
    target_ulong mac_address = args[4];
#endif

    if (!dev) {
        return H_PARAMETER;
    }

    if (dev->isopen) {
        hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
                      "H_FREE_LOGICAL_LAN\n");
        return H_RESOURCE;
    }

    if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_VIO_TCE_PAGE_SIZE),
                 SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
        hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx " for "
                      "H_REGISTER_LOGICAL_LAN\n", buf_list);
        return H_PARAMETER;
    }

    filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_VIO_TCE_PAGE_SIZE);
    if (check_bd(dev, filter_list_bd, SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
        hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx " for "
                      "H_REGISTER_LOGICAL_LAN\n", filter_list);
        return H_PARAMETER;
    }

    if (!(rec_queue & VLAN_BD_VALID)
        || (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) {
        hcall_dprintf("Bad receive queue for H_REGISTER_LOGICAL_LAN\n");
        return H_PARAMETER;
    }

    dev->buf_list = buf_list;
    sdev->signal_state = 0;

    rec_queue &= ~VLAN_BD_TOGGLE;

    /* Initialize the buffer list */
    stq_tce(sdev, buf_list, rec_queue);
    stq_tce(sdev, buf_list + 8, filter_list_bd);
    spapr_tce_dma_zero(sdev, buf_list + VLAN_RX_BDS_OFF,
                       SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF);
    dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8;
    dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8;
    dev->rx_bufs = 0;
    dev->rxq_ptr = 0;

    /* Initialize the receive queue */
    spapr_tce_dma_zero(sdev, VLAN_BD_ADDR(rec_queue), VLAN_BD_LEN(rec_queue));

    dev->isopen = 1;
    return H_SUCCESS;
}


static target_ulong h_free_logical_lan(CPUState *env, sPAPREnvironment *spapr,
                                       target_ulong opcode, target_ulong *args)
{
    target_ulong reg = args[0];
    VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
    VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;

    if (!dev) {
        return H_PARAMETER;
    }

    if (!dev->isopen) {
        hcall_dprintf("H_FREE_LOGICAL_LAN called without "
                      "H_REGISTER_LOGICAL_LAN\n");
        return H_RESOURCE;
    }

    dev->buf_list = 0;
    dev->rx_bufs = 0;
    dev->isopen = 0;
    return H_SUCCESS;
}

static target_ulong h_add_logical_lan_buffer(CPUState *env,
                                             sPAPREnvironment *spapr,
                                             target_ulong opcode,
                                             target_ulong *args)
{
    target_ulong reg = args[0];
    target_ulong buf = args[1];
    VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
    VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
    vlan_bd_t bd;

    dprintf("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx
            ", 0x" TARGET_FMT_lx ")\n", reg, buf);

    if (!sdev) {
        hcall_dprintf("Wrong device in h_add_logical_lan_buffer\n");
        return H_PARAMETER;
    }

    if ((check_bd(dev, buf, 4) < 0)
        || (VLAN_BD_LEN(buf) < 16)) {
        hcall_dprintf("Bad buffer enqueued in h_add_logical_lan_buffer\n");
        return H_PARAMETER;
    }

    if (!dev->isopen || dev->rx_bufs >= VLAN_MAX_BUFS) {
        return H_RESOURCE;
    }

    do {
        dev->add_buf_ptr += 8;
        if (dev->add_buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
            dev->add_buf_ptr = VLAN_RX_BDS_OFF;
        }

        bd = ldq_tce(sdev, dev->buf_list + dev->add_buf_ptr);
    } while (bd & VLAN_BD_VALID);

    stq_tce(sdev, dev->buf_list + dev->add_buf_ptr, buf);

    dev->rx_bufs++;

    dprintf("h_add_logical_lan_buffer():  Added buf  ptr=%d  rx_bufs=%d"
            " bd=0x%016llx\n", dev->add_buf_ptr, dev->rx_bufs,
            (unsigned long long)buf);

    return H_SUCCESS;
}

static target_ulong h_send_logical_lan(CPUState *env, sPAPREnvironment *spapr,
                                       target_ulong opcode, target_ulong *args)
{
    target_ulong reg = args[0];
    target_ulong *bufs = args + 1;
    target_ulong continue_token = args[7];
    VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
    VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
    unsigned total_len;
    uint8_t *lbuf, *p;
    int i, nbufs;
    int ret;

    dprintf("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx ", <bufs>, 0x"
            TARGET_FMT_lx ")\n", reg, continue_token);

    if (!sdev) {
        return H_PARAMETER;
    }

    dprintf("rxbufs = %d\n", dev->rx_bufs);

    if (!dev->isopen) {
        return H_DROPPED;
    }

    if (continue_token) {
        return H_HARDWARE; /* FIXME actually handle this */
    }

    total_len = 0;
    for (i = 0; i < 6; i++) {
        dprintf("   buf desc: 0x" TARGET_FMT_lx "\n", bufs[i]);
        if (!(bufs[i] & VLAN_BD_VALID)) {
            break;
        }
        total_len += VLAN_BD_LEN(bufs[i]);
    }

    nbufs = i;
    dprintf("h_send_logical_lan() %d buffers, total length 0x%x\n",
            nbufs, total_len);

    if (total_len == 0) {
        return H_SUCCESS;
    }

    if (total_len > MAX_PACKET_SIZE) {
        /* Don't let the guest force too large an allocation */
        return H_RESOURCE;
    }

    lbuf = alloca(total_len);
    p = lbuf;
    for (i = 0; i < nbufs; i++) {
        ret = spapr_tce_dma_read(sdev, VLAN_BD_ADDR(bufs[i]),
                                 p, VLAN_BD_LEN(bufs[i]));
        if (ret < 0) {
            return ret;
        }

        p += VLAN_BD_LEN(bufs[i]);
    }

    qemu_send_packet(&dev->nic->nc, lbuf, total_len);

    return H_SUCCESS;
}

static target_ulong h_multicast_ctrl(CPUState *env, sPAPREnvironment *spapr,
                                     target_ulong opcode, target_ulong *args)
{
    target_ulong reg = args[0];
    VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);

    if (!dev) {
        return H_PARAMETER;
    }

    return H_SUCCESS;
}

static void vlan_hcalls(VIOsPAPRBus *bus)
{
    spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan);
    spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan);
    spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan);
    spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
                             h_add_logical_lan_buffer);
    spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
}

static VIOsPAPRDeviceInfo spapr_vlan = {
    .init = spapr_vlan_init,
    .devnode = spapr_vlan_devnode,
    .dt_name = "l-lan",
    .dt_type = "network",
    .dt_compatible = "IBM,l-lan",
    .signal_mask = 0x1,
    .hcalls = vlan_hcalls,
    .qdev.name = "spapr-vlan",
    .qdev.size = sizeof(VIOsPAPRVLANDevice),
    .qdev.props = (Property[]) {
        DEFINE_PROP_UINT32("reg", VIOsPAPRDevice, reg, 0x1000),
        DEFINE_PROP_UINT32("dma-window", VIOsPAPRDevice, rtce_window_size,
                           0x10000000),
        DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf),
        DEFINE_PROP_END_OF_LIST(),
    },
};

static void spapr_vlan_register(void)
{
    spapr_vio_bus_register_withprop(&spapr_vlan);
}
device_init(spapr_vlan_register);
Commit	Line	Data
8d90ad90 DG	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 "hw.h"
	28	#include "net.h"
	29	#include "hw/qdev.h"
	30	#include "hw/spapr.h"
	31	#include "hw/spapr_vio.h"
	32
	33	#include <libfdt.h>
	34
	35	#define ETH_ALEN 6
	36	#define MAX_PACKET_SIZE 65536
	37
	38	/#define DEBUG/
	39
	40	#ifdef DEBUG
	41	#define dprintf(fmt...) do { fprintf(stderr, fmt); } while (0)
	42	#else
	43	#define dprintf(fmt...)
	44	#endif
	45
	46	/*
	47	* Virtual LAN device
	48	*/
	49
	50	typedef uint64_t vlan_bd_t;
	51
	52	#define VLAN_BD_VALID 0x8000000000000000ULL
	53	#define VLAN_BD_TOGGLE 0x4000000000000000ULL
	54	#define VLAN_BD_NO_CSUM 0x0200000000000000ULL
	55	#define VLAN_BD_CSUM_GOOD 0x0100000000000000ULL
	56	#define VLAN_BD_LEN_MASK 0x00ffffff00000000ULL
	57	#define VLAN_BD_LEN(bd) (((bd) & VLAN_BD_LEN_MASK) >> 32)
	58	#define VLAN_BD_ADDR_MASK 0x00000000ffffffffULL
	59	#define VLAN_BD_ADDR(bd) ((bd) & VLAN_BD_ADDR_MASK)
	60
	61	#define VLAN_VALID_BD(addr, len) (VLAN_BD_VALID \| \
	62	(((len) << 32) & VLAN_BD_LEN_MASK) \| \
	63	(addr & VLAN_BD_ADDR_MASK))
	64
65	#define VLAN_RXQC_TOGGLE 0x80
66	#define VLAN_RXQC_VALID 0x40
67	#define VLAN_RXQC_NO_CSUM 0x02
68	#define VLAN_RXQC_CSUM_GOOD 0x01
69
70	#define VLAN_RQ_ALIGNMENT 16
71	#define VLAN_RXQ_BD_OFF 0
72	#define VLAN_FILTER_BD_OFF 8
73	#define VLAN_RX_BDS_OFF 16
74	#define VLAN_MAX_BUFS ((SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF) / 8)
75
76	typedef struct VIOsPAPRVLANDevice {
77	VIOsPAPRDevice sdev;
78	NICConf nicconf;
79	NICState *nic;
80	int isopen;
81	target_ulong buf_list;
82	int add_buf_ptr, use_buf_ptr, rx_bufs;
83	target_ulong rxq_ptr;
84	} VIOsPAPRVLANDevice;
85
86	static int spapr_vlan_can_receive(VLANClientState *nc)
87	{
88	VIOsPAPRVLANDevice *dev = DO_UPCAST(NICState, nc, nc)->opaque;
89
90	return (dev->isopen && dev->rx_bufs > 0);
91	}
92
93	static ssize_t spapr_vlan_receive(VLANClientState nc, const uint8_t buf,
94	size_t size)
95	{
96	VIOsPAPRDevice *sdev = DO_UPCAST(NICState, nc, nc)->opaque;
97	VIOsPAPRVLANDevice dev = (VIOsPAPRVLANDevice )sdev;
98	vlan_bd_t rxq_bd = ldq_tce(sdev, dev->buf_list + VLAN_RXQ_BD_OFF);
99	vlan_bd_t bd;
100	int buf_ptr = dev->use_buf_ptr;
101	uint64_t handle;
102	uint8_t control;
103
104	dprintf("spapr_vlan_receive() [%s] rx_bufs=%d\n", sdev->qdev.id,
105	dev->rx_bufs);
106
107	if (!dev->isopen) {
108	return -1;
109	}
110
111	if (!dev->rx_bufs) {
112	return -1;
113	}
114
115	do {
116	buf_ptr += 8;
117	if (buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
118	buf_ptr = VLAN_RX_BDS_OFF;
119	}
120
121	bd = ldq_tce(sdev, dev->buf_list + buf_ptr);
122	dprintf("use_buf_ptr=%d bd=0x%016llx\n",
123	buf_ptr, (unsigned long long)bd);
124	} while ((!(bd & VLAN_BD_VALID) \|\| (VLAN_BD_LEN(bd) < (size + 8)))
125	&& (buf_ptr != dev->use_buf_ptr));
126
127	if (!(bd & VLAN_BD_VALID) \|\| (VLAN_BD_LEN(bd) < (size + 8))) {
128	/* Failed to find a suitable buffer */
129	return -1;
130	}
131
132	/* Remove the buffer from the pool */
133	dev->rx_bufs--;
134	dev->use_buf_ptr = buf_ptr;
135	stq_tce(sdev, dev->buf_list + dev->use_buf_ptr, 0);
136
137	dprintf("Found buffer: ptr=%d num=%d\n", dev->use_buf_ptr, dev->rx_bufs);
138
139	/* Transfer the packet data */
140	if (spapr_tce_dma_write(sdev, VLAN_BD_ADDR(bd) + 8, buf, size) < 0) {
141	return -1;
142	}
143
144	dprintf("spapr_vlan_receive: DMA write completed\n");
145
146	/* Update the receive queue */
147	control = VLAN_RXQC_TOGGLE \| VLAN_RXQC_VALID;
148	if (rxq_bd & VLAN_BD_TOGGLE) {
149	control ^= VLAN_RXQC_TOGGLE;
150	}
151
152	handle = ldq_tce(sdev, VLAN_BD_ADDR(bd));
153	stq_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 8, handle);
154	stw_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 4, size);
155	sth_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8);
156	stb_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr, control);
157
158	dprintf("wrote rxq entry (ptr=0x%llx): 0x%016llx 0x%016llx\n",
159	(unsigned long long)dev->rxq_ptr,
160	(unsigned long long)ldq_tce(sdev, VLAN_BD_ADDR(rxq_bd) +
161	dev->rxq_ptr),
162	(unsigned long long)ldq_tce(sdev, VLAN_BD_ADDR(rxq_bd) +
163	dev->rxq_ptr + 8));
164
165	dev->rxq_ptr += 16;
166	if (dev->rxq_ptr >= VLAN_BD_LEN(rxq_bd)) {
167	dev->rxq_ptr = 0;
168	stq_tce(sdev, dev->buf_list + VLAN_RXQ_BD_OFF, rxq_bd ^ VLAN_BD_TOGGLE);
169	}
170
171	if (sdev->signal_state & 1) {
172	qemu_irq_pulse(sdev->qirq);
173	}
174
175	return size;
176	}
177
178	static NetClientInfo net_spapr_vlan_info = {
179	.type = NET_CLIENT_TYPE_NIC,
180	.size = sizeof(NICState),
181	.can_receive = spapr_vlan_can_receive,
182	.receive = spapr_vlan_receive,
183	};
184
185	static int spapr_vlan_init(VIOsPAPRDevice *sdev)
186	{
187	VIOsPAPRVLANDevice dev = (VIOsPAPRVLANDevice )sdev;
188	VIOsPAPRBus *bus;
189
190	bus = DO_UPCAST(VIOsPAPRBus, bus, sdev->qdev.parent_bus);
191
192	qemu_macaddr_default_if_unset(&dev->nicconf.macaddr);
193
194	dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf,
195	sdev->qdev.info->name, sdev->qdev.id, dev);
196	qemu_format_nic_info_str(&dev->nic->nc, dev->nicconf.macaddr.a);
197
198	return 0;
199	}
200
201	void spapr_vlan_create(VIOsPAPRBus bus, uint32_t reg, NICInfo nd,
202	qemu_irq qirq, uint32_t vio_irq_num)
203	{
204	DeviceState *dev;
205	VIOsPAPRDevice *sdev;
206
207	dev = qdev_create(&bus->bus, "spapr-vlan");
208	qdev_prop_set_uint32(dev, "reg", reg);
209
210	qdev_set_nic_properties(dev, nd);
211
212	qdev_init_nofail(dev);
213	sdev = (VIOsPAPRDevice *)dev;
214	sdev->qirq = qirq;
215	sdev->vio_irq_num = vio_irq_num;
216	}
217
218	static int spapr_vlan_devnode(VIOsPAPRDevice dev, void fdt, int node_off)
219	{
220	VIOsPAPRVLANDevice vdev = (VIOsPAPRVLANDevice )dev;
221	uint8_t padded_mac[8] = {0, 0};
222	int ret;
223
224	/* Some old phyp versions give the mac address in an 8-byte
225	* property. The kernel driver has an insane workaround for this;
226	* rather than doing the obvious thing and checking the property
227	* length, it checks whether the first byte has 0b10 in the low
228	* bits. If a correct 6-byte property has a different first byte
229	* the kernel will get the wrong mac address, overrunning its
230	* buffer in the process (read only, thank goodness).
231	*
232	* Here we workaround the kernel workaround by always supplying an
233	* 8-byte property, with the mac address in the last six bytes */
234	memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);
235	ret = fdt_setprop(fdt, node_off, "local-mac-address",
236	padded_mac, sizeof(padded_mac));
237	if (ret < 0) {
238	return ret;
239	}
240
241	ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0);
242	if (ret < 0) {
243	return ret;
244	}
245
246	return 0;
247	}
248
249	static int check_bd(VIOsPAPRVLANDevice *dev, vlan_bd_t bd,
250	target_ulong alignment)
251	{
252	if ((VLAN_BD_ADDR(bd) % alignment)
253	\|\| (VLAN_BD_LEN(bd) % alignment)) {
254	return -1;
255	}
256
257	if (spapr_vio_check_tces(&dev->sdev, VLAN_BD_ADDR(bd),
258	VLAN_BD_LEN(bd), SPAPR_TCE_RW) != 0) {
259	return -1;
260	}
261
262	return 0;
263	}
264
265	static target_ulong h_register_logical_lan(CPUState *env,
266	sPAPREnvironment *spapr,
267	target_ulong opcode,
268	target_ulong *args)
269	{
270	target_ulong reg = args[0];
271	target_ulong buf_list = args[1];
272	target_ulong rec_queue = args[2];
273	target_ulong filter_list = args[3];
274	VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
275	VIOsPAPRVLANDevice dev = (VIOsPAPRVLANDevice )sdev;
276	vlan_bd_t filter_list_bd;
277	#ifdef DEBUG
278	target_ulong mac_address = args[4];
279	#endif
280
281	if (!dev) {
282	return H_PARAMETER;
283	}
284
285	if (dev->isopen) {
286	hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
287	"H_FREE_LOGICAL_LAN\n");
288	return H_RESOURCE;
289	}
290
291	if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_VIO_TCE_PAGE_SIZE),
292	SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
293	hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx " for "
294	"H_REGISTER_LOGICAL_LAN\n", buf_list);
295	return H_PARAMETER;
296	}
297
298	filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_VIO_TCE_PAGE_SIZE);
299	if (check_bd(dev, filter_list_bd, SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
300	hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx " for "
301	"H_REGISTER_LOGICAL_LAN\n", filter_list);
302	return H_PARAMETER;
303	}
304
305	if (!(rec_queue & VLAN_BD_VALID)
306	\|\| (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) {
307	hcall_dprintf("Bad receive queue for H_REGISTER_LOGICAL_LAN\n");
308	return H_PARAMETER;
309	}
310
311	dev->buf_list = buf_list;
312	sdev->signal_state = 0;
313
314	rec_queue &= ~VLAN_BD_TOGGLE;
315
316	/* Initialize the buffer list */
317	stq_tce(sdev, buf_list, rec_queue);
318	stq_tce(sdev, buf_list + 8, filter_list_bd);
319	spapr_tce_dma_zero(sdev, buf_list + VLAN_RX_BDS_OFF,
320	SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF);
321	dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8;
322	dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8;
323	dev->rx_bufs = 0;
324	dev->rxq_ptr = 0;
325
326	/* Initialize the receive queue */
327	spapr_tce_dma_zero(sdev, VLAN_BD_ADDR(rec_queue), VLAN_BD_LEN(rec_queue));
328
329	dev->isopen = 1;
330	return H_SUCCESS;
331	}
332
333
334	static target_ulong h_free_logical_lan(CPUState env, sPAPREnvironment spapr,
335	target_ulong opcode, target_ulong *args)
336	{
337	target_ulong reg = args[0];
338	VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
339	VIOsPAPRVLANDevice dev = (VIOsPAPRVLANDevice )sdev;
340
341	if (!dev) {
342	return H_PARAMETER;
343	}
344
345	if (!dev->isopen) {
346	hcall_dprintf("H_FREE_LOGICAL_LAN called without "
347	"H_REGISTER_LOGICAL_LAN\n");
348	return H_RESOURCE;
349	}
350
351	dev->buf_list = 0;
352	dev->rx_bufs = 0;
353	dev->isopen = 0;
354	return H_SUCCESS;
355	}
356
357	static target_ulong h_add_logical_lan_buffer(CPUState *env,
358	sPAPREnvironment *spapr,
359	target_ulong opcode,
360	target_ulong *args)
361	{
362	target_ulong reg = args[0];
363	target_ulong buf = args[1];
364	VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
365	VIOsPAPRVLANDevice dev = (VIOsPAPRVLANDevice )sdev;
366	vlan_bd_t bd;
367
368	dprintf("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx
369	", 0x" TARGET_FMT_lx ")\n", reg, buf);
370
371	if (!sdev) {
372	hcall_dprintf("Wrong device in h_add_logical_lan_buffer\n");
373	return H_PARAMETER;
374	}
375
376	if ((check_bd(dev, buf, 4) < 0)
377	\|\| (VLAN_BD_LEN(buf) < 16)) {
378	hcall_dprintf("Bad buffer enqueued in h_add_logical_lan_buffer\n");
379	return H_PARAMETER;
380	}
381
382	if (!dev->isopen \|\| dev->rx_bufs >= VLAN_MAX_BUFS) {
383	return H_RESOURCE;
384	}
385
386	do {
387	dev->add_buf_ptr += 8;
388	if (dev->add_buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
389	dev->add_buf_ptr = VLAN_RX_BDS_OFF;
390	}
391
392	bd = ldq_tce(sdev, dev->buf_list + dev->add_buf_ptr);
393	} while (bd & VLAN_BD_VALID);
394
395	stq_tce(sdev, dev->buf_list + dev->add_buf_ptr, buf);
396
397	dev->rx_bufs++;
398
399	dprintf("h_add_logical_lan_buffer(): Added buf ptr=%d rx_bufs=%d"
400	" bd=0x%016llx\n", dev->add_buf_ptr, dev->rx_bufs,
401	(unsigned long long)buf);
402
403	return H_SUCCESS;
404	}
405
406	static target_ulong h_send_logical_lan(CPUState env, sPAPREnvironment spapr,
407	target_ulong opcode, target_ulong *args)
408	{
409	target_ulong reg = args[0];
410	target_ulong *bufs = args + 1;
411	target_ulong continue_token = args[7];
412	VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
413	VIOsPAPRVLANDevice dev = (VIOsPAPRVLANDevice )sdev;
414	unsigned total_len;
415	uint8_t lbuf, p;
416	int i, nbufs;
417	int ret;
418
419	dprintf("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx ", <bufs>, 0x"
420	TARGET_FMT_lx ")\n", reg, continue_token);
421
422	if (!sdev) {
423	return H_PARAMETER;
424	}
425
426	dprintf("rxbufs = %d\n", dev->rx_bufs);
427
428	if (!dev->isopen) {
429	return H_DROPPED;
430	}
431
432	if (continue_token) {
433	return H_HARDWARE; /* FIXME actually handle this */
434	}
435
436	total_len = 0;
437	for (i = 0; i < 6; i++) {
438	dprintf(" buf desc: 0x" TARGET_FMT_lx "\n", bufs[i]);
439	if (!(bufs[i] & VLAN_BD_VALID)) {
440	break;
441	}
442	total_len += VLAN_BD_LEN(bufs[i]);
443	}
444
445	nbufs = i;
446	dprintf("h_send_logical_lan() %d buffers, total length 0x%x\n",
447	nbufs, total_len);
448
449	if (total_len == 0) {
450	return H_SUCCESS;
451	}
452
453	if (total_len > MAX_PACKET_SIZE) {
454	/* Don't let the guest force too large an allocation */
455	return H_RESOURCE;
456	}
457
458	lbuf = alloca(total_len);
459	p = lbuf;
460	for (i = 0; i < nbufs; i++) {
461	ret = spapr_tce_dma_read(sdev, VLAN_BD_ADDR(bufs[i]),
462	p, VLAN_BD_LEN(bufs[i]));
463	if (ret < 0) {
464	return ret;
465	}
466
467	p += VLAN_BD_LEN(bufs[i]);
468	}
469
470	qemu_send_packet(&dev->nic->nc, lbuf, total_len);
471
472	return H_SUCCESS;
473	}
474
475	static target_ulong h_multicast_ctrl(CPUState env, sPAPREnvironment spapr,
476	target_ulong opcode, target_ulong *args)
477	{
478	target_ulong reg = args[0];
479	VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
480
481	if (!dev) {
482	return H_PARAMETER;
483	}
484
485	return H_SUCCESS;
486	}
487
488	static void vlan_hcalls(VIOsPAPRBus *bus)
489	{
490	spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan);
491	spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan);
492	spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan);
493	spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
494	h_add_logical_lan_buffer);
495	spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
496	}
497
498	static VIOsPAPRDeviceInfo spapr_vlan = {
499	.init = spapr_vlan_init,
500	.devnode = spapr_vlan_devnode,
501	.dt_name = "l-lan",
502	.dt_type = "network",
503	.dt_compatible = "IBM,l-lan",
504	.signal_mask = 0x1,
505	.hcalls = vlan_hcalls,
506	.qdev.name = "spapr-vlan",
507	.qdev.size = sizeof(VIOsPAPRVLANDevice),
508	.qdev.props = (Property[]) {
509	DEFINE_PROP_UINT32("reg", VIOsPAPRDevice, reg, 0x1000),
510	DEFINE_PROP_UINT32("dma-window", VIOsPAPRDevice, rtce_window_size,
511	0x10000000),
512	DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf),
513	DEFINE_PROP_END_OF_LIST(),
514	},
515	};
516
517	static void spapr_vlan_register(void)
518	{
519	spapr_vio_bus_register_withprop(&spapr_vlan);
520	}
521	device_init(spapr_vlan_register);