platform: goldfish: pipe: Add DMA support to goldfish pipe
PATCH v2 6/21 platform: goldfish: pipe: Add DMA support to goldfish pipe
From: Roman Kiryanov <[email protected]>
Goldfish DMA is an extension to the pipe device and is designed to facilitate high-speed RAM->RAM transfers from guest to host.
See uapi/linux/goldfish/goldfish_dma.h for more details.
---
Changes in v2:
- Got sign-off from Lingfeng Yang.
- Removed the license boilerplate from goldfish_dma.h.
- Rebased.
drivers/platform/goldfish/goldfish_pipe.c | 312 +++++++++++++++++- .../platform/goldfish/goldfish_pipe_qemu.h | 2 + include/uapi/linux/goldfish/goldfish_dma.h | 71 ++++ 3 files changed, 383 insertions(+), 2 deletions(-) create mode 100644 include/uapi/linux/goldfish/goldfish_dma.h
drivers/platform/goldfish/goldfish_pipe.c +310 -2
@@ -63,21 +63,28 @@#include <linux/mm.h> #include <linux/acpi.h> #include <linux/bug.h> +#include <uapi/linux/goldfish/goldfish_dma.h> #include "goldfish_pipe_qemu.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 =2 , +PIPE_DRIVER_VERSION =4 ,PIPE_CURRENT_DEVICE_VERSION =2 };enum {MAX_BUFFERS_PER_COMMAND =336 ,MAX_SIGNALLED_PIPES =64 , -INITIAL_PIPES_CAPACITY =64 +INITIAL_PIPES_CAPACITY =64 , +DMA_REGION_MIN_SIZE =PAGE_SIZE , +DMA_REGION_MAX_SIZE =256 <<20 };struct goldfish_pipe_dev ;
@@ -100,6 +107,11 @@ struct goldfish_pipe_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; }; };
@@ -122,6 +134,24 @@ struct goldfish_pipe_dev_buffers { 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 */
@@ -162,6 +192,9 @@ struct goldfish_pipe {/* 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
@@ -208,6 +241,9 @@ struct goldfish_pipe_dev {int irq;int version;unsigned char __iomem *base; + +/* DMA info */ +size_t dma_alloc_total; };static struct goldfish_pipe_dev goldfish_pipe_dev;
@@ -739,6 +775,8 @@ static int goldfish_pipe_open(struct inode *inode, struct file *file)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 ;
@@ -754,6 +792,40 @@ static int goldfish_pipe_open(struct inode *inode, struct file *file)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;
@@ -761,6 +833,7 @@ static int goldfish_pipe_release(struct inode *inode, struct file *filp)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);
@@ -769,11 +842,242 @@ static int goldfish_pipe_release(struct inode *inode, struct file *filp)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; +return goldfish_pipe_cmd_locked (pipe,PIPE_CMD_DMA_HOST_MAP ); +} + +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(FIELD_SIZEOF(struct goldfish_dma_ioctl_info, phys_begin) < + FIELD_SIZEOF(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,
@@ -781,6 +1085,10 @@ static const struct file_operations goldfish_pipe_fops = { .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 struct miscdevice goldfish_pipe_miscdev = {
drivers/platform/goldfish/goldfish_pipe_qemu.h +2 -0
@@ -93,6 +93,8 @@ enum PipeCmdCode {* 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 */
include/uapi/linux/goldfish/goldfish_dma.h new file +71 -0
71 lines not on this page · raw message
Signature · 1 line
2.19.0.605.g01d371f741-goog
PATCH v2 9/21 platform: goldfish: pipe: Remove the goldfish_pipe_dev global variable
From: Roman Kiryanov <[email protected]>
This is the last patch in the series of patches to remove mutable global variables to introduce another version of the pipe driver for the older host interface. I don't want to have two driver states where only one is used.
---
Changes in v2:
- Rebased to address that goldfish_pipe_dev is static now.
drivers/platform/goldfish/goldfish_pipe.c | 66 +++++++++++++---------- 1 file changed, 37 insertions(+), 29 deletions(-)
drivers/platform/goldfish/goldfish_pipe.c +37 -29
@@ -202,6 +202,9 @@ struct goldfish_pipe {* waiting to be awoken. */ struct goldfish_pipe_dev { +/* A magic number to check if this is an instance of this struct */ +void *magic; +/* * Global device spinlock. Protects the following members: * - pipes, pipes_capacity
@@ -251,8 +254,6 @@ struct goldfish_pipe_dev {size_t dma_alloc_total; }; -static struct goldfish_pipe_dev goldfish_pipe_dev; -static int goldfish_pipe_cmd_locked (struct goldfish_pipe *pipe,enum PipeCmdCode cmd) {
@@ -647,6 +648,9 @@ static void goldfish_interrupt_task(unsigned long dev_addr) } } +static void goldfish_pipe_device_deinit (struct platform_device *pdev, +struct goldfish_pipe_dev *dev); +/* * The general idea of the interrupt handling: *
@@ -667,7 +671,7 @@ static irqreturn_t goldfish_pipe_interrupt(int irq, void *dev_id)unsigned long flags;struct goldfish_pipe_dev *dev = dev_id; -if (dev != &goldfish_pipe_dev) +if (dev->magic != &goldfish_pipe_device_deinit)return IRQ_NONE ;/* Request the signalled pipes from the device */
@@ -719,6 +723,14 @@ static int get_free_pipe_id_locked(struct goldfish_pipe_dev *dev)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
@@ -732,7 +744,7 @@ static int get_free_pipe_id_locked(struct goldfish_pipe_dev *dev)*/ static int goldfish_pipe_open (struct inode *inode,struct file *file) { -struct goldfish_pipe_dev *dev = &goldfish_pipe_dev; +struct goldfish_pipe_dev *dev =to_goldfish_pipe_dev (file);unsigned long flags;int id;int status;
@@ -1112,9 +1124,9 @@ static void write_pa_addr(void *addr, void __iomem *portl, void __iomem *porth)writel (lower_32_bits (paddr), portl); } -static int goldfish_pipe_device_init (struct platform_device *pdev) +static int goldfish_pipe_device_init (struct platform_device *pdev, +struct goldfish_pipe_dev *dev) { -struct goldfish_pipe_dev *dev = &goldfish_pipe_dev;int err; tasklet_init(&dev->irq_tasklet, &goldfish_interrupt_task,
@@ -1169,26 +1181,29 @@ static int goldfish_pipe_device_init(struct platform_device *pdev) dev->base +PIPE_REG_OPEN_BUFFER , dev->base + PIPE_REG_OPEN_BUFFER_HIGH); +platform_set_drvdata (pdev, dev);return 0 ; } -static void goldfish_pipe_device_deinit (struct platform_device *pdev) +static void goldfish_pipe_device_deinit (struct platform_device *pdev, +struct goldfish_pipe_dev *dev) { -misc_deregister (&goldfish_pipe_dev.miscdev); -tasklet_kill (&goldfish_pipe_dev.irq_tasklet); -kfree (goldfish_pipe_dev.pipes); -free_page ((unsigned long )goldfish_pipe_dev.buffers); +misc_deregister (&dev->miscdev); +tasklet_kill (&dev->irq_tasklet); +kfree (dev->pipes); +free_page ((unsigned long )dev->buffers); }static int goldfish_pipe_probe (struct platform_device *pdev) { -int err;struct resource *r; -struct goldfish_pipe_dev *dev = &goldfish_pipe_dev; +struct goldfish_pipe_dev *dev; -/* not thread safe, but this should not happen */ -WARN_ON (dev->base); + dev =devm_kzalloc (&pdev->dev,sizeof (*dev),GFP_KERNEL ); +if (!dev) +return -ENOMEM ; + dev->magic = &goldfish_pipe_device_deinit;spin_lock_init (&dev->lock); r =platform_get_resource (pdev,IORESOURCE_MEM ,0 );
@@ -1203,10 +1218,9 @@ static int goldfish_pipe_probe(struct platform_device *pdev) } r =platform_get_resource (pdev,IORESOURCE_IRQ ,0 ); -if (!r) { - err = -EINVAL ; - goto error; - } +if (!r) +return -EINVAL ; + dev->irq = r->start;/*
@@ -1221,20 +1235,14 @@ static int goldfish_pipe_probe(struct platform_device *pdev)if (WARN_ON (dev->version <PIPE_CURRENT_DEVICE_VERSION ))return -EINVAL ; - err =goldfish_pipe_device_init (pdev); -if (!err) -return 0 ; - -error: - dev->base =NULL ; -return err; +return goldfish_pipe_device_init (pdev, dev); }static int goldfish_pipe_remove (struct platform_device *pdev) { -struct goldfish_pipe_dev *dev = &goldfish_pipe_dev; -goldfish_pipe_device_deinit (pdev); - dev->base =NULL ; +struct goldfish_pipe_dev *dev =platform_get_drvdata (pdev); + +goldfish_pipe_device_deinit (pdev, dev);return 0 ; }
Signature · 1 line
2.19.0.605.g01d371f741-goog
PATCH v2 13/21 platform: goldfish: pipe: Split the driver to v2 specific and the rest
In reply to [email protected]From: Roman Kiryanov <[email protected]>
Move probe/remove and other driver stuff to a separate file to plug v1 there later.
---
Changes in v2:
- Removed breakage of allmodconfig.
drivers/platform/goldfish/Makefile | 3 +- drivers/platform/goldfish/goldfish_pipe.c | 145 +++++++++++++++++++ drivers/platform/goldfish/goldfish_pipe.h | 24 +++ drivers/platform/goldfish/goldfish_pipe_v2.c | 102 ++----------- drivers/platform/goldfish/goldfish_pipe_v2.h | 24 +++ 5 files changed, 210 insertions(+), 88 deletions(-) create mode 100644 drivers/platform/goldfish/goldfish_pipe.c create mode 100644 drivers/platform/goldfish/goldfish_pipe.h create mode 100644 drivers/platform/goldfish/goldfish_pipe_v2.h
drivers/platform/goldfish/Makefile +2 -1
@@ -1,4 +1,5 @@ # # Makefile for Goldfish platform specific drivers # -obj-$(CONFIG_GOLDFISH_PIPE) += goldfish_pipe_v2.o +obj-$(CONFIG_GOLDFISH_PIPE) += goldfish_pipe_all.o +goldfish_pipe_all-objs := goldfish_pipe.o goldfish_pipe_v2.o
drivers/platform/goldfish/goldfish_pipe.c new file +145 -0
145 lines not on this page · raw message
drivers/platform/goldfish/goldfish_pipe.h new file +24 -0
@@ -0,0 +1,24 @@ +/* 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 + +struct goldfish_pipe_dev_base { +/* the destructor, the pointer is set in init */ +int (*deinit)(void *pipe_dev,struct platform_device *pdev); +}; + +#endif /* GOLDFISH_PIPE_H */
drivers/platform/goldfish/goldfish_pipe_v2.c +15 -87
163 lines not on this page · raw message
drivers/platform/goldfish/goldfish_pipe_v2.h new file +24 -0
@@ -0,0 +1,24 @@ +/* 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_V2_H +#define GOLDFISH_PIPE_V2_H + +/* The entry point to the pipe v2 driver */ +int goldfish_pipe_device_init (struct platform_device *pdev, +char __iomem *base, +int irq); + +#endif /* #define GOLDFISH_PIPE_V2_H */
Signature · 1 line
2.19.0.605.g01d371f741-goog
PATCH v2 19/21 platform: goldfish: pipe: Add the goldfish_pipe_v1 driver
In reply to [email protected]From: Roman Kiryanov <[email protected]>
This is the v1 goldfish pipe driver.
---
Changes in v2:
- Rebased (Makefile).
drivers/platform/goldfish/Makefile | 2 +- drivers/platform/goldfish/goldfish_pipe.c | 9 +- .../platform/goldfish/goldfish_pipe_qemu.h | 27 + drivers/platform/goldfish/goldfish_pipe_v1.c | 632 ++++++++++++++++++ drivers/platform/goldfish/goldfish_pipe_v1.h | 24 + 5 files changed, 689 insertions(+), 5 deletions(-) create mode 100644 drivers/platform/goldfish/goldfish_pipe_v1.c create mode 100644 drivers/platform/goldfish/goldfish_pipe_v1.h
drivers/platform/goldfish/Makefile +1 -1
@@ -2,4 +2,4 @@ # Makefile for Goldfish platform specific drivers # obj-$(CONFIG_GOLDFISH_PIPE) += goldfish_pipe_all.o -goldfish_pipe_all-objs := goldfish_pipe.o goldfish_pipe_v2.o +goldfish_pipe_all-objs := goldfish_pipe.o goldfish_pipe_v1.o goldfish_pipe_v2.o
drivers/platform/goldfish/goldfish_pipe.c +5 -4
@@ -56,6 +56,7 @@#include <linux/acpi.h> #include "goldfish_pipe_qemu.h" #include "goldfish_pipe.h" +#include "goldfish_pipe_v1.h" #include "goldfish_pipe_v2.h" /*
@@ -105,10 +106,10 @@ static int goldfish_pipe_probe(struct platform_device *pdev)writel ((u32 )PIPE_DRIVER_VERSION , base +PIPE_V2_REG_VERSION ); version =readl (base +PIPE_V2_REG_VERSION ); -if (WARN_ON (version <PIPE_CURRENT_DEVICE_VERSION )) -return -EINVAL ; - -return goldfish_pipe_device_v2_init (pdev, base, irq); +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)
drivers/platform/goldfish/goldfish_pipe_qemu.h +27 -0
@@ -62,6 +62,33 @@ enum PipeFlagsBits { 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 ,
drivers/platform/goldfish/goldfish_pipe_v1.c new file +632 -0
632 lines not on this page · raw message
drivers/platform/goldfish/goldfish_pipe_v1.h new file +24 -0
@@ -0,0 +1,24 @@ +/* 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_V1_H +#define GOLDFISH_PIPE_V1_H + +/* The entry point to the pipe v1 driver */ +int goldfish_pipe_device_v1_init (struct platform_device *pdev, +void __iomem *base, +int irq); + +#endif /* #define GOLDFISH_PIPE_V1_H */
Signature · 1 line
2.19.0.605.g01d371f741-goog
Quoted 7 lines · On Wed, Sep 26, 2018 at 04:02:19PM -0700, [email protected] wrote:
From: Roman Kiryanov <[email protected]>
Goldfish DMA is an extension to the pipe device and is designed to facilitate high-speed
RAM->RAMtransfers from guest to host.See
uapi/linux/goldfish/goldfish_dma.hfor more details.
Quoted 7 lines
Signed-off-by Roman Kiryanov <[email protected]>Signed-off-by Lingfeng Yang <[email protected]>---
Changes in v2:
- Got sign-off from Lingfeng Yang.
- Removed the license boilerplate fromgoldfish_dma.h.
- Rebased.
I don't understand this series. Please start over with 01/XX as your other patches were all merged.
And I still think you need a better justification for this, given the many other ways the kernel already has for this feature...
thanks,
greg k-h