Delete files from the deprecated branch
Bug: 160884952
Test: presubmit
Signed-off-by: Roman Kiryanov <rkir@google.com>
Change-Id: I07fa78c918ac9819143c5c70282b7bc9e9fdb235
diff --git a/DEPRECATED b/DEPRECATED
new file mode 100644
index 0000000..addbb21
--- /dev/null
+++ b/DEPRECATED
@@ -0,0 +1 @@
+This branch is deprecated, please use android12-5.4 instead.
diff --git a/Kbuild b/Kbuild
deleted file mode 100644
index 45ab612..0000000
--- a/Kbuild
+++ /dev/null
@@ -1,6 +0,0 @@
-goldfish_pipe-objs = goldfish_pipe_base.o goldfish_pipe_v1.o goldfish_pipe_v2.o
-
-obj-m += goldfish_pipe.o
-obj-m += goldfish_sync.o
-obj-m += goldfish_address_space.o
-obj-m += goldfish_battery.o
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 231822e..0000000
--- a/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-all:
- $(MAKE) -C $(KERNEL_SRC) M=$(M) modules $(KBUILD_OPTIONS)
-
-modules_install:
- $(MAKE) M=$(M) -C $(KERNEL_SRC) modules_install
-
-clean:
- $(MAKE) -C $(KERNEL_SRC) M=$(M) clean
diff --git a/build.config.goldfish b/build.config.goldfish
deleted file mode 100644
index 3f961ba..0000000
--- a/build.config.goldfish
+++ /dev/null
@@ -1,5 +0,0 @@
-. ${ROOT_DIR}/common/build.config.common
-. ${ROOT_DIR}/common/build.config.gki
-
-EXT_MODULES="goldfish-modules"
-FRAGMENT_DEFCONFIG_PATH="${ROOT_DIR}/goldfish-modules/goldfish_defconfig.fragment"
diff --git a/build.config.goldfish.aarch64 b/build.config.goldfish.aarch64
deleted file mode 100644
index 7c4def9..0000000
--- a/build.config.goldfish.aarch64
+++ /dev/null
@@ -1,7 +0,0 @@
-. ${ROOT_DIR}/goldfish-modules/build.config.goldfish
-. ${ROOT_DIR}/common/build.config.aarch64
-
-DEFCONFIG=goldfish_aarch64_defconfig
-DEFCONFIG_PATH="${ROOT_DIR}/common/arch/arm64/configs"
-PRE_DEFCONFIG_CMDS="KCONFIG_CONFIG=${DEFCONFIG_PATH}/${DEFCONFIG} ${ROOT_DIR}/common/scripts/kconfig/merge_config.sh -m -r ${DEFCONFIG_PATH}/gki_defconfig ${FRAGMENT_DEFCONFIG_PATH}"
-POST_DEFCONFIG_CMDS="rm ${DEFCONFIG_PATH}/${DEFCONFIG}"
diff --git a/build.config.goldfish.x86_64 b/build.config.goldfish.x86_64
deleted file mode 100644
index 7564b73..0000000
--- a/build.config.goldfish.x86_64
+++ /dev/null
@@ -1,7 +0,0 @@
-. ${ROOT_DIR}/goldfish-modules/build.config.goldfish
-. ${ROOT_DIR}/common/build.config.x86_64
-
-DEFCONFIG=goldfish_86_64_defconfig
-DEFCONFIG_PATH="${ROOT_DIR}/common/arch/x86/configs"
-PRE_DEFCONFIG_CMDS="KCONFIG_CONFIG=${DEFCONFIG_PATH}/${DEFCONFIG} ${ROOT_DIR}/common/scripts/kconfig/merge_config.sh -m -r ${DEFCONFIG_PATH}/gki_defconfig ${FRAGMENT_DEFCONFIG_PATH}"
-POST_DEFCONFIG_CMDS="rm ${DEFCONFIG_PATH}/${DEFCONFIG}"
diff --git a/defconfig_test.h b/defconfig_test.h
deleted file mode 100644
index 6b0dfb6..0000000
--- a/defconfig_test.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/* Put all options we expect gki_defconfig to provide us here */
-
-#ifndef CONFIG_BRIDGE
-#error CONFIG_BRIDGE is required
-#endif
-
-#ifndef CONFIG_VETH
-#error CONFIG_VETH is required
-#endif
-
-#ifndef CONFIG_CFG80211
-#error CONFIG_CFG80211 is required
-#endif
-
-#ifndef CONFIG_NAMESPACES
-#error CONFIG_NAMESPACES is required
-#endif
-
-#ifndef CONFIG_PCI
-#error CONFIG_PCI is required
-#endif
-
-#ifndef CONFIG_ZRAM
-#error CONFIG_ZRAM is required
-#endif
-
-#ifndef CONFIG_ZSMALLOC
-#error CONFIG_ZSMALLOC is required
-#endif
-
-#ifndef CONFIG_COMPAT
-#error CONFIG_COMPAT is required
-#endif
diff --git a/goldfish_address_space.c b/goldfish_address_space.c
deleted file mode 100644
index 6eaaebf..0000000
--- a/goldfish_address_space.c
+++ /dev/null
@@ -1,932 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-
-#include "defconfig_test.h"
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/wait.h>
-#include <linux/fs.h>
-#include <linux/io.h>
-#include <linux/uaccess.h>
-#include <linux/miscdevice.h>
-
-#include <linux/device.h>
-#include <linux/pci_regs.h>
-#include <linux/pci_ids.h>
-#include <linux/pci.h>
-
-#include "uapi/goldfish_address_space.h"
-
-MODULE_DESCRIPTION("A Goldfish driver that allocates address space ranges in "
- "the guest to populate them later in the host. This allows "
- "sharing host's memory with the guest.");
-MODULE_AUTHOR("Roman Kiryanov <rkir@google.com>");
-MODULE_LICENSE("GPL v2");
-
-#define AS_DEBUG 0
-
-#if AS_DEBUG
- #define AS_DPRINT(fmt, ...) \
- printk(KERN_ERR "%s:%d " fmt "\n", \
- __func__, __LINE__, ##__VA_ARGS__);
-#else
- #define AS_DPRINT(fmt, ...)
-#endif
-
-enum as_register_id {
- AS_REGISTER_COMMAND = 0,
- AS_REGISTER_STATUS = 4,
- AS_REGISTER_GUEST_PAGE_SIZE = 8,
- AS_REGISTER_BLOCK_SIZE_LOW = 12,
- AS_REGISTER_BLOCK_SIZE_HIGH = 16,
- AS_REGISTER_BLOCK_OFFSET_LOW = 20,
- AS_REGISTER_BLOCK_OFFSET_HIGH = 24,
- AS_REGISTER_PING = 28,
- AS_REGISTER_PING_INFO_ADDR_LOW = 32,
- AS_REGISTER_PING_INFO_ADDR_HIGH = 36,
- AS_REGISTER_HANDLE = 40,
- AS_REGISTER_PHYS_START_LOW = 44,
- AS_REGISTER_PHYS_START_HIGH = 48,
-};
-
-enum as_command_id {
- AS_COMMAND_ALLOCATE_BLOCK = 1,
- AS_COMMAND_DEALLOCATE_BLOCK = 2,
- AS_COMMAND_GEN_HANDLE = 3,
- AS_COMMAND_DESTROY_HANDLE = 4,
- AS_COMMAND_TELL_PING_INFO_ADDR = 5,
-};
-
-#define AS_PCI_VENDOR_ID 0x607D
-#define AS_PCI_DEVICE_ID 0xF153
-#define AS_ALLOCATED_BLOCKS_INITIAL_CAPACITY 32
-#define AS_INVALID_HANDLE (~(0))
-
-enum as_pci_bar_id {
- AS_PCI_CONTROL_BAR_ID = 0,
- AS_PCI_AREA_BAR_ID = 1,
-};
-
-struct as_device_state {
- struct miscdevice miscdevice;
- struct pci_dev *dev;
- struct as_driver_state *driver_state;
-
- void __iomem *io_registers;
-
- void *address_area; /* to claim the address space */
-
- /* physical address to allocate from */
- unsigned long address_area_phys_address;
-
- struct mutex registers_lock; /* protects registers */
-};
-
-struct as_block {
- u64 offset;
- u64 size;
-};
-
-struct as_allocated_blocks {
- struct as_block *blocks; /* a dynamic array of allocated blocks */
- int blocks_size;
- int blocks_capacity;
- struct mutex blocks_lock; /* protects operations with blocks */
-};
-
-struct as_file_state {
- struct as_device_state *device_state;
- struct as_allocated_blocks allocated_blocks;
- struct as_allocated_blocks shared_allocated_blocks;
- struct goldfish_address_space_ping *ping_info;
- struct mutex ping_info_lock; /* protects ping_info */
- u32 handle; /* handle generated by the host */
-};
-
-static void __iomem *as_register_address(void __iomem *base,
- int offset)
-{
- WARN_ON(!base);
-
- return ((char __iomem *)base) + offset;
-}
-
-static void as_write_register(void __iomem *registers,
- int offset,
- u32 value)
-{
- writel(value, as_register_address(registers, offset));
-}
-
-static u32 as_read_register(void __iomem *registers, int offset)
-{
- return readl(as_register_address(registers, offset));
-}
-
-static int as_run_command(struct as_device_state *state, enum as_command_id cmd)
-{
- WARN_ON(!state);
-
- as_write_register(state->io_registers, AS_REGISTER_COMMAND, cmd);
- return -as_read_register(state->io_registers, AS_REGISTER_STATUS);
-}
-
-static void as_ping_impl(struct as_device_state *state, u32 handle)
-{
- as_write_register(state->io_registers, AS_REGISTER_PING, handle);
-}
-
-static long
-as_ioctl_allocate_block_locked_impl(struct as_device_state *state,
- u64 *size, u64 *offset)
-{
- long res;
-
- as_write_register(state->io_registers,
- AS_REGISTER_BLOCK_SIZE_LOW,
- lower_32_bits(*size));
- as_write_register(state->io_registers,
- AS_REGISTER_BLOCK_SIZE_HIGH,
- upper_32_bits(*size));
-
- res = as_run_command(state, AS_COMMAND_ALLOCATE_BLOCK);
- if (!res) {
- u64 low = as_read_register(state->io_registers,
- AS_REGISTER_BLOCK_OFFSET_LOW);
- u64 high = as_read_register(state->io_registers,
- AS_REGISTER_BLOCK_OFFSET_HIGH);
- *offset = low | (high << 32);
-
- low = as_read_register(state->io_registers,
- AS_REGISTER_BLOCK_SIZE_LOW);
- high = as_read_register(state->io_registers,
- AS_REGISTER_BLOCK_SIZE_HIGH);
- *size = low | (high << 32);
- }
-
- return res;
-}
-
-static long
-as_ioctl_unallocate_block_locked_impl(struct as_device_state *state, u64 offset)
-{
- as_write_register(state->io_registers,
- AS_REGISTER_BLOCK_OFFSET_LOW,
- lower_32_bits(offset));
- as_write_register(state->io_registers,
- AS_REGISTER_BLOCK_OFFSET_HIGH,
- upper_32_bits(offset));
-
- return as_run_command(state, AS_COMMAND_DEALLOCATE_BLOCK);
-}
-
-static int as_blocks_grow_capacity(int old_capacity)
-{
- WARN_ON(old_capacity < 0);
-
- return old_capacity + old_capacity;
-}
-
-static int
-as_blocks_insert(struct as_allocated_blocks *allocated_blocks,
- u64 offset,
- u64 size)
-{
- int blocks_size;
-
- if (mutex_lock_interruptible(&allocated_blocks->blocks_lock))
- return -ERESTARTSYS;
-
- blocks_size = allocated_blocks->blocks_size;
-
- WARN_ON(allocated_blocks->blocks_capacity < 1);
- WARN_ON(allocated_blocks->blocks_capacity <
- allocated_blocks->blocks_size);
- WARN_ON(!allocated_blocks->blocks);
-
- if (allocated_blocks->blocks_capacity == blocks_size) {
- int new_capacity =
- as_blocks_grow_capacity(
- allocated_blocks->blocks_capacity);
- struct as_block *new_blocks =
- kcalloc(new_capacity,
- sizeof(allocated_blocks->blocks[0]),
- GFP_KERNEL);
-
- if (!new_blocks) {
- mutex_unlock(&allocated_blocks->blocks_lock);
- return -ENOMEM;
- }
-
- memcpy(new_blocks, allocated_blocks->blocks,
- blocks_size * sizeof(allocated_blocks->blocks[0]));
-
- kfree(allocated_blocks->blocks);
- allocated_blocks->blocks = new_blocks;
- allocated_blocks->blocks_capacity = new_capacity;
- }
-
- WARN_ON(blocks_size >= allocated_blocks->blocks_capacity);
-
- allocated_blocks->blocks[blocks_size] =
- (struct as_block){ .offset = offset, .size = size };
- allocated_blocks->blocks_size = blocks_size + 1;
-
- mutex_unlock(&allocated_blocks->blocks_lock);
- return 0;
-}
-
-static int
-as_blocks_remove(struct as_allocated_blocks *allocated_blocks, u64 offset)
-{
- long res = -ENXIO;
- struct as_block *blocks;
- int blocks_size;
- int i;
-
- if (mutex_lock_interruptible(&allocated_blocks->blocks_lock))
- return -ERESTARTSYS;
-
- blocks = allocated_blocks->blocks;
- WARN_ON(!blocks);
-
- blocks_size = allocated_blocks->blocks_size;
- WARN_ON(blocks_size < 0);
-
- for (i = 0; i < blocks_size; ++i) {
- if (offset == blocks[i].offset) {
- int last = blocks_size - 1;
-
- if (last > i)
- blocks[i] = blocks[last];
-
- --allocated_blocks->blocks_size;
- res = 0;
- break;
- }
- }
-
- if (res)
- pr_err("%s: Block not found atoffset: 0x%llx\n",
- __func__, offset);
-
- mutex_unlock(&allocated_blocks->blocks_lock);
- return res;
-}
-
-static int
-as_blocks_check_if_mine(struct as_allocated_blocks *allocated_blocks,
- u64 offset,
- u64 size)
-{
- const u64 end = offset + size;
- int res = -EPERM;
- struct as_block *block;
- int blocks_size;
-
- if (mutex_lock_interruptible(&allocated_blocks->blocks_lock))
- return -ERESTARTSYS;
-
- block = allocated_blocks->blocks;
- WARN_ON(!block);
-
- blocks_size = allocated_blocks->blocks_size;
- WARN_ON(blocks_size < 0);
-
- for (; blocks_size > 0; --blocks_size, ++block) {
- u64 block_offset = block->offset;
- u64 block_end = block_offset + block->size;
-
- if (offset >= block_offset && end <= block_end) {
- res = 0;
- break;
- }
- }
-
- mutex_unlock(&allocated_blocks->blocks_lock);
- return res;
-}
-
-static int as_open(struct inode *inode, struct file *filp)
-{
- struct as_file_state *file_state;
- struct as_device_state *device_state;
- struct goldfish_address_space_ping *ping_info;
- u64 ping_info_phys;
- u64 ping_info_phys_returned;
- int err;
-
- AS_DPRINT("Get free page");
- ping_info =
- (struct goldfish_address_space_ping *)
- __get_free_page(GFP_KERNEL);
- ping_info_phys = virt_to_phys(ping_info);
- AS_DPRINT("Got free page: %p 0x%llx", ping_info,
- (unsigned long long)ping_info_phys);
-
- if (!ping_info) {
- printk(KERN_ERR "Could not alloc goldfish_address_space command buffer!\n");
- err = -ENOMEM;
- goto err_ping_info_alloc_failed;
- }
-
- file_state = kzalloc(sizeof(*file_state), GFP_KERNEL);
- if (!file_state) {
- err = -ENOMEM;
- goto err_file_state_alloc_failed;
- }
-
- file_state->device_state =
- container_of(filp->private_data,
- struct as_device_state,
- miscdevice);
- device_state = file_state->device_state;
-
- file_state->allocated_blocks.blocks =
- kcalloc(AS_ALLOCATED_BLOCKS_INITIAL_CAPACITY,
- sizeof(file_state->allocated_blocks.blocks[0]),
- GFP_KERNEL);
-
- if (!file_state->allocated_blocks.blocks) {
- err = -ENOMEM;
- goto err_file_state_blocks_alloc_failed;
- }
-
- file_state->shared_allocated_blocks.blocks =
- kcalloc(
- AS_ALLOCATED_BLOCKS_INITIAL_CAPACITY,
- sizeof(file_state->shared_allocated_blocks.blocks[0]),
- GFP_KERNEL);
-
- if (!file_state->shared_allocated_blocks.blocks) {
- err = -ENOMEM;
- goto err_file_state_blocks_alloc_failed;
- }
-
- file_state->allocated_blocks.blocks_size = 0;
- file_state->allocated_blocks.blocks_capacity =
- AS_ALLOCATED_BLOCKS_INITIAL_CAPACITY;
- mutex_init(&file_state->allocated_blocks.blocks_lock);
-
- file_state->shared_allocated_blocks.blocks_size = 0;
- file_state->shared_allocated_blocks.blocks_capacity =
- AS_ALLOCATED_BLOCKS_INITIAL_CAPACITY;
- mutex_init(&file_state->shared_allocated_blocks.blocks_lock);
-
- mutex_init(&file_state->ping_info_lock);
- file_state->ping_info = ping_info;
-
- AS_DPRINT("Acq regs lock");
- mutex_lock(&device_state->registers_lock);
- AS_DPRINT("Got regs lock, gen handle");
- as_run_command(device_state, AS_COMMAND_GEN_HANDLE);
- file_state->handle = as_read_register(
- device_state->io_registers,
- AS_REGISTER_HANDLE);
- AS_DPRINT("Got regs lock, read handle: %u", file_state->handle);
- mutex_unlock(&device_state->registers_lock);
-
- if (file_state->handle == AS_INVALID_HANDLE) {
- err = -EINVAL;
- goto err_gen_handle_failed;
- }
-
- AS_DPRINT("Acq regs lock 2");
- mutex_lock(&device_state->registers_lock);
- AS_DPRINT("Acqd regs lock 2, write handle and ping info addr");
- as_write_register(
- device_state->io_registers,
- AS_REGISTER_HANDLE,
- file_state->handle);
- as_write_register(
- device_state->io_registers,
- AS_REGISTER_PING_INFO_ADDR_LOW,
- lower_32_bits(ping_info_phys));
- as_write_register(
- device_state->io_registers,
- AS_REGISTER_PING_INFO_ADDR_HIGH,
- upper_32_bits(ping_info_phys));
- AS_DPRINT("Do tell ping info addr");
- as_run_command(device_state, AS_COMMAND_TELL_PING_INFO_ADDR);
- ping_info_phys_returned =
- ((u64)as_read_register(device_state->io_registers,
- AS_REGISTER_PING_INFO_ADDR_LOW)) |
- ((u64)as_read_register(device_state->io_registers,
- AS_REGISTER_PING_INFO_ADDR_HIGH) << 32);
- AS_DPRINT("Read back");
-
- if (ping_info_phys != ping_info_phys_returned) {
- printk(KERN_ERR "%s: Invalid result for ping info phys addr: expected 0x%llx, got 0x%llx\n",
- __func__,
- ping_info_phys, ping_info_phys_returned);
- err = -EINVAL;
- goto err_ping_info_failed;
- }
-
- mutex_unlock(&device_state->registers_lock);
-
- filp->private_data = file_state;
- return 0;
-
-err_ping_info_failed:
-err_gen_handle_failed:
- kfree(file_state->allocated_blocks.blocks);
- kfree(file_state->shared_allocated_blocks.blocks);
-err_file_state_blocks_alloc_failed:
- kfree(file_state);
-err_file_state_alloc_failed:
- free_page((unsigned long)ping_info);
-err_ping_info_alloc_failed:
- return err;
-}
-
-static int as_release(struct inode *inode, struct file *filp)
-{
- struct as_file_state *file_state = filp->private_data;
- struct as_allocated_blocks *allocated_blocks =
- &file_state->allocated_blocks;
- struct as_allocated_blocks *shared_allocated_blocks =
- &file_state->shared_allocated_blocks;
- struct goldfish_address_space_ping *ping_info = file_state->ping_info;
- struct as_device_state *state = file_state->device_state;
- int blocks_size, shared_blocks_size;
- int i;
-
- WARN_ON(!state);
- WARN_ON(!allocated_blocks);
- WARN_ON(!allocated_blocks->blocks);
- WARN_ON(allocated_blocks->blocks_size < 0);
- WARN_ON(!shared_allocated_blocks);
- WARN_ON(!shared_allocated_blocks->blocks);
- WARN_ON(shared_allocated_blocks->blocks_size < 0);
- WARN_ON(!ping_info);
-
- blocks_size = allocated_blocks->blocks_size;
- shared_blocks_size = shared_allocated_blocks->blocks_size;
-
- mutex_lock(&state->registers_lock);
-
- as_write_register(state->io_registers, AS_REGISTER_HANDLE,
- file_state->handle);
- as_run_command(state, AS_COMMAND_DESTROY_HANDLE);
-
- for (i = 0; i < blocks_size; ++i) {
- WARN_ON(as_ioctl_unallocate_block_locked_impl(
- state, allocated_blocks->blocks[i].offset));
- }
-
- // Do not unalloc shared blocks as they are host-owned
-
- mutex_unlock(&state->registers_lock);
-
- kfree(allocated_blocks->blocks);
- kfree(shared_allocated_blocks->blocks);
- free_page((unsigned long)ping_info);
- kfree(file_state);
- return 0;
-}
-
-static int as_mmap_impl(struct as_device_state *state,
- size_t size,
- struct vm_area_struct *vma)
-{
- unsigned long pfn = (state->address_area_phys_address >> PAGE_SHIFT) +
- vma->vm_pgoff;
-
- return remap_pfn_range(vma,
- vma->vm_start,
- pfn,
- size,
- vma->vm_page_prot);
-}
-
-static int as_mmap(struct file *filp, struct vm_area_struct *vma)
-{
- struct as_file_state *file_state = filp->private_data;
- struct as_allocated_blocks *allocated_blocks =
- &file_state->allocated_blocks;
- struct as_allocated_blocks *shared_allocated_blocks =
- &file_state->shared_allocated_blocks;
- size_t size = PAGE_ALIGN(vma->vm_end - vma->vm_start);
- int res_check_nonshared, res_check_shared;
-
- WARN_ON(!allocated_blocks);
-
- res_check_nonshared =
- as_blocks_check_if_mine(allocated_blocks,
- vma->vm_pgoff << PAGE_SHIFT,
- size);
-
- res_check_shared =
- as_blocks_check_if_mine(shared_allocated_blocks,
- vma->vm_pgoff << PAGE_SHIFT,
- size);
-
- if (res_check_nonshared && res_check_shared)
- return res_check_nonshared;
- else
- return as_mmap_impl(file_state->device_state, size, vma);
-}
-
-static long as_ioctl_allocate_block_impl(
- struct as_device_state *state,
- struct goldfish_address_space_allocate_block *request)
-{
- long res;
-
- if (mutex_lock_interruptible(&state->registers_lock))
- return -ERESTARTSYS;
-
- res = as_ioctl_allocate_block_locked_impl(state,
- &request->size,
- &request->offset);
- if (!res) {
- request->phys_addr =
- state->address_area_phys_address + request->offset;
- }
-
- mutex_unlock(&state->registers_lock);
- return res;
-}
-
-static void
-as_ioctl_unallocate_block_impl(struct as_device_state *state, u64 offset)
-{
- mutex_lock(&state->registers_lock);
- WARN_ON(as_ioctl_unallocate_block_locked_impl(state, offset));
- mutex_unlock(&state->registers_lock);
-}
-
-static long
-as_ioctl_allocate_block(struct as_allocated_blocks *allocated_blocks,
- struct as_device_state *state,
- void __user *ptr)
-{
- long res;
- struct goldfish_address_space_allocate_block request;
-
- if (copy_from_user(&request, ptr, sizeof(request)))
- return -EFAULT;
-
- res = as_ioctl_allocate_block_impl(state, &request);
- if (!res) {
- res = as_blocks_insert(allocated_blocks,
- request.offset,
- request.size);
-
- if (res) {
- as_ioctl_unallocate_block_impl(state, request.offset);
- } else if (copy_to_user(ptr, &request, sizeof(request))) {
- as_ioctl_unallocate_block_impl(state, request.offset);
- res = -EFAULT;
- }
- }
-
- return res;
-}
-
-static long
-as_ioctl_unallocate_block(struct as_allocated_blocks *allocated_blocks,
- struct as_device_state *state,
- void __user *ptr)
-{
- long res;
- u64 offset;
-
- if (copy_from_user(&offset, ptr, sizeof(offset)))
- return -EFAULT;
-
- res = as_blocks_remove(allocated_blocks, offset);
- if (!res)
- as_ioctl_unallocate_block_impl(state, offset);
-
- return res;
-}
-
-static long
-as_ioctl_claim_block(struct as_allocated_blocks *allocated_blocks,
- struct as_device_state *state,
- void __user *ptr)
-{
- long res;
- struct goldfish_address_space_claim_shared request;
-
- if (copy_from_user(&request, ptr, sizeof(request)))
- return -EFAULT;
-
- res = as_blocks_insert(allocated_blocks,
- request.offset,
- request.size);
-
- if (res)
- return res;
- else if (copy_to_user(ptr, &request, sizeof(request)))
- return -EFAULT;
-
- return 0;
-}
-
-static long
-as_ioctl_unclaim_block(struct as_allocated_blocks *allocated_blocks,
- struct as_device_state *state,
- void __user *ptr)
-{
- long res;
- u64 offset;
-
- if (copy_from_user(&offset, ptr, sizeof(offset)))
- return -EFAULT;
-
- res = as_blocks_remove(allocated_blocks, offset);
- if (res)
- pr_err("%s: as_blocks_remove failed (%ld)\n", __func__, res);
-
- return res;
-}
-
-static long
-as_ioctl_ping_impl(struct goldfish_address_space_ping *ping_info,
- struct as_device_state *state,
- u32 handle,
- void __user *ptr)
-{
- struct goldfish_address_space_ping user_copy;
-
- if (copy_from_user(&user_copy, ptr, sizeof(user_copy)))
- return -EFAULT;
-
- *ping_info = user_copy;
-
- // Convert to phys addrs
- ping_info->offset += state->address_area_phys_address;
-
- mutex_lock(&state->registers_lock);
- as_ping_impl(state, handle);
- mutex_unlock(&state->registers_lock);
-
- memcpy(&user_copy, ping_info, sizeof(user_copy));
- if (copy_to_user(ptr, &user_copy, sizeof(user_copy)))
- return -EFAULT;
-
- return 0;
-}
-
-static long as_ioctl_ping(struct as_file_state *file_state, void __user *ptr)
-{
- long ret;
-
- mutex_lock(&file_state->ping_info_lock);
- ret = as_ioctl_ping_impl(file_state->ping_info,
- file_state->device_state,
- file_state->handle,
- ptr);
- mutex_unlock(&file_state->ping_info_lock);
-
- return ret;
-}
-
-static long as_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
- struct as_file_state *file_state = filp->private_data;
- long res = -ENOTTY;
-
- switch (cmd) {
- case GOLDFISH_ADDRESS_SPACE_IOCTL_ALLOCATE_BLOCK:
- res = as_ioctl_allocate_block(&file_state->allocated_blocks,
- file_state->device_state,
- (void __user *)arg);
- break;
-
- case GOLDFISH_ADDRESS_SPACE_IOCTL_DEALLOCATE_BLOCK:
- res = as_ioctl_unallocate_block(&file_state->allocated_blocks,
- file_state->device_state,
- (void __user *)arg);
- break;
-
- case GOLDFISH_ADDRESS_SPACE_IOCTL_PING:
- res = as_ioctl_ping(file_state, (void __user *)arg);
- break;
-
- case GOLDFISH_ADDRESS_SPACE_IOCTL_CLAIM_SHARED:
- res = as_ioctl_claim_block(
- &file_state->shared_allocated_blocks,
- file_state->device_state,
- (void __user *)arg);
- break;
-
- case GOLDFISH_ADDRESS_SPACE_IOCTL_UNCLAIM_SHARED:
- res = as_ioctl_unclaim_block(
- &file_state->shared_allocated_blocks,
- file_state->device_state,
- (void __user *)arg);
- break;
-
- default:
- res = -ENOTTY;
- }
-
- return res;
-}
-
-static const struct file_operations userspace_file_operations = {
- .owner = THIS_MODULE,
- .open = as_open,
- .release = as_release,
- .mmap = as_mmap,
- .unlocked_ioctl = as_ioctl,
- .compat_ioctl = as_ioctl,
-};
-
-static void __iomem __must_check *ioremap_pci_bar(struct pci_dev *dev,
- int bar_id)
-{
- void __iomem *io;
- unsigned long size = pci_resource_len(dev, bar_id);
-
- if (!size)
- return IOMEM_ERR_PTR(-ENXIO);
-
- io = ioremap(pci_resource_start(dev, bar_id), size);
- if (!io)
- return IOMEM_ERR_PTR(-ENOMEM);
-
- return io;
-}
-
-static void __must_check *memremap_pci_bar(struct pci_dev *dev,
- int bar_id,
- unsigned long flags)
-{
- void *mem;
- unsigned long size = pci_resource_len(dev, bar_id);
-
- if (!size)
- return ERR_PTR(-ENXIO);
-
- mem = memremap(pci_resource_start(dev, bar_id), size, flags);
- if (!mem)
- return ERR_PTR(-ENOMEM);
-
- return mem;
-}
-
-
-static void fill_miscdevice(struct miscdevice *miscdev)
-{
- memset(miscdev, 0, sizeof(*miscdev));
-
- miscdev->minor = MISC_DYNAMIC_MINOR;
- miscdev->name = GOLDFISH_ADDRESS_SPACE_DEVICE_NAME;
- miscdev->fops = &userspace_file_operations;
-}
-
-static int __must_check
-create_as_device(struct pci_dev *dev, const struct pci_device_id *id)
-{
- int res;
- struct as_device_state *state;
-
- state = kzalloc(sizeof(*state), GFP_KERNEL);
- if (!state)
- return -ENOMEM;
-
- res = pci_request_region(dev,
- AS_PCI_CONTROL_BAR_ID,
- "Address space control");
- if (res) {
- pr_err("(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR%d",
- dev->bus->number,
- dev->devfn,
- AS_PCI_CONTROL_BAR_ID);
- goto out_free_device_state;
- }
-
- res = pci_request_region(dev,
- AS_PCI_AREA_BAR_ID,
- "Address space area");
- if (res) {
- pr_err("(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR%d",
- dev->bus->number,
- dev->devfn,
- AS_PCI_AREA_BAR_ID);
- goto out_release_control_bar;
- }
-
- fill_miscdevice(&state->miscdevice);
- res = misc_register(&state->miscdevice);
- if (res)
- goto out_release_area_bar;
-
- state->io_registers = ioremap_pci_bar(dev,
- AS_PCI_CONTROL_BAR_ID);
- if (IS_ERR(state->io_registers)) {
- res = PTR_ERR(state->io_registers);
- goto out_misc_deregister;
- }
-
- state->address_area = memremap_pci_bar(dev,
- AS_PCI_AREA_BAR_ID,
- MEMREMAP_WB);
- if (IS_ERR(state->address_area)) {
- res = PTR_ERR(state->address_area);
- goto out_iounmap;
- }
-
- state->address_area_phys_address =
- pci_resource_start(dev, AS_PCI_AREA_BAR_ID);
-
- as_write_register(state->io_registers,
- AS_REGISTER_GUEST_PAGE_SIZE,
- PAGE_SIZE);
- as_write_register(state->io_registers,
- AS_REGISTER_PHYS_START_LOW,
- lower_32_bits(state->address_area_phys_address));
- as_write_register(state->io_registers,
- AS_REGISTER_PHYS_START_HIGH,
- upper_32_bits(state->address_area_phys_address));
-
- state->dev = dev;
- mutex_init(&state->registers_lock);
-
- pci_set_drvdata(dev, state);
- return 0;
-
-out_iounmap:
- iounmap(state->io_registers);
-out_misc_deregister:
- misc_deregister(&state->miscdevice);
-out_release_area_bar:
- pci_release_region(dev, AS_PCI_AREA_BAR_ID);
-out_release_control_bar:
- pci_release_region(dev, AS_PCI_CONTROL_BAR_ID);
-out_free_device_state:
- kzfree(state);
-
- return res;
-}
-
-static void as_pci_destroy_device(struct as_device_state *state)
-{
- memunmap(state->address_area);
- iounmap(state->io_registers);
- misc_deregister(&state->miscdevice);
- pci_release_region(state->dev, AS_PCI_AREA_BAR_ID);
- pci_release_region(state->dev, AS_PCI_CONTROL_BAR_ID);
- kfree(state);
-}
-
-static int __must_check
-as_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
-{
- int res;
- u8 hardware_revision;
-
- res = pci_enable_device(dev);
- if (res)
- return res;
-
- res = pci_read_config_byte(dev, PCI_REVISION_ID, &hardware_revision);
- if (res)
- goto out_disable_pci;
-
- switch (hardware_revision) {
- case 1:
- res = create_as_device(dev, id);
- break;
-
- default:
- res = -ENODEV;
- goto out_disable_pci;
- }
-
- return 0;
-
-out_disable_pci:
- pci_disable_device(dev);
-
- return res;
-}
-
-static void as_pci_remove(struct pci_dev *dev)
-{
- struct as_device_state *state = pci_get_drvdata(dev);
-
- as_pci_destroy_device(state);
- pci_disable_device(dev);
-}
-
-static const struct pci_device_id as_pci_tbl[] = {
- { PCI_DEVICE(AS_PCI_VENDOR_ID, AS_PCI_DEVICE_ID), },
- { }
-};
-MODULE_DEVICE_TABLE(pci, as_pci_tbl);
-
-static struct pci_driver goldfish_address_space_driver = {
- .name = GOLDFISH_ADDRESS_SPACE_DEVICE_NAME,
- .id_table = as_pci_tbl,
- .probe = as_pci_probe,
- .remove = as_pci_remove,
-};
-
-module_pci_driver(goldfish_address_space_driver);
diff --git a/goldfish_battery.c b/goldfish_battery.c
deleted file mode 100644
index 08f789c..0000000
--- a/goldfish_battery.c
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- * Power supply driver for the goldfish emulator
- *
- * Copyright (C) 2008 Google, Inc.
- * Copyright (C) 2012 Intel, Inc.
- * Copyright (C) 2013 Intel, Inc.
- * Author: Mike Lockwood <lockwood@android.com>
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- */
-
-#include <linux/module.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/power_supply.h>
-#include <linux/types.h>
-#include <linux/pci.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/acpi.h>
-
-#define POWER_SUPPLY_CURRENT_UA (900000) /* in uAmp */
-#define POWER_SUPPLY_CHARGE_FULL_UAH (300000) /* in uAmp*H */
-
-struct goldfish_battery_data {
- void __iomem *reg_base;
- int irq;
- spinlock_t lock;
-
- struct power_supply *battery;
- struct power_supply *ac;
-};
-
-#define GOLDFISH_BATTERY_READ(data, addr) \
- (readl(data->reg_base + addr))
-#define GOLDFISH_BATTERY_WRITE(data, addr, x) \
- (writel(x, data->reg_base + addr))
-
-/*
- * Temporary variable used between goldfish_battery_probe() and
- * goldfish_battery_open().
- */
-static struct goldfish_battery_data *battery_data;
-
-enum {
- /* status register */
- BATTERY_INT_STATUS = 0x00,
- /* set this to enable IRQ */
- BATTERY_INT_ENABLE = 0x04,
- BATTERY_AC_ONLINE = 0x08,
- BATTERY_STATUS = 0x0C,
- BATTERY_HEALTH = 0x10,
- BATTERY_PRESENT = 0x14,
- BATTERY_CAPACITY = 0x18,
- BATTERY_VOLTAGE = 0x1C,
- BATTERY_TEMP = 0x20,
- BATTERY_CHARGE_COUNTER = 0x24,
- BATTERY_VOLTAGE_MAX = 0x28,
- BATTERY_CURRENT_MAX = 0x2c,
- BATTERY_STATUS_CHANGED = 1U << 0,
- AC_STATUS_CHANGED = 1U << 1,
- BATTERY_INT_MASK = BATTERY_STATUS_CHANGED | AC_STATUS_CHANGED,
-};
-
-
-static int goldfish_ac_get_property(struct power_supply *psy,
- enum power_supply_property psp,
- union power_supply_propval *val)
-{
- struct goldfish_battery_data *data = power_supply_get_drvdata(psy);
- int ret = 0;
-
- switch (psp) {
- case POWER_SUPPLY_PROP_ONLINE:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_AC_ONLINE);
- break;
-
- case POWER_SUPPLY_PROP_VOLTAGE_MAX:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_VOLTAGE_MAX);
- break;
- case POWER_SUPPLY_PROP_CURRENT_MAX:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CURRENT_MAX);
- break;
- default:
- ret = -EINVAL;
- break;
- }
- return ret;
-}
-
-static int goldfish_battery_get_property(struct power_supply *psy,
- enum power_supply_property psp,
- union power_supply_propval *val)
-{
- struct goldfish_battery_data *data = power_supply_get_drvdata(psy);
- int ret = 0;
-
- switch (psp) {
- case POWER_SUPPLY_PROP_STATUS:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);
- break;
- case POWER_SUPPLY_PROP_HEALTH:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);
- break;
- case POWER_SUPPLY_PROP_PRESENT:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);
- break;
- case POWER_SUPPLY_PROP_TECHNOLOGY:
- val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
- break;
- case POWER_SUPPLY_PROP_CAPACITY:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);
- break;
- case POWER_SUPPLY_PROP_VOLTAGE_NOW:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_VOLTAGE);
- break;
- case POWER_SUPPLY_PROP_TEMP:
- val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_TEMP);
- break;
- case POWER_SUPPLY_PROP_CHARGE_COUNTER:
- val->intval = GOLDFISH_BATTERY_READ(data,
- BATTERY_CHARGE_COUNTER);
- break;
- case POWER_SUPPLY_PROP_CURRENT_NOW:
- val->intval = POWER_SUPPLY_CURRENT_UA;
- break;
- case POWER_SUPPLY_PROP_CURRENT_AVG:
- val->intval = POWER_SUPPLY_CURRENT_UA;
- break;
- case POWER_SUPPLY_PROP_CHARGE_FULL:
- val->intval = POWER_SUPPLY_CHARGE_FULL_UAH;
- break;
- case POWER_SUPPLY_PROP_CYCLE_COUNT:
- val->intval = 10;
- break;
- default:
- ret = -EINVAL;
- break;
- }
-
- return ret;
-}
-
-static enum power_supply_property goldfish_battery_props[] = {
- POWER_SUPPLY_PROP_STATUS,
- POWER_SUPPLY_PROP_HEALTH,
- POWER_SUPPLY_PROP_PRESENT,
- POWER_SUPPLY_PROP_TECHNOLOGY,
- POWER_SUPPLY_PROP_CAPACITY,
- POWER_SUPPLY_PROP_VOLTAGE_NOW,
- POWER_SUPPLY_PROP_TEMP,
- POWER_SUPPLY_PROP_CHARGE_COUNTER,
- POWER_SUPPLY_PROP_CURRENT_NOW,
- POWER_SUPPLY_PROP_CURRENT_AVG,
- POWER_SUPPLY_PROP_CHARGE_FULL,
- POWER_SUPPLY_PROP_CYCLE_COUNT,
-};
-
-static enum power_supply_property goldfish_ac_props[] = {
- POWER_SUPPLY_PROP_ONLINE,
- POWER_SUPPLY_PROP_VOLTAGE_MAX,
- POWER_SUPPLY_PROP_CURRENT_MAX,
-};
-
-static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)
-{
- unsigned long irq_flags;
- struct goldfish_battery_data *data = dev_id;
- uint32_t status;
-
- spin_lock_irqsave(&data->lock, irq_flags);
-
- /* read status flags, which will clear the interrupt */
- status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);
- status &= BATTERY_INT_MASK;
-
- if (status & BATTERY_STATUS_CHANGED)
- power_supply_changed(data->battery);
- if (status & AC_STATUS_CHANGED)
- power_supply_changed(data->ac);
-
- spin_unlock_irqrestore(&data->lock, irq_flags);
- return status ? IRQ_HANDLED : IRQ_NONE;
-}
-
-static const struct power_supply_desc battery_desc = {
- .properties = goldfish_battery_props,
- .num_properties = ARRAY_SIZE(goldfish_battery_props),
- .get_property = goldfish_battery_get_property,
- .name = "battery",
- .type = POWER_SUPPLY_TYPE_BATTERY,
-};
-
-static const struct power_supply_desc ac_desc = {
- .properties = goldfish_ac_props,
- .num_properties = ARRAY_SIZE(goldfish_ac_props),
- .get_property = goldfish_ac_get_property,
- .name = "ac",
- .type = POWER_SUPPLY_TYPE_MAINS,
-};
-
-static int goldfish_battery_probe(struct platform_device *pdev)
-{
- int ret;
- struct resource *r;
- struct goldfish_battery_data *data;
- struct power_supply_config psy_cfg = {};
-
- data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
- if (data == NULL)
- return -ENOMEM;
-
- spin_lock_init(&data->lock);
-
- r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (r == NULL) {
- dev_err(&pdev->dev, "platform_get_resource failed\n");
- return -ENODEV;
- }
-
- data->reg_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
- if (data->reg_base == NULL) {
- dev_err(&pdev->dev, "unable to remap MMIO\n");
- return -ENOMEM;
- }
-
- data->irq = platform_get_irq(pdev, 0);
- if (data->irq < 0) {
- dev_err(&pdev->dev, "platform_get_irq failed\n");
- return -ENODEV;
- }
-
- ret = devm_request_irq(&pdev->dev, data->irq, goldfish_battery_interrupt,
- IRQF_SHARED, pdev->name, data);
- if (ret)
- return ret;
-
- psy_cfg.drv_data = data;
-
- data->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg);
- if (IS_ERR(data->ac))
- return PTR_ERR(data->ac);
-
- data->battery = power_supply_register(&pdev->dev, &battery_desc,
- &psy_cfg);
- if (IS_ERR(data->battery)) {
- power_supply_unregister(data->ac);
- return PTR_ERR(data->battery);
- }
-
- platform_set_drvdata(pdev, data);
- battery_data = data;
-
- GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);
- return 0;
-}
-
-static int goldfish_battery_remove(struct platform_device *pdev)
-{
- struct goldfish_battery_data *data = platform_get_drvdata(pdev);
-
- power_supply_unregister(data->battery);
- power_supply_unregister(data->ac);
- battery_data = NULL;
- return 0;
-}
-
-static const struct of_device_id goldfish_battery_of_match[] = {
- { .compatible = "google,goldfish-battery", },
- {},
-};
-MODULE_DEVICE_TABLE(of, goldfish_battery_of_match);
-
-static const struct acpi_device_id goldfish_battery_acpi_match[] = {
- { "GFSH0001", 0 },
- { },
-};
-MODULE_DEVICE_TABLE(acpi, goldfish_battery_acpi_match);
-
-static struct platform_driver goldfish_battery_device = {
- .probe = goldfish_battery_probe,
- .remove = goldfish_battery_remove,
- .driver = {
- .name = "goldfish-battery",
- .of_match_table = goldfish_battery_of_match,
- .acpi_match_table = ACPI_PTR(goldfish_battery_acpi_match),
- }
-};
-module_platform_driver(goldfish_battery_device);
-
-MODULE_AUTHOR("Mike Lockwood lockwood@android.com");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Battery driver for the Goldfish emulator");
diff --git a/goldfish_defconfig.fragment b/goldfish_defconfig.fragment
deleted file mode 100644
index 2a7f522..0000000
--- a/goldfish_defconfig.fragment
+++ /dev/null
@@ -1,23 +0,0 @@
-# CONFIG_CRYPTO_DEV_VIRTIO is not set
-
-CONFIG_BLK_DEV_MD=m
-CONFIG_CPUFREQ_DUMMY=m
-CONFIG_DRM_VIRTIO_GPU=m
-CONFIG_HW_RANDOM_VIRTIO=m
-CONFIG_MAC80211_HWSIM=m
-CONFIG_RTC_DRV_TEST=m
-CONFIG_SDCARD_FS=m
-CONFIG_SND_HDA_CODEC_REALTEK=m
-CONFIG_SND_HDA_INTEL=m
-CONFIG_TEST_STACKINIT=m
-CONFIG_TEST_MEMINIT=m
-CONFIG_USB_DUMMY_HCD=m
-CONFIG_VIRTIO_BLK=m
-CONFIG_VIRTIO_CONSOLE=m
-CONFIG_VIRTIO_INPUT=m
-CONFIG_VIRTIO_MMIO=m
-CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y
-CONFIG_VIRTIO_NET=m
-CONFIG_VIRTIO_PCI=m
-CONFIG_VIRTIO_PMEM=m
-CONFIG_INCREMENTAL_FS=m
diff --git a/goldfish_pipe.h b/goldfish_pipe.h
deleted file mode 100644
index 385e306..0000000
--- a/goldfish_pipe.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2018 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-#ifndef GOLDFISH_PIPE_H
-#define GOLDFISH_PIPE_H
-
-#define DEVICE_NAME "goldfish_pipe"
-
-struct goldfish_pipe_dev_base {
- /* the destructor, the pointer is set in init */
- int (*deinit)(void *pipe_dev, struct platform_device *pdev);
-};
-
-/* The entry point to the pipe v1 driver */
-int goldfish_pipe_device_v1_init(struct platform_device *pdev,
- void __iomem *base,
- int irq);
-
-/* The entry point to the pipe v2 driver */
-int goldfish_pipe_device_v2_init(struct platform_device *pdev,
- char __iomem *base,
- int irq);
-
-#endif /* GOLDFISH_PIPE_H */
diff --git a/goldfish_pipe_base.c b/goldfish_pipe_base.c
deleted file mode 100644
index 9a59f4f..0000000
--- a/goldfish_pipe_base.c
+++ /dev/null
@@ -1,146 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2012 Intel, Inc.
- * Copyright (C) 2013 Intel, Inc.
- * Copyright (C) 2014 Linaro Limited
- * Copyright (C) 2011-2016 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-/* This source file contains the implementation of a special device driver
- * that intends to provide a *very* fast communication channel between the
- * guest system and the QEMU emulator.
- *
- * Usage from the guest is simply the following (error handling simplified):
- *
- * int fd = open("/dev/qemu_pipe",O_RDWR);
- * .... write() or read() through the pipe.
- *
- * This driver doesn't deal with the exact protocol used during the session.
- * It is intended to be as simple as something like:
- *
- * // do this _just_ after opening the fd to connect to a specific
- * // emulator service.
- * const char* msg = "<pipename>";
- * if (write(fd, msg, strlen(msg)+1) < 0) {
- * ... could not connect to <pipename> service
- * close(fd);
- * }
- *
- * // after this, simply read() and write() to communicate with the
- * // service. Exact protocol details left as an exercise to the reader.
- *
- * This driver is very fast because it doesn't copy any data through
- * intermediate buffers, since the emulator is capable of translating
- * guest user addresses into host ones.
- *
- * Note that we must however ensure that each user page involved in the
- * exchange is properly mapped during a transfer.
- */
-
-#include "defconfig_test.h"
-
-#include <linux/module.h>
-#include <linux/mod_devicetable.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/platform_device.h>
-#include <linux/io.h>
-#include <linux/acpi.h>
-#include "goldfish_pipe_qemu.h"
-#include "goldfish_pipe.h"
-
-/*
- * Update this when something changes in the driver's behavior so the host
- * can benefit from knowing it
- * Notes:
- * version 2 was an intermediate release and isn't supported anymore.
- * version 3 is goldfish_pipe_v2 without DMA support.
- * version 4 (current) is goldfish_pipe_v2 with DMA support.
- */
-enum {
- PIPE_DRIVER_VERSION = 4,
- PIPE_CURRENT_DEVICE_VERSION = 2
-};
-
-static int goldfish_pipe_probe(struct platform_device *pdev)
-{
- struct resource *r;
- char __iomem *base;
- int irq;
- int version;
-
- r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!r || resource_size(r) < PAGE_SIZE) {
- dev_err(&pdev->dev, "can't allocate i/o page\n");
- return -EINVAL;
- }
- base = devm_ioremap(&pdev->dev, r->start, PAGE_SIZE);
- if (!base) {
- dev_err(&pdev->dev, "ioremap failed\n");
- return -EINVAL;
- }
-
- r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
- if (!r)
- return -EINVAL;
-
- irq = r->start;
-
- /*
- * Exchange the versions with the host device
- *
- * Note: v1 driver used to not report its version, so we write it before
- * reading device version back: this allows the host implementation to
- * detect the old driver (if there was no version write before read).
- */
- writel(PIPE_DRIVER_VERSION, base + PIPE_V2_REG_VERSION);
- version = readl(base + PIPE_V2_REG_VERSION);
-
- if (version < PIPE_CURRENT_DEVICE_VERSION)
- return goldfish_pipe_device_v1_init(pdev, base, irq);
- else
- return goldfish_pipe_device_v2_init(pdev, base, irq);
-}
-
-static int goldfish_pipe_remove(struct platform_device *pdev)
-{
- struct goldfish_pipe_dev_base *dev = platform_get_drvdata(pdev);
-
- return dev->deinit(dev, pdev);
-}
-
-static const struct acpi_device_id goldfish_pipe_acpi_match[] = {
- { "GFSH0003", 0 },
- { },
-};
-MODULE_DEVICE_TABLE(acpi, goldfish_pipe_acpi_match);
-
-static const struct of_device_id goldfish_pipe_of_match[] = {
- { .compatible = "google,android-pipe", },
- {},
-};
-MODULE_DEVICE_TABLE(of, goldfish_pipe_of_match);
-
-static struct platform_driver goldfish_pipe_driver = {
- .probe = goldfish_pipe_probe,
- .remove = goldfish_pipe_remove,
- .driver = {
- .name = "goldfish_pipe",
- .of_match_table = goldfish_pipe_of_match,
- .acpi_match_table = ACPI_PTR(goldfish_pipe_acpi_match),
- }
-};
-
-module_platform_driver(goldfish_pipe_driver);
-MODULE_AUTHOR("David Turner <digit@google.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/goldfish_pipe_qemu.h b/goldfish_pipe_qemu.h
deleted file mode 100644
index 134c32c..0000000
--- a/goldfish_pipe_qemu.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2018 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-/*
- * IMPORTANT: The following constants must match the ones used and defined in
- * external/qemu/include/hw/misc/goldfish_pipe.h
- */
-
-#ifndef GOLDFISH_PIPE_QEMU_H
-#define GOLDFISH_PIPE_QEMU_H
-
-/* List of bitflags returned in status of CMD_POLL command */
-enum PipePollFlags {
- PIPE_POLL_IN = 1 << 0,
- PIPE_POLL_OUT = 1 << 1,
- PIPE_POLL_HUP = 1 << 2
-};
-
-/* Possible status values used to signal errors */
-enum PipeErrors {
- PIPE_ERROR_INVAL = -1,
- PIPE_ERROR_AGAIN = -2,
- PIPE_ERROR_NOMEM = -3,
- PIPE_ERROR_IO = -4
-};
-
-/* Bit-flags used to signal events from the emulator */
-enum PipeWakeFlags {
- /* emulator closed pipe */
- PIPE_WAKE_CLOSED = 1 << 0,
-
- /* pipe can now be read from */
- PIPE_WAKE_READ = 1 << 1,
-
- /* pipe can now be written to */
- PIPE_WAKE_WRITE = 1 << 2,
-
- /* unlock this pipe's DMA buffer */
- PIPE_WAKE_UNLOCK_DMA = 1 << 3,
-
- /* unlock DMA buffer of the pipe shared to this pipe */
- PIPE_WAKE_UNLOCK_DMA_SHARED = 1 << 4,
-};
-
-/* Possible pipe closing reasons */
-enum PipeCloseReason {
- /* guest sent a close command */
- PIPE_CLOSE_GRACEFUL = 0,
-
- /* guest rebooted, we're closing the pipes */
- PIPE_CLOSE_REBOOT = 1,
-
- /* close old pipes on snapshot load */
- PIPE_CLOSE_LOAD_SNAPSHOT = 2,
-
- /* some unrecoverable error on the pipe */
- PIPE_CLOSE_ERROR = 3,
-};
-
-/* Bit flags for the 'flags' field */
-enum PipeFlagsBits {
- BIT_CLOSED_ON_HOST = 0, /* pipe closed by host */
- BIT_WAKE_ON_WRITE = 1, /* want to be woken on writes */
- BIT_WAKE_ON_READ = 2, /* want to be woken on reads */
-};
-
-enum PipeV1Regs {
- /* write: value = command */
- PIPE_V1_REG_COMMAND = 0x00,
- /* read */
- PIPE_V1_REG_STATUS = 0x04,
- /* read/write: channel id */
- PIPE_V1_REG_CHANNEL = 0x08,
- /* read/write: channel id */
- PIPE_V1_REG_CHANNEL_HIGH = 0x30,
- /* read/write: buffer size */
- PIPE_V1_REG_SIZE = 0x0C,
- /* write: physical address */
- PIPE_V1_REG_ADDRESS = 0x10,
- /* write: physical address */
- PIPE_V1_REG_ADDRESS_HIGH = 0x34,
- /* read: wake flags */
- PIPE_V1_REG_WAKES = 0x14,
- /* read/write: batch data address */
- PIPE_V1_REG_PARAMS_ADDR_LOW = 0x18,
- /* read/write: batch data address */
- PIPE_V1_REG_PARAMS_ADDR_HIGH = 0x1C,
- /* write: batch access */
- PIPE_V1_REG_ACCESS_PARAMS = 0x20,
- /* read: device version */
- PIPE_V1_REG_VERSION = 0x24,
-};
-
-enum PipeV2Regs {
- PIPE_V2_REG_CMD = 0,
-
- PIPE_V2_REG_SIGNAL_BUFFER_HIGH = 4,
- PIPE_V2_REG_SIGNAL_BUFFER = 8,
- PIPE_V2_REG_SIGNAL_BUFFER_COUNT = 12,
-
- PIPE_V2_REG_OPEN_BUFFER_HIGH = 20,
- PIPE_V2_REG_OPEN_BUFFER = 24,
-
- PIPE_V2_REG_VERSION = 36,
-
- PIPE_V2_REG_GET_SIGNALLED = 48,
-};
-
-enum PipeCmdCode {
- /* to be used by the pipe device itself */
- PIPE_CMD_OPEN = 1,
-
- PIPE_CMD_CLOSE,
- PIPE_CMD_POLL,
- PIPE_CMD_WRITE,
- PIPE_CMD_WAKE_ON_WRITE,
- PIPE_CMD_READ,
- PIPE_CMD_WAKE_ON_READ,
-
- /*
- * TODO(zyy): implement a deferred read/write execution to allow
- * parallel processing of pipe operations on the host.
- */
- PIPE_CMD_WAKE_ON_DONE_IO,
- PIPE_CMD_DMA_HOST_MAP,
- PIPE_CMD_DMA_HOST_UNMAP,
-};
-
-#endif /* GOLDFISH_PIPE_QEMU_H */
diff --git a/goldfish_pipe_v1.c b/goldfish_pipe_v1.c
deleted file mode 100644
index 759b0b8..0000000
--- a/goldfish_pipe_v1.c
+++ /dev/null
@@ -1,632 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2011 Google, Inc.
- * Copyright (C) 2012 Intel, Inc.
- * Copyright (C) 2013 Intel, Inc.
- * Copyright (C) 2014 Linaro Limited
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-/* This source file contains the implementation of the legacy version of
- * a goldfish pipe device driver. See goldfish_pipe_v2.c for the current
- * version.
- */
-
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/spinlock.h>
-#include <linux/miscdevice.h>
-#include <linux/platform_device.h>
-#include <linux/poll.h>
-#include <linux/sched.h>
-#include <linux/bitops.h>
-#include <linux/slab.h>
-#include <linux/io.h>
-#include <linux/dma-mapping.h>
-#include <linux/mm.h>
-#include <linux/bug.h>
-#include <linux/goldfish.h>
-
-#include "goldfish_pipe_qemu.h"
-#include "goldfish_pipe.h"
-
-#define MAX_PAGES_TO_GRAB 32
-
-/* A value that will not be set by qemu emulator */
-#define INITIAL_BATCH_RESULT (0xdeadbeaf)
-
-struct goldfish_pipe_dev;
-
-/* This data type models a given pipe instance */
-struct goldfish_pipe {
- struct goldfish_pipe_dev *dev;
-
- /* The wake flags pipe is waiting for
- * Note: not protected with any lock, uses atomic operations
- * and barriers to make it thread-safe.
- */
- unsigned long flags;
-
- wait_queue_head_t wake_queue;
-
- /* protects access to the pipe */
- struct mutex lock;
-};
-
-struct access_params {
- unsigned long channel;
- u32 size;
- unsigned long address;
- u32 cmd;
- u32 result;
- /* reserved for future extension */
- u32 flags;
-};
-
-/* The driver state. Holds a reference to the i/o page used to
- * communicate with the emulator, and a wake queue for blocked tasks
- * waiting to be awoken.
- */
-struct goldfish_pipe_dev {
- /* Needed for the 'remove' call */
- struct goldfish_pipe_dev_base super;
-
- /* ptr to platform device's device struct */
- struct device *pdev_dev;
-
- /* the base address for MMIO */
- char __iomem *base;
-
- struct access_params *aps;
-
- struct miscdevice miscdev;
-
- /* Global device spinlock */
- spinlock_t lock;
-};
-
-static int goldfish_pipe_device_deinit(void *raw_dev,
- struct platform_device *pdev);
-
-static u32 goldfish_cmd_status(struct goldfish_pipe *pipe, u32 cmd)
-{
- unsigned long flags;
- u32 status;
- struct goldfish_pipe_dev *dev = pipe->dev;
-
- spin_lock_irqsave(&dev->lock, flags);
- gf_write_ptr(pipe, dev->base + PIPE_V1_REG_CHANNEL,
- dev->base + PIPE_V1_REG_CHANNEL_HIGH);
- writel(cmd, dev->base + PIPE_V1_REG_COMMAND);
- status = readl(dev->base + PIPE_V1_REG_STATUS);
- spin_unlock_irqrestore(&dev->lock, flags);
- return status;
-}
-
-static void goldfish_cmd(struct goldfish_pipe *pipe, u32 cmd)
-{
- unsigned long flags;
- struct goldfish_pipe_dev *dev = pipe->dev;
-
- spin_lock_irqsave(&dev->lock, flags);
- gf_write_ptr(pipe, dev->base + PIPE_V1_REG_CHANNEL,
- dev->base + PIPE_V1_REG_CHANNEL_HIGH);
- writel(cmd, dev->base + PIPE_V1_REG_COMMAND);
- spin_unlock_irqrestore(&dev->lock, flags);
-}
-
-/* This function converts an error code returned by the emulator through
- * the PIPE_V1_REG_STATUS i/o register into a valid negative errno value.
- */
-static int goldfish_pipe_error_convert(int status)
-{
- switch (status) {
- case PIPE_ERROR_AGAIN:
- return -EAGAIN;
- case PIPE_ERROR_NOMEM:
- return -ENOMEM;
- case PIPE_ERROR_IO:
- return -EIO;
- default:
- return -EINVAL;
- }
-}
-
-/*
- * Notice: QEMU will return 0 for un-known register access, indicating
- * access_params is supported or not
- */
-static int valid_batchbuffer_addr(struct goldfish_pipe_dev *dev,
- struct access_params *aps)
-{
- u32 aph, apl;
- u64 paddr;
-
- aph = readl(dev->base + PIPE_V1_REG_PARAMS_ADDR_HIGH);
- apl = readl(dev->base + PIPE_V1_REG_PARAMS_ADDR_LOW);
-
- paddr = ((u64)aph << 32) | apl;
- return paddr == (__pa(aps));
-}
-
-static int setup_access_params_addr(struct platform_device *pdev,
- struct goldfish_pipe_dev *dev)
-{
- u64 paddr;
- struct access_params *aps;
-
- aps = devm_kzalloc(&pdev->dev, sizeof(struct access_params),
- GFP_KERNEL);
- if (!aps)
- return -ENOMEM;
-
- paddr = __pa(aps);
- writel((u32)(paddr >> 32), dev->base + PIPE_V1_REG_PARAMS_ADDR_HIGH);
- writel((u32)paddr, dev->base + PIPE_V1_REG_PARAMS_ADDR_LOW);
-
- if (valid_batchbuffer_addr(dev, aps)) {
- dev->aps = aps;
- return 0;
- }
-
- devm_kfree(&pdev->dev, aps);
- return -EFAULT;
-}
-
-static int access_with_param(struct goldfish_pipe_dev *dev, const int cmd,
- unsigned long address, unsigned long avail,
- struct goldfish_pipe *pipe, int *status)
-{
- struct access_params *aps = dev->aps;
-
- if (!aps)
- return -EINVAL;
-
- aps->result = INITIAL_BATCH_RESULT;
- aps->channel = (unsigned long)pipe;
- aps->size = avail;
- aps->address = address;
- aps->cmd = cmd;
- writel(cmd, dev->base + PIPE_V1_REG_ACCESS_PARAMS);
-
- /*
- * If the aps->result has not changed, that means
- * that the batch command failed
- */
- if (aps->result == INITIAL_BATCH_RESULT)
- return -EINVAL;
-
- *status = aps->result;
- return 0;
-}
-
-static int transfer_pages(struct goldfish_pipe_dev *dev,
- struct goldfish_pipe *pipe,
- int cmd,
- unsigned long xaddr,
- unsigned long size)
-{
- unsigned long irq_flags;
- int status = 0;
-
- spin_lock_irqsave(&dev->lock, irq_flags);
- if (access_with_param(dev, cmd, xaddr, size, pipe, &status)) {
- gf_write_ptr(pipe, dev->base + PIPE_V1_REG_CHANNEL,
- dev->base + PIPE_V1_REG_CHANNEL_HIGH);
-
- writel(size, dev->base + PIPE_V1_REG_SIZE);
-
- gf_write_ptr((void *)xaddr,
- dev->base + PIPE_V1_REG_ADDRESS,
- dev->base + PIPE_V1_REG_ADDRESS_HIGH);
-
- writel(cmd, dev->base + PIPE_V1_REG_COMMAND);
-
- status = readl(dev->base + PIPE_V1_REG_STATUS);
- }
- spin_unlock_irqrestore(&dev->lock, irq_flags);
-
- return status;
-}
-
-static unsigned long translate_address(const struct page *page,
- unsigned long addr)
-{
- return page_to_phys(page) | (addr & ~PAGE_MASK);
-}
-
-static ssize_t goldfish_pipe_read_write(struct file *filp, char __user *buffer,
- size_t bufflen, int is_write)
-{
- struct goldfish_pipe *pipe = filp->private_data;
- struct goldfish_pipe_dev *dev = pipe->dev;
- unsigned long address;
- unsigned long address_end;
- const int wake_bit = is_write ? BIT_WAKE_ON_WRITE : BIT_WAKE_ON_READ;
- const int pipe_cmd = is_write ? PIPE_CMD_WRITE : PIPE_CMD_READ;
- int count = 0;
- int ret = -EINVAL;
-
- /* If the emulator already closed the pipe, no need to go further */
- if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
- return -EIO;
-
- /* Null reads or writes succeeds */
- if (unlikely(bufflen == 0))
- return 0;
-
- /* Check the buffer range for access */
- if (!access_ok(buffer, bufflen))
- return -EFAULT;
-
- address = (unsigned long)buffer;
- address_end = address + bufflen;
-
- /* Serialize access to the pipe */
- if (mutex_lock_interruptible(&pipe->lock))
- return -ERESTARTSYS;
-
- while (address < address_end) {
- struct page *pages[MAX_PAGES_TO_GRAB];
- unsigned long page_end = (address & PAGE_MASK) + PAGE_SIZE;
- unsigned long avail;
- unsigned long xaddr;
- unsigned long xaddr_prev;
- long first_page;
- long last_page;
- long requested_pages;
- int status;
- int n_pages;
- int page_i;
- int num_contiguous_pages;
-
- /*
- * Attempt to grab multiple physically contiguous pages.
- */
- first_page = address & PAGE_MASK;
- last_page = (address_end - 1) & PAGE_MASK;
- requested_pages =
- min(((last_page - first_page) >> PAGE_SHIFT) + 1,
- (long)MAX_PAGES_TO_GRAB);
-
- ret = get_user_pages_fast(first_page, requested_pages,
- !is_write, pages);
- if (ret < 0) {
- dev_err(dev->pdev_dev,
- "%s: get_user_pages_fast failed: %d\n",
- __func__, ret);
- break;
- } else if (!ret) {
- dev_err(dev->pdev_dev,
- "%s: error: no pages returned, requested %ld\n",
- __func__, requested_pages);
- break;
- }
-
- n_pages = ret;
- xaddr = translate_address(pages[0], address);
- xaddr_prev = xaddr;
- num_contiguous_pages = 1;
- for (page_i = 1; page_i < n_pages; page_i++) {
- unsigned long xaddr_i;
-
- xaddr_i = translate_address(pages[page_i], address);
- if (xaddr_i == xaddr_prev + PAGE_SIZE) {
- page_end += PAGE_SIZE;
- xaddr_prev = xaddr_i;
- num_contiguous_pages++;
- } else {
- dev_err(dev->pdev_dev,
- "%s: discontinuous page boundary: %d "
- "pages instead\n",
- __func__, page_i);
- break;
- }
- }
- avail = min(page_end, address_end) - address;
-
- status = transfer_pages(dev, pipe, pipe_cmd, xaddr, avail);
-
- for (page_i = 0; page_i < n_pages; page_i++) {
- if (status > 0 && !is_write &&
- page_i < num_contiguous_pages)
- set_page_dirty(pages[page_i]);
-
- put_page(pages[page_i]);
- }
-
- if (status > 0) { /* Correct transfer */
- count += status;
- address += status;
- continue;
- } else if (status == 0) { /* EOF */
- ret = 0;
- break;
- } else if (status < 0 && count > 0) {
- /*
- * An error occurred and we already transferred
- * something on one of the previous pages.
- * Just return what we already copied and log this
- * err.
- *
- * Note: This seems like an incorrect approach but
- * cannot change it until we check if any user space
- * ABI relies on this behavior.
- */
- if (status != PIPE_ERROR_AGAIN)
- dev_err_ratelimited(dev->pdev_dev,
- "backend returned error %d on %s\n",
- status, is_write ? "write" : "read");
- ret = 0;
- break;
- }
-
- /*
- * If the error is not PIPE_ERROR_AGAIN, or if we are not in
- * non-blocking mode, just return the error code.
- */
- if (status != PIPE_ERROR_AGAIN ||
- (filp->f_flags & O_NONBLOCK) != 0) {
- ret = goldfish_pipe_error_convert(status);
- break;
- }
-
- /*
- * The backend blocked the read/write, wait until the backend
- * tells us it's ready to process more data.
- */
- set_bit(wake_bit, &pipe->flags);
-
- /* Tell the emulator we're going to wait for a wake event */
- goldfish_cmd(pipe, pipe_cmd);
-
- /* Unlock the pipe, then wait for the wake signal */
- mutex_unlock(&pipe->lock);
-
- while (test_bit(wake_bit, &pipe->flags)) {
- if (wait_event_interruptible(pipe->wake_queue,
- !test_bit(wake_bit, &pipe->flags)))
- return -ERESTARTSYS;
-
- if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
- return -EIO;
- }
-
- /* Try to re-acquire the lock */
- if (mutex_lock_interruptible(&pipe->lock))
- return -ERESTARTSYS;
- }
- mutex_unlock(&pipe->lock);
-
- return (ret < 0) ? ret : count;
-}
-
-static ssize_t goldfish_pipe_read(struct file *filp, char __user *buffer,
- size_t bufflen, loff_t *ppos)
-{
- return goldfish_pipe_read_write(filp, buffer, bufflen,
- /* is_write */ 0);
-}
-
-static ssize_t goldfish_pipe_write(struct file *filp,
- const char __user *buffer, size_t bufflen,
- loff_t *ppos)
-{
- return goldfish_pipe_read_write(filp, (char __user *)buffer,
- bufflen, /* is_write */ 1);
-}
-
-static unsigned int goldfish_pipe_poll(struct file *filp, poll_table *wait)
-{
- struct goldfish_pipe *pipe = filp->private_data;
- unsigned int mask = 0;
- int status;
-
- if (mutex_lock_interruptible(&pipe->lock))
- return -ERESTARTSYS;
-
- poll_wait(filp, &pipe->wake_queue, wait);
-
- status = goldfish_cmd_status(pipe, PIPE_CMD_POLL);
-
- mutex_unlock(&pipe->lock);
-
- if (status & PIPE_POLL_IN)
- mask |= POLLIN | POLLRDNORM;
-
- if (status & PIPE_POLL_OUT)
- mask |= POLLOUT | POLLWRNORM;
-
- if (status & PIPE_POLL_HUP)
- mask |= POLLHUP;
-
- if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
- mask |= POLLERR;
-
- return mask;
-}
-
-static irqreturn_t goldfish_pipe_interrupt(int irq, void *dev_id)
-{
- struct goldfish_pipe_dev *dev = dev_id;
- unsigned long irq_flags;
- int count = 0;
-
- /*
- * We're going to read from the emulator a list of (channel,flags)
- * pairs corresponding to the wake events that occurred on each
- * blocked pipe (i.e. channel).
- */
- spin_lock_irqsave(&dev->lock, irq_flags);
- for (;;) {
- /* First read the channel, 0 means the end of the list */
- struct goldfish_pipe *pipe;
- unsigned long wakes;
- unsigned long channel = 0;
-
-#ifdef CONFIG_64BIT
- channel =
- (u64)readl(dev->base + PIPE_V1_REG_CHANNEL_HIGH) << 32;
-#endif
- channel |= readl(dev->base + PIPE_V1_REG_CHANNEL);
- if (!channel)
- break;
-
- /* Convert channel to struct pipe pointer + read wake flags */
- wakes = readl(dev->base + PIPE_V1_REG_WAKES);
- pipe = (struct goldfish_pipe *)(ptrdiff_t)channel;
-
- /* Did the emulator just closed a pipe? */
- if (wakes & PIPE_WAKE_CLOSED) {
- set_bit(BIT_CLOSED_ON_HOST, &pipe->flags);
- wakes |= PIPE_WAKE_READ | PIPE_WAKE_WRITE;
- }
- if (wakes & PIPE_WAKE_READ)
- clear_bit(BIT_WAKE_ON_READ, &pipe->flags);
- if (wakes & PIPE_WAKE_WRITE)
- clear_bit(BIT_WAKE_ON_WRITE, &pipe->flags);
-
- wake_up_interruptible(&pipe->wake_queue);
- count++;
- }
- spin_unlock_irqrestore(&dev->lock, irq_flags);
-
- return (count == 0) ? IRQ_NONE : IRQ_HANDLED;
-}
-
-/* A helper function to get the instance of goldfish_pipe_dev from file */
-static struct goldfish_pipe_dev *to_goldfish_pipe_dev(struct file *file)
-{
- struct miscdevice *miscdev = file->private_data;
-
- return container_of(miscdev, struct goldfish_pipe_dev, miscdev);
-}
-
-/**
- * goldfish_pipe_open - open a channel to the AVD
- * @inode: inode of device
- * @file: file struct of opener
- *
- * Create a new pipe link between the emulator and the use application.
- * Each new request produces a new pipe.
- *
- * Note: we use the pipe ID as a mux. All goldfish emulations are 32bit
- * right now so this is fine. A move to 64bit will need this addressing
- */
-static int goldfish_pipe_open(struct inode *inode, struct file *file)
-{
- struct goldfish_pipe_dev *dev = to_goldfish_pipe_dev(file);
- struct goldfish_pipe *pipe;
- int status;
-
- /* Allocate new pipe kernel object */
- pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
- if (!pipe)
- return -ENOMEM;
-
- pipe->dev = dev;
- init_waitqueue_head(&pipe->wake_queue);
- mutex_init(&pipe->lock);
-
- /*
- * Now, tell the emulator we're opening a new pipe. We use the
- * pipe object's address as the channel identifier for simplicity.
- */
-
- status = goldfish_cmd_status(pipe, PIPE_CMD_OPEN);
- if (status < 0) {
- kfree(pipe);
- return status;
- }
-
- /* All is done, save the pipe into the file's private data field */
- file->private_data = pipe;
- return 0;
-}
-
-static int goldfish_pipe_release(struct inode *inode, struct file *filp)
-{
- struct goldfish_pipe *pipe = filp->private_data;
-
- pr_debug("%s: call. pipe=%p file=%p\n", __func__, pipe, filp);
- /* The guest is closing the channel, so tell the emulator right now */
- goldfish_cmd(pipe, PIPE_CMD_CLOSE);
- kfree(pipe);
- filp->private_data = NULL;
- return 0;
-}
-
-static const struct file_operations goldfish_pipe_fops = {
- .owner = THIS_MODULE,
- .read = goldfish_pipe_read,
- .write = goldfish_pipe_write,
- .poll = goldfish_pipe_poll,
- .open = goldfish_pipe_open,
- .release = goldfish_pipe_release,
-};
-
-static void init_miscdevice(struct miscdevice *miscdev)
-{
- memset(miscdev, 0, sizeof(*miscdev));
-
- miscdev->minor = MISC_DYNAMIC_MINOR;
- miscdev->name = DEVICE_NAME;
- miscdev->fops = &goldfish_pipe_fops;
-};
-
-static int goldfish_pipe_device_deinit(void *raw_dev,
- struct platform_device *pdev);
-
-int goldfish_pipe_device_v1_init(struct platform_device *pdev,
- void __iomem *base,
- int irq)
-{
- struct goldfish_pipe_dev *dev;
- int err;
-
- dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
- if (!dev)
- return -ENOMEM;
-
- dev->super.deinit = &goldfish_pipe_device_deinit;
- dev->pdev_dev = &pdev->dev;
- spin_lock_init(&dev->lock);
-
- err = devm_request_irq(&pdev->dev, irq,
- &goldfish_pipe_interrupt, IRQF_SHARED,
- DEVICE_NAME, dev);
- if (err) {
- dev_err(&pdev->dev, "unable to allocate IRQ for v1\n");
- return err;
- }
-
- init_miscdevice(&dev->miscdev);
- err = misc_register(&dev->miscdev);
- if (err) {
- dev_err(&pdev->dev, "unable to register v1 device\n");
- return err;
- }
-
- setup_access_params_addr(pdev, dev);
-
- platform_set_drvdata(pdev, dev);
- return 0;
-}
-
-static int goldfish_pipe_device_deinit(void *raw_dev,
- struct platform_device *pdev)
-{
- struct goldfish_pipe_dev *dev = raw_dev;
-
- misc_deregister(&dev->miscdev);
- return 0;
-}
diff --git a/goldfish_pipe_v2.c b/goldfish_pipe_v2.c
deleted file mode 100644
index f5e6401..0000000
--- a/goldfish_pipe_v2.c
+++ /dev/null
@@ -1,1216 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2012 Intel, Inc.
- * Copyright (C) 2013 Intel, Inc.
- * Copyright (C) 2014 Linaro Limited
- * Copyright (C) 2011-2016 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-/* This source file contains the implementation of a special device driver
- * that intends to provide a *very* fast communication channel between the
- * guest system and the QEMU emulator.
- *
- * Usage from the guest is simply the following (error handling simplified):
- *
- * int fd = open("/dev/qemu_pipe",O_RDWR);
- * .... write() or read() through the pipe.
- *
- * This driver doesn't deal with the exact protocol used during the session.
- * It is intended to be as simple as something like:
- *
- * // do this _just_ after opening the fd to connect to a specific
- * // emulator service.
- * const char* msg = "<pipename>";
- * if (write(fd, msg, strlen(msg)+1) < 0) {
- * ... could not connect to <pipename> service
- * close(fd);
- * }
- *
- * // after this, simply read() and write() to communicate with the
- * // service. Exact protocol details left as an exercise to the reader.
- *
- * This driver is very fast because it doesn't copy any data through
- * intermediate buffers, since the emulator is capable of translating
- * guest user addresses into host ones.
- *
- * Note that we must however ensure that each user page involved in the
- * exchange is properly mapped during a transfer.
- */
-
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/spinlock.h>
-#include <linux/miscdevice.h>
-#include <linux/platform_device.h>
-#include <linux/poll.h>
-#include <linux/sched.h>
-#include <linux/bitops.h>
-#include <linux/slab.h>
-#include <linux/io.h>
-#include <linux/dma-mapping.h>
-#include <linux/mm.h>
-#include <linux/bug.h>
-
-#include "uapi/goldfish_dma.h"
-#include "goldfish_pipe_qemu.h"
-#include "goldfish_pipe.h"
-
-/*
- * Update this when something changes in the driver's behavior so the host
- * can benefit from knowing it
- * Notes:
- * version 2 was an intermediate release and isn't supported anymore.
- * version 3 is goldfish_pipe_v2 without DMA support.
- * version 4 (current) is goldfish_pipe_v2 with DMA support.
- */
-enum {
- PIPE_DRIVER_VERSION = 4,
- PIPE_CURRENT_DEVICE_VERSION = 2
-};
-
-enum {
- MAX_BUFFERS_PER_COMMAND = 336,
- MAX_SIGNALLED_PIPES = 64,
- INITIAL_PIPES_CAPACITY = 64,
- DMA_REGION_MIN_SIZE = PAGE_SIZE,
- DMA_REGION_MAX_SIZE = 256 << 20
-};
-
-struct goldfish_pipe_dev;
-
-static int goldfish_pipe_device_deinit(void *raw_dev,
- struct platform_device *pdev);
-
-/* A per-pipe command structure, shared with the host */
-struct goldfish_pipe_command {
- s32 cmd; /* PipeCmdCode, guest -> host */
- s32 id; /* pipe id, guest -> host */
- s32 status; /* command execution status, host -> guest */
- s32 reserved; /* to pad to 64-bit boundary */
- union {
- /* Parameters for PIPE_CMD_{READ,WRITE} */
- struct {
- /* number of buffers, guest -> host */
- u32 buffers_count;
- /* number of consumed bytes, host -> guest */
- s32 consumed_size;
- /* buffer pointers, guest -> host */
- u64 ptrs[MAX_BUFFERS_PER_COMMAND];
- /* buffer sizes, guest -> host */
- u32 sizes[MAX_BUFFERS_PER_COMMAND];
- } rw_params;
- /* Parameters for PIPE_CMD_DMA_HOST_(UN)MAP */
- struct {
- u64 dma_paddr;
- u64 sz;
- } dma_maphost_params;
- };
-};
-
-/* A single signalled pipe information */
-struct signalled_pipe_buffer {
- u32 id;
- u32 flags;
-};
-
-/* Parameters for the PIPE_CMD_OPEN command */
-struct open_command_param {
- u64 command_buffer_ptr;
- u32 rw_params_max_count;
-};
-
-/* Device-level set of buffers shared with the host */
-struct goldfish_pipe_dev_buffers {
- struct open_command_param open_command_params;
- struct signalled_pipe_buffer
- signalled_pipe_buffers[MAX_SIGNALLED_PIPES];
-};
-
-/*
- * The main data structure tracking state is
- * struct goldfish_dma_context, which is included
- * as an extra pointer field in struct goldfish_pipe.
- * Each such context is associated with possibly
- * one physical address and size describing the
- * allocated DMA region, and only one allocation
- * is allowed for each pipe fd. Further allocations
- * require more open()'s of pipe fd's.
- */
-struct goldfish_dma_context {
- struct device *pdev_dev; /* pointer to feed to dma_*_coherent */
- void *dma_vaddr; /* kernel vaddr of dma region */
- size_t dma_size; /* size of dma region */
- dma_addr_t phys_begin; /* paddr of dma region */
- dma_addr_t phys_end; /* paddr of dma region + dma_size */
-};
-
-/* This data type models a given pipe instance */
-struct goldfish_pipe {
- /* pipe ID - index into goldfish_pipe_dev::pipes array */
- u32 id;
-
- /* The wake flags pipe is waiting for
- * Note: not protected with any lock, uses atomic operations
- * and barriers to make it thread-safe.
- */
- unsigned long flags;
-
- /* wake flags host have signalled,
- * - protected by goldfish_pipe_dev::lock
- */
- unsigned long signalled_flags;
-
- /* A pointer to command buffer */
- struct goldfish_pipe_command *command_buffer;
-
- /* doubly linked list of signalled pipes, protected by
- * goldfish_pipe_dev::lock
- */
- struct goldfish_pipe *prev_signalled;
- struct goldfish_pipe *next_signalled;
-
- /*
- * A pipe's own lock. Protects the following:
- * - *command_buffer - makes sure a command can safely write its
- * parameters to the host and read the results back.
- */
- struct mutex lock;
-
- /* A wake queue for sleeping until host signals an event */
- wait_queue_head_t wake_queue;
-
- /* Pointer to the parent goldfish_pipe_dev instance */
- struct goldfish_pipe_dev *dev;
-
- /* A buffer of pages, too large to fit into a stack frame */
- struct page *pages[MAX_BUFFERS_PER_COMMAND];
-
- /* Holds information about reserved DMA region for this pipe */
- struct goldfish_dma_context *dma;
-};
-
-/* The global driver data. Holds a reference to the i/o page used to
- * communicate with the emulator, and a wake queue for blocked tasks
- * waiting to be awoken.
- */
-struct goldfish_pipe_dev {
- /* Needed for 'remove' */
- struct goldfish_pipe_dev_base super;
-
- /*
- * Global device spinlock. Protects the following members:
- * - pipes, pipes_capacity
- * - [*pipes, *pipes + pipes_capacity) - array data
- * - first_signalled_pipe,
- * goldfish_pipe::prev_signalled,
- * goldfish_pipe::next_signalled,
- * goldfish_pipe::signalled_flags - all singnalled-related fields,
- * in all allocated pipes
- * - open_command_params - PIPE_CMD_OPEN-related buffers
- *
- * It looks like a lot of different fields, but the trick is that
- * the only operation that happens often is the signalled pipes array
- * manipulation. That's why it's OK for now to keep the rest of the
- * fields under the same lock. If we notice too much contention because
- * of PIPE_CMD_OPEN, then we should add a separate lock there.
- */
- spinlock_t lock;
-
- /*
- * Array of the pipes of |pipes_capacity| elements,
- * indexed by goldfish_pipe::id
- */
- struct goldfish_pipe **pipes;
- u32 pipes_capacity;
-
- /* Pointers to the buffers host uses for interaction with this driver */
- struct goldfish_pipe_dev_buffers *buffers;
-
- /* Head of a doubly linked list of signalled pipes */
- struct goldfish_pipe *first_signalled_pipe;
-
- /* ptr to platform device's device struct */
- struct device *pdev_dev;
-
- /* Some device-specific data */
- unsigned char __iomem *base;
-
- /* an irq tasklet to run goldfish_interrupt_task */
- struct tasklet_struct irq_tasklet;
-
- struct miscdevice miscdev;
-
- /* DMA info */
- size_t dma_alloc_total;
-};
-
-static int goldfish_pipe_cmd_locked(struct goldfish_pipe *pipe,
- enum PipeCmdCode cmd)
-{
- pipe->command_buffer->cmd = cmd;
- /* failure by default */
- pipe->command_buffer->status = PIPE_ERROR_INVAL;
- writel(pipe->id, pipe->dev->base + PIPE_V2_REG_CMD);
- return pipe->command_buffer->status;
-}
-
-static int goldfish_pipe_cmd(struct goldfish_pipe *pipe, enum PipeCmdCode cmd)
-{
- int status;
-
- if (mutex_lock_interruptible(&pipe->lock))
- return PIPE_ERROR_IO;
- status = goldfish_pipe_cmd_locked(pipe, cmd);
- mutex_unlock(&pipe->lock);
- return status;
-}
-
-/*
- * This function converts an error code returned by the emulator through
- * the PIPE_V2_REG_STATUS i/o register into a valid negative errno value.
- */
-static int goldfish_pipe_error_convert(int status)
-{
- switch (status) {
- case PIPE_ERROR_AGAIN:
- return -EAGAIN;
- case PIPE_ERROR_NOMEM:
- return -ENOMEM;
- case PIPE_ERROR_IO:
- return -EIO;
- default:
- return -EINVAL;
- }
-}
-
-static int goldfish_pin_user_pages(unsigned long first_page,
- unsigned long last_page,
- unsigned int last_page_size,
- int is_write,
- struct page *pages[MAX_BUFFERS_PER_COMMAND],
- unsigned int *iter_last_page_size)
-{
- int ret;
- int requested_pages = ((last_page - first_page) >> PAGE_SHIFT) + 1;
-
- if (requested_pages > MAX_BUFFERS_PER_COMMAND) {
- requested_pages = MAX_BUFFERS_PER_COMMAND;
- *iter_last_page_size = PAGE_SIZE;
- } else {
- *iter_last_page_size = last_page_size;
- }
-
- ret = get_user_pages_fast(first_page, requested_pages, !is_write,
- pages);
- if (ret <= 0)
- return -EFAULT;
- if (ret < requested_pages)
- *iter_last_page_size = PAGE_SIZE;
-
- return ret;
-}
-
-static void release_user_pages(struct page **pages, int pages_count,
- int is_write, s32 consumed_size)
-{
- int i;
-
- for (i = 0; i < pages_count; i++) {
- if (!is_write && consumed_size > 0)
- set_page_dirty(pages[i]);
- put_page(pages[i]);
- }
-}
-
-/* Populate the call parameters, merging adjacent pages together */
-static void populate_rw_params(struct page **pages,
- int pages_count,
- unsigned long address,
- unsigned long address_end,
- unsigned long first_page,
- unsigned long last_page,
- unsigned int iter_last_page_size,
- int is_write,
- struct goldfish_pipe_command *command)
-{
- /*
- * Process the first page separately - it's the only page that
- * needs special handling for its start address.
- */
- unsigned long xaddr = page_to_phys(pages[0]);
- unsigned long xaddr_prev = xaddr;
- int buffer_idx = 0;
- int i = 1;
- int size_on_page = first_page == last_page
- ? (int)(address_end - address)
- : (PAGE_SIZE - (address & ~PAGE_MASK));
- command->rw_params.ptrs[0] = (u64)(xaddr | (address & ~PAGE_MASK));
- command->rw_params.sizes[0] = size_on_page;
- for (; i < pages_count; ++i) {
- xaddr = page_to_phys(pages[i]);
- size_on_page = (i == pages_count - 1) ?
- iter_last_page_size : PAGE_SIZE;
- if (xaddr == xaddr_prev + PAGE_SIZE) {
- command->rw_params.sizes[buffer_idx] += size_on_page;
- } else {
- ++buffer_idx;
- command->rw_params.ptrs[buffer_idx] = (u64)xaddr;
- command->rw_params.sizes[buffer_idx] = size_on_page;
- }
- xaddr_prev = xaddr;
- }
- command->rw_params.buffers_count = buffer_idx + 1;
-}
-
-static int transfer_max_buffers(struct goldfish_pipe *pipe,
- unsigned long address,
- unsigned long address_end,
- int is_write,
- unsigned long last_page,
- unsigned int last_page_size,
- s32 *consumed_size,
- int *status)
-{
- unsigned long first_page = address & PAGE_MASK;
- unsigned int iter_last_page_size;
- int pages_count;
-
- /* Serialize access to the pipe command buffers */
- if (mutex_lock_interruptible(&pipe->lock))
- return -ERESTARTSYS;
-
- pages_count = goldfish_pin_user_pages(first_page,
- last_page,
- last_page_size,
- is_write,
- pipe->pages,
- &iter_last_page_size);
- if (pages_count < 0) {
- mutex_unlock(&pipe->lock);
- return pages_count;
- }
-
- populate_rw_params(pipe->pages, pages_count, address, address_end,
- first_page, last_page, iter_last_page_size, is_write,
- pipe->command_buffer);
-
- /* Transfer the data */
- *status = goldfish_pipe_cmd_locked(pipe,
- is_write ? PIPE_CMD_WRITE : PIPE_CMD_READ);
-
- *consumed_size = pipe->command_buffer->rw_params.consumed_size;
-
- release_user_pages(pipe->pages, pages_count, is_write, *consumed_size);
-
- mutex_unlock(&pipe->lock);
- return 0;
-}
-
-static int wait_for_host_signal(struct goldfish_pipe *pipe, int is_write)
-{
- u32 wake_bit = is_write ? BIT_WAKE_ON_WRITE : BIT_WAKE_ON_READ;
-
- set_bit(wake_bit, &pipe->flags);
-
- /* Tell the emulator we're going to wait for a wake event */
- goldfish_pipe_cmd(pipe,
- is_write ? PIPE_CMD_WAKE_ON_WRITE : PIPE_CMD_WAKE_ON_READ);
-
- while (test_bit(wake_bit, &pipe->flags)) {
- if (wait_event_interruptible(pipe->wake_queue,
- !test_bit(wake_bit, &pipe->flags)))
- return -ERESTARTSYS;
-
- if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
- return -EIO;
- }
-
- return 0;
-}
-
-static ssize_t goldfish_pipe_read_write(struct file *filp,
- char __user *buffer,
- size_t bufflen,
- int is_write)
-{
- struct goldfish_pipe *pipe = filp->private_data;
- int count = 0, ret = -EINVAL;
- unsigned long address, address_end, last_page;
- unsigned int last_page_size;
-
- /* If the emulator already closed the pipe, no need to go further */
- if (unlikely(test_bit(BIT_CLOSED_ON_HOST, &pipe->flags)))
- return -EIO;
- /* Null reads or writes succeeds */
- if (unlikely(bufflen == 0))
- return 0;
- /* Check the buffer range for access */
- if (unlikely(!access_ok(buffer, bufflen)))
- return -EFAULT;
-
- address = (unsigned long)buffer;
- address_end = address + bufflen;
- last_page = (address_end - 1) & PAGE_MASK;
- last_page_size = ((address_end - 1) & ~PAGE_MASK) + 1;
-
- while (address < address_end) {
- s32 consumed_size;
- int status;
-
- ret = transfer_max_buffers(pipe, address, address_end, is_write,
- last_page, last_page_size,
- &consumed_size, &status);
- if (ret < 0)
- break;
-
- if (consumed_size > 0) {
- /* No matter what's the status, we've transferred
- * something.
- */
- count += consumed_size;
- address += consumed_size;
- }
- if (status > 0)
- continue;
- if (status == 0) {
- /* EOF */
- ret = 0;
- break;
- }
- if (count > 0) {
- /*
- * An error occurred, but we already transferred
- * something on one of the previous iterations.
- * Just return what we already copied and log this
- * err.
- */
- if (status != PIPE_ERROR_AGAIN)
- dev_err_ratelimited(pipe->dev->pdev_dev,
- "backend error %d on %s\n",
- status, is_write ? "write" : "read");
- break;
- }
-
- /*
- * If the error is not PIPE_ERROR_AGAIN, or if we are in
- * non-blocking mode, just return the error code.
- */
- if (status != PIPE_ERROR_AGAIN ||
- (filp->f_flags & O_NONBLOCK) != 0) {
- ret = goldfish_pipe_error_convert(status);
- break;
- }
-
- status = wait_for_host_signal(pipe, is_write);
- if (status < 0)
- return status;
- }
-
- if (count > 0)
- return count;
- return ret;
-}
-
-static ssize_t goldfish_pipe_read(struct file *filp, char __user *buffer,
- size_t bufflen, loff_t *ppos)
-{
- return goldfish_pipe_read_write(filp, buffer, bufflen,
- /* is_write */ 0);
-}
-
-static ssize_t goldfish_pipe_write(struct file *filp,
- const char __user *buffer, size_t bufflen,
- loff_t *ppos)
-{
- /* cast away the const */
- char __user *no_const_buffer = (char __user *)buffer;
-
- return goldfish_pipe_read_write(filp, no_const_buffer, bufflen,
- /* is_write */ 1);
-}
-
-static unsigned int goldfish_pipe_poll(struct file *filp, poll_table *wait)
-{
- struct goldfish_pipe *pipe = filp->private_data;
- unsigned int mask = 0;
- int status;
-
- poll_wait(filp, &pipe->wake_queue, wait);
-
- status = goldfish_pipe_cmd(pipe, PIPE_CMD_POLL);
- if (status < 0)
- return -ERESTARTSYS;
-
- if (status & PIPE_POLL_IN)
- mask |= POLLIN | POLLRDNORM;
- if (status & PIPE_POLL_OUT)
- mask |= POLLOUT | POLLWRNORM;
- if (status & PIPE_POLL_HUP)
- mask |= POLLHUP;
- if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
- mask |= POLLERR;
-
- return mask;
-}
-
-static void signalled_pipes_add_locked(struct goldfish_pipe_dev *dev,
- u32 id, u32 flags)
-{
- struct goldfish_pipe *pipe;
-
- if (WARN_ON(id >= dev->pipes_capacity))
- return;
-
- pipe = dev->pipes[id];
- if (!pipe)
- return;
- pipe->signalled_flags |= flags;
-
- if (pipe->prev_signalled || pipe->next_signalled ||
- dev->first_signalled_pipe == pipe)
- return; /* already in the list */
- pipe->next_signalled = dev->first_signalled_pipe;
- if (dev->first_signalled_pipe)
- dev->first_signalled_pipe->prev_signalled = pipe;
- dev->first_signalled_pipe = pipe;
-}
-
-static void signalled_pipes_remove_locked(struct goldfish_pipe_dev *dev,
- struct goldfish_pipe *pipe)
-{
- if (pipe->prev_signalled)
- pipe->prev_signalled->next_signalled = pipe->next_signalled;
- if (pipe->next_signalled)
- pipe->next_signalled->prev_signalled = pipe->prev_signalled;
- if (pipe == dev->first_signalled_pipe)
- dev->first_signalled_pipe = pipe->next_signalled;
- pipe->prev_signalled = NULL;
- pipe->next_signalled = NULL;
-}
-
-static struct goldfish_pipe *signalled_pipes_pop_front(
- struct goldfish_pipe_dev *dev, int *wakes)
-{
- struct goldfish_pipe *pipe;
- unsigned long flags;
-
- spin_lock_irqsave(&dev->lock, flags);
-
- pipe = dev->first_signalled_pipe;
- if (pipe) {
- *wakes = pipe->signalled_flags;
- pipe->signalled_flags = 0;
- /*
- * This is an optimized version of
- * signalled_pipes_remove_locked()
- * - We want to make it as fast as possible to
- * wake the sleeping pipe operations faster.
- */
- dev->first_signalled_pipe = pipe->next_signalled;
- if (dev->first_signalled_pipe)
- dev->first_signalled_pipe->prev_signalled = NULL;
- pipe->next_signalled = NULL;
- }
-
- spin_unlock_irqrestore(&dev->lock, flags);
- return pipe;
-}
-
-static void goldfish_interrupt_task(unsigned long dev_addr)
-{
- /* Iterate over the signalled pipes and wake them one by one */
- struct goldfish_pipe_dev *dev = (struct goldfish_pipe_dev *)dev_addr;
- struct goldfish_pipe *pipe;
- int wakes;
-
- while ((pipe = signalled_pipes_pop_front(dev, &wakes)) != NULL) {
- if (wakes & PIPE_WAKE_CLOSED) {
- pipe->flags = 1 << BIT_CLOSED_ON_HOST;
- } else {
- if (wakes & PIPE_WAKE_READ)
- clear_bit(BIT_WAKE_ON_READ, &pipe->flags);
- if (wakes & PIPE_WAKE_WRITE)
- clear_bit(BIT_WAKE_ON_WRITE, &pipe->flags);
- }
- /*
- * wake_up_interruptible() implies a write barrier, so don't
- * explicitly add another one here.
- */
- wake_up_interruptible(&pipe->wake_queue);
- }
-}
-
-/*
- * The general idea of the interrupt handling:
- *
- * 1. device raises an interrupt if there's at least one signalled pipe
- * 2. IRQ handler reads the signalled pipes and their count from the device
- * 3. device writes them into a shared buffer and returns the count
- * it only resets the IRQ if it has returned all signalled pipes,
- * otherwise it leaves it raised, so IRQ handler will be called
- * again for the next chunk
- * 4. IRQ handler adds all returned pipes to the device's signalled pipes list
- * 5. IRQ handler launches a tasklet to process the signalled pipes from the
- * list in a separate context
- */
-static irqreturn_t goldfish_pipe_interrupt(int irq, void *dev_id)
-{
- u32 count;
- u32 i;
- unsigned long flags;
- struct goldfish_pipe_dev *dev = dev_id;
-
- if (dev->super.deinit != &goldfish_pipe_device_deinit)
- return IRQ_NONE;
-
- /* Request the signalled pipes from the device */
- spin_lock_irqsave(&dev->lock, flags);
-
- count = readl(dev->base + PIPE_V2_REG_GET_SIGNALLED);
- if (count == 0) {
- spin_unlock_irqrestore(&dev->lock, flags);
- return IRQ_NONE;
- }
- if (count > MAX_SIGNALLED_PIPES)
- count = MAX_SIGNALLED_PIPES;
-
- for (i = 0; i < count; ++i)
- signalled_pipes_add_locked(dev,
- dev->buffers->signalled_pipe_buffers[i].id,
- dev->buffers->signalled_pipe_buffers[i].flags);
-
- spin_unlock_irqrestore(&dev->lock, flags);
-
- tasklet_schedule(&dev->irq_tasklet);
- return IRQ_HANDLED;
-}
-
-static int get_free_pipe_id_locked(struct goldfish_pipe_dev *dev)
-{
- int id;
-
- for (id = 0; id < dev->pipes_capacity; ++id)
- if (!dev->pipes[id])
- return id;
-
- {
- /* Reallocate the array.
- * Since get_free_pipe_id_locked runs with interrupts disabled,
- * we don't want to make calls that could lead to sleep.
- */
- u32 new_capacity = 2 * dev->pipes_capacity;
- struct goldfish_pipe **pipes =
- kcalloc(new_capacity, sizeof(*pipes), GFP_ATOMIC);
- if (!pipes)
- return -ENOMEM;
- memcpy(pipes, dev->pipes, sizeof(*pipes) * dev->pipes_capacity);
- kfree(dev->pipes);
- dev->pipes = pipes;
- id = dev->pipes_capacity;
- dev->pipes_capacity = new_capacity;
- }
- return id;
-}
-
-/* A helper function to get the instance of goldfish_pipe_dev from file */
-static struct goldfish_pipe_dev *to_goldfish_pipe_dev(struct file *file)
-{
- struct miscdevice *miscdev = file->private_data;
-
- return container_of(miscdev, struct goldfish_pipe_dev, miscdev);
-}
-
-/**
- * goldfish_pipe_open - open a channel to the AVD
- * @inode: inode of device
- * @file: file struct of opener
- *
- * Create a new pipe link between the emulator and the use application.
- * Each new request produces a new pipe.
- *
- * Note: we use the pipe ID as a mux. All goldfish emulations are 32bit
- * right now so this is fine. A move to 64bit will need this addressing
- */
-static int goldfish_pipe_open(struct inode *inode, struct file *file)
-{
- struct goldfish_pipe_dev *dev = to_goldfish_pipe_dev(file);
- unsigned long flags;
- int id;
- int status;
-
- /* Allocate new pipe kernel object */
- struct goldfish_pipe *pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
-
- if (!pipe)
- return -ENOMEM;
-
- pipe->dev = dev;
- mutex_init(&pipe->lock);
- init_waitqueue_head(&pipe->wake_queue);
-
- /*
- * Command buffer needs to be allocated on its own page to make sure
- * it is physically contiguous in host's address space.
- */
- BUILD_BUG_ON(sizeof(struct goldfish_pipe_command) > PAGE_SIZE);
- pipe->command_buffer =
- (struct goldfish_pipe_command *)__get_free_page(GFP_KERNEL);
- if (!pipe->command_buffer) {
- status = -ENOMEM;
- goto err_pipe;
- }
-
- spin_lock_irqsave(&dev->lock, flags);
-
- id = get_free_pipe_id_locked(dev);
- if (id < 0) {
- status = id;
- goto err_id_locked;
- }
-
- dev->pipes[id] = pipe;
- pipe->id = id;
- pipe->command_buffer->id = id;
-
- /* Now tell the emulator we're opening a new pipe. */
- dev->buffers->open_command_params.rw_params_max_count =
- MAX_BUFFERS_PER_COMMAND;
- dev->buffers->open_command_params.command_buffer_ptr =
- (u64)(unsigned long)__pa(pipe->command_buffer);
- status = goldfish_pipe_cmd_locked(pipe, PIPE_CMD_OPEN);
- spin_unlock_irqrestore(&dev->lock, flags);
- if (status < 0)
- goto err_cmd;
- pipe->dma = NULL;
-
- /* All is done, save the pipe into the file's private data field */
- file->private_data = pipe;
- return 0;
-
-err_cmd:
- spin_lock_irqsave(&dev->lock, flags);
- dev->pipes[id] = NULL;
-err_id_locked:
- spin_unlock_irqrestore(&dev->lock, flags);
- free_page((unsigned long)pipe->command_buffer);
-err_pipe:
- kfree(pipe);
- return status;
-}
-
-static void goldfish_pipe_dma_release_host(struct goldfish_pipe *pipe)
-{
- struct goldfish_dma_context *dma = pipe->dma;
- struct device *pdev_dev;
-
- if (!dma)
- return;
-
- pdev_dev = pipe->dev->pdev_dev;
-
- if (dma->dma_vaddr) {
- pipe->command_buffer->dma_maphost_params.dma_paddr =
- dma->phys_begin;
- pipe->command_buffer->dma_maphost_params.sz = dma->dma_size;
- goldfish_pipe_cmd(pipe, PIPE_CMD_DMA_HOST_UNMAP);
- }
-}
-
-static void goldfish_pipe_dma_release_guest(struct goldfish_pipe *pipe)
-{
- struct goldfish_dma_context *dma = pipe->dma;
-
- if (!dma)
- return;
-
- if (dma->dma_vaddr) {
- dma_free_coherent(dma->pdev_dev,
- dma->dma_size,
- dma->dma_vaddr,
- dma->phys_begin);
- pipe->dev->dma_alloc_total -= dma->dma_size;
- }
-}
-
-static int goldfish_pipe_release(struct inode *inode, struct file *filp)
-{
- unsigned long flags;
- struct goldfish_pipe *pipe = filp->private_data;
- struct goldfish_pipe_dev *dev = pipe->dev;
-
- /* The guest is closing the channel, so tell the emulator right now */
- goldfish_pipe_dma_release_host(pipe);
- goldfish_pipe_cmd(pipe, PIPE_CMD_CLOSE);
-
- spin_lock_irqsave(&dev->lock, flags);
- dev->pipes[pipe->id] = NULL;
- signalled_pipes_remove_locked(dev, pipe);
- spin_unlock_irqrestore(&dev->lock, flags);
-
- filp->private_data = NULL;
-
- /* Even if a fd is duped or involved in a forked process,
- * open/release methods are called only once, ever.
- * This makes goldfish_pipe_release a safe point
- * to delete the DMA region.
- */
- goldfish_pipe_dma_release_guest(pipe);
-
- kfree(pipe->dma);
- free_page((unsigned long)pipe->command_buffer);
- kfree(pipe);
-
- return 0;
-}
-
-/* VMA open/close are for debugging purposes only.
- * One might think that fork() (and thus pure calls to open())
- * will require some sort of bookkeeping or refcounting
- * for dma contexts (incl. when to call dma_free_coherent),
- * but |vm_private_data| field and |vma_open/close| are only
- * for situations where the driver needs to interact with vma's
- * directly with its own per-VMA data structure (which does
- * need to be refcounted).
- *
- * Here, we just use the kernel's existing
- * VMA processing; we don't do anything on our own.
- * The only reason we would want to do so is if we had to do
- * special processing for the virtual (not physical) memory
- * already associated with DMA memory; it is much less related
- * to the task of knowing when to alloc/dealloc DMA memory.
- */
-static void goldfish_dma_vma_open(struct vm_area_struct *vma)
-{
- /* Not used */
-}
-
-static void goldfish_dma_vma_close(struct vm_area_struct *vma)
-{
- /* Not used */
-}
-
-static const struct vm_operations_struct goldfish_dma_vm_ops = {
- .open = goldfish_dma_vma_open,
- .close = goldfish_dma_vma_close,
-};
-
-static bool is_page_size_multiple(unsigned long sz)
-{
- return !(sz & (PAGE_SIZE - 1));
-}
-
-static bool check_region_size_valid(size_t size)
-{
- if (size < DMA_REGION_MIN_SIZE)
- return false;
-
- if (size > DMA_REGION_MAX_SIZE)
- return false;
-
- return is_page_size_multiple(size);
-}
-
-static int goldfish_pipe_dma_alloc_locked(struct goldfish_pipe *pipe)
-{
- struct goldfish_dma_context *dma = pipe->dma;
-
- if (dma->dma_vaddr)
- return 0;
-
- dma->phys_begin = 0;
- dma->dma_vaddr = dma_alloc_coherent(dma->pdev_dev,
- dma->dma_size,
- &dma->phys_begin,
- GFP_KERNEL);
- if (!dma->dma_vaddr)
- return -ENOMEM;
-
- dma->phys_end = dma->phys_begin + dma->dma_size;
- pipe->dev->dma_alloc_total += dma->dma_size;
- pipe->command_buffer->dma_maphost_params.dma_paddr = dma->phys_begin;
- pipe->command_buffer->dma_maphost_params.sz = dma->dma_size;
-
- goldfish_pipe_cmd_locked(pipe, PIPE_CMD_DMA_HOST_MAP);
- /* A workaround for b/110152998 */
- return 0;
-}
-
-static int goldfish_dma_mmap_locked(struct goldfish_pipe *pipe,
- struct vm_area_struct *vma)
-{
- struct goldfish_dma_context *dma = pipe->dma;
- struct device *pdev_dev = pipe->dev->pdev_dev;
- size_t sz_requested = vma->vm_end - vma->vm_start;
- int status;
-
- if (!check_region_size_valid(sz_requested)) {
- dev_err(pdev_dev, "%s: bad size (%zu) requested\n", __func__,
- sz_requested);
- return -EINVAL;
- }
-
- /* Alloc phys region if not allocated already. */
- status = goldfish_pipe_dma_alloc_locked(pipe);
- if (status)
- return status;
-
- status = remap_pfn_range(vma,
- vma->vm_start,
- dma->phys_begin >> PAGE_SHIFT,
- sz_requested,
- vma->vm_page_prot);
- if (status < 0) {
- dev_err(pdev_dev, "Cannot remap pfn range....\n");
- return -EAGAIN;
- }
- vma->vm_ops = &goldfish_dma_vm_ops;
- return 0;
-}
-
-/* When we call mmap() on a pipe fd, we obtain a pointer into
- * the physically contiguous DMA region of the pipe device
- * (Goldfish DMA).
- */
-static int goldfish_dma_mmap(struct file *filp, struct vm_area_struct *vma)
-{
- struct goldfish_pipe *pipe =
- (struct goldfish_pipe *)(filp->private_data);
- int status;
-
- if (mutex_lock_interruptible(&pipe->lock))
- return -ERESTARTSYS;
-
- status = goldfish_dma_mmap_locked(pipe, vma);
- mutex_unlock(&pipe->lock);
- return status;
-}
-
-static int goldfish_pipe_dma_create_region(struct goldfish_pipe *pipe,
- size_t size)
-{
- struct goldfish_dma_context *dma =
- kzalloc(sizeof(struct goldfish_dma_context), GFP_KERNEL);
- struct device *pdev_dev = pipe->dev->pdev_dev;
-
- if (dma) {
- if (mutex_lock_interruptible(&pipe->lock)) {
- kfree(dma);
- return -ERESTARTSYS;
- }
-
- if (pipe->dma) {
- mutex_unlock(&pipe->lock);
- kfree(dma);
- dev_err(pdev_dev, "The DMA region already allocated\n");
- return -EBUSY;
- }
-
- dma->dma_size = size;
- dma->pdev_dev = pipe->dev->pdev_dev;
- pipe->dma = dma;
- mutex_unlock(&pipe->lock);
- return 0;
- }
-
- dev_err(pdev_dev, "Could not allocate DMA context info!\n");
- return -ENOMEM;
-}
-
-static long goldfish_dma_ioctl_getoff(struct goldfish_pipe *pipe,
- unsigned long arg)
-{
- struct device *pdev_dev = pipe->dev->pdev_dev;
- struct goldfish_dma_ioctl_info ioctl_data;
- struct goldfish_dma_context *dma;
-
- BUILD_BUG_ON(sizeof_field(struct goldfish_dma_ioctl_info, phys_begin) <
- sizeof_field(struct goldfish_dma_context, phys_begin));
-
- if (mutex_lock_interruptible(&pipe->lock)) {
- dev_err(pdev_dev, "DMA_GETOFF: the pipe is not locked\n");
- return -EACCES;
- }
-
- dma = pipe->dma;
- if (dma) {
- ioctl_data.phys_begin = dma->phys_begin;
- ioctl_data.size = dma->dma_size;
- } else {
- ioctl_data.phys_begin = 0;
- ioctl_data.size = 0;
- }
-
- if (copy_to_user((void __user *)arg, &ioctl_data,
- sizeof(ioctl_data))) {
- mutex_unlock(&pipe->lock);
- return -EFAULT;
- }
-
- mutex_unlock(&pipe->lock);
- return 0;
-}
-
-static long goldfish_dma_ioctl_create_region(struct goldfish_pipe *pipe,
- unsigned long arg)
-{
- struct goldfish_dma_ioctl_info ioctl_data;
-
- if (copy_from_user(&ioctl_data, (void __user *)arg, sizeof(ioctl_data)))
- return -EFAULT;
-
- if (!check_region_size_valid(ioctl_data.size)) {
- dev_err(pipe->dev->pdev_dev,
- "DMA_CREATE_REGION: bad size (%lld) requested\n",
- ioctl_data.size);
- return -EINVAL;
- }
-
- return goldfish_pipe_dma_create_region(pipe, ioctl_data.size);
-}
-
-static long goldfish_dma_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
-{
- struct goldfish_pipe *pipe =
- (struct goldfish_pipe *)(file->private_data);
-
- switch (cmd) {
- case GOLDFISH_DMA_IOC_LOCK:
- return 0;
- case GOLDFISH_DMA_IOC_UNLOCK:
- wake_up_interruptible(&pipe->wake_queue);
- return 0;
- case GOLDFISH_DMA_IOC_GETOFF:
- return goldfish_dma_ioctl_getoff(pipe, arg);
- case GOLDFISH_DMA_IOC_CREATE_REGION:
- return goldfish_dma_ioctl_create_region(pipe, arg);
- }
- return -ENOTTY;
-}
-
-static const struct file_operations goldfish_pipe_fops = {
- .owner = THIS_MODULE,
- .read = goldfish_pipe_read,
- .write = goldfish_pipe_write,
- .poll = goldfish_pipe_poll,
- .open = goldfish_pipe_open,
- .release = goldfish_pipe_release,
- /* DMA-related operations */
- .mmap = goldfish_dma_mmap,
- .unlocked_ioctl = goldfish_dma_ioctl,
- .compat_ioctl = goldfish_dma_ioctl,
-};
-
-static void init_miscdevice(struct miscdevice *miscdev)
-{
- memset(miscdev, 0, sizeof(*miscdev));
-
- miscdev->minor = MISC_DYNAMIC_MINOR;
- miscdev->name = DEVICE_NAME;
- miscdev->fops = &goldfish_pipe_fops;
-}
-
-static void write_pa_addr(void *addr, void __iomem *portl, void __iomem *porth)
-{
- const unsigned long paddr = __pa(addr);
-
- writel(upper_32_bits(paddr), porth);
- writel(lower_32_bits(paddr), portl);
-}
-
-int goldfish_pipe_device_v2_init(struct platform_device *pdev,
- char __iomem *base,
- int irq)
-{
- struct goldfish_pipe_dev *dev;
- int err;
-
- dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
- if (!dev)
- return -ENOMEM;
-
- dev->super.deinit = &goldfish_pipe_device_deinit;
- spin_lock_init(&dev->lock);
-
- tasklet_init(&dev->irq_tasklet, &goldfish_interrupt_task,
- (unsigned long)dev);
-
- err = devm_request_irq(&pdev->dev, irq,
- goldfish_pipe_interrupt,
- IRQF_SHARED, DEVICE_NAME, dev);
- if (err) {
- dev_err(&pdev->dev, "unable to allocate IRQ for v2\n");
- return err;
- }
-
- init_miscdevice(&dev->miscdev);
- err = misc_register(&dev->miscdev);
- if (err) {
- dev_err(&pdev->dev, "unable to register v2 device\n");
- return err;
- }
-
- dev->base = base;
- dev->pdev_dev = &pdev->dev;
- dev->first_signalled_pipe = NULL;
- dev->pipes_capacity = INITIAL_PIPES_CAPACITY;
- dev->pipes = kcalloc(dev->pipes_capacity, sizeof(*dev->pipes),
- GFP_KERNEL);
- if (!dev->pipes) {
- misc_deregister(&dev->miscdev);
- return -ENOMEM;
- }
-
- /*
- * We're going to pass two buffers, open_command_params and
- * signalled_pipe_buffers, to the host. This means each of those buffers
- * needs to be contained in a single physical page. The easiest choice
- * is to just allocate a page and place the buffers in it.
- */
- BUILD_BUG_ON(sizeof(struct goldfish_pipe_dev_buffers) > PAGE_SIZE);
- dev->buffers = (struct goldfish_pipe_dev_buffers *)
- __get_free_page(GFP_KERNEL);
- if (!dev->buffers) {
- kfree(dev->pipes);
- misc_deregister(&dev->miscdev);
- return -ENOMEM;
- }
-
- /* Send the buffer addresses to the host */
- write_pa_addr(&dev->buffers->signalled_pipe_buffers,
- dev->base + PIPE_V2_REG_SIGNAL_BUFFER,
- dev->base + PIPE_V2_REG_SIGNAL_BUFFER_HIGH);
-
- writel(MAX_SIGNALLED_PIPES,
- dev->base + PIPE_V2_REG_SIGNAL_BUFFER_COUNT);
-
- write_pa_addr(&dev->buffers->open_command_params,
- dev->base + PIPE_V2_REG_OPEN_BUFFER,
- dev->base + PIPE_V2_REG_OPEN_BUFFER_HIGH);
-
- platform_set_drvdata(pdev, dev);
- return 0;
-}
-
-static int goldfish_pipe_device_deinit(void *raw_dev,
- struct platform_device *pdev)
-{
- struct goldfish_pipe_dev *dev = raw_dev;
-
- misc_deregister(&dev->miscdev);
- tasklet_kill(&dev->irq_tasklet);
- kfree(dev->pipes);
- free_page((unsigned long)dev->buffers);
-
- return 0;
-}
diff --git a/goldfish_sync.c b/goldfish_sync.c
deleted file mode 100644
index 913f619..0000000
--- a/goldfish_sync.c
+++ /dev/null
@@ -1,835 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+
-
-/* The Goldfish sync driver is designed to provide a interface
- * between the underlying host's sync device and the kernel's
- * fence sync framework.
- *
- * The purpose of the device/driver is to enable lightweight creation and
- * signaling of timelines and fences in order to synchronize the guest with
- * host-side graphics events.
- *
- * Each time the interrupt trips, the driver may perform a sync operation.
- */
-
-#include "defconfig_test.h"
-
-#include <linux/acpi.h>
-#include <linux/dma-fence.h>
-#include <linux/fdtable.h>
-#include <linux/file.h>
-#include <linux/fs.h>
-#include <linux/io.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/kref.h>
-#include <linux/miscdevice.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/spinlock.h>
-#include <linux/string.h>
-#include <linux/sync_file.h>
-#include <linux/syscalls.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-
-#include "uapi/goldfish_sync.h"
-
-struct sync_pt {
- struct dma_fence base; /* must be the first field in this struct */
- struct list_head active_list; /* see active_list_head below */
-};
-
-struct goldfish_sync_state;
-
-struct goldfish_sync_timeline {
- struct goldfish_sync_state *sync_state;
-
- /* This object is owned by userspace from open() calls and also each
- * sync_pt refers to it.
- */
- struct kref kref;
- char name[32]; /* for debugging */
-
- u64 context;
- unsigned int seqno;
- /* list of active (unsignaled/errored) sync_pts */
- struct list_head active_list_head;
- spinlock_t lock; /* protects the fields above */
-};
-
-/* The above definitions (command codes, register layout, ioctl definitions)
- * need to be in sync with the following files:
- *
- * Host-side (emulator):
- * external/qemu/android/emulation/goldfish_sync.h
- * external/qemu-android/hw/misc/goldfish_sync.c
- *
- * Guest-side (system image):
- * device/generic/goldfish-opengl/system/egl/goldfish_sync.h
- * device/generic/goldfish/ueventd.ranchu.rc
- * platform/build/target/board/generic/sepolicy/file_contexts
- */
-struct goldfish_sync_hostcmd {
- /* sorted for alignment */
- u64 handle;
- u64 hostcmd_handle;
- u32 cmd;
- u32 time_arg;
-};
-
-struct goldfish_sync_guestcmd {
- u64 host_command; /* u64 for alignment */
- u64 glsync_handle;
- u64 thread_handle;
- u64 guest_timeline_handle;
-};
-
-/* The host operations are: */
-enum cmd_id {
- /* Ready signal - used to mark when irq should lower */
- CMD_SYNC_READY = 0,
-
- /* Create a new timeline. writes timeline handle */
- CMD_CREATE_SYNC_TIMELINE = 1,
-
- /* Create a fence object. reads timeline handle and time argument.
- * Writes fence fd to the SYNC_REG_HANDLE register.
- */
- CMD_CREATE_SYNC_FENCE = 2,
-
- /* Increments timeline. reads timeline handle and time argument */
- CMD_SYNC_TIMELINE_INC = 3,
-
- /* Destroys a timeline. reads timeline handle */
- CMD_DESTROY_SYNC_TIMELINE = 4,
-
- /* Starts a wait on the host with the given glsync object and
- * sync thread handle.
- */
- CMD_TRIGGER_HOST_WAIT = 5,
-};
-
-/* The host register layout is: */
-enum sync_reg_id {
- /* host->guest batch commands */
- SYNC_REG_BATCH_COMMAND = 0x00,
-
- /* guest->host batch commands */
- SYNC_REG_BATCH_GUESTCOMMAND = 0x04,
-
- /* communicate physical address of host->guest batch commands */
- SYNC_REG_BATCH_COMMAND_ADDR = 0x08,
- SYNC_REG_BATCH_COMMAND_ADDR_HIGH = 0x0C, /* 64-bit part */
-
- /* communicate physical address of guest->host commands */
- SYNC_REG_BATCH_GUESTCOMMAND_ADDR = 0x10,
- SYNC_REG_BATCH_GUESTCOMMAND_ADDR_HIGH = 0x14, /* 64-bit part */
-
- /* signals that the device has been probed */
- SYNC_REG_INIT = 0x18,
-};
-
-#define GOLDFISH_SYNC_MAX_CMDS 32
-
-/* The driver state: */
-struct goldfish_sync_state {
- struct miscdevice miscdev;
-
- char __iomem *reg_base;
- int irq;
-
- /* Used to generate unique names, see goldfish_sync_timeline::name. */
- u64 id_counter;
-
- /* |mutex_lock| protects all concurrent access
- * to timelines for both kernel and user space.
- */
- struct mutex mutex_lock;
-
- /* Buffer holding commands issued from host. */
- struct goldfish_sync_hostcmd to_do[GOLDFISH_SYNC_MAX_CMDS];
- u32 to_do_end;
- /* Protects to_do and to_do_end */
- spinlock_t to_do_lock;
-
- /* Buffers for the reading or writing
- * of individual commands. The host can directly write
- * to |batch_hostcmd| (and then this driver immediately
- * copies contents to |to_do|). This driver either replies
- * through |batch_hostcmd| or simply issues a
- * guest->host command through |batch_guestcmd|.
- */
- struct goldfish_sync_hostcmd batch_hostcmd;
- struct goldfish_sync_guestcmd batch_guestcmd;
-
- /* Used to give this struct itself to a work queue
- * function for executing actual sync commands.
- */
- struct work_struct work_item;
-};
-
-static struct goldfish_sync_timeline
-*goldfish_dma_fence_parent(struct dma_fence *fence)
-{
- return container_of(fence->lock, struct goldfish_sync_timeline, lock);
-}
-
-static struct sync_pt *goldfish_sync_fence_to_sync_pt(struct dma_fence *fence)
-{
- return container_of(fence, struct sync_pt, base);
-}
-
-/* sync_state->mutex_lock must be locked. */
-struct goldfish_sync_timeline __must_check
-*goldfish_sync_timeline_create(struct goldfish_sync_state *sync_state)
-{
- struct goldfish_sync_timeline *tl;
-
- tl = kzalloc(sizeof(*tl), GFP_KERNEL);
- if (!tl)
- return NULL;
-
- tl->sync_state = sync_state;
- kref_init(&tl->kref);
- snprintf(tl->name, sizeof(tl->name),
- "%s:%llu", GOLDFISH_SYNC_DEVICE_NAME,
- ++sync_state->id_counter);
- tl->context = dma_fence_context_alloc(1);
- tl->seqno = 0;
- INIT_LIST_HEAD(&tl->active_list_head);
- spin_lock_init(&tl->lock);
-
- return tl;
-}
-
-static void goldfish_sync_timeline_free(struct kref *kref)
-{
- struct goldfish_sync_timeline *tl =
- container_of(kref, struct goldfish_sync_timeline, kref);
-
- kfree(tl);
-}
-
-static void goldfish_sync_timeline_get(struct goldfish_sync_timeline *tl)
-{
- kref_get(&tl->kref);
-}
-
-void goldfish_sync_timeline_put(struct goldfish_sync_timeline *tl)
-{
- kref_put(&tl->kref, goldfish_sync_timeline_free);
-}
-
-void goldfish_sync_timeline_signal(struct goldfish_sync_timeline *tl,
- unsigned int inc)
-{
- unsigned long flags;
- struct sync_pt *pt, *next;
-
- spin_lock_irqsave(&tl->lock, flags);
- tl->seqno += inc;
-
- list_for_each_entry_safe(pt, next, &tl->active_list_head, active_list) {
- /* dma_fence_is_signaled_locked has side effects */
- if (dma_fence_is_signaled_locked(&pt->base))
- list_del_init(&pt->active_list);
- }
- spin_unlock_irqrestore(&tl->lock, flags);
-}
-
-static const struct dma_fence_ops goldfish_sync_timeline_fence_ops;
-
-static struct sync_pt __must_check
-*goldfish_sync_pt_create(struct goldfish_sync_timeline *tl,
- unsigned int value)
-{
- struct sync_pt *pt = kzalloc(sizeof(*pt), GFP_KERNEL);
-
- if (!pt)
- return NULL;
-
- dma_fence_init(&pt->base,
- &goldfish_sync_timeline_fence_ops,
- &tl->lock,
- tl->context,
- value);
- INIT_LIST_HEAD(&pt->active_list);
- goldfish_sync_timeline_get(tl); /* pt refers to tl */
-
- return pt;
-}
-
-static void goldfish_sync_pt_destroy(struct sync_pt *pt)
-{
- struct goldfish_sync_timeline *tl =
- goldfish_dma_fence_parent(&pt->base);
- unsigned long flags;
-
- spin_lock_irqsave(&tl->lock, flags);
- if (!list_empty(&pt->active_list))
- list_del(&pt->active_list);
- spin_unlock_irqrestore(&tl->lock, flags);
-
- goldfish_sync_timeline_put(tl); /* unref pt from tl */
- dma_fence_free(&pt->base);
-}
-
-static const char
-*goldfish_sync_timeline_fence_get_driver_name(struct dma_fence *fence)
-{
- return "sw_sync";
-}
-
-static const char
-*goldfish_sync_timeline_fence_get_timeline_name(struct dma_fence *fence)
-{
- struct goldfish_sync_timeline *tl = goldfish_dma_fence_parent(fence);
-
- return tl->name;
-}
-
-static void goldfish_sync_timeline_fence_release(struct dma_fence *fence)
-{
- goldfish_sync_pt_destroy(goldfish_sync_fence_to_sync_pt(fence));
-}
-
-static bool goldfish_sync_timeline_fence_signaled(struct dma_fence *fence)
-{
- struct goldfish_sync_timeline *tl = goldfish_dma_fence_parent(fence);
-
- return tl->seqno >= fence->seqno;
-}
-
-static bool
-goldfish_sync_timeline_fence_enable_signaling(struct dma_fence *fence)
-{
- struct sync_pt *pt;
- struct goldfish_sync_timeline *tl;
-
- if (goldfish_sync_timeline_fence_signaled(fence))
- return false;
-
- pt = goldfish_sync_fence_to_sync_pt(fence);
- tl = goldfish_dma_fence_parent(fence);
- list_add_tail(&pt->active_list, &tl->active_list_head);
- return true;
-}
-
-static void goldfish_sync_timeline_fence_value_str(struct dma_fence *fence,
- char *str, int size)
-{
- snprintf(str, size, "%d", fence->seqno);
-}
-
-static void goldfish_sync_timeline_fence_timeline_value_str(
- struct dma_fence *fence,
- char *str, int size)
-{
- struct goldfish_sync_timeline *tl = goldfish_dma_fence_parent(fence);
-
- snprintf(str, size, "%d", tl->seqno);
-}
-
-static const struct dma_fence_ops goldfish_sync_timeline_fence_ops = {
- .get_driver_name = goldfish_sync_timeline_fence_get_driver_name,
- .get_timeline_name = goldfish_sync_timeline_fence_get_timeline_name,
- .enable_signaling = goldfish_sync_timeline_fence_enable_signaling,
- .signaled = goldfish_sync_timeline_fence_signaled,
- .wait = dma_fence_default_wait,
- .release = goldfish_sync_timeline_fence_release,
- .fence_value_str = goldfish_sync_timeline_fence_value_str,
- .timeline_value_str = goldfish_sync_timeline_fence_timeline_value_str,
-};
-
-static int __must_check
-goldfish_sync_fence_create(struct goldfish_sync_timeline *tl, u32 val)
-{
- struct sync_pt *pt;
- struct sync_file *sync_file_obj = NULL;
- int fd;
-
- pt = goldfish_sync_pt_create(tl, val);
- if (!pt)
- return -1;
-
- fd = get_unused_fd_flags(O_CLOEXEC);
- if (fd < 0)
- goto err_cleanup_pt;
-
- sync_file_obj = sync_file_create(&pt->base);
- if (!sync_file_obj)
- goto err_cleanup_fd_pt;
-
- fd_install(fd, sync_file_obj->file);
-
- dma_fence_put(&pt->base); /* sync_file_obj now owns the fence */
- return fd;
-
-err_cleanup_fd_pt:
- put_unused_fd(fd);
-err_cleanup_pt:
- goldfish_sync_pt_destroy(pt);
-
- return -1;
-}
-
-static inline void
-goldfish_sync_cmd_queue(struct goldfish_sync_state *sync_state,
- u32 cmd,
- u64 handle,
- u32 time_arg,
- u64 hostcmd_handle)
-{
- struct goldfish_sync_hostcmd *to_add;
-
- WARN_ON(sync_state->to_do_end == GOLDFISH_SYNC_MAX_CMDS);
-
- to_add = &sync_state->to_do[sync_state->to_do_end];
-
- to_add->cmd = cmd;
- to_add->handle = handle;
- to_add->time_arg = time_arg;
- to_add->hostcmd_handle = hostcmd_handle;
-
- ++sync_state->to_do_end;
-}
-
-static inline void
-goldfish_sync_hostcmd_reply(struct goldfish_sync_state *sync_state,
- u32 cmd,
- u64 handle,
- u32 time_arg,
- u64 hostcmd_handle)
-{
- unsigned long irq_flags;
- struct goldfish_sync_hostcmd *batch_hostcmd =
- &sync_state->batch_hostcmd;
-
- spin_lock_irqsave(&sync_state->to_do_lock, irq_flags);
-
- batch_hostcmd->cmd = cmd;
- batch_hostcmd->handle = handle;
- batch_hostcmd->time_arg = time_arg;
- batch_hostcmd->hostcmd_handle = hostcmd_handle;
- writel(0, sync_state->reg_base + SYNC_REG_BATCH_COMMAND);
-
- spin_unlock_irqrestore(&sync_state->to_do_lock, irq_flags);
-}
-
-static inline void
-goldfish_sync_send_guestcmd(struct goldfish_sync_state *sync_state,
- u32 cmd,
- u64 glsync_handle,
- u64 thread_handle,
- u64 timeline_handle)
-{
- unsigned long irq_flags;
- struct goldfish_sync_guestcmd *batch_guestcmd =
- &sync_state->batch_guestcmd;
-
- spin_lock_irqsave(&sync_state->to_do_lock, irq_flags);
-
- batch_guestcmd->host_command = cmd;
- batch_guestcmd->glsync_handle = glsync_handle;
- batch_guestcmd->thread_handle = thread_handle;
- batch_guestcmd->guest_timeline_handle = timeline_handle;
- writel(0, sync_state->reg_base + SYNC_REG_BATCH_GUESTCOMMAND);
-
- spin_unlock_irqrestore(&sync_state->to_do_lock, irq_flags);
-}
-
-/* |goldfish_sync_interrupt| handles IRQ raises from the virtual device.
- * In the context of OpenGL, this interrupt will fire whenever we need
- * to signal a fence fd in the guest, with the command
- * |CMD_SYNC_TIMELINE_INC|.
- * However, because this function will be called in an interrupt context,
- * it is necessary to do the actual work of signaling off of interrupt context.
- * The shared work queue is used for this purpose. At the end when
- * all pending commands are intercepted by the interrupt handler,
- * we call |schedule_work|, which will later run the actual
- * desired sync command in |goldfish_sync_work_item_fn|.
- */
-static irqreturn_t
-goldfish_sync_interrupt_impl(struct goldfish_sync_state *sync_state)
-{
- struct goldfish_sync_hostcmd *batch_hostcmd =
- &sync_state->batch_hostcmd;
-
- spin_lock(&sync_state->to_do_lock);
- for (;;) {
- u32 nextcmd;
- u32 command_r;
- u64 handle_rw;
- u32 time_r;
- u64 hostcmd_handle_rw;
-
- readl(sync_state->reg_base + SYNC_REG_BATCH_COMMAND);
- nextcmd = batch_hostcmd->cmd;
-
- if (nextcmd == 0)
- break;
-
- command_r = nextcmd;
- handle_rw = batch_hostcmd->handle;
- time_r = batch_hostcmd->time_arg;
- hostcmd_handle_rw = batch_hostcmd->hostcmd_handle;
-
- goldfish_sync_cmd_queue(sync_state,
- command_r,
- handle_rw,
- time_r,
- hostcmd_handle_rw);
- }
- spin_unlock(&sync_state->to_do_lock);
-
- schedule_work(&sync_state->work_item);
- return IRQ_HANDLED;
-}
-
-static const struct file_operations goldfish_sync_fops;
-
-static irqreturn_t goldfish_sync_interrupt(int irq, void *dev_id)
-{
- struct goldfish_sync_state *sync_state = dev_id;
-
- return (sync_state->miscdev.fops == &goldfish_sync_fops) ?
- goldfish_sync_interrupt_impl(sync_state) : IRQ_NONE;
-}
-
-/* We expect that commands will come in at a slow enough rate
- * so that incoming items will not be more than
- * GOLDFISH_SYNC_MAX_CMDS.
- *
- * This is because the way the sync device is used,
- * it's only for managing buffer data transfers per frame,
- * with a sequential dependency between putting things in
- * to_do and taking them out. Once a set of commands is
- * queued up in to_do, the user of the device waits for
- * them to be processed before queuing additional commands,
- * which limits the rate at which commands come in
- * to the rate at which we take them out here.
- *
- * We also don't expect more than MAX_CMDS to be issued
- * at once; there is a correspondence between
- * which buffers need swapping to the (display / buffer queue)
- * to particular commands, and we don't expect there to be
- * enough display or buffer queues in operation at once
- * to overrun GOLDFISH_SYNC_MAX_CMDS.
- */
-static u32 __must_check
-goldfish_sync_grab_commands(struct goldfish_sync_state *sync_state,
- struct goldfish_sync_hostcmd *dst)
-{
- u32 to_do_end;
- u32 i;
- unsigned long irq_flags;
-
- spin_lock_irqsave(&sync_state->to_do_lock, irq_flags);
-
- to_do_end = sync_state->to_do_end;
- for (i = 0; i < to_do_end; i++)
- dst[i] = sync_state->to_do[i];
- sync_state->to_do_end = 0;
-
- spin_unlock_irqrestore(&sync_state->to_do_lock, irq_flags);
-
- return to_do_end;
-}
-
-void goldfish_sync_run_hostcmd(struct goldfish_sync_state *sync_state,
- struct goldfish_sync_hostcmd *todo)
-{
- struct goldfish_sync_timeline *tl =
- (struct goldfish_sync_timeline *)(uintptr_t)todo->handle;
- int sync_fence_fd;
-
- switch (todo->cmd) {
- case CMD_SYNC_READY:
- break;
-
- case CMD_CREATE_SYNC_TIMELINE:
- tl = goldfish_sync_timeline_create(sync_state);
- WARN_ON(!tl);
- goldfish_sync_hostcmd_reply(sync_state,
- CMD_CREATE_SYNC_TIMELINE,
- (uintptr_t)tl,
- 0,
- todo->hostcmd_handle);
- break;
-
- case CMD_CREATE_SYNC_FENCE:
- WARN_ON(!tl);
- sync_fence_fd = goldfish_sync_fence_create(tl, todo->time_arg);
- goldfish_sync_hostcmd_reply(sync_state,
- CMD_CREATE_SYNC_FENCE,
- sync_fence_fd,
- 0,
- todo->hostcmd_handle);
- break;
-
- case CMD_SYNC_TIMELINE_INC:
- WARN_ON(!tl);
- goldfish_sync_timeline_signal(tl, todo->time_arg);
- break;
-
- case CMD_DESTROY_SYNC_TIMELINE:
- WARN_ON(!tl);
- goldfish_sync_timeline_put(tl);
- break;
- }
-}
-
-/* |goldfish_sync_work_item_fn| does the actual work of servicing
- * host->guest sync commands. This function is triggered whenever
- * the IRQ for the goldfish sync device is raised. Once it starts
- * running, it grabs the contents of the buffer containing the
- * commands it needs to execute (there may be multiple, because
- * our IRQ is active high and not edge triggered), and then
- * runs all of them one after the other.
- */
-static void goldfish_sync_work_item_fn(struct work_struct *input)
-{
- struct goldfish_sync_state *sync_state =
- container_of(input, struct goldfish_sync_state, work_item);
-
- struct goldfish_sync_hostcmd to_run[GOLDFISH_SYNC_MAX_CMDS];
- u32 to_do_end;
- u32 i;
-
- mutex_lock(&sync_state->mutex_lock);
-
- to_do_end = goldfish_sync_grab_commands(sync_state, to_run);
-
- for (i = 0; i < to_do_end; i++)
- goldfish_sync_run_hostcmd(sync_state, &to_run[i]);
-
- mutex_unlock(&sync_state->mutex_lock);
-}
-
-static int goldfish_sync_open(struct inode *inode, struct file *filp)
-{
- struct goldfish_sync_state *sync_state =
- container_of(filp->private_data,
- struct goldfish_sync_state,
- miscdev);
-
- if (mutex_lock_interruptible(&sync_state->mutex_lock))
- return -ERESTARTSYS;
-
- filp->private_data = goldfish_sync_timeline_create(sync_state);
- mutex_unlock(&sync_state->mutex_lock);
-
- return filp->private_data ? 0 : -ENOMEM;
-}
-
-static int goldfish_sync_release(struct inode *inode, struct file *filp)
-{
- struct goldfish_sync_timeline *tl = filp->private_data;
-
- goldfish_sync_timeline_put(tl);
- return 0;
-}
-
-/* |goldfish_sync_ioctl| is the guest-facing interface of goldfish sync
- * and is used in conjunction with eglCreateSyncKHR to queue up the
- * actual work of waiting for the EGL sync command to complete,
- * possibly returning a fence fd to the guest.
- */
-static long
-goldfish_sync_ioctl_locked(struct goldfish_sync_timeline *tl,
- unsigned int cmd,
- unsigned long arg)
-{
- struct goldfish_sync_ioctl_info ioctl_data;
- int fd_out = -1;
-
- switch (cmd) {
- case GOLDFISH_SYNC_IOC_QUEUE_WORK:
- if (copy_from_user(&ioctl_data,
- (void __user *)arg,
- sizeof(ioctl_data)))
- return -EFAULT;
-
- if (!ioctl_data.host_syncthread_handle_in)
- return -EFAULT;
-
- fd_out = goldfish_sync_fence_create(tl, tl->seqno + 1);
- ioctl_data.fence_fd_out = fd_out;
-
- if (copy_to_user((void __user *)arg,
- &ioctl_data,
- sizeof(ioctl_data))) {
- ksys_close(fd_out);
- return -EFAULT;
- }
-
- /* We are now about to trigger a host-side wait;
- * accumulate on |pending_waits|.
- */
- goldfish_sync_send_guestcmd(tl->sync_state,
- CMD_TRIGGER_HOST_WAIT,
- ioctl_data.host_glsync_handle_in,
- ioctl_data.host_syncthread_handle_in,
- (u64)(uintptr_t)tl);
- return 0;
-
- default:
- return -ENOTTY;
- }
-}
-
-static long goldfish_sync_ioctl(struct file *filp,
- unsigned int cmd,
- unsigned long arg)
-{
- struct goldfish_sync_timeline *tl = filp->private_data;
- struct goldfish_sync_state *x = tl->sync_state;
- long res;
-
- if (mutex_lock_interruptible(&x->mutex_lock))
- return -ERESTARTSYS;
-
- res = goldfish_sync_ioctl_locked(tl, cmd, arg);
- mutex_unlock(&x->mutex_lock);
-
- return res;
-}
-
-static bool setup_verify_batch_cmd_addr(char *reg_base,
- void *batch_addr,
- u32 addr_offset,
- u32 addr_offset_high)
-{
- u64 batch_addr_phys;
- u64 batch_addr_phys_test_lo;
- u64 batch_addr_phys_test_hi;
-
- batch_addr_phys = virt_to_phys(batch_addr);
- writel(lower_32_bits(batch_addr_phys), reg_base + addr_offset);
- writel(upper_32_bits(batch_addr_phys), reg_base + addr_offset_high);
-
- batch_addr_phys_test_lo = readl(reg_base + addr_offset);
- batch_addr_phys_test_hi = readl(reg_base + addr_offset_high);
-
- batch_addr_phys = batch_addr_phys_test_lo |
- (batch_addr_phys_test_hi << 32);
-
- return virt_to_phys(batch_addr) == batch_addr_phys;
-}
-
-static const struct file_operations goldfish_sync_fops = {
- .owner = THIS_MODULE,
- .open = goldfish_sync_open,
- .release = goldfish_sync_release,
- .unlocked_ioctl = goldfish_sync_ioctl,
- .compat_ioctl = goldfish_sync_ioctl,
-};
-
-static void fill_miscdevice(struct miscdevice *misc)
-{
- misc->name = GOLDFISH_SYNC_DEVICE_NAME;
- misc->minor = MISC_DYNAMIC_MINOR;
- misc->fops = &goldfish_sync_fops;
-}
-
-static int goldfish_sync_probe(struct platform_device *pdev)
-{
- struct goldfish_sync_state *sync_state;
- struct resource *ioresource;
- int result;
-
- sync_state = devm_kzalloc(&pdev->dev, sizeof(*sync_state), GFP_KERNEL);
- if (!sync_state)
- return -ENOMEM;
-
- spin_lock_init(&sync_state->to_do_lock);
- mutex_init(&sync_state->mutex_lock);
- INIT_WORK(&sync_state->work_item, goldfish_sync_work_item_fn);
-
- ioresource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!ioresource)
- return -ENODEV;
-
- sync_state->reg_base =
- devm_ioremap(&pdev->dev, ioresource->start, PAGE_SIZE);
- if (!sync_state->reg_base)
- return -ENOMEM;
-
- result = platform_get_irq(pdev, 0);
- if (result < 0)
- return -ENODEV;
-
- sync_state->irq = result;
-
- result = devm_request_irq(&pdev->dev,
- sync_state->irq,
- goldfish_sync_interrupt,
- IRQF_SHARED,
- pdev->name,
- sync_state);
- if (result)
- return -ENODEV;
-
- if (!setup_verify_batch_cmd_addr(sync_state->reg_base,
- &sync_state->batch_hostcmd,
- SYNC_REG_BATCH_COMMAND_ADDR,
- SYNC_REG_BATCH_COMMAND_ADDR_HIGH))
- return -ENODEV;
-
- if (!setup_verify_batch_cmd_addr(sync_state->reg_base,
- &sync_state->batch_guestcmd,
- SYNC_REG_BATCH_GUESTCOMMAND_ADDR,
- SYNC_REG_BATCH_GUESTCOMMAND_ADDR_HIGH))
- return -ENODEV;
-
- fill_miscdevice(&sync_state->miscdev);
- result = misc_register(&sync_state->miscdev);
- if (result)
- return -ENODEV;
-
- writel(0, sync_state->reg_base + SYNC_REG_INIT);
-
- platform_set_drvdata(pdev, sync_state);
-
- return 0;
-}
-
-static int goldfish_sync_remove(struct platform_device *pdev)
-{
- struct goldfish_sync_state *sync_state = platform_get_drvdata(pdev);
-
- misc_deregister(&sync_state->miscdev);
- return 0;
-}
-
-static const struct of_device_id goldfish_sync_of_match[] = {
- { .compatible = "google,goldfish-sync", },
- {},
-};
-MODULE_DEVICE_TABLE(of, goldfish_sync_of_match);
-
-static const struct acpi_device_id goldfish_sync_acpi_match[] = {
- { "GFSH0006", 0 },
- { },
-};
-MODULE_DEVICE_TABLE(acpi, goldfish_sync_acpi_match);
-
-static struct platform_driver goldfish_sync = {
- .probe = goldfish_sync_probe,
- .remove = goldfish_sync_remove,
- .driver = {
- .name = GOLDFISH_SYNC_DEVICE_NAME,
- .of_match_table = goldfish_sync_of_match,
- .acpi_match_table = ACPI_PTR(goldfish_sync_acpi_match),
- }
-};
-module_platform_driver(goldfish_sync);
-
-MODULE_AUTHOR("Google, Inc.");
-MODULE_DESCRIPTION("Android QEMU Sync Driver");
-MODULE_LICENSE("GPL");
-MODULE_VERSION("2.0");
diff --git a/uapi/goldfish_address_space.h b/uapi/goldfish_address_space.h
deleted file mode 100644
index f18304f..0000000
--- a/uapi/goldfish_address_space.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef UAPI_GOLDFISH_ADDRESS_SPACE_H
-#define UAPI_GOLDFISH_ADDRESS_SPACE_H
-
-#include <linux/types.h>
-
-#define GOLDFISH_ADDRESS_SPACE_DEVICE_NAME "goldfish_address_space"
-
-struct goldfish_address_space_allocate_block {
- __u64 size;
- __u64 offset;
- __u64 phys_addr;
-};
-
-struct goldfish_address_space_ping {
- __u64 offset;
- __u64 size;
- __u64 metadata;
- __u32 version;
- __u32 wait_fd;
- __u32 wait_flags;
- __u32 direction;
-};
-
-struct goldfish_address_space_claim_shared {
- __u64 offset;
- __u64 size;
-};
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_MAGIC 'G'
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_OP(OP, T) \
- _IOWR(GOLDFISH_ADDRESS_SPACE_IOCTL_MAGIC, OP, T)
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_ALLOCATE_BLOCK \
- GOLDFISH_ADDRESS_SPACE_IOCTL_OP(10, \
- struct goldfish_address_space_allocate_block)
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_DEALLOCATE_BLOCK \
- GOLDFISH_ADDRESS_SPACE_IOCTL_OP(11, __u64)
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_PING \
- GOLDFISH_ADDRESS_SPACE_IOCTL_OP(12, \
- struct goldfish_address_space_ping)
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_CLAIM_SHARED \
- GOLDFISH_ADDRESS_SPACE_IOCTL_OP(13, \
- struct goldfish_address_space_claim_shared)
-
-#define GOLDFISH_ADDRESS_SPACE_IOCTL_UNCLAIM_SHARED \
- GOLDFISH_ADDRESS_SPACE_IOCTL_OP(14, __u64)
-
-#endif /* UAPI_GOLDFISH_ADDRESS_SPACE_H */
diff --git a/uapi/goldfish_dma.h b/uapi/goldfish_dma.h
deleted file mode 100644
index a901902..0000000
--- a/uapi/goldfish_dma.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2018 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-#ifndef UAPI_GOLDFISH_DMA_H
-#define UAPI_GOLDFISH_DMA_H
-
-#include <linux/types.h>
-
-/* GOLDFISH DMA
- *
- * Goldfish DMA is an extension to the pipe device
- * and is designed to facilitate high-speed RAM->RAM
- * transfers from guest to host.
- *
- * Interface (guest side):
- *
- * The guest user calls goldfish_dma_alloc (ioctls)
- * and then mmap() on a goldfish pipe fd,
- * which means that it wants high-speed access to
- * host-visible memory.
- *
- * The guest can then write into the pointer
- * returned by mmap(), and these writes
- * become immediately visible on the host without BQL
- * or otherweise context switching.
- *
- * dma_alloc_coherent() is used to obtain contiguous
- * physical memory regions, and we allocate and interact
- * with this region on both guest and host through
- * the following ioctls:
- *
- * - LOCK: lock the region for data access.
- * - UNLOCK: unlock the region. This may also be done from the host
- * through the WAKE_ON_UNLOCK_DMA procedure.
- * - CREATE_REGION: initialize size info for a dma region.
- * - GETOFF: send physical address to guest drivers.
- * - (UN)MAPHOST: uses goldfish_pipe_cmd to tell the host to
- * (un)map to the guest physical address associated
- * with the current dma context. This makes the physically
- * contiguous memory (in)visible to the host.
- *
- * Guest userspace obtains a pointer to the DMA memory
- * through mmap(), which also lazily allocates the memory
- * with dma_alloc_coherent. (On last pipe close(), the region is freed).
- * The mmaped() region can handle very high bandwidth
- * transfers, and pipe operations can be used at the same
- * time to handle synchronization and command communication.
- */
-
-#define GOLDFISH_DMA_BUFFER_SIZE (32 * 1024 * 1024)
-
-struct goldfish_dma_ioctl_info {
- __u64 phys_begin;
- __u64 size;
-};
-
-/* There is an ioctl associated with goldfish dma driver.
- * Make it conflict with ioctls that are not likely to be used
- * in the emulator.
- * 'G' 00-3F drivers/misc/sgi-gru/grulib.h conflict!
- * 'G' 00-0F linux/gigaset_dev.h conflict!
- */
-#define GOLDFISH_DMA_IOC_MAGIC 'G'
-#define GOLDFISH_DMA_IOC_OP(OP) _IOWR(GOLDFISH_DMA_IOC_MAGIC, OP, \
- struct goldfish_dma_ioctl_info)
-
-#define GOLDFISH_DMA_IOC_LOCK GOLDFISH_DMA_IOC_OP(0)
-#define GOLDFISH_DMA_IOC_UNLOCK GOLDFISH_DMA_IOC_OP(1)
-#define GOLDFISH_DMA_IOC_GETOFF GOLDFISH_DMA_IOC_OP(2)
-#define GOLDFISH_DMA_IOC_CREATE_REGION GOLDFISH_DMA_IOC_OP(3)
-
-#endif /* UAPI_GOLDFISH_DMA_H */
diff --git a/uapi/goldfish_sync.h b/uapi/goldfish_sync.h
deleted file mode 100644
index 01d762f..0000000
--- a/uapi/goldfish_sync.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-
-#ifndef UAPI_GOLDFISH_SYNC_H
-#define UAPI_GOLDFISH_SYNC_H
-
-#include <linux/types.h>
-
-#define GOLDFISH_SYNC_DEVICE_NAME "goldfish_sync"
-
-struct goldfish_sync_ioctl_info {
- __u64 host_glsync_handle_in;
- __u64 host_syncthread_handle_in;
- __s32 fence_fd_out;
-};
-
-/* There is an ioctl associated with goldfish sync driver.
- * Make it conflict with ioctls that are not likely to be used
- * in the emulator.
- *
- * '@' 00-0F linux/radeonfb.h conflict!
- * '@' 00-0F drivers/video/aty/aty128fb.c conflict!
- */
-#define GOLDFISH_SYNC_IOC_MAGIC '@'
-
-#define GOLDFISH_SYNC_IOC_QUEUE_WORK \
- _IOWR(GOLDFISH_SYNC_IOC_MAGIC, 0, struct goldfish_sync_ioctl_info)
-
-#endif /* UAPI_GOLDFISH_SYNC_H */
