From patchwork Sat Apr 22 17:35:19 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bjorn Andersson X-Patchwork-Id: 97954 Delivered-To: patch@linaro.org Received: by 10.140.109.52 with SMTP id k49csp814264qgf; Sat, 22 Apr 2017 10:35:41 -0700 (PDT) X-Received: by 10.98.7.140 with SMTP id 12mr17373017pfh.202.1492882541452; Sat, 22 Apr 2017 10:35:41 -0700 (PDT) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id o13si13825668pfg.277.2017.04.22.10.35.41; Sat, 22 Apr 2017 10:35:41 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1426077AbdDVRff (ORCPT + 10 others); Sat, 22 Apr 2017 13:35:35 -0400 Received: from mail-it0-f48.google.com ([209.85.214.48]:34966 "EHLO mail-it0-f48.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1043994AbdDVRf2 (ORCPT ); Sat, 22 Apr 2017 13:35:28 -0400 Received: by mail-it0-f48.google.com with SMTP id 70so18111124ita.0 for ; Sat, 22 Apr 2017 10:35:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=iouheyWDdINu+dqDnemJ8dD/7O6CYycHOITfE87eiBs=; b=PLvVS2jQQGdkB8bggq03Yf/PyC2rSZoy2eDYW9ZQ2LPQE4eqcBNzL8cDrwsnis4195 xbs0+JciIsyCEwbAusWSaCN5w26L4OdME2Dp9j9gQuDP/0S3b7jRxifiH9BTqhysBhrD sR2yhT7uHxzydRjOPWnrqKQH8Zl7brlXeicOU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=iouheyWDdINu+dqDnemJ8dD/7O6CYycHOITfE87eiBs=; b=e9z/b9meOXeKp6hNp69K3b7ZJpGbkUrSMxruVNiTVZYXr9uJoPrHsnYRx3ndu4sUjq KzGlUJM3bUpnELVbRaEYs3IvreAkj1Is/EaNZ+q0yh5T6ZWT55vsXMGuCSLzmmFtZEPk gYRLDrt9/tqWCrQSQo9V3S/0EaROusYA9LFNdQ0gR8StePFCJOupPoMm4FbDscAi3cDa bWlqeZbSY8Q2TSIYax9PnvVbtzWJDPDxVHN04Co/zHegMe5RouHc7BThKX35uixHrl0n b7LrsvZB5EYy1XMLr2l7tgapWOdnwS4EpQ2m5/CSrZLZHbbv06WsjTWaxRNgBwajhGId Jcgw== X-Gm-Message-State: AN3rC/5gQJtHhZChz53mZMRSgLK6JXAGZPajCwSWr8lUDFSCiEhI4mhQ 6Gs/YcYPQia84nDZ X-Received: by 10.84.225.145 with SMTP id u17mr21988061plj.91.1492882527044; Sat, 22 Apr 2017 10:35:27 -0700 (PDT) Received: from localhost.localdomain (ip68-111-223-48.sd.sd.cox.net. [68.111.223.48]) by smtp.gmail.com with ESMTPSA id r73sm22477462pfa.65.2017.04.22.10.35.25 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sat, 22 Apr 2017 10:35:26 -0700 (PDT) From: Bjorn Andersson To: Andy Gross , David Brown , Frank Rowand , Rob Herring , Mark Rutland Cc: linux-arm-msm@vger.kernel.org, linux-soc@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC 3/3] soc: qcom: rfsa driver Date: Sat, 22 Apr 2017 10:35:19 -0700 Message-Id: <20170422173519.5782-3-bjorn.andersson@linaro.org> X-Mailer: git-send-email 2.12.0 In-Reply-To: <20170422173519.5782-1-bjorn.andersson@linaro.org> References: <20170422173519.5782-1-bjorn.andersson@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The rfsa driver is used for allocating and exposing regions of shared memory with remote processors for the purpose of exchanging sector-data between the remote filesystem service and its clients. It provides accessors for the properties needed by the user space remote filesystem implementation through sysfs and a character device that can be used to read and write the requested chunks of data. Signed-off-by: Bjorn Andersson --- drivers/soc/qcom/Kconfig | 8 ++ drivers/soc/qcom/Makefile | 1 + drivers/soc/qcom/rfsa.c | 261 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 270 insertions(+) create mode 100644 drivers/soc/qcom/rfsa.c -- 2.12.0 diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig index 9fca977ef18d..788a63cd430e 100644 --- a/drivers/soc/qcom/Kconfig +++ b/drivers/soc/qcom/Kconfig @@ -24,6 +24,14 @@ config QCOM_PM modes. It interface with various system drivers to put the cores in low power modes. +config QCOM_RFSA + tristate "Qualcomm Remote Filesystem Access driver" + help + The Qualcomm remote filesystem access driver is used for allocating + and exposing regions of shared memory with remote processors for the + purpose of exchanging sector-data between the remote filesystem + service and its clients. + config QCOM_SMEM tristate "Qualcomm Shared Memory Manager (SMEM)" depends on ARCH_QCOM diff --git a/drivers/soc/qcom/Makefile b/drivers/soc/qcom/Makefile index 414f0de274fa..d1bbc791ddc0 100644 --- a/drivers/soc/qcom/Makefile +++ b/drivers/soc/qcom/Makefile @@ -1,6 +1,7 @@ obj-$(CONFIG_QCOM_GSBI) += qcom_gsbi.o obj-$(CONFIG_QCOM_MDT_LOADER) += mdt_loader.o obj-$(CONFIG_QCOM_PM) += spm.o +obj-$(CONFIG_QCOM_RFSA) += rfsa.o obj-$(CONFIG_QCOM_SMD_RPM) += smd-rpm.o obj-$(CONFIG_QCOM_SMEM) += smem.o obj-$(CONFIG_QCOM_SMEM_STATE) += smem_state.o diff --git a/drivers/soc/qcom/rfsa.c b/drivers/soc/qcom/rfsa.c new file mode 100644 index 000000000000..1b79976dad9d --- /dev/null +++ b/drivers/soc/qcom/rfsa.c @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2017 Linaro Ltd. + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define QCOM_RFSA_DEV_MAX (MINORMASK + 1) + +static dev_t qcom_rfsa_major; + +struct qcom_rfsa { + struct device dev; + struct cdev cdev; + + void *base; + phys_addr_t addr; + phys_addr_t size; + + unsigned int client_id; +}; + +static ssize_t qcom_rfsa_show(struct device *dev, + struct device_attribute *attr, + char *buf); + +static DEVICE_ATTR(phys_addr, 0400, qcom_rfsa_show, NULL); +static DEVICE_ATTR(size, 0400, qcom_rfsa_show, NULL); +static DEVICE_ATTR(client_id, 0400, qcom_rfsa_show, NULL); + +static ssize_t qcom_rfsa_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct qcom_rfsa *rfsa = container_of(dev, struct qcom_rfsa, dev); + + if (attr == &dev_attr_phys_addr) + return sprintf(buf, "%pa\n", &rfsa->addr); + if (attr == &dev_attr_size) + return sprintf(buf, "%pa\n", &rfsa->size); + if (attr == &dev_attr_client_id) + return sprintf(buf, "%d\n", rfsa->client_id); + + return -EINVAL; +} + +static struct attribute *qcom_rfsa_attrs[] = { + &dev_attr_phys_addr.attr, + &dev_attr_size.attr, + &dev_attr_client_id.attr, + NULL +}; +ATTRIBUTE_GROUPS(qcom_rfsa); + +static int qcom_rfsa_open(struct inode *inode, struct file *filp) +{ + struct qcom_rfsa *rfsa = container_of(inode->i_cdev, struct qcom_rfsa, cdev); + + get_device(&rfsa->dev); + filp->private_data = rfsa; + + return 0; +} +static ssize_t qcom_rfsa_read(struct file *filp, + char __user *buf, size_t count, loff_t *f_pos) +{ + struct qcom_rfsa *rfsa = filp->private_data; + + if (*f_pos >= rfsa->size) + return 0; + + if (*f_pos + count >= rfsa->size) + count = rfsa->size - *f_pos; + + if (copy_to_user(buf, rfsa->base + *f_pos, count)) + return -EFAULT; + + *f_pos += count; + return count; +} + +static ssize_t qcom_rfsa_write(struct file *filp, + const char __user *buf, size_t count, + loff_t *f_pos) +{ + struct qcom_rfsa *rfsa = filp->private_data; + + if (*f_pos >= rfsa->size) + return 0; + + if (*f_pos + count >= rfsa->size) + count = rfsa->size - *f_pos; + + if (copy_from_user(rfsa->base + *f_pos, buf, count)) + return -EFAULT; + + *f_pos += count; + return count; +} + +static int qcom_rfsa_release(struct inode *inode, struct file *filp) +{ + struct qcom_rfsa *rfsa = filp->private_data; + + put_device(&rfsa->dev); + + return 0; +} + +static const struct file_operations qcom_rfsa_fops = { + .owner = THIS_MODULE, + .open = qcom_rfsa_open, + .read = qcom_rfsa_read, + .write = qcom_rfsa_write, + .release = qcom_rfsa_release, + .llseek = default_llseek, +}; + +static void qcom_rfsa_release_device(struct device *dev) +{ + struct qcom_rfsa *rfsa = container_of(dev, struct qcom_rfsa, dev); + + kfree(rfsa); +} + +static int qcom_rfsa_probe(struct platform_device *pdev) +{ + struct device_node *node = pdev->dev.of_node; + struct reserved_mem *rmem; + struct qcom_rfsa *rfsa; + u32 client_id; + int ret; + + rmem = of_get_reserved_mem_by_idx(node, 0); + if (!rmem) { + dev_err(&pdev->dev, "failed to acquire memory region\n"); + return -EINVAL; + } + + ret = of_property_read_u32(node, "qcom,client-id", &client_id); + if (ret) { + dev_err(&pdev->dev, "failed to parse \"qcom,client-id\"\n"); + return ret; + + } + + rfsa = kzalloc(sizeof(*rfsa), GFP_KERNEL); + if (!rfsa) + return -ENOMEM; + + rfsa->addr = rmem->base; + rfsa->client_id = client_id; + rfsa->size = rmem->size; + + device_initialize(&rfsa->dev); + rfsa->dev.parent = &pdev->dev; + rfsa->dev.groups = qcom_rfsa_groups; + + cdev_init(&rfsa->cdev, &qcom_rfsa_fops); + rfsa->cdev.owner = THIS_MODULE; + + dev_set_name(&rfsa->dev, "qcom_rfsa%d", client_id); + rfsa->dev.id = client_id; + rfsa->dev.devt = MKDEV(MAJOR(qcom_rfsa_major), client_id); + + ret = cdev_device_add(&rfsa->cdev, &rfsa->dev); + if (ret) { + dev_err(&pdev->dev, "failed to add cdev: %d\n", ret); + put_device(&rfsa->dev); + return ret; + } + + rfsa->dev.release = qcom_rfsa_release_device; + + rfsa->base = devm_memremap(&rfsa->dev, rfsa->addr, rfsa->size, MEMREMAP_WC); + if (IS_ERR(rfsa->base)) { + dev_err(&pdev->dev, "failed to remap rfsa region\n"); + + device_del(&rfsa->dev); + put_device(&rfsa->dev); + + return PTR_ERR(rfsa->base); + } + + dev_set_drvdata(&pdev->dev, rfsa); + + return 0; +} + +static int qcom_rfsa_remove(struct platform_device *pdev) +{ + struct qcom_rfsa *rfsa = dev_get_drvdata(&pdev->dev); + + cdev_del(&rfsa->cdev); + device_del(&rfsa->dev); + put_device(&rfsa->dev); + + return 0; +} + +static const struct of_device_id qcom_rfsa_of_match[] = { + { .compatible = "qcom,rfsa" }, + {} +}; +MODULE_DEVICE_TABLE(of, qcom_rfsa_of_match); + +static struct platform_driver qcom_rfsa_driver = { + .probe = qcom_rfsa_probe, + .remove = qcom_rfsa_remove, + .driver = { + .name = "qcom_rfsa", + .of_match_table = qcom_rfsa_of_match, + }, +}; + +static int qcom_rfsa_init(void) +{ + int ret; + + ret = alloc_chrdev_region(&qcom_rfsa_major, 0, QCOM_RFSA_DEV_MAX, + "qcom_rfsa"); + if (ret < 0) { + pr_err("qcom_rfsa: failed to allocate char dev region\n"); + return ret; + } + + ret = platform_driver_register(&qcom_rfsa_driver); + if (ret < 0) { + pr_err("qcom_rfsa: failed to register rfsa driver\n"); + unregister_chrdev_region(qcom_rfsa_major, QCOM_RFSA_DEV_MAX); + } + + return ret; +} +module_init(qcom_rfsa_init); + +static void qcom_rfsa_exit(void) +{ + platform_driver_unregister(&qcom_rfsa_driver); + unregister_chrdev_region(qcom_rfsa_major, QCOM_RFSA_DEV_MAX); +} +module_exit(qcom_rfsa_exit);