Enable adb with android-pipe in IA image (fa26a69b) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/platform/Kconfig

+0 −2

Original line number	Diff line number	Diff line
		if X86
		source "drivers/platform/x86/Kconfig"
		endif
		if GOLDFISH
		source "drivers/platform/goldfish/Kconfig"
		endif

		source "drivers/platform/chrome/Kconfig"

drivers/platform/goldfish/Kconfig

+18 −0

Original line number	Diff line number	Diff line
		menuconfig GOLDFISH
		bool "Platform support for Goldfish virtual devices"
		depends on X86_32 \|\| X86_64 \|\| ARM \|\| ARM64 \|\| MIPS
		---help---
		Say Y here to get to see options for the Goldfish virtual platform.
		This option alone does not add any kernel code.

		Unless you are building for the Android Goldfish emulator say N here.

		if GOLDFISH

		config GOLDFISH_BUS
		tristate "Goldfish platform bus"
		---help---
		This is a virtual bus to host Goldfish Android Virtual Devices.

		config GOLDFISH_PIPE
		tristate "Goldfish virtual device for QEMU pipes"
		---help---
		This is a virtual device to drive the QEMU pipe interface used by
		the Goldfish Android Virtual Device.

		endif # GOLDFISH

drivers/platform/goldfish/Makefile

+1 −1

Original line number	Diff line number	Diff line
		#
		# Makefile for Goldfish platform specific drivers
		#
		obj-$(CONFIG_GOLDFISH) += pdev_bus.o
		obj-$(CONFIG_GOLDFISH_BUS) += pdev_bus.o
		obj-$(CONFIG_GOLDFISH_PIPE) += goldfish_pipe.o

drivers/platform/goldfish/goldfish_pipe.c

+113 −65

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		* 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
		@@ -57,6 +58,8 @@
		#include <linux/slab.h>
		#include <linux/io.h>
		#include <linux/goldfish.h>
		#include <linux/mm.h>
		#include <linux/acpi.h>

		/*
		* IMPORTANT: The following constants must match the ones used and defined
		@@ -75,6 +78,7 @@
		#define PIPE_REG_PARAMS_ADDR_LOW 0x18 /* read/write: batch data address */
		#define PIPE_REG_PARAMS_ADDR_HIGH 0x1c /* read/write: batch data address */
		#define PIPE_REG_ACCESS_PARAMS 0x20 /* write: batch access */
		#define PIPE_REG_VERSION 0x24 /* read: device version */

		/* list of commands for PIPE_REG_COMMAND */
		#define CMD_OPEN 1 /* open new channel */
		@@ -90,12 +94,6 @@
		#define CMD_WRITE_BUFFER 4 /* send a user buffer to the emulator */
		#define CMD_WAKE_ON_WRITE 5 /* tell the emulator to wake us when writing
		is possible */

		/* The following commands are related to read operations, they must be
		* listed in the same order than the corresponding write ones, since we
		* will use (CMD_READ_BUFFER - CMD_WRITE_BUFFER) as a special offset
		* in goldfish_pipe_read_write() below.
		*/
		#define CMD_READ_BUFFER 6 /* receive a user buffer from the emulator */
		#define CMD_WAKE_ON_READ 7 /* tell the emulator to wake us when reading
		* is possible */
		@@ -130,6 +128,7 @@ struct goldfish_pipe_dev {
		unsigned char __iomem *base;
		struct access_params *aps;
		int irq;
		u32 version;
		};

		static struct goldfish_pipe_dev pipe_dev[1];
		@@ -263,19 +262,14 @@ static int access_with_param(struct goldfish_pipe_dev *dev, const int cmd,
		return 0;
		}

		/* This function is used for both reading from and writing to a given
		* pipe.
		*/
		static ssize_t goldfish_pipe_read_write(struct file filp, char __user buffer,
		size_t bufflen, int is_write)
		{
		unsigned long irq_flags;
		struct goldfish_pipe *pipe = filp->private_data;
		struct goldfish_pipe_dev *dev = pipe->dev;
		const int cmd_offset = is_write ? 0
		: (CMD_READ_BUFFER - CMD_WRITE_BUFFER);
		unsigned long address, address_end;
		int ret = 0;
		int count = 0, ret = -EINVAL;

		/* If the emulator already closed the pipe, no need to go further */
		if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
		@@ -303,58 +297,82 @@ static ssize_t goldfish_pipe_read_write(struct file filp, char __user buffer,
		: address_end;
		unsigned long avail = next - address;
		int status, wakeBit;
		struct page *page;

		/* Ensure that the corresponding page is properly mapped */
		/* FIXME: this isn't safe or sufficient - use get_user_pages */
		if (is_write) {
		char c;
		/* Ensure that the page is mapped and readable */
		if (__get_user(c, (char __user *)address)) {
		if (!ret)
		ret = -EFAULT;
		break;
		}
		/* Either vaddr or paddr depending on the device version */
		unsigned long xaddr;

		/*
		* We grab the pages on a page-by-page basis in case user
		* space gives us a potentially huge buffer but the read only
		* returns a small amount, then there's no need to pin that
		* much memory to the process.
		*/
		down_read(&current->mm->mmap_sem);
		ret = get_user_pages(current, current->mm, address, 1,
		!is_write, 0, &page, NULL);
		up_read(&current->mm->mmap_sem);
		if (ret < 0)
		return ret;

		if (dev->version) {
		/* Device version 1 or newer (qemu-android) expects the
		* physical address. */
		xaddr = page_to_phys(page) \| (address & ~PAGE_MASK);
		} else {
		/* Ensure that the page is mapped and writable */
		if (__put_user(0, (char __user *)address)) {
		if (!ret)
		ret = -EFAULT;
		break;
		}
		/* Device version 0 (classic emulator) expects the
		* virtual address. */
		xaddr = address;
		}

		/* Now, try to transfer the bytes in the current page */
		spin_lock_irqsave(&dev->lock, irq_flags);
		if (access_with_param(dev, CMD_WRITE_BUFFER + cmd_offset,
		address, avail, pipe, &status)) {
		if (access_with_param(dev,
		is_write ? CMD_WRITE_BUFFER : CMD_READ_BUFFER,
		xaddr, avail, pipe, &status)) {
		gf_write64((u64)(unsigned long)pipe,
		dev->base + PIPE_REG_CHANNEL,
		dev->base + PIPE_REG_CHANNEL_HIGH);
		writel(avail, dev->base + PIPE_REG_SIZE);
		gf_write64(address, dev->base + PIPE_REG_ADDRESS,
		gf_write64(xaddr, dev->base + PIPE_REG_ADDRESS,
		dev->base + PIPE_REG_ADDRESS_HIGH);
		writel(CMD_WRITE_BUFFER + cmd_offset,
		writel(is_write ? CMD_WRITE_BUFFER : CMD_READ_BUFFER,
		dev->base + PIPE_REG_COMMAND);
		status = readl(dev->base + PIPE_REG_STATUS);
		}
		spin_unlock_irqrestore(&dev->lock, irq_flags);

		if (status > 0 && !is_write)
		set_page_dirty(page);
		put_page(page);

		if (status > 0) { /* Correct transfer */
		ret += status;
		count += status;
		address += status;
		continue;
		}

		if (status == 0) /* EOF */
		} else if (status == 0) { /* EOF */
		ret = 0;
		break;

		/* An error occured. If we already transfered stuff, just
		* return with its count. We expect the next call to return
		* an error code */
		if (ret > 0)
		} else if (status < 0 && count > 0) {
		/*
		* An error occured and we already transfered
		* 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)
		pr_info_ratelimited("goldfish_pipe: 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
		/*
		* 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 \|\|
		@@ -363,14 +381,16 @@ static ssize_t goldfish_pipe_read_write(struct file filp, char __user buffer,
		break;
		}

		/* We will have to wait until more data/space is available.
		* First, mark the pipe as waiting for a specific wake signal.
		/*
		* The backend blocked the read/write, wait until the backend
		* tells us it's ready to process more data.
		*/
		wakeBit = is_write ? BIT_WAKE_ON_WRITE : BIT_WAKE_ON_READ;
		set_bit(wakeBit, &pipe->flags);

		/* Tell the emulator we're going to wait for a wake event */
		goldfish_cmd(pipe, CMD_WAKE_ON_WRITE + cmd_offset);
		goldfish_cmd(pipe,
		is_write ? CMD_WAKE_ON_WRITE : CMD_WAKE_ON_READ);

		/* Unlock the pipe, then wait for the wake signal */
		mutex_unlock(&pipe->lock);
		@@ -378,22 +398,29 @@ static ssize_t goldfish_pipe_read_write(struct file filp, char __user buffer,
		while (test_bit(wakeBit, &pipe->flags)) {
		if (wait_event_interruptible(
		pipe->wake_queue,
		!test_bit(wakeBit, &pipe->flags)))
		return -ERESTARTSYS;
		!test_bit(wakeBit, &pipe->flags))) {
		ret = -ERESTARTSYS;
		break;
		}

		if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags))
		return -EIO;
		if (test_bit(BIT_CLOSED_ON_HOST, &pipe->flags)) {
		ret = -EIO;
		break;
		}
		}

		/* Try to re-acquire the lock */
		if (mutex_lock_interruptible(&pipe->lock))
		return -ERESTARTSYS;

		/* Try the transfer again */
		continue;
		if (mutex_lock_interruptible(&pipe->lock)) {
		ret = -ERESTARTSYS;
		break;
		}
		}
		mutex_unlock(&pipe->lock);

		if (ret < 0)
		return ret;
		else
		return count;
		}

		static ssize_t goldfish_pipe_read(struct file filp, char __user buffer,
		@@ -446,7 +473,8 @@ static irqreturn_t goldfish_pipe_interrupt(int irq, void *dev_id)
		unsigned long irq_flags;
		int count = 0;

		/* We're going to read from the emulator a list of (channel,flags)
		/*
		* We're going to read from the emulator a list of (channel,flags)
		* pairs corresponding to the wake events that occured on each
		* blocked pipe (i.e. channel).
		*/
		@@ -600,6 +628,11 @@ static int goldfish_pipe_probe(struct platform_device *pdev)
		goto error;
		}
		setup_access_params_addr(pdev, dev);

		/* Although the pipe device in the classic Android emulator does not
		* recognize the 'version' register, it won't treat this as an error
		* either and will simply return 0, which is fine. */
		dev->version = readl(dev->base + PIPE_REG_VERSION);
		return 0;

		error:
		@@ -615,11 +648,26 @@ static int goldfish_pipe_remove(struct platform_device *pdev)
		return 0;
		}

		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 = "generic,android-pipe", },
		{},
		};
		MODULE_DEVICE_TABLE(of, goldfish_pipe_of_match);

		static struct platform_driver goldfish_pipe = {
		.probe = goldfish_pipe_probe,
		.remove = goldfish_pipe_remove,
		.driver = {
		.name = "goldfish_pipe"
		.name = "goldfish_pipe",
		.owner = THIS_MODULE,
		.of_match_table = goldfish_pipe_of_match,
		.acpi_match_table = ACPI_PTR(goldfish_pipe_acpi_match),
		}
		};