eeprom: at24: remove at24_platform_data (4fa882c9) · Commits · 戴 / test

MAINTAINERS

+0 −1

Original line number	Diff line number	Diff line
		@@ -2503,7 +2503,6 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux.git
		S: Maintained
		F: Documentation/devicetree/bindings/eeprom/at24.txt
		F: drivers/misc/eeprom/at24.c
		F: include/linux/platform_data/at24.h

		ATA OVER ETHERNET (AOE) DRIVER
		M: "Ed L. Cashin" <ed.cashin@acm.org>

drivers/misc/eeprom/at24.c

+75 −87

Original line number	Diff line number	Diff line
		@@ -22,10 +22,24 @@
		#include <linux/i2c.h>
		#include <linux/nvmem-provider.h>
		#include <linux/regmap.h>
		#include <linux/platform_data/at24.h>
		#include <linux/pm_runtime.h>
		#include <linux/gpio/consumer.h>

		/* Address pointer is 16 bit. */
		#define AT24_FLAG_ADDR16 BIT(7)
		/* sysfs-entry will be read-only. */
		#define AT24_FLAG_READONLY BIT(6)
		/* sysfs-entry will be world-readable. */
		#define AT24_FLAG_IRUGO BIT(5)
		/* Take always 8 addresses (24c00). */
		#define AT24_FLAG_TAKE8ADDR BIT(4)
		/* Factory-programmed serial number. */
		#define AT24_FLAG_SERIAL BIT(3)
		/* Factory-programmed mac address. */
		#define AT24_FLAG_MAC BIT(2)
		/* Does not auto-rollover reads to the next slave address. */
		#define AT24_FLAG_NO_RDROL BIT(1)

		/*
		* I2C EEPROMs from most vendors are inexpensive and mostly interchangeable.
		* Differences between different vendor product lines (like Atmel AT24C or
		@@ -107,10 +121,6 @@ module_param_named(write_timeout, at24_write_timeout, uint, 0);
		MODULE_PARM_DESC(at24_write_timeout, "Time (in ms) to try writes (default 25)");

		struct at24_chip_data {
		/*
		* these fields mirror their equivalents in
		* struct at24_platform_data
		*/
		u32 byte_len;
		u8 flags;
		};
		@@ -471,63 +481,11 @@ static int at24_write(void priv, unsigned int off, void val, size_t count)
		return 0;
		}

		static void at24_properties_to_pdata(struct device *dev,
		struct at24_platform_data *chip)
		{
		int err;
		u32 val;

		if (device_property_present(dev, "read-only"))
		chip->flags \|= AT24_FLAG_READONLY;
		if (device_property_present(dev, "no-read-rollover"))
		chip->flags \|= AT24_FLAG_NO_RDROL;

		err = device_property_read_u32(dev, "address-width", &val);
		if (!err) {
		switch (val) {
		case 8:
		if (chip->flags & AT24_FLAG_ADDR16)
		dev_warn(dev, "Override address width to be 8, while default is 16\n");
		chip->flags &= ~AT24_FLAG_ADDR16;
		break;
		case 16:
		chip->flags \|= AT24_FLAG_ADDR16;
		break;
		default:
		dev_warn(dev, "Bad \"address-width\" property: %u\n",
		val);
		}
		}

		err = device_property_read_u32(dev, "size", &val);
		if (!err)
		chip->byte_len = val;

		err = device_property_read_u32(dev, "pagesize", &val);
		if (!err) {
		chip->page_size = val;
		} else {
		/*
		* This is slow, but we can't know all eeproms, so we better
		* play safe. Specifying custom eeprom-types via platform_data
		* is recommended anyhow.
		*/
		chip->page_size = 1;
		}
		}

		static int at24_get_pdata(struct device dev, struct at24_platform_data pdata)
		static const struct at24_chip_data at24_get_chip_data(struct device dev)
		{
		struct device_node *of_node = dev->of_node;
		const struct at24_chip_data *cdata;
		const struct i2c_device_id *id;
		struct at24_platform_data *pd;

		pd = dev_get_platdata(dev);
		if (pd) {
		memcpy(pdata, pd, sizeof(*pdata));
		return 0;
		}

		id = i2c_match_id(at24_ids, to_i2c_client(dev));

		@@ -544,13 +502,9 @@ static int at24_get_pdata(struct device dev, struct at24_platform_data pdata)
		cdata = acpi_device_get_match_data(dev);

		if (!cdata)
		return -ENODEV;

		pdata->byte_len = cdata->byte_len;
		pdata->flags = cdata->flags;
		at24_properties_to_pdata(dev, pdata);
		return ERR_PTR(-ENODEV);

		return 0;
		return cdata;
		}

		static void at24_remove_dummy_clients(struct at24_data *at24)
		@@ -619,7 +573,8 @@ static int at24_probe(struct i2c_client *client)
		{
		struct regmap_config regmap_config = { };
		struct nvmem_config nvmem_config = { };
		struct at24_platform_data pdata = { };
		u32 byte_len, page_size, flags, addrw;
		const struct at24_chip_data *cdata;
		struct device *dev = &client->dev;
		bool i2c_fn_i2c, i2c_fn_block;
		unsigned int i, num_addresses;
		@@ -634,35 +589,72 @@ static int at24_probe(struct i2c_client *client)
		i2c_fn_block = i2c_check_functionality(client->adapter,
		I2C_FUNC_SMBUS_WRITE_I2C_BLOCK);

		err = at24_get_pdata(dev, &pdata);
		cdata = at24_get_chip_data(dev);
		if (IS_ERR(cdata))
		return PTR_ERR(cdata);

		err = device_property_read_u32(dev, "pagesize", &page_size);
		if (err)
		return err;
		/*
		* This is slow, but we can't know all eeproms, so we better
		* play safe. Specifying custom eeprom-types via platform_data
		* is recommended anyhow.
		*/
		page_size = 1;

		flags = cdata->flags;
		if (device_property_present(dev, "read-only"))
		flags \|= AT24_FLAG_READONLY;
		if (device_property_present(dev, "no-read-rollover"))
		flags \|= AT24_FLAG_NO_RDROL;

		err = device_property_read_u32(dev, "address-width", &addrw);
		if (!err) {
		switch (addrw) {
		case 8:
		if (flags & AT24_FLAG_ADDR16)
		dev_warn(dev,
		"Override address width to be 8, while default is 16\n");
		flags &= ~AT24_FLAG_ADDR16;
		break;
		case 16:
		flags \|= AT24_FLAG_ADDR16;
		break;
		default:
		dev_warn(dev, "Bad \"address-width\" property: %u\n",
		addrw);
		}
		}

		err = device_property_read_u32(dev, "size", &byte_len);
		if (err)
		byte_len = cdata->byte_len;

		if (!i2c_fn_i2c && !i2c_fn_block)
		pdata.page_size = 1;
		page_size = 1;

		if (!pdata.page_size) {
		if (!page_size) {
		dev_err(dev, "page_size must not be 0!\n");
		return -EINVAL;
		}

		if (!is_power_of_2(pdata.page_size))
		if (!is_power_of_2(page_size))
		dev_warn(dev, "page_size looks suspicious (no power of 2)!\n");

		if (pdata.flags & AT24_FLAG_TAKE8ADDR)
		if (flags & AT24_FLAG_TAKE8ADDR)
		num_addresses = 8;
		else
		num_addresses = DIV_ROUND_UP(pdata.byte_len,
		(pdata.flags & AT24_FLAG_ADDR16) ? 65536 : 256);
		num_addresses = DIV_ROUND_UP(byte_len,
		(flags & AT24_FLAG_ADDR16) ? 65536 : 256);

		if ((pdata.flags & AT24_FLAG_SERIAL) && (pdata.flags & AT24_FLAG_MAC)) {
		if ((flags & AT24_FLAG_SERIAL) && (flags & AT24_FLAG_MAC)) {
		dev_err(dev,
		"invalid device data - cannot have both AT24_FLAG_SERIAL & AT24_FLAG_MAC.");
		return -EINVAL;
		}

		regmap_config.val_bits = 8;
		regmap_config.reg_bits = (pdata.flags & AT24_FLAG_ADDR16) ? 16 : 8;
		regmap_config.reg_bits = (flags & AT24_FLAG_ADDR16) ? 16 : 8;
		regmap_config.disable_locking = true;

		regmap = devm_regmap_init_i2c(client, &regmap_config);
		@@ -675,11 +667,11 @@ static int at24_probe(struct i2c_client *client)
		return -ENOMEM;

		mutex_init(&at24->lock);
		at24->byte_len = pdata.byte_len;
		at24->page_size = pdata.page_size;
		at24->flags = pdata.flags;
		at24->byte_len = byte_len;
		at24->page_size = page_size;
		at24->flags = flags;
		at24->num_addresses = num_addresses;
		at24->offset_adj = at24_get_offset_adj(pdata.flags, pdata.byte_len);
		at24->offset_adj = at24_get_offset_adj(flags, byte_len);
		at24->client[0].client = client;
		at24->client[0].regmap = regmap;

		@@ -687,10 +679,10 @@ static int at24_probe(struct i2c_client *client)
		if (IS_ERR(at24->wp_gpio))
		return PTR_ERR(at24->wp_gpio);

		writable = !(pdata.flags & AT24_FLAG_READONLY);
		writable = !(flags & AT24_FLAG_READONLY);
		if (writable) {
		at24->write_max = min_t(unsigned int,
		pdata.page_size, at24_io_limit);
		page_size, at24_io_limit);
		if (!i2c_fn_i2c && at24->write_max > I2C_SMBUS_BLOCK_MAX)
		at24->write_max = I2C_SMBUS_BLOCK_MAX;
		}
		@@ -733,7 +725,7 @@ static int at24_probe(struct i2c_client *client)
		nvmem_config.priv = at24;
		nvmem_config.stride = 1;
		nvmem_config.word_size = 1;
		nvmem_config.size = pdata.byte_len;
		nvmem_config.size = byte_len;

		at24->nvmem = devm_nvmem_register(dev, &nvmem_config);
		if (IS_ERR(at24->nvmem)) {
		@@ -742,13 +734,9 @@ static int at24_probe(struct i2c_client *client)
		}

		dev_info(dev, "%u byte %s EEPROM, %s, %u bytes/write\n",
		pdata.byte_len, client->name,
		byte_len, client->name,
		writable ? "writable" : "read-only", at24->write_max);

		/* export data to kernel code */
		if (pdata.setup)
		pdata.setup(at24->nvmem, pdata.context);

		return 0;

		err_clients:

include/linux/platform_data/at24.h

deleted100644 → 0

+0 −60

Original line number	Diff line number	Diff line
		/*
		* at24.h - platform_data for the at24 (generic eeprom) driver
		* (C) Copyright 2008 by Pengutronix
		* (C) Copyright 2012 by Wolfram Sang
		* same license as the driver
		*/

		#ifndef _LINUX_AT24_H
		#define _LINUX_AT24_H

		#include <linux/types.h>
		#include <linux/nvmem-consumer.h>
		#include <linux/bitops.h>

		/**
		* struct at24_platform_data - data to set up at24 (generic eeprom) driver
		* @byte_len: size of eeprom in byte
		* @page_size: number of byte which can be written in one go
		* @flags: tunable options, check AT24_FLAG_* defines
		* @setup: an optional callback invoked after eeprom is probed; enables kernel
		code to access eeprom via nvmem, see example
		* @context: optional parameter passed to setup()
		*
		* If you set up a custom eeprom type, please double-check the parameters.
		* Especially page_size needs extra care, as you risk data loss if your value
		* is bigger than what the chip actually supports!
		*
		* An example in pseudo code for a setup() callback:
		*
		* void get_mac_addr(struct nvmem_device nvmem, void context)
		* {
		* u8 *mac_addr = ethernet_pdata->mac_addr;
		* off_t offset = context;
		*
		* // Read MAC addr from EEPROM
		* if (nvmem_device_read(nvmem, offset, ETH_ALEN, mac_addr) == ETH_ALEN)
		* pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr);
		* }
		*
		* This function pointer and context can now be set up in at24_platform_data.
		*/

		struct at24_platform_data {
		u32 byte_len; /* size (sum of all addr) */
		u16 page_size; /* for writes */
		u8 flags;
		#define AT24_FLAG_ADDR16 BIT(7) /* address pointer is 16 bit */
		#define AT24_FLAG_READONLY BIT(6) /* sysfs-entry will be read-only */
		#define AT24_FLAG_IRUGO BIT(5) /* sysfs-entry will be world-readable */
		#define AT24_FLAG_TAKE8ADDR BIT(4) /* take always 8 addresses (24c00) */
		#define AT24_FLAG_SERIAL BIT(3) /* factory-programmed serial number */
		#define AT24_FLAG_MAC BIT(2) /* factory-programmed mac address */
		#define AT24_FLAG_NO_RDROL BIT(1) /* does not auto-rollover reads to */
		/* the next slave address */

		void (setup)(struct nvmem_device nvmem, void *context);
		void *context;
		};

		#endif /* _LINUX_AT24_H */

Admin message