diff options
Diffstat (limited to 'hw/msi.c')
| -rw-r--r-- | hw/msi.c | 395 |
1 files changed, 0 insertions, 395 deletions
diff --git a/hw/msi.c b/hw/msi.c deleted file mode 100644 index 33037a80e..000000000 --- a/hw/msi.c +++ /dev/null @@ -1,395 +0,0 @@ -/* - * msi.c - * - * Copyright (c) 2010 Isaku Yamahata <yamahata at valinux co jp> - * VA Linux Systems Japan K.K. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - - * You should have received a copy of the GNU General Public License along - * with this program; if not, see <http://www.gnu.org/licenses/>. - */ - -#include "msi.h" -#include "range.h" - -/* Eventually those constants should go to Linux pci_regs.h */ -#define PCI_MSI_PENDING_32 0x10 -#define PCI_MSI_PENDING_64 0x14 - -/* PCI_MSI_ADDRESS_LO */ -#define PCI_MSI_ADDRESS_LO_MASK (~0x3) - -/* If we get rid of cap allocator, we won't need those. */ -#define PCI_MSI_32_SIZEOF 0x0a -#define PCI_MSI_64_SIZEOF 0x0e -#define PCI_MSI_32M_SIZEOF 0x14 -#define PCI_MSI_64M_SIZEOF 0x18 - -#define PCI_MSI_VECTORS_MAX 32 - -/* Flag for interrupt controller to declare MSI/MSI-X support */ -bool msi_supported; - -/* If we get rid of cap allocator, we won't need this. */ -static inline uint8_t msi_cap_sizeof(uint16_t flags) -{ - switch (flags & (PCI_MSI_FLAGS_MASKBIT | PCI_MSI_FLAGS_64BIT)) { - case PCI_MSI_FLAGS_MASKBIT | PCI_MSI_FLAGS_64BIT: - return PCI_MSI_64M_SIZEOF; - case PCI_MSI_FLAGS_64BIT: - return PCI_MSI_64_SIZEOF; - case PCI_MSI_FLAGS_MASKBIT: - return PCI_MSI_32M_SIZEOF; - case 0: - return PCI_MSI_32_SIZEOF; - default: - abort(); - break; - } - return 0; -} - -//#define MSI_DEBUG - -#ifdef MSI_DEBUG -# define MSI_DPRINTF(fmt, ...) \ - fprintf(stderr, "%s:%d " fmt, __func__, __LINE__, ## __VA_ARGS__) -#else -# define MSI_DPRINTF(fmt, ...) do { } while (0) -#endif -#define MSI_DEV_PRINTF(dev, fmt, ...) \ - MSI_DPRINTF("%s:%x " fmt, (dev)->name, (dev)->devfn, ## __VA_ARGS__) - -static inline unsigned int msi_nr_vectors(uint16_t flags) -{ - return 1U << - ((flags & PCI_MSI_FLAGS_QSIZE) >> (ffs(PCI_MSI_FLAGS_QSIZE) - 1)); -} - -static inline uint8_t msi_flags_off(const PCIDevice* dev) -{ - return dev->msi_cap + PCI_MSI_FLAGS; -} - -static inline uint8_t msi_address_lo_off(const PCIDevice* dev) -{ - return dev->msi_cap + PCI_MSI_ADDRESS_LO; -} - -static inline uint8_t msi_address_hi_off(const PCIDevice* dev) -{ - return dev->msi_cap + PCI_MSI_ADDRESS_HI; -} - -static inline uint8_t msi_data_off(const PCIDevice* dev, bool msi64bit) -{ - return dev->msi_cap + (msi64bit ? PCI_MSI_DATA_64 : PCI_MSI_DATA_32); -} - -static inline uint8_t msi_mask_off(const PCIDevice* dev, bool msi64bit) -{ - return dev->msi_cap + (msi64bit ? PCI_MSI_MASK_64 : PCI_MSI_MASK_32); -} - -static inline uint8_t msi_pending_off(const PCIDevice* dev, bool msi64bit) -{ - return dev->msi_cap + (msi64bit ? PCI_MSI_PENDING_64 : PCI_MSI_PENDING_32); -} - -/* - * Special API for POWER to configure the vectors through - * a side channel. Should never be used by devices. - */ -void msi_set_message(PCIDevice *dev, MSIMessage msg) -{ - uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); - bool msi64bit = flags & PCI_MSI_FLAGS_64BIT; - - if (msi64bit) { - pci_set_quad(dev->config + msi_address_lo_off(dev), msg.address); - } else { - pci_set_long(dev->config + msi_address_lo_off(dev), msg.address); - } - pci_set_word(dev->config + msi_data_off(dev, msi64bit), msg.data); -} - -MSIMessage msi_get_message(PCIDevice *dev, unsigned int vector) -{ - uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); - bool msi64bit = flags & PCI_MSI_FLAGS_64BIT; - unsigned int nr_vectors = msi_nr_vectors(flags); - MSIMessage msg; - - assert(vector < nr_vectors); - - if (msi64bit) { - msg.address = pci_get_quad(dev->config + msi_address_lo_off(dev)); - } else { - msg.address = pci_get_long(dev->config + msi_address_lo_off(dev)); - } - - /* upper bit 31:16 is zero */ - msg.data = pci_get_word(dev->config + msi_data_off(dev, msi64bit)); - if (nr_vectors > 1) { - msg.data &= ~(nr_vectors - 1); - msg.data |= vector; - } - - return msg; -} - -bool msi_enabled(const PCIDevice *dev) -{ - return msi_present(dev) && - (pci_get_word(dev->config + msi_flags_off(dev)) & - PCI_MSI_FLAGS_ENABLE); -} - -int msi_init(struct PCIDevice *dev, uint8_t offset, - unsigned int nr_vectors, bool msi64bit, bool msi_per_vector_mask) -{ - unsigned int vectors_order; - uint16_t flags; - uint8_t cap_size; - int config_offset; - - if (!msi_supported) { - return -ENOTSUP; - } - - MSI_DEV_PRINTF(dev, - "init offset: 0x%"PRIx8" vector: %"PRId8 - " 64bit %d mask %d\n", - offset, nr_vectors, msi64bit, msi_per_vector_mask); - - assert(!(nr_vectors & (nr_vectors - 1))); /* power of 2 */ - assert(nr_vectors > 0); - assert(nr_vectors <= PCI_MSI_VECTORS_MAX); - /* the nr of MSI vectors is up to 32 */ - vectors_order = ffs(nr_vectors) - 1; - - flags = vectors_order << (ffs(PCI_MSI_FLAGS_QMASK) - 1); - if (msi64bit) { - flags |= PCI_MSI_FLAGS_64BIT; - } - if (msi_per_vector_mask) { - flags |= PCI_MSI_FLAGS_MASKBIT; - } - - cap_size = msi_cap_sizeof(flags); - config_offset = pci_add_capability(dev, PCI_CAP_ID_MSI, offset, cap_size); - if (config_offset < 0) { - return config_offset; - } - - dev->msi_cap = config_offset; - dev->cap_present |= QEMU_PCI_CAP_MSI; - - pci_set_word(dev->config + msi_flags_off(dev), flags); - pci_set_word(dev->wmask + msi_flags_off(dev), - PCI_MSI_FLAGS_QSIZE | PCI_MSI_FLAGS_ENABLE); - pci_set_long(dev->wmask + msi_address_lo_off(dev), - PCI_MSI_ADDRESS_LO_MASK); - if (msi64bit) { - pci_set_long(dev->wmask + msi_address_hi_off(dev), 0xffffffff); - } - pci_set_word(dev->wmask + msi_data_off(dev, msi64bit), 0xffff); - - if (msi_per_vector_mask) { - /* Make mask bits 0 to nr_vectors - 1 writable. */ - pci_set_long(dev->wmask + msi_mask_off(dev, msi64bit), - 0xffffffff >> (PCI_MSI_VECTORS_MAX - nr_vectors)); - } - return config_offset; -} - -void msi_uninit(struct PCIDevice *dev) -{ - uint16_t flags; - uint8_t cap_size; - - if (!msi_present(dev)) { - return; - } - flags = pci_get_word(dev->config + msi_flags_off(dev)); - cap_size = msi_cap_sizeof(flags); - pci_del_capability(dev, PCI_CAP_ID_MSI, cap_size); - dev->cap_present &= ~QEMU_PCI_CAP_MSI; - - MSI_DEV_PRINTF(dev, "uninit\n"); -} - -void msi_reset(PCIDevice *dev) -{ - uint16_t flags; - bool msi64bit; - - if (!msi_present(dev)) { - return; - } - - flags = pci_get_word(dev->config + msi_flags_off(dev)); - flags &= ~(PCI_MSI_FLAGS_QSIZE | PCI_MSI_FLAGS_ENABLE); - msi64bit = flags & PCI_MSI_FLAGS_64BIT; - - pci_set_word(dev->config + msi_flags_off(dev), flags); - pci_set_long(dev->config + msi_address_lo_off(dev), 0); - if (msi64bit) { - pci_set_long(dev->config + msi_address_hi_off(dev), 0); - } - pci_set_word(dev->config + msi_data_off(dev, msi64bit), 0); - if (flags & PCI_MSI_FLAGS_MASKBIT) { - pci_set_long(dev->config + msi_mask_off(dev, msi64bit), 0); - pci_set_long(dev->config + msi_pending_off(dev, msi64bit), 0); - } - MSI_DEV_PRINTF(dev, "reset\n"); -} - -static bool msi_is_masked(const PCIDevice *dev, unsigned int vector) -{ - uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); - uint32_t mask; - assert(vector < PCI_MSI_VECTORS_MAX); - - if (!(flags & PCI_MSI_FLAGS_MASKBIT)) { - return false; - } - - mask = pci_get_long(dev->config + - msi_mask_off(dev, flags & PCI_MSI_FLAGS_64BIT)); - return mask & (1U << vector); -} - -void msi_notify(PCIDevice *dev, unsigned int vector) -{ - uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); - bool msi64bit = flags & PCI_MSI_FLAGS_64BIT; - unsigned int nr_vectors = msi_nr_vectors(flags); - MSIMessage msg; - - assert(vector < nr_vectors); - if (msi_is_masked(dev, vector)) { - assert(flags & PCI_MSI_FLAGS_MASKBIT); - pci_long_test_and_set_mask( - dev->config + msi_pending_off(dev, msi64bit), 1U << vector); - MSI_DEV_PRINTF(dev, "pending vector 0x%x\n", vector); - return; - } - - msg = msi_get_message(dev, vector); - - MSI_DEV_PRINTF(dev, - "notify vector 0x%x" - " address: 0x%"PRIx64" data: 0x%"PRIx32"\n", - vector, msg.address, msg.data); - stl_le_phys(msg.address, msg.data); -} - -/* Normally called by pci_default_write_config(). */ -void msi_write_config(PCIDevice *dev, uint32_t addr, uint32_t val, int len) -{ - uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); - bool msi64bit = flags & PCI_MSI_FLAGS_64BIT; - bool msi_per_vector_mask = flags & PCI_MSI_FLAGS_MASKBIT; - unsigned int nr_vectors; - uint8_t log_num_vecs; - uint8_t log_max_vecs; - unsigned int vector; - uint32_t pending; - - if (!msi_present(dev) || - !ranges_overlap(addr, len, dev->msi_cap, msi_cap_sizeof(flags))) { - return; - } - -#ifdef MSI_DEBUG - MSI_DEV_PRINTF(dev, "addr 0x%"PRIx32" val 0x%"PRIx32" len %d\n", - addr, val, len); - MSI_DEV_PRINTF(dev, "ctrl: 0x%"PRIx16" address: 0x%"PRIx32, - flags, - pci_get_long(dev->config + msi_address_lo_off(dev))); - if (msi64bit) { - fprintf(stderr, " address-hi: 0x%"PRIx32, - pci_get_long(dev->config + msi_address_hi_off(dev))); - } - fprintf(stderr, " data: 0x%"PRIx16, - pci_get_word(dev->config + msi_data_off(dev, msi64bit))); - if (flags & PCI_MSI_FLAGS_MASKBIT) { - fprintf(stderr, " mask 0x%"PRIx32" pending 0x%"PRIx32, - pci_get_long(dev->config + msi_mask_off(dev, msi64bit)), - pci_get_long(dev->config + msi_pending_off(dev, msi64bit))); - } - fprintf(stderr, "\n"); -#endif - - if (!(flags & PCI_MSI_FLAGS_ENABLE)) { - return; - } - - /* - * Now MSI is enabled, clear INTx# interrupts. - * the driver is prohibited from writing enable bit to mask - * a service request. But the guest OS could do this. - * So we just discard the interrupts as moderate fallback. - * - * 6.8.3.3. Enabling Operation - * While enabled for MSI or MSI-X operation, a function is prohibited - * from using its INTx# pin (if implemented) to request - * service (MSI, MSI-X, and INTx# are mutually exclusive). - */ - pci_device_deassert_intx(dev); - - /* - * nr_vectors might be set bigger than capable. So clamp it. - * This is not legal by spec, so we can do anything we like, - * just don't crash the host - */ - log_num_vecs = - (flags & PCI_MSI_FLAGS_QSIZE) >> (ffs(PCI_MSI_FLAGS_QSIZE) - 1); - log_max_vecs = - (flags & PCI_MSI_FLAGS_QMASK) >> (ffs(PCI_MSI_FLAGS_QMASK) - 1); - if (log_num_vecs > log_max_vecs) { - flags &= ~PCI_MSI_FLAGS_QSIZE; - flags |= log_max_vecs << (ffs(PCI_MSI_FLAGS_QSIZE) - 1); - pci_set_word(dev->config + msi_flags_off(dev), flags); - } - - if (!msi_per_vector_mask) { - /* if per vector masking isn't supported, - there is no pending interrupt. */ - return; - } - - nr_vectors = msi_nr_vectors(flags); - - /* This will discard pending interrupts, if any. */ - pending = pci_get_long(dev->config + msi_pending_off(dev, msi64bit)); - pending &= 0xffffffff >> (PCI_MSI_VECTORS_MAX - nr_vectors); - pci_set_long(dev->config + msi_pending_off(dev, msi64bit), pending); - - /* deliver pending interrupts which are unmasked */ - for (vector = 0; vector < nr_vectors; ++vector) { - if (msi_is_masked(dev, vector) || !(pending & (1U << vector))) { - continue; - } - - pci_long_test_and_clear_mask( - dev->config + msi_pending_off(dev, msi64bit), 1U << vector); - msi_notify(dev, vector); - } -} - -unsigned int msi_nr_vectors_allocated(const PCIDevice *dev) -{ - uint16_t flags = pci_get_word(dev->config + msi_flags_off(dev)); - return msi_nr_vectors(flags); -} |