Commit c229472a authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/dgibson/tags/ppc-for-2.8-20160923' into staging 



ppc patch queue 2016-09-23

This pull request supersedes ppc-for-2.8-20160922.  There was a clang
build error in that, and I've also added one extra patch in the new pull.

Included in this set of ppc and spapr patches are:
    * TCG implementations for more POWER9 instructions
    * Some preliminary XICS fixes in preparataion for the pnv machine type
    * A significant ADB (Macintosh kbd/mouse) cleanup
    * Some conversions to use trace instead of debug macros
    * Fixes to correctly handle global TLB flush synchronization in
      TCG.  This is already a bug, but it will have much more impact
      when we get MTTCG
    * Add more qtest testcases for Power
    * Some MAINTAINERS updates
    * Assorted bugfixes
    * Add the basics of NUMA associativity to the spapr PCI host bridge

This touches some test files and monitor.c which are technically
outside the ppc code, but coming through this tree because the changes
are primarily of interest to ppc.

# gpg: Signature made Fri 23 Sep 2016 08:14:47 BST
# gpg:                using RSA key 0x6C38CACA20D9B392
# gpg: Good signature from "David Gibson <david@gibson.dropbear.id.au>"
# gpg:                 aka "David Gibson (Red Hat) <dgibson@redhat.com>"
# gpg:                 aka "David Gibson (ozlabs.org) <dgibson@ozlabs.org>"
# gpg:                 aka "David Gibson (kernel.org) <dwg@kernel.org>"
# Primary key fingerprint: 75F4 6586 AE61 A66C C44E  87DC 6C38 CACA 20D9 B392

* remotes/dgibson/tags/ppc-for-2.8-20160923: (45 commits)
  spapr_pci: Add numa node id
  monitor: fix crash for platforms without a CPU 0
  linux-user: ppc64: fix ARCH_206 bit in AT_HWCAP
  ppc/kvm: Mark 64kB page size support as disabled if not available
  ppc/xics: An ICS with offset 0 is assumed to be uninitialized
  ppc/xics: account correct irq status
  Enable H_CLEAR_MOD and H_CLEAR_REF hypercalls on KVM/PPC64.
  target-ppc: tlbie/tlbivax should have global effect
  target-ppc: add flag in check_tlb_flush()
  target-ppc: add TLB_NEED_LOCAL_FLUSH flag
  spapr: Introduce sPAPRCPUCoreClass
  target-ppc: implement darn instruction
  target-ppc: add stxsi[bh]x instruction
  target-ppc: add lxsi[bw]zx instruction
  target-ppc: add xxspltib instruction
  target-ppc: consolidate store conditional
  target-ppc: move out stqcx impementation
  target-ppc: consolidate load with reservation
  target-ppc: convert st[16,32,64]r to use new macro
  target-ppc: convert st64 to use new macro
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 4c892756 4814401f

MAINTAINERS

+15 −0
Original line number Diff line number Diff line
@@ -172,6 +172,7 @@ L: qemu-ppc@nongnu.org 
S: Maintained

F: target-ppc/

F: hw/ppc/

F: include/hw/ppc/

F: disas/ppc.c



S390
@@ -574,6 +575,9 @@ L: qemu-ppc@nongnu.org 
S: Supported

F: hw/ppc/e500.[hc]

F: hw/ppc/e500plat.c

F: include/hw/ppc/ppc_e500.h

F: include/hw/pci-host/ppce500.h

F: pc-bios/u-boot.e500



mpc8544ds

M: Alexander Graf <agraf@suse.de>
@@ -591,6 +595,8 @@ F: hw/ppc/mac_newworld.c 
F: hw/pci-host/uninorth.c

F: hw/pci-bridge/dec.[hc]

F: hw/misc/macio/

F: include/hw/ppc/mac_dbdma.h

F: hw/nvram/mac_nvram.c



Old World

M: Alexander Graf <agraf@suse.de>
@@ -618,6 +624,14 @@ F: include/hw/*/spapr* 
F: hw/*/xics*

F: include/hw/*/xics*

F: pc-bios/spapr-rtas/*

F: pc-bios/spapr-rtas.bin

F: pc-bios/slof.bin

F: docs/specs/ppc-spapr-hcalls.txt

F: docs/specs/ppc-spapr-hotplug.txt

F: tests/spapr*

F: tests/libqos/*spapr*

F: tests/rtas*

F: tests/libqos/rtas*



virtex_ml507

M: Edgar E. Iglesias <edgar.iglesias@gmail.com>
@@ -815,6 +829,7 @@ M: Alexander Graf <agraf@suse.de> 
L: qemu-ppc@nongnu.org

S: Odd Fixes

F: hw/ppc/ppc4*.c

F: include/hw/ppc/ppc4xx.h



ppce500

M: Alexander Graf <agraf@suse.de>

hw/input/adb.c

+184 −45
Original line number Diff line number Diff line
@@ -25,6 +25,9 @@ 
#include "hw/hw.h"

#include "hw/input/adb.h"

#include "ui/console.h"

#include "include/hw/input/adb-keys.h"

#include "ui/input.h"

#include "sysemu/sysemu.h"



/* debug ADB */

//#define DEBUG_ADB
@@ -59,6 +62,9 @@ do { printf("ADB: " fmt , ## __VA_ARGS__); } while (0) 
/* error codes */

#define ADB_RET_NOTPRESENT (-2)



/* The adb keyboard doesn't have every key imaginable */

#define NO_KEY 0xff



static void adb_device_reset(ADBDevice *d)

{

    qdev_reset_all(DEVICE(d));
@@ -187,23 +193,125 @@ typedef struct ADBKeyboardClass { 
    DeviceRealize parent_realize;

} ADBKeyboardClass;



static const uint8_t pc_to_adb_keycode[256] = {

  0, 53, 18, 19, 20, 21, 23, 22, 26, 28, 25, 29, 27, 24, 51, 48,

 12, 13, 14, 15, 17, 16, 32, 34, 31, 35, 33, 30, 36, 54,  0,  1,

  2,  3,  5,  4, 38, 40, 37, 41, 39, 50, 56, 42,  6,  7,  8,  9,

 11, 45, 46, 43, 47, 44,123, 67, 58, 49, 57,122,120, 99,118, 96,

 97, 98,100,101,109, 71,107, 89, 91, 92, 78, 86, 87, 88, 69, 83,

 84, 85, 82, 65,  0,  0, 10,103,111,  0,  0,110, 81,  0,  0,  0,

  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  0,  0,  0, 94,  0, 93,  0,  0,  0,  0,  0,  0,104,102,  0,  0,

  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 76,125,  0,  0,

  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,105,  0,  0,  0,  0,  0,

  0,  0,  0,  0,  0, 75,  0,  0,124,  0,  0,  0,  0,  0,  0,  0,

  0,  0,  0,  0,  0,  0,  0,115, 62,116,  0, 59,  0, 60,  0,119,

 61,121,114,117,  0,  0,  0,  0,  0,  0,  0, 55,126,  0,127,  0,

  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  0,  0,  0,  0,  0, 95,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

int qcode_to_adb_keycode[] = {

     /* Make sure future additions are automatically set to NO_KEY */

    [0 ... 0xff]               = NO_KEY,



    [Q_KEY_CODE_SHIFT]         = ADB_KEY_LEFT_SHIFT,

    [Q_KEY_CODE_SHIFT_R]       = ADB_KEY_RIGHT_SHIFT,

    [Q_KEY_CODE_ALT]           = ADB_KEY_LEFT_OPTION,

    [Q_KEY_CODE_ALT_R]         = ADB_KEY_RIGHT_OPTION,

    [Q_KEY_CODE_ALTGR]         = ADB_KEY_RIGHT_OPTION,

    [Q_KEY_CODE_CTRL]          = ADB_KEY_LEFT_CONTROL,

    [Q_KEY_CODE_CTRL_R]        = ADB_KEY_RIGHT_CONTROL,

    [Q_KEY_CODE_META_L]        = ADB_KEY_COMMAND,

    [Q_KEY_CODE_META_R]        = ADB_KEY_COMMAND,

    [Q_KEY_CODE_SPC]           = ADB_KEY_SPACEBAR,



    [Q_KEY_CODE_ESC]           = ADB_KEY_ESC,

    [Q_KEY_CODE_1]             = ADB_KEY_1,

    [Q_KEY_CODE_2]             = ADB_KEY_2,

    [Q_KEY_CODE_3]             = ADB_KEY_3,

    [Q_KEY_CODE_4]             = ADB_KEY_4,

    [Q_KEY_CODE_5]             = ADB_KEY_5,

    [Q_KEY_CODE_6]             = ADB_KEY_6,

    [Q_KEY_CODE_7]             = ADB_KEY_7,

    [Q_KEY_CODE_8]             = ADB_KEY_8,

    [Q_KEY_CODE_9]             = ADB_KEY_9,

    [Q_KEY_CODE_0]             = ADB_KEY_0,

    [Q_KEY_CODE_MINUS]         = ADB_KEY_MINUS,

    [Q_KEY_CODE_EQUAL]         = ADB_KEY_EQUAL,

    [Q_KEY_CODE_BACKSPACE]     = ADB_KEY_DELETE,

    [Q_KEY_CODE_TAB]           = ADB_KEY_TAB,

    [Q_KEY_CODE_Q]             = ADB_KEY_Q,

    [Q_KEY_CODE_W]             = ADB_KEY_W,

    [Q_KEY_CODE_E]             = ADB_KEY_E,

    [Q_KEY_CODE_R]             = ADB_KEY_R,

    [Q_KEY_CODE_T]             = ADB_KEY_T,

    [Q_KEY_CODE_Y]             = ADB_KEY_Y,

    [Q_KEY_CODE_U]             = ADB_KEY_U,

    [Q_KEY_CODE_I]             = ADB_KEY_I,

    [Q_KEY_CODE_O]             = ADB_KEY_O,

    [Q_KEY_CODE_P]             = ADB_KEY_P,

    [Q_KEY_CODE_BRACKET_LEFT]  = ADB_KEY_LEFT_BRACKET,

    [Q_KEY_CODE_BRACKET_RIGHT] = ADB_KEY_RIGHT_BRACKET,

    [Q_KEY_CODE_RET]           = ADB_KEY_RETURN,

    [Q_KEY_CODE_A]             = ADB_KEY_A,

    [Q_KEY_CODE_S]             = ADB_KEY_S,

    [Q_KEY_CODE_D]             = ADB_KEY_D,

    [Q_KEY_CODE_F]             = ADB_KEY_F,

    [Q_KEY_CODE_G]             = ADB_KEY_G,

    [Q_KEY_CODE_H]             = ADB_KEY_H,

    [Q_KEY_CODE_J]             = ADB_KEY_J,

    [Q_KEY_CODE_K]             = ADB_KEY_K,

    [Q_KEY_CODE_L]             = ADB_KEY_L,

    [Q_KEY_CODE_SEMICOLON]     = ADB_KEY_SEMICOLON,

    [Q_KEY_CODE_APOSTROPHE]    = ADB_KEY_APOSTROPHE,

    [Q_KEY_CODE_GRAVE_ACCENT]  = ADB_KEY_GRAVE_ACCENT,

    [Q_KEY_CODE_BACKSLASH]     = ADB_KEY_BACKSLASH,

    [Q_KEY_CODE_Z]             = ADB_KEY_Z,

    [Q_KEY_CODE_X]             = ADB_KEY_X,

    [Q_KEY_CODE_C]             = ADB_KEY_C,

    [Q_KEY_CODE_V]             = ADB_KEY_V,

    [Q_KEY_CODE_B]             = ADB_KEY_B,

    [Q_KEY_CODE_N]             = ADB_KEY_N,

    [Q_KEY_CODE_M]             = ADB_KEY_M,

    [Q_KEY_CODE_COMMA]         = ADB_KEY_COMMA,

    [Q_KEY_CODE_DOT]           = ADB_KEY_PERIOD,

    [Q_KEY_CODE_SLASH]         = ADB_KEY_FORWARD_SLASH,

    [Q_KEY_CODE_ASTERISK]      = ADB_KEY_KP_MULTIPLY,

    [Q_KEY_CODE_CAPS_LOCK]     = ADB_KEY_CAPS_LOCK,



    [Q_KEY_CODE_F1]            = ADB_KEY_F1,

    [Q_KEY_CODE_F2]            = ADB_KEY_F2,

    [Q_KEY_CODE_F3]            = ADB_KEY_F3,

    [Q_KEY_CODE_F4]            = ADB_KEY_F4,

    [Q_KEY_CODE_F5]            = ADB_KEY_F5,

    [Q_KEY_CODE_F6]            = ADB_KEY_F6,

    [Q_KEY_CODE_F7]            = ADB_KEY_F7,

    [Q_KEY_CODE_F8]            = ADB_KEY_F8,

    [Q_KEY_CODE_F9]            = ADB_KEY_F9,

    [Q_KEY_CODE_F10]           = ADB_KEY_F10,

    [Q_KEY_CODE_F11]           = ADB_KEY_F11,

    [Q_KEY_CODE_F12]           = ADB_KEY_F12,

    [Q_KEY_CODE_PRINT]         = ADB_KEY_F13,

    [Q_KEY_CODE_SYSRQ]         = ADB_KEY_F13,

    [Q_KEY_CODE_SCROLL_LOCK]   = ADB_KEY_F14,

    [Q_KEY_CODE_PAUSE]         = ADB_KEY_F15,



    [Q_KEY_CODE_NUM_LOCK]      = ADB_KEY_KP_CLEAR,

    [Q_KEY_CODE_KP_EQUALS]     = ADB_KEY_KP_EQUAL,

    [Q_KEY_CODE_KP_DIVIDE]     = ADB_KEY_KP_DIVIDE,

    [Q_KEY_CODE_KP_MULTIPLY]   = ADB_KEY_KP_MULTIPLY,

    [Q_KEY_CODE_KP_SUBTRACT]   = ADB_KEY_KP_SUBTRACT,

    [Q_KEY_CODE_KP_ADD]        = ADB_KEY_KP_PLUS,

    [Q_KEY_CODE_KP_ENTER]      = ADB_KEY_KP_ENTER,

    [Q_KEY_CODE_KP_DECIMAL]    = ADB_KEY_KP_PERIOD,

    [Q_KEY_CODE_KP_0]          = ADB_KEY_KP_0,

    [Q_KEY_CODE_KP_1]          = ADB_KEY_KP_1,

    [Q_KEY_CODE_KP_2]          = ADB_KEY_KP_2,

    [Q_KEY_CODE_KP_3]          = ADB_KEY_KP_3,

    [Q_KEY_CODE_KP_4]          = ADB_KEY_KP_4,

    [Q_KEY_CODE_KP_5]          = ADB_KEY_KP_5,

    [Q_KEY_CODE_KP_6]          = ADB_KEY_KP_6,

    [Q_KEY_CODE_KP_7]          = ADB_KEY_KP_7,

    [Q_KEY_CODE_KP_8]          = ADB_KEY_KP_8,

    [Q_KEY_CODE_KP_9]          = ADB_KEY_KP_9,



    [Q_KEY_CODE_UP]            = ADB_KEY_UP,

    [Q_KEY_CODE_DOWN]          = ADB_KEY_DOWN,

    [Q_KEY_CODE_LEFT]          = ADB_KEY_LEFT,

    [Q_KEY_CODE_RIGHT]         = ADB_KEY_RIGHT,



    [Q_KEY_CODE_HELP]          = ADB_KEY_HELP,

    [Q_KEY_CODE_INSERT]        = ADB_KEY_HELP,

    [Q_KEY_CODE_DELETE]        = ADB_KEY_FORWARD_DELETE,

    [Q_KEY_CODE_HOME]          = ADB_KEY_HOME,

    [Q_KEY_CODE_END]           = ADB_KEY_END,

    [Q_KEY_CODE_PGUP]          = ADB_KEY_PAGE_UP,

    [Q_KEY_CODE_PGDN]          = ADB_KEY_PAGE_DOWN,



    [Q_KEY_CODE_POWER]         = ADB_KEY_POWER

};



static void adb_kbd_put_keycode(void *opaque, int keycode)
@@ -220,35 +328,40 @@ static void adb_kbd_put_keycode(void *opaque, int keycode) 


static int adb_kbd_poll(ADBDevice *d, uint8_t *obuf)

{

    static int ext_keycode;

    KBDState *s = ADB_KEYBOARD(d);

    int adb_keycode, keycode;

    int keycode;

    int olen;



    olen = 0;

    for(;;) {

        if (s->count == 0)

            break;

    if (s->count == 0) {

        return 0;

    }

    keycode = s->data[s->rptr];

        if (++s->rptr == sizeof(s->data))

    s->rptr++;

    if (s->rptr == sizeof(s->data)) {

        s->rptr = 0;

    }

    s->count--;



        if (keycode == 0xe0) {

            ext_keycode = 1;

    /*

     * The power key is the only two byte value key, so it is a special case.

     * Since 0x7f is not a used keycode for ADB we overload it to indicate the

     * power button when we're storing keycodes in our internal buffer, and

     * expand it out to two bytes when we send to the guest.

     */

    if (keycode == 0x7f) {

        obuf[0] = 0x7f;

        obuf[1] = 0x7f;

        olen = 2;

    } else {

            if (ext_keycode)

                adb_keycode =  pc_to_adb_keycode[keycode | 0x80];

            else

                adb_keycode =  pc_to_adb_keycode[keycode & 0x7f];

            obuf[0] = adb_keycode | (keycode & 0x80);

            /* NOTE: could put a second keycode if needed */

        obuf[0] = keycode;

        /* NOTE: the power key key-up is the two byte sequence 0xff 0xff;

         * otherwise we could in theory send a second keycode in the second

         * byte, but choose not to bother.

         */

        obuf[1] = 0xff;

        olen = 2;

            ext_keycode = 0;

            break;

        }

    }



    return olen;

}
@@ -313,6 +426,29 @@ static int adb_kbd_request(ADBDevice *d, uint8_t *obuf, 
    return olen;

}



/* This is where keyboard events enter this file */

static void adb_keyboard_event(DeviceState *dev, QemuConsole *src,

                               InputEvent *evt)

{

    KBDState *s = (KBDState *)dev;

    int qcode, keycode;



    qcode = qemu_input_key_value_to_qcode(evt->u.key.data->key);

    if (qcode >= ARRAY_SIZE(qcode_to_adb_keycode)) {

        return;

    }

    keycode = qcode_to_adb_keycode[qcode];

    if (keycode == NO_KEY) {  /* We don't want to send this to the guest */

        ADB_DPRINTF("Ignoring NO_KEY\n");

        return;

    }

    if (evt->u.key.data->down == false) { /* if key release event */

        keycode = keycode | 0x80;   /* create keyboard break code */

    }



    adb_kbd_put_keycode(s, keycode);

}



static const VMStateDescription vmstate_adb_kbd = {

    .name = "adb_kbd",

    .version_id = 2,
@@ -340,14 +476,17 @@ static void adb_kbd_reset(DeviceState *dev) 
    s->count = 0;

}



static QemuInputHandler adb_keyboard_handler = {

    .name  = "QEMU ADB Keyboard",

    .mask  = INPUT_EVENT_MASK_KEY,

    .event = adb_keyboard_event,

};



static void adb_kbd_realizefn(DeviceState *dev, Error **errp)

{

    ADBDevice *d = ADB_DEVICE(dev);

    ADBKeyboardClass *akc = ADB_KEYBOARD_GET_CLASS(dev);



    akc->parent_realize(dev, errp);



    qemu_add_kbd_event_handler(adb_kbd_put_keycode, d);

    qemu_input_handler_register(dev, &adb_keyboard_handler);

}



static void adb_kbd_initfn(Object *obj)

hw/intc/xics.c

+5 −2
Original line number Diff line number Diff line
@@ -505,8 +505,11 @@ static void ics_reject(ICSState *ics, int nr) 
    ICSIRQState *irq = ics->irqs + nr - ics->offset;



    trace_xics_ics_reject(nr, nr - ics->offset);

    irq->status |= XICS_STATUS_REJECTED; /* Irrelevant but harmless for LSI */

    irq->status &= ~XICS_STATUS_SENT; /* Irrelevant but harmless for MSI */

    if (irq->flags & XICS_FLAGS_IRQ_MSI) {

        irq->status |= XICS_STATUS_REJECTED;

    } else if (irq->flags & XICS_FLAGS_IRQ_LSI) {

        irq->status &= ~XICS_STATUS_SENT;

    }

}



static void ics_resend(ICSState *ics)

hw/net/spapr_llan.c

+25 −36
Original line number Diff line number Diff line
@@ -34,20 +34,13 @@ 
#include "hw/ppc/spapr.h"

#include "hw/ppc/spapr_vio.h"

#include "sysemu/sysemu.h"

#include "trace.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



/* Compatibility flags for migration */

#define SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT  0

#define SPAPRVLAN_FLAG_RX_BUF_POOLS      (1 << SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT)
@@ -158,8 +151,10 @@ static vlan_bd_t spapr_vlan_get_rx_bd_from_pool(VIOsPAPRVLANDevice *dev, 
        return 0;

    }



    DPRINTF("Found buffer: pool=%d count=%d rxbufs=%d\n", pool,

            dev->rx_pool[pool]->count, dev->rx_bufs);



    trace_spapr_vlan_get_rx_bd_from_pool_found(pool,

                                               dev->rx_pool[pool]->count,

                                               dev->rx_bufs);



    /* Remove the buffer from the pool */

    dev->rx_pool[pool]->count--;
@@ -186,8 +181,8 @@ static vlan_bd_t spapr_vlan_get_rx_bd_from_page(VIOsPAPRVLANDevice *dev, 
        }



        bd = vio_ldq(&dev->sdev, dev->buf_list + buf_ptr);

        DPRINTF("use_buf_ptr=%d bd=0x%016llx\n",

                buf_ptr, (unsigned long long)bd);



        trace_spapr_vlan_get_rx_bd_from_page(buf_ptr, (uint64_t)bd);

    } while ((!(bd & VLAN_BD_VALID) || VLAN_BD_LEN(bd) < size + 8)

             && buf_ptr != dev->use_buf_ptr);
@@ -200,7 +195,7 @@ static vlan_bd_t spapr_vlan_get_rx_bd_from_page(VIOsPAPRVLANDevice *dev, 
    dev->use_buf_ptr = buf_ptr;

    vio_stq(&dev->sdev, dev->buf_list + dev->use_buf_ptr, 0);



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

    trace_spapr_vlan_get_rx_bd_from_page_found(dev->use_buf_ptr, dev->rx_bufs);



    return bd;

}
@@ -215,8 +210,7 @@ static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf, 
    uint64_t handle;

    uint8_t control;



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

            dev->rx_bufs);

    trace_spapr_vlan_receive(sdev->qdev.id, dev->rx_bufs);



    if (!dev->isopen) {

        return -1;
@@ -244,7 +238,7 @@ static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf, 
        return -1;

    }



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

    trace_spapr_vlan_receive_dma_completed();



    /* Update the receive queue */

    control = VLAN_RXQC_TOGGLE | VLAN_RXQC_VALID;
@@ -258,11 +252,10 @@ static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf, 
    vio_sth(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8);

    vio_stb(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)vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +

    trace_spapr_vlan_receive_wrote(dev->rxq_ptr,

                                   vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +

                                                 dev->rxq_ptr),

            (unsigned long long)vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +

                                   vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +

                                                 dev->rxq_ptr + 8));



    dev->rxq_ptr += 16;
@@ -580,7 +573,7 @@ static target_long spapr_vlan_add_rxbuf_to_pool(VIOsPAPRVLANDevice *dev, 
                qsort(dev->rx_pool, RX_MAX_POOLS, sizeof(dev->rx_pool[0]),

                      rx_pool_size_compare);

                pool = spapr_vlan_get_rx_pool_id(dev, size);

                DPRINTF("created RX pool %d for size %lld\n", pool,

                trace_spapr_vlan_add_rxbuf_to_pool_create(pool,

                                                          VLAN_BD_LEN(buf));

                break;

            }
@@ -591,8 +584,8 @@ static target_long spapr_vlan_add_rxbuf_to_pool(VIOsPAPRVLANDevice *dev, 
        return H_RESOURCE;

    }



    DPRINTF("h_add_llan_buf():  Add buf using pool %i (size %lli, count=%i)\n",

            pool, VLAN_BD_LEN(buf), dev->rx_pool[pool]->count);

    trace_spapr_vlan_add_rxbuf_to_pool(pool, VLAN_BD_LEN(buf),

                                       dev->rx_pool[pool]->count);



    dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count++] = buf;
@@ -623,8 +616,7 @@ static target_long spapr_vlan_add_rxbuf_to_page(VIOsPAPRVLANDevice *dev, 


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



    DPRINTF("h_add_llan_buf():  Added buf  ptr=%d  rx_bufs=%d bd=0x%016llx\n",

            dev->add_buf_ptr, dev->rx_bufs, (unsigned long long)buf);

    trace_spapr_vlan_add_rxbuf_to_page(dev->add_buf_ptr, dev->rx_bufs, buf);



    return 0;

}
@@ -640,8 +632,7 @@ static target_ulong h_add_logical_lan_buffer(PowerPCCPU *cpu, 
    VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev);

    target_long ret;



    DPRINTF("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx

            ", 0x" TARGET_FMT_lx ")\n", reg, buf);

    trace_spapr_vlan_h_add_logical_lan_buffer(reg, buf);



    if (!sdev) {

        hcall_dprintf("Bad device\n");
@@ -694,14 +685,13 @@ static target_ulong h_send_logical_lan(PowerPCCPU *cpu, 
    int i, nbufs;

    int ret;



    DPRINTF("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx ", <bufs>, 0x"

            TARGET_FMT_lx ")\n", reg, continue_token);

    trace_spapr_vlan_h_send_logical_lan(reg, continue_token);



    if (!sdev) {

        return H_PARAMETER;

    }



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

    trace_spapr_vlan_h_send_logical_lan_rxbufs(dev->rx_bufs);



    if (!dev->isopen) {

        return H_DROPPED;
@@ -713,7 +703,7 @@ static target_ulong h_send_logical_lan(PowerPCCPU *cpu, 


    total_len = 0;

    for (i = 0; i < 6; i++) {

        DPRINTF("   buf desc: 0x" TARGET_FMT_lx "\n", bufs[i]);

        trace_spapr_vlan_h_send_logical_lan_buf_desc(bufs[i]);

        if (!(bufs[i] & VLAN_BD_VALID)) {

            break;

        }
@@ -721,8 +711,7 @@ static target_ulong h_send_logical_lan(PowerPCCPU *cpu, 
    }



    nbufs = i;

    DPRINTF("h_send_logical_lan() %d buffers, total length 0x%x\n",

            nbufs, total_len);

    trace_spapr_vlan_h_send_logical_lan_total(nbufs, total_len);



    if (total_len == 0) {

        return H_SUCCESS;

hw/net/trace-events

+16 −0
Original line number Diff line number Diff line
@@ -270,3 +270,19 @@ e1000e_cfg_support_virtio(bool support) "Virtio header supported: %d" 


e1000e_vm_state_running(void) "VM state is running"

e1000e_vm_state_stopped(void) "VM state is stopped"



# hw/net/spapr_llan.c

spapr_vlan_get_rx_bd_from_pool_found(int pool, int32_t count, uint32_t rx_bufs) "pool=%d count=%"PRId32" rxbufs=%"PRIu32

spapr_vlan_get_rx_bd_from_page(int buf_ptr, uint64_t bd) "use_buf_ptr=%d bd=0x%016"PRIx64

spapr_vlan_get_rx_bd_from_page_found(uint32_t use_buf_ptr, uint32_t rx_bufs) "ptr=%"PRIu32" rxbufs=%"PRIu32

spapr_vlan_receive(const char *id, uint32_t rx_bufs) "[%s] rx_bufs=%"PRIu32

spapr_vlan_receive_dma_completed(void) "DMA write completed"

spapr_vlan_receive_wrote(uint64_t ptr, uint64_t hi, uint64_t lo) "rxq entry (ptr=0x%"PRIx64"): 0x%016"PRIx64" 0x%016"PRIx64

spapr_vlan_add_rxbuf_to_pool_create(int pool, uint64_t len) "created RX pool %d for size %"PRIu64

spapr_vlan_add_rxbuf_to_pool(int pool, uint64_t len, int32_t count) "add buf using pool %d (size %"PRIu64", count=%"PRId32")"

spapr_vlan_add_rxbuf_to_page(uint32_t ptr, uint32_t rx_bufs, uint64_t bd) "added buf ptr=%"PRIu32"  rx_bufs=%"PRIu32" bd=0x%016"PRIx64

spapr_vlan_h_add_logical_lan_buffer(uint64_t reg, uint64_t buf) "H_ADD_LOGICAL_LAN_BUFFER(0x%"PRIx64", 0x%"PRIx64")"

spapr_vlan_h_send_logical_lan(uint64_t reg, uint64_t continue_token) "H_SEND_LOGICAL_LAN(0x%"PRIx64", <bufs>, 0x%"PRIx64")"

spapr_vlan_h_send_logical_lan_rxbufs(uint32_t rx_bufs) "rxbufs = %"PRIu32

spapr_vlan_h_send_logical_lan_buf_desc(uint64_t buf) "   buf desc: 0x%"PRIx64

spapr_vlan_h_send_logical_lan_total(int nbufs, unsigned total_len) "%d buffers, total length 0x%x"