lkml.org 
[lkml]   [2013]   [Oct]   [30]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH] drivers: misc: stcam: Renesas stcam device
Date
This is a driver for the ternary content addressable memory unit from Renesas. It
allows filtering on bits, and wildcards thru the chip.

Signed-off-by: Daniel Walker <dwalker@fifo99.com>
---
drivers/misc/Kconfig | 7 +
drivers/misc/Makefile | 1 +
drivers/misc/stcam.c | 348 ++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 356 insertions(+)
create mode 100644 drivers/misc/stcam.c

diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 8dacd4c..1f9bc31 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -528,6 +528,13 @@ config SRAM
the genalloc API. It is supposed to be used for small on-chip SRAM
areas found on many SoCs.

+config STCAM
+ bool "Renesas stcam device"
+ help
+ This is a ternary content addressable memory unit (TCAM) from Renesas. It
+ allows filtering on bits, and wildcards.
+
+
source "drivers/misc/c2port/Kconfig"
source "drivers/misc/eeprom/Kconfig"
source "drivers/misc/cb710/Kconfig"
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index c235d5b..30d413e 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -53,3 +53,4 @@ obj-$(CONFIG_INTEL_MEI) += mei/
obj-$(CONFIG_VMWARE_VMCI) += vmw_vmci/
obj-$(CONFIG_LATTICE_ECP3_CONFIG) += lattice-ecp3-config.o
obj-$(CONFIG_SRAM) += sram.o
+obj-$(CONFIG_STCAM) += stcam.o
diff --git a/drivers/misc/stcam.c b/drivers/misc/stcam.c
new file mode 100644
index 0000000..b395a09
--- /dev/null
+++ b/drivers/misc/stcam.c
@@ -0,0 +1,348 @@
+/*------------------------------------------------------------------
+ * stcam.c - I2C driver for the Renesas stcam device
+ *
+ * January 2013, Craig MacFarlane
+ *
+ * Copyright (c) 2013 by Cisco Systems, Inc.
+ * All rights reserved.
+ *------------------------------------------------------------------
+ */
+
+#include <linux/i2c.h>
+#include <linux/sysctl.h>
+#include <linux/version.h>
+#include <linux/semaphore.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+/*
+ * client instance data
+ */
+struct stcam_data {
+ struct mutex mutex;
+ struct i2c_client *client;
+ long reg;
+};
+
+/*
+ * stcam_i2c_read_block_data
+ *
+ * Read an arbitrary amount of data
+ */
+int
+stcam_i2c_read_block_data(struct i2c_client *client, uint32_t reg,
+ char *buf, int count)
+{
+ struct i2c_msg msg[2];
+ uint8_t register_buf[3];
+
+ register_buf[2] = reg & 0xFF;
+ register_buf[1] = (reg >> 8) & 0xFF;
+ register_buf[0] = (reg >> 16) & 0xFF;
+
+ msg[0].addr = client->addr;
+ msg[0].flags = 0;
+ msg[0].len = 3;
+ msg[0].buf = register_buf;
+
+ msg[1].addr = client->addr;
+ msg[1].flags = I2C_M_RD;
+ msg[1].len = count;
+ msg[1].buf = buf;
+
+ return i2c_transfer(client->adapter, msg, 2);
+}
+
+/*
+ * stcam_i2c_write_block_data
+ *
+ * Write 4 bytes of data to offset reg.
+ */
+int
+stcam_i2c_write_block_data(struct i2c_client *client, uint32_t reg,
+ uint32_t data)
+{
+ struct i2c_msg msg;
+ uint8_t write_buf[7];
+
+ write_buf[2] = reg & 0xFF;
+ write_buf[1] = (reg >> 8) & 0xFF;
+ write_buf[0] = (reg >> 16) & 0xFF;
+
+ write_buf[6] = data & 0xFF;
+ write_buf[5] = (data >> 8) & 0xFF;
+ write_buf[4] = (data >> 16) & 0xFF;
+ write_buf[3] = (data >> 24) & 0xFF;
+
+ msg.addr = client->addr;
+ msg.flags = 0;
+ msg.len = 7;
+ msg.buf = write_buf;
+
+ return i2c_transfer(client->adapter, &msg, 1);
+}
+
+#ifdef CONFIG_X86_64
+/* swap function for Intel arch */
+#define STCAM_SWAP(x) \
+ (((x & 0x000000FFUL) << 24) | \
+ ((x & 0x0000FF00UL) << 8) | \
+ ((x & 0x00FF0000UL) >> 8) | \
+ ((x & 0xFF000000UL) >> 24))
+#else
+#define STCAM_SWAP(x) (x)
+#endif
+
+/*
+ * show_id
+ *
+ * Convenience function to dump the ID register
+ */
+static ssize_t
+show_id(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ s32 rtn;
+ unsigned char val_upper[4];
+ unsigned char val_lower[4];
+ uint32_t u_upper;
+ uint32_t u_lower;
+
+ struct i2c_client *client = to_i2c_client(dev);
+ struct stcam_data *data = i2c_get_clientdata(client);
+
+ mutex_lock(&data->mutex);
+ rtn = stcam_i2c_read_block_data(client, 0x02, val_upper, 4);
+ rtn = stcam_i2c_read_block_data(client, 0x03, val_lower, 4);
+ mutex_unlock(&data->mutex);
+ if (rtn == -1) {
+ dev_err(dev, "read stcam register read failed \n");
+ rtn = 0;
+ } else {
+ u_upper = *(uint32_t *)val_upper;
+ u_upper = STCAM_SWAP(u_upper);
+ u_lower = *(uint32_t *)val_lower;
+ u_lower = STCAM_SWAP(u_lower);
+ return snprintf(buf, PAGE_SIZE, "%08X %08X", u_upper, u_lower);
+ }
+
+ return rtn;
+}
+
+/*
+ * show_reg
+ *
+ * Read an arbitrary register.
+ *
+ * To use write the register to read to
+ * /sys/bus/i2c/drivers/stcam/<slave-addr>/reg
+ *
+ * e.g.
+ * echo <val> > /sys/bus/i2c/drivers/stcam/<slave-addr>/reg
+ *
+ * Then cat reg. The driver caches the register to read from and
+ * performs the read when when you do a read from the file.
+ */
+static ssize_t
+show_reg(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ s32 rtn;
+ struct i2c_client *client = to_i2c_client(dev);
+ struct stcam_data *data = i2c_get_clientdata(client);
+ unsigned char val[4];
+ uint32_t u_val;
+
+ mutex_lock(&data->mutex);
+ rtn = stcam_i2c_read_block_data(client, data->reg, val, 4);
+ mutex_unlock(&data->mutex);
+ if (rtn == -1) {
+ dev_err(dev, "read stcam register read failed \n");
+ rtn = 0;
+ } else {
+ u_val = *(uint32_t *)val;
+ u_val = STCAM_SWAP(u_val);
+ rtn = snprintf(buf, PAGE_SIZE, "%08X\n", u_val);
+ }
+ return rtn;
+}
+
+/*
+ * set_reg
+ *
+ * Cache a register to read from. See show_reg
+ */
+static ssize_t
+set_reg(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct stcam_data *data = i2c_get_clientdata(client);
+ int ret = kstrtoul(buf, 10, &data->reg);
+
+ return (ret == 0) ? count : ret;
+}
+
+/*
+ * set_write_reg
+ *
+ * Write to the cached register.
+ */
+static ssize_t
+set_write_reg(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ s32 rtn;
+ struct i2c_client *client = to_i2c_client(dev);
+ struct stcam_data *data = i2c_get_clientdata(client);
+ long val;
+
+ rtn = kstrtoul(buf, 10, &val);
+
+ if (rtn == 0) {
+ mutex_lock(&data->mutex);
+ rtn = stcam_i2c_write_block_data(client, data->reg,
+ (uint32_t)val);
+ mutex_unlock(&data->mutex);
+
+ return count;
+ } else
+ return rtn;
+}
+
+static DEVICE_ATTR(id, S_IRUGO, show_id, NULL);
+static DEVICE_ATTR(reg, S_IWUSR | S_IRUGO, show_reg, set_reg);
+static DEVICE_ATTR(write_reg, S_IWUSR, NULL, set_write_reg);
+
+/*
+ * stcam_detect
+ *
+ * called by i2c_detect
+ */
+static int
+stcam_detect(struct i2c_client *client,
+ struct i2c_board_info *info)
+{
+ int rtn = 0;
+
+ strlcpy(info->type, "stcam", I2C_NAME_SIZE);
+
+ pr_debug("rtn = %d\n", (unsigned int)rtn);
+ return rtn;
+}
+
+/*
+ * stcam_probe
+ */
+static int
+stcam_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+ struct stcam_data *data;
+ struct device *dev = &client->dev;
+ struct i2c_adapter *adapter = client->adapter;
+ int rtn = 0;
+ int rc;
+
+ rtn = 0;
+ data = NULL;
+
+ if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+ pr_err("stcam unsupported function\n");
+ rtn = -ENOSYS;
+ goto _exit;
+ }
+
+ data = kzalloc(sizeof(*data), GFP_KERNEL);
+ if (data == NULL) {
+ pr_err("failed to allocate client data memory\n");
+ rtn = -ENOMEM;
+ goto _exit;
+ }
+
+ mutex_init(&data->mutex);
+ data->client = client;
+
+ i2c_set_clientdata(client, data);
+
+ rc = device_create_file(dev, &dev_attr_id);
+ rc = device_create_file(dev, &dev_attr_reg);
+ rc = device_create_file(dev, &dev_attr_write_reg);
+
+_exit:
+ if (rtn != 0)
+ kfree(data);
+
+
+ pr_debug("rtn = %d\n", rtn);
+ return rtn;
+}
+
+/*
+ * stcam_remove
+ */
+static int stcam_remove(struct i2c_client *client)
+{
+ int rtn = 0;
+ struct stcam_data *data;
+
+ data = i2c_get_clientdata(client);
+ kfree(data);
+
+ pr_debug("stcam rtn = %d\n", rtn);
+ return rtn;
+}
+
+static struct i2c_device_id stcam_idtable[] = {
+ { "stcam", 0},
+ { },
+};
+
+MODULE_DEVICE_TABLE(i2c, stcam_idtable);
+
+
+/*
+ * this is the driver that will be inserted
+ */
+static struct i2c_driver stcam_chip_driver = {
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = "stcam",
+ },
+ .id_table = stcam_idtable,
+ .probe = stcam_probe,
+ .remove = stcam_remove,
+ .detect = stcam_detect,
+ .class = I2C_CLASS_HWMON,
+};
+
+/*
+ * stcam_init
+ */
+int
+stcam_init(void)
+{
+ int rtn;
+
+ rtn = i2c_add_driver(&stcam_chip_driver);
+ if (rtn) {
+ pr_err("Could not initialize stcam driver, rtn = %d\n", rtn);
+ return rtn;
+ }
+ pr_debug("stcam rtn = %d\n", rtn);
+ return rtn;
+}
+
+/*
+ * stcam_exit
+ */
+void
+stcam_exit(void)
+{
+ i2c_del_driver(&stcam_chip_driver);
+ pr_debug("exit\n");
+}
+
+MODULE_AUTHOR("Cisco Systems Inc.");
+MODULE_DESCRIPTION("sTCAM I2C Driver");
+MODULE_LICENSE("GPL");
+
+module_init(stcam_init);
+module_exit(stcam_exit);
--
1.8.3.2


\
 
 \ /
  Last update: 2013-10-30 20:41    [W:0.040 / U:2.504 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site