arch/arm/mach-msm/peripheral-loader.c

/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * 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/string.h>
#include <linux/platform_device.h>
#include <linux/firmware.h>
#include <linux/io.h>
#include <linux/debugfs.h>
#include <linux/elf.h>
#include <linux/mutex.h>
#include <linux/memblock.h>

#include <asm/uaccess.h>
#include <asm/setup.h>

#include "peripheral-loader.h"

static DEFINE_MUTEX(pil_list_lock);
static LIST_HEAD(pil_list);

static struct pil_device *__find_peripheral(const char *str)
{
	struct pil_device *dev;

	list_for_each_entry(dev, &pil_list, list)
		if (!strcmp(dev->name, str))
			return dev;
	return NULL;
}

static struct pil_device *find_peripheral(const char *str)
{
	struct pil_device *dev;

	if (!str)
		return NULL;

	mutex_lock(&pil_list_lock);
	dev = __find_peripheral(str);
	mutex_unlock(&pil_list_lock);

	return dev;
}

#define IOMAP_SIZE SZ_4M

static int load_segment(const struct elf32_phdr *phdr, unsigned num,
		struct pil_device *pil)
{
	int ret, count, paddr;
	char fw_name[30];
	const struct firmware *fw = NULL;
	const u8 *data;

	if (memblock_is_region_memory(phdr->p_paddr, phdr->p_memsz)) {
		dev_err(&pil->pdev.dev, "Kernel memory would be overwritten");
		return -EPERM;
	}

	if (phdr->p_filesz) {
		snprintf(fw_name, ARRAY_SIZE(fw_name), "%s.b%02d", pil->name,
				num);
		ret = request_firmware(&fw, fw_name, &pil->pdev.dev);
		if (ret) {
			dev_err(&pil->pdev.dev, "Failed to locate blob %s\n",
					fw_name);
			return ret;
		}

		if (fw->size != phdr->p_filesz) {
			dev_err(&pil->pdev.dev,
					"Blob size %u doesn't match %u\n",
					fw->size, phdr->p_filesz);
			ret = -EPERM;
			goto release_fw;
		}
	}

	/* Load the segment into memory */
	count = phdr->p_filesz;
	paddr = phdr->p_paddr;
	data = fw ? fw->data : NULL;
	while (count > 0) {
		int size;
		u8 __iomem *buf;

		size = min_t(size_t, IOMAP_SIZE, count);
		buf = ioremap(paddr, size);
		if (!buf) {
			dev_err(&pil->pdev.dev, "Failed to map memory\n");
			ret = -ENOMEM;
			goto release_fw;
		}
		memcpy(buf, data, size);
		iounmap(buf);

		count -= size;
		paddr += size;
		data += size;
	}

	/* Zero out trailing memory */
	count = phdr->p_memsz - phdr->p_filesz;
	while (count > 0) {
		int size;
		u8 __iomem *buf;

		size = min_t(size_t, IOMAP_SIZE, count);
		buf = ioremap(paddr, size);
		if (!buf) {
			dev_err(&pil->pdev.dev, "Failed to map memory\n");
			ret = -ENOMEM;
			goto release_fw;
		}
		memset(buf, 0, size);
		iounmap(buf);

		count -= size;
		paddr += size;
	}

	ret = pil->ops->verify_blob(pil, phdr->p_paddr, phdr->p_memsz);
	if (ret)
		dev_err(&pil->pdev.dev, "Blob %u failed verification\n", num);

release_fw:
	release_firmware(fw);
	return ret;
}

#define segment_is_hash(flag) (((flag) & (0x7 << 24)) == (0x2 << 24))

static int segment_is_loadable(const struct elf32_phdr *p)
{
	return (p->p_type & PT_LOAD) && !segment_is_hash(p->p_flags);
}

static int load_image(struct pil_device *pil)
{
	int i, ret;
	char fw_name[30];
	struct elf32_hdr *ehdr;
	const struct elf32_phdr *phdr;
	const struct firmware *fw;

	snprintf(fw_name, sizeof(fw_name), "%s.mdt", pil->name);
	ret = request_firmware(&fw, fw_name, &pil->pdev.dev);
	if (ret) {
		dev_err(&pil->pdev.dev, "Failed to locate %s\n", fw_name);
		goto out;
	}

	if (fw->size < sizeof(*ehdr)) {
		dev_err(&pil->pdev.dev, "Not big enough to be an elf header\n");
		ret = -EIO;
		goto release_fw;
	}

	ehdr = (struct elf32_hdr *)fw->data;
	if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG)) {
		dev_err(&pil->pdev.dev, "Not an elf header\n");
		ret = -EIO;
		goto release_fw;
	}

	if (ehdr->e_phnum == 0) {
		dev_err(&pil->pdev.dev, "No loadable segments\n");
		ret = -EIO;
		goto release_fw;
	}
	if (sizeof(struct elf32_phdr) * ehdr->e_phnum +
	    sizeof(struct elf32_hdr) > fw->size) {
		dev_err(&pil->pdev.dev, "Program headers not within mdt\n");
		ret = -EIO;
		goto release_fw;
	}

	ret = pil->ops->init_image(pil, fw->data, fw->size);
	if (ret) {
		dev_err(&pil->pdev.dev, "Invalid firmware metadata\n");
		goto release_fw;
	}

	phdr = (const struct elf32_phdr *)(fw->data + sizeof(struct elf32_hdr));
	for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
		if (!segment_is_loadable(phdr))
			continue;

		ret = load_segment(phdr, i, pil);
		if (ret) {
			dev_err(&pil->pdev.dev, "Failed to load segment %d\n",
					i);
			goto release_fw;
		}
	}

	ret = pil->ops->auth_and_reset(pil);
	if (ret) {
		dev_err(&pil->pdev.dev, "Failed to bring out of reset\n");
		goto release_fw;
	}

release_fw:
	release_firmware(fw);
out:
	return ret;
}

/**
 * pil_get() - Load a peripheral into memory and take it out of reset
 * @name: pointer to a string containing the name of the peripheral to load
 *
 * This function returns a pointer if it succeeds. If an error occurs an
 * ERR_PTR is returned.
 *
 * If PIL is not enabled in the kernel, the value %NULL will be returned.
 */
void *pil_get(const char *name)
{
	int ret;
	struct pil_device *pil;
	struct pil_device *pil_d;
	void *retval;

	pil = retval = find_peripheral(name);
	if (!pil)
		return ERR_PTR(-ENODEV);

	pil_d = find_peripheral(pil->depends_on);
	if (pil_d) {
		void *p = pil_get(pil_d->name);
		if (IS_ERR(p))
			return p;
	}

	mutex_lock(&pil->lock);
	if (pil->count) {
		pil->count++;
		goto unlock;
	}

	ret = load_image(pil);
	if (ret) {
		retval = ERR_PTR(ret);
		goto unlock;
	}

	pil->count++;
unlock:
	mutex_unlock(&pil->lock);
	return retval;
}
EXPORT_SYMBOL(pil_get);

/**
 * pil_put() - Inform PIL the peripheral no longer needs to be active
 * @peripheral_handle: pointer from a previous call to pil_get()
 *
 * This doesn't imply that a peripheral is shutdown or in reset since another
 * driver could be using the peripheral.
 */
void pil_put(void *peripheral_handle)
{
	struct pil_device *pil_d;
	struct pil_device *pil = peripheral_handle;
	if (!pil || IS_ERR(pil))
		return;

	mutex_lock(&pil->lock);
	WARN(!pil->count, "%s: Reference count mismatch\n", __func__);
	/* TODO: Peripheral shutdown support */
	if (pil->count == 1)
		goto unlock;
	if (pil->count)
		pil->count--;
	if (pil->count == 0)
		pil->ops->shutdown(pil);
unlock:
	mutex_unlock(&pil->lock);

	pil_d = find_peripheral(pil->depends_on);
	if (pil_d)
		pil_put(pil_d);
}
EXPORT_SYMBOL(pil_put);

void pil_force_shutdown(const char *name)
{
	struct pil_device *pil;

	pil = find_peripheral(name);
	if (!pil)
		return;

	mutex_lock(&pil->lock);
	if (!WARN(!pil->count, "%s: Reference count mismatch\n", __func__))
		pil->ops->shutdown(pil);
	mutex_unlock(&pil->lock);
}
EXPORT_SYMBOL(pil_force_shutdown);

int pil_force_boot(const char *name)
{
	int ret = -EINVAL;
	struct pil_device *pil;

	pil = find_peripheral(name);
	if (!pil)
		return -EINVAL;

	mutex_lock(&pil->lock);
	if (!WARN(!pil->count, "%s: Reference count mismatch\n", __func__))
		ret = load_image(pil);
	mutex_unlock(&pil->lock);

	return ret;
}
EXPORT_SYMBOL(pil_force_boot);

#ifdef CONFIG_DEBUG_FS
int msm_pil_debugfs_open(struct inode *inode, struct file *filp)
{
	filp->private_data = inode->i_private;
	return 0;
}

static ssize_t msm_pil_debugfs_read(struct file *filp, char __user *ubuf,
		size_t cnt, loff_t *ppos)
{
	int r;
	char buf[40];
	struct pil_device *pil = filp->private_data;

	mutex_lock(&pil->lock);
	r = snprintf(buf, sizeof(buf), "%d\n", pil->count);
	mutex_unlock(&pil->lock);
	return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
}

static ssize_t msm_pil_debugfs_write(struct file *filp,
		const char __user *ubuf, size_t cnt, loff_t *ppos)
{
	struct pil_device *pil = filp->private_data;
	char buf[4];

	if (cnt > sizeof(buf))
		return -EINVAL;

	if (copy_from_user(&buf, ubuf, cnt))
		return -EFAULT;

	if (!strncmp(buf, "get", 3)) {
		if (IS_ERR(pil_get(pil->name)))
			return -EIO;
	} else if (!strncmp(buf, "put", 3))
		pil_put(pil);
	else
		return -EINVAL;

	return cnt;
}

static const struct file_operations msm_pil_debugfs_fops = {
	.open	= msm_pil_debugfs_open,
	.read	= msm_pil_debugfs_read,
	.write	= msm_pil_debugfs_write,
};

static struct dentry *pil_base_dir;

static int msm_pil_debugfs_init(void)
{
	pil_base_dir = debugfs_create_dir("pil", NULL);
	if (!pil_base_dir) {
		pil_base_dir = NULL;
		return -ENOMEM;
	}

	return 0;
}
arch_initcall(msm_pil_debugfs_init);

static int msm_pil_debugfs_add(struct pil_device *pil)
{
	if (!pil_base_dir)
		return -ENOMEM;

	if (!debugfs_create_file(pil->name, S_IRUGO | S_IWUSR, pil_base_dir,
				pil, &msm_pil_debugfs_fops))
		return -ENOMEM;
	return 0;
}
#else
static int msm_pil_debugfs_add(struct pil_device *pil) { return 0; }
#endif

static int msm_pil_shutdown_at_boot(void)
{
	struct pil_device *pil;

	mutex_lock(&pil_list_lock);
	list_for_each_entry(pil, &pil_list, list)
		pil->ops->shutdown(pil);
	mutex_unlock(&pil_list_lock);

	return 0;
}
late_initcall(msm_pil_shutdown_at_boot);

int msm_pil_add_device(struct pil_device *pil)
{
	int ret;
	ret = platform_device_register(&pil->pdev);
	if (ret)
		return ret;

	mutex_init(&pil->lock);

	mutex_lock(&pil_list_lock);
	list_add(&pil->list, &pil_list);
	mutex_unlock(&pil_list_lock);

	msm_pil_debugfs_add(pil);
	return 0;
}

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Load peripheral images and bring peripherals out of reset");