From patchwork Fri Mar 13 09:50:14 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Srinivas Kandagatla X-Patchwork-Id: 45755 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-lb0-f197.google.com (mail-lb0-f197.google.com [209.85.217.197]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id E7EEA214BF for ; Fri, 13 Mar 2015 09:50:37 +0000 (UTC) Received: by lbiz11 with SMTP id z11sf15831804lbi.2 for ; Fri, 13 Mar 2015 02:50:36 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:delivered-to:from:to:cc:subject :date:message-id:in-reply-to:references:sender:precedence:list-id :x-original-sender:x-original-authentication-results:mailing-list :list-post:list-help:list-archive:list-unsubscribe; bh=0GxOOPF1KCcbxCLC4978vgY9d84JA9iB93lX0K7zZYA=; b=PBF9OYXe1Dy5X/53pSWfYG16LL44rTBFisB0lHEDQFJQKgvo+J/CfxoQGOJ0AtLzfD LgZiP4v6TNHB4Lxm9PNrYgRarhil5F1F8Jc1BDJ65VIIqN0WYijMY/V4jol0rblPMTlZ DJXkIZZmOhPXo11QIDx7KPJEOUhn7orjeKQMCQFujf2QvLiM7YCXQxdQ1YyHCwlx/vq4 aIzCKb1PJd38RKh62MvOciZx58XR2vCUF2QDN77nMJVFkxWUhVOSmsuQnU/dDpgqDIad AIfiIoJzwdo//BGanX4J3JFvr6Q62B0k8TqcaF7ULADUHZUtdml4VxwUF8M2jDX/d2Wv Lhgg== X-Gm-Message-State: ALoCoQl8VPgy5z4PEJIZ90jCa5LFb5XDCt7gRPA6LzPrCrqzA4XEvcOUk+hQrsfezDIKCaPemHMg X-Received: by 10.112.142.1 with SMTP id rs1mr5109143lbb.19.1426240236526; Fri, 13 Mar 2015 02:50:36 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.181.137 with SMTP id dw9ls352091lac.85.gmail; Fri, 13 Mar 2015 02:50:36 -0700 (PDT) X-Received: by 10.112.73.65 with SMTP id j1mr42128754lbv.87.1426240236374; Fri, 13 Mar 2015 02:50:36 -0700 (PDT) Received: from mail-la0-f44.google.com (mail-la0-f44.google.com. [209.85.215.44]) by mx.google.com with ESMTPS id i6si1006746lbc.75.2015.03.13.02.50.36 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 13 Mar 2015 02:50:36 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.44 as permitted sender) client-ip=209.85.215.44; Received: by labgm9 with SMTP id gm9so21435084lab.11 for ; Fri, 13 Mar 2015 02:50:36 -0700 (PDT) X-Received: by 10.152.121.33 with SMTP id lh1mr42737056lab.86.1426240236273; Fri, 13 Mar 2015 02:50:36 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.35.133 with SMTP id h5csp786110lbj; Fri, 13 Mar 2015 02:50:34 -0700 (PDT) X-Received: by 10.66.66.166 with SMTP id g6mr101468460pat.88.1426240233736; Fri, 13 Mar 2015 02:50:33 -0700 (PDT) Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id 4si3006048pdi.235.2015.03.13.02.50.32; Fri, 13 Mar 2015 02:50:33 -0700 (PDT) Received-SPF: none (google.com: devicetree-owner@vger.kernel.org does not designate permitted sender hosts) client-ip=209.132.180.67; Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754100AbbCMJua (ORCPT + 5 others); Fri, 13 Mar 2015 05:50:30 -0400 Received: from mail-we0-f179.google.com ([74.125.82.179]:44718 "EHLO mail-we0-f179.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752099AbbCMJuT (ORCPT ); Fri, 13 Mar 2015 05:50:19 -0400 Received: by wesp10 with SMTP id p10so22034139wes.11 for ; Fri, 13 Mar 2015 02:50:18 -0700 (PDT) X-Received: by 10.180.20.43 with SMTP id k11mr853358wie.93.1426240218319; Fri, 13 Mar 2015 02:50:18 -0700 (PDT) Received: from srini-ThinkPad-X1-Carbon-2nd.dlink.com (host-2-99-228-8.as13285.net. [2.99.228.8]) by mx.google.com with ESMTPSA id lx10sm2071050wjb.17.2015.03.13.02.50.16 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 13 Mar 2015 02:50:17 -0700 (PDT) From: Srinivas Kandagatla To: linux-arm-kernel@lists.infradead.org Cc: Maxime Ripard , Rob Herring , Pawel Moll , Kumar Gala , linux-api@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, Stephen Boyd , Arnd Bergmann , broonie@kernel.org, Greg Kroah-Hartman , linux-arm-msm@vger.kernel.org, Srinivas Kandagatla Subject: [PATCH v2 1/7] eeprom: Add a simple EEPROM framework for eeprom providers Date: Fri, 13 Mar 2015 09:50:14 +0000 Message-Id: <1426240214-2434-1-git-send-email-srinivas.kandagatla@linaro.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1426240157-2383-1-git-send-email-srinivas.kandagatla@linaro.org> References: <1426240157-2383-1-git-send-email-srinivas.kandagatla@linaro.org> Sender: devicetree-owner@vger.kernel.org Precedence: list List-ID: X-Mailing-List: devicetree@vger.kernel.org X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: srinivas.kandagatla@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.44 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 List-Post: , List-Help: , List-Archive: List-Unsubscribe: , This patch adds just providers part of the framework just to enable easy review. Up until now, EEPROM drivers were stored in drivers/misc, where they all had to duplicate pretty much the same code to register a sysfs file, allow in-kernel users to access the content of the devices they were driving, etc. This was also a problem as far as other in-kernel users were involved, since the solutions used were pretty much different from on driver to another, there was a rather big abstraction leak. This introduction of this framework aims at solving this. It also introduces DT representation for consumer devices to go get the data they require (MAC Addresses, SoC/Revision ID, part numbers, and so on) from the EEPROMs. Having regmap interface to this framework would give much better abstraction for eeproms on different buses. Signed-off-by: Maxime Ripard [Maxime Ripard: intial version of eeprom framework] Signed-off-by: Srinivas Kandagatla --- drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/eeprom/Kconfig | 11 +++ drivers/eeprom/Makefile | 5 + drivers/eeprom/core.c | 213 ++++++++++++++++++++++++++++++++++++++++ include/linux/eeprom-provider.h | 47 +++++++++ 6 files changed, 279 insertions(+) create mode 100644 drivers/eeprom/Kconfig create mode 100644 drivers/eeprom/Makefile create mode 100644 drivers/eeprom/core.c create mode 100644 include/linux/eeprom-provider.h diff --git a/drivers/Kconfig b/drivers/Kconfig index c70d6e4..d7afc82 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -184,4 +184,6 @@ source "drivers/thunderbolt/Kconfig" source "drivers/android/Kconfig" +source "drivers/eeprom/Kconfig" + endmenu diff --git a/drivers/Makefile b/drivers/Makefile index 527a6da..57eb5b0 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -165,3 +165,4 @@ obj-$(CONFIG_RAS) += ras/ obj-$(CONFIG_THUNDERBOLT) += thunderbolt/ obj-$(CONFIG_CORESIGHT) += coresight/ obj-$(CONFIG_ANDROID) += android/ +obj-$(CONFIG_EEPROM) += eeprom/ diff --git a/drivers/eeprom/Kconfig b/drivers/eeprom/Kconfig new file mode 100644 index 0000000..21e1847 --- /dev/null +++ b/drivers/eeprom/Kconfig @@ -0,0 +1,11 @@ +menuconfig EEPROM + tristate "EEPROM Support" + depends on OF + select REGMAP + help + Support for EEPROM alike devices. + + This framework is designed to provide a generic interface to EEPROM + from both the Linux Kernel and the userspace. + + If unsure, say no. diff --git a/drivers/eeprom/Makefile b/drivers/eeprom/Makefile new file mode 100644 index 0000000..250c95a --- /dev/null +++ b/drivers/eeprom/Makefile @@ -0,0 +1,5 @@ +# +# Makefile for eeprom drivers. +# + +obj-$(CONFIG_EEPROM) += core.o diff --git a/drivers/eeprom/core.c b/drivers/eeprom/core.c new file mode 100644 index 0000000..a9839de --- /dev/null +++ b/drivers/eeprom/core.c @@ -0,0 +1,213 @@ +/* + * EEPROM framework core. + * + * Copyright (C) 2015 Srinivas Kandagatla + * Copyright (C) 2013 Maxime Ripard + * + * 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 + +struct eeprom_device { + struct regmap *regmap; + int stride; + size_t size; + + struct module *owner; + struct device dev; + int id; + int users; +}; + +static DEFINE_MUTEX(eeprom_mutex); +static DEFINE_IDA(eeprom_ida); + +#define to_eeprom(d) container_of(d, struct eeprom_device, dev) + +static ssize_t bin_attr_eeprom_read(struct file *filp, struct kobject *kobj, + struct bin_attribute *attr, + char *buf, loff_t offset, size_t count) +{ + struct device *dev = container_of(kobj, struct device, kobj); + struct eeprom_device *eeprom = to_eeprom(dev); + int rc; + + if (offset > eeprom->size) + return -EINVAL; + + if (offset + count > eeprom->size) + count = eeprom->size - offset; + + rc = regmap_bulk_read(eeprom->regmap, offset, + buf, count/eeprom->stride); + + if (IS_ERR_VALUE(rc)) + return rc; + + return count - count % eeprom->stride; +} + +static ssize_t bin_attr_eeprom_write(struct file *filp, struct kobject *kobj, + struct bin_attribute *attr, + char *buf, loff_t offset, size_t count) +{ + struct device *dev = container_of(kobj, struct device, kobj); + struct eeprom_device *eeprom = to_eeprom(dev); + int rc; + + if (offset > eeprom->size) + return -EINVAL; + + if (offset + count > eeprom->size) + count = eeprom->size - offset; + + rc = regmap_bulk_write(eeprom->regmap, offset, + buf, count/eeprom->stride); + + if (IS_ERR_VALUE(rc)) + return rc; + + return count - count % eeprom->stride; +} + +static struct bin_attribute bin_attr_eeprom = { + .attr = { + .name = "eeprom", + .mode = S_IWUSR | S_IRUGO, + }, + .read = bin_attr_eeprom_read, + .write = bin_attr_eeprom_write, +}; + +static struct bin_attribute *eeprom_bin_attributes[] = { + &bin_attr_eeprom, + NULL, +}; + +static const struct attribute_group eeprom_bin_group = { + .bin_attrs = eeprom_bin_attributes, +}; + +static const struct attribute_group *eeprom_dev_groups[] = { + &eeprom_bin_group, + NULL, +}; + +static void eeprom_release(struct device *dev) +{ + kfree(to_eeprom(dev)); +} + +static struct class eeprom_class = { + .name = "eeprom", + .dev_groups = eeprom_dev_groups, + .dev_release = eeprom_release, +}; + +/** + * eeprom_register(): Register a eeprom device for given eeprom. + * Also creates an binary entry in /sys/class/eeprom/name-id/eeprom + * + * @eeprom: eeprom device that needs to be created + * + * The return value will be an error code on error or a zero on success. + * The eeprom_device and sysfs entery will be freed by the eeprom_unregister(). + */ + +struct eeprom_device *eeprom_register(struct eeprom_config *config) +{ + struct eeprom_device *eeprom; + int rval; + + if (!config->regmap || !config->size) { + dev_err(config->dev, "Regmap not found\n"); + return ERR_PTR(-EINVAL); + } + + eeprom = kzalloc(sizeof(*eeprom), GFP_KERNEL); + if (!eeprom) + return ERR_PTR(-ENOMEM); + + eeprom->id = ida_simple_get(&eeprom_ida, 0, 0, GFP_KERNEL); + if (eeprom->id < 0) + return ERR_PTR(eeprom->id); + + eeprom->owner = config->owner; + eeprom->regmap = config->regmap; + eeprom->stride = config->stride; + eeprom->size = config->size; + eeprom->dev.class = &eeprom_class; + eeprom->dev.parent = config->dev; + eeprom->dev.of_node = config->dev ? config->dev->of_node : NULL; + dev_set_name(&eeprom->dev, "%s%d", + config->name ? : "eeprom", config->id); + + device_initialize(&eeprom->dev); + + dev_dbg(&eeprom->dev, "Registering eeprom device %s\n", + dev_name(&eeprom->dev)); + + rval = device_add(&eeprom->dev); + if (rval) + return ERR_PTR(rval); + + return eeprom; +} +EXPORT_SYMBOL_GPL(eeprom_register); + +/** + * eeprom_unregister(): Unregister previously registered eeprom device + * + * @eeprom: Pointer to previously registered eeprom device. + * + * The return value will be an non zero on error or a zero on success. + */ +int eeprom_unregister(struct eeprom_device *eeprom) +{ + mutex_lock(&eeprom_mutex); + if (eeprom->users) { + mutex_unlock(&eeprom_mutex); + return -EBUSY; + } + mutex_unlock(&eeprom_mutex); + + device_del(&eeprom->dev); + + return 0; +} +EXPORT_SYMBOL_GPL(eeprom_unregister); + +static int eeprom_init(void) +{ + return class_register(&eeprom_class); +} + +static void eeprom_exit(void) +{ + class_unregister(&eeprom_class); +} + +subsys_initcall(eeprom_init); +module_exit(eeprom_exit); + +MODULE_AUTHOR("Srinivas Kandagatla + * Copyright (C) 2013 Maxime Ripard + * + * This file is licensed under the terms of the GNU General Public + * License version 2. This program is licensed "as is" without any + * warranty of any kind, whether express or implied. + */ + +#ifndef _LINUX_EEPROM_PROVIDER_H +#define _LINUX_EEPROM_PROVIDER_H + +#include + +struct eeprom_device; + +struct eeprom_config { + struct device *dev; + struct regmap *regmap; + const char *name; + int id; + int stride; + size_t size; + struct module *owner; +}; + +#if IS_ENABLED(CONFIG_EEPROM) + +struct eeprom_device *eeprom_register(struct eeprom_config *cfg); +int eeprom_unregister(struct eeprom_device *eeprom); + +#else + +static inline struct eeprom_device *eeprom_register(struct eeprom_config *cfg) +{ + return NULL; +} +static inline int eeprom_unregister(struct eeprom_device *eeprom) +{ + return -ENOSYS; +} + +#endif /* CONFIG_EEPROM */ + +#endif /* ifndef _LINUX_EEPROM_PROVIDER_H */