diff --git a/drivers/Kconfig b/drivers/Kconfig index eb3a587..8bab7ac 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -3,6 +3,7 @@ source "drivers/serial/Kconfig" source "drivers/net/Kconfig" source "drivers/spi/Kconfig" +source "drivers/i2c/Kconfig" source "drivers/nor/Kconfig" source "drivers/nand/Kconfig" source "drivers/usb/Kconfig" diff --git a/drivers/Makefile b/drivers/Makefile index 518060a..5dc7756 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -4,4 +4,5 @@ obj-y += nor/ obj-y += usb/ obj-$(CONFIG_SPI) += spi/ +obj-$(CONFIG_I2C) += i2c/ obj-$(CONFIG_VIDEO) += video/ diff --git a/drivers/i2c/Kconfig b/drivers/i2c/Kconfig new file mode 100644 index 0000000..46723ed --- /dev/null +++ b/drivers/i2c/Kconfig @@ -0,0 +1,16 @@ +menuconfig I2C + bool "I2C drivers " + +if I2C + +config DRIVER_I2C_IMX + bool "i.MX I2C Master driver" + depends on ARCH_IMX + +config DRIVER_I2C_MC13892 + bool "MC13892 a.k.a. PMIC driver" + +config DRIVER_I2C_MC9SDZ60 + bool "MC9SDZ60 driver" + +endif diff --git a/drivers/i2c/Makefile b/drivers/i2c/Makefile new file mode 100644 index 0000000..5dd642f --- /dev/null +++ b/drivers/i2c/Makefile @@ -0,0 +1,6 @@ +obj-$(CONFIG_I2C) += i2c.o + +obj-$(CONFIG_DRIVER_I2C_IMX) += i2c-imx.o + +obj-$(CONFIG_DRIVER_I2C_MC13892) += mc13892.o +obj-$(CONFIG_DRIVER_I2C_MC9SDZ60) += mc9sdz60.o diff --git a/drivers/i2c/i2c-imx.c b/drivers/i2c/i2c-imx.c new file mode 100644 index 0000000..33d9fe9 --- /dev/null +++ b/drivers/i2c/i2c-imx.c @@ -0,0 +1,501 @@ +/* + * Copyright (C) 2002 Motorola GSG-China + * 2009 Marc Kleine-Budde, Pengutronix + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + * + * Author: + * Darius Augulis, Teltonika Inc. + * + * Desc.: + * Implementation of I2C Adapter/Algorithm Driver + * for I2C Bus integrated in Freescale i.MX/MXC processors + * + * Derived from Motorola GSG China I2C example driver + * + * Copyright (C) 2005 Torsten Koschorrek + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include + +/* This will be the driver name */ +#define DRIVER_NAME "i2c-imx" + +/* Default value */ +#define IMX_I2C_BIT_RATE 100000 /* 100kHz */ + +/* IMX I2C registers */ +#define IMX_I2C_IADR 0x00 /* i2c slave address */ +#define IMX_I2C_IFDR 0x04 /* i2c frequency divider */ +#define IMX_I2C_I2CR 0x08 /* i2c control */ +#define IMX_I2C_I2SR 0x0C /* i2c status */ +#define IMX_I2C_I2DR 0x10 /* i2c transfer data */ + +/* Bits of IMX I2C registers */ +#define I2SR_RXAK 0x01 +#define I2SR_IIF 0x02 +#define I2SR_SRW 0x04 +#define I2SR_IAL 0x10 +#define I2SR_IBB 0x20 +#define I2SR_IAAS 0x40 +#define I2SR_ICF 0x80 +#define I2CR_RSTA 0x04 +#define I2CR_TXAK 0x08 +#define I2CR_MTX 0x10 +#define I2CR_MSTA 0x20 +#define I2CR_IIEN 0x40 +#define I2CR_IEN 0x80 + +/* + * sorted list of clock divider, register value pairs + * taken from table 26-5, p.26-9, Freescale i.MX + * Integrated Portable System Processor Reference Manual + * Document Number: MC9328MXLRM, Rev. 5.1, 06/2007 + * + * Duplicated divider values removed from list + */ +static u16 i2c_clk_div[50][2] = { + { 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 }, + { 30, 0x00 }, { 32, 0x24 }, { 36, 0x25 }, { 40, 0x26 }, + { 42, 0x03 }, { 44, 0x27 }, { 48, 0x28 }, { 52, 0x05 }, + { 56, 0x29 }, { 60, 0x06 }, { 64, 0x2A }, { 72, 0x2B }, + { 80, 0x2C }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A }, + { 112, 0x2E }, { 128, 0x2F }, { 144, 0x0C }, { 160, 0x30 }, + { 192, 0x31 }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 }, + { 288, 0x10 }, { 320, 0x34 }, { 384, 0x35 }, { 448, 0x36 }, + { 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x38 }, + { 768, 0x39 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B }, + { 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E }, + { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D }, + { 3072, 0x1E }, { 3840, 0x1F } +}; + +struct imx_i2c_struct { + struct i2c_adapter adapter; + unsigned int disable_delay; + int stopped; + unsigned int ifdr; /* IMX_I2C_IFDR */ +}; +#define to_imx_i2c_struct(a) container_of(a, struct imx_i2c_struct, adapter) + +#ifdef CONFIG_I2C_DEBUG +static void i2c_imx_dump_reg(struct i2c_adapter *adapter) +{ + unsigned long base = adapter->dev->map_base; + u32 reg_cr, reg_sr; + + reg_cr = readb(base + IMX_I2C_I2CR); + reg_sr = readb(base + IMX_I2C_I2SR); + + dev_dbg(adapter->dev, "CONTROL:\t" + "IEN =%d, IIEN=%d, MSTA=%d, MTX =%d, TXAK=%d, RSTA=%d\n", + (reg_cr & I2CR_IEN ? 1 : 0), (reg_cr & I2CR_IIEN ? 1 : 0), + (reg_cr & I2CR_MSTA ? 1 : 0), (reg_cr & I2CR_MTX ? 1 : 0), + (reg_cr & I2CR_TXAK ? 1 : 0), (reg_cr & I2CR_RSTA ? 1 : 0)); + + dev_dbg(adapter->dev, "STATUS:\t" + "ICF =%d, IAAS=%d, IB =%d, IAL =%d, SRW =%d, IIF =%d, RXAK=%d\n", + (reg_sr & I2SR_ICF ? 1 : 0), (reg_sr & I2SR_IAAS ? 1 : 0), + (reg_sr & I2SR_IBB ? 1 : 0), (reg_sr & I2SR_IAL ? 1 : 0), + (reg_sr & I2SR_SRW ? 1 : 0), (reg_sr & I2SR_IIF ? 1 : 0), + (reg_sr & I2SR_RXAK ? 1 : 0)); +} +#else +static inline void i2c_imx_dump_reg(struct i2c_adapter *adapter) +{ + return; +} +#endif + +static int i2c_imx_bus_busy(struct i2c_adapter *adapter, int for_busy) +{ + unsigned long base = adapter->dev->map_base; + uint64_t start; + unsigned int temp; + + start = get_time_ns(); + while (1) { + temp = readb(base + IMX_I2C_I2SR); + if (for_busy && (temp & I2SR_IBB)) + break; + if (!for_busy && !(temp & I2SR_IBB)) + break; + if (is_timeout(start, MSECOND)) { + dev_warn(adapter->dev, "<%s> I2C bus is busy\n", __func__); + return -EIO; + } + } + + return 0; +} + +static int i2c_imx_trx_complete(struct i2c_adapter *adapter) +{ + unsigned long base = adapter->dev->map_base; + uint64_t start; + + start = get_time_ns(); + while (1) { + unsigned int reg = readb(base + IMX_I2C_I2SR); + if (reg & I2SR_ICF) + break; + + if (is_timeout(start, 100 * MSECOND)) { + dev_warn(adapter->dev, "<%s> TXR timeout\n", __func__); + return -EIO; + } + + writeb(0x0, base + IMX_I2C_I2SR); + } + + return 0; +} + +static int i2c_imx_wait_iif(struct i2c_adapter *adapter) +{ + unsigned long base = adapter->dev->map_base; + uint64_t start; + + start = get_time_ns(); + while (1) { + unsigned int reg = readb(base + IMX_I2C_I2SR); + if (reg & I2SR_IIF) + break; + + if (is_timeout(start, 100 * MSECOND)) { + dev_warn(adapter->dev, "<%s> IIF timeout\n", __func__); + return -EIO; + } + } + + return 0; +} + +static int i2c_imx_acked(struct i2c_adapter *adapter) +{ + unsigned long base = adapter->dev->map_base; + + if (readb(base + IMX_I2C_I2SR) & I2SR_RXAK) { + dev_notice(adapter->dev, "<%s> No ACK\n", __func__); + return -EIO; + } + + return 0; +} + +static int i2c_imx_start(struct i2c_adapter *adapter) +{ + struct imx_i2c_struct *i2c_imx = to_imx_i2c_struct(adapter); + unsigned long base = adapter->dev->map_base; + unsigned int temp = 0; + int result; + + writeb(i2c_imx->ifdr, base + IMX_I2C_IFDR); + /* Enable I2C controller */ + writeb(0, base + IMX_I2C_I2SR); + writeb(I2CR_IEN, base + IMX_I2C_I2CR); + + /* Wait controller to be stable */ + udelay(100); + + /* Start I2C transaction */ + temp = readb(base + IMX_I2C_I2CR); + temp |= I2CR_MSTA; + writeb(temp, base + IMX_I2C_I2CR); + + result = i2c_imx_bus_busy(adapter, 1); + if (result) + return result; + + i2c_imx->stopped = 0; + + temp |= I2CR_MTX | I2CR_TXAK; + writeb(temp, base + IMX_I2C_I2CR); + + return result; +} + +static void i2c_imx_stop(struct i2c_adapter *adapter) +{ + struct imx_i2c_struct *i2c_imx = to_imx_i2c_struct(adapter); + unsigned long base = adapter->dev->map_base; + unsigned int temp = 0; + + if (!i2c_imx->stopped) { + /* Stop I2C transaction */ + temp = readb(base + IMX_I2C_I2CR); + temp &= ~(I2CR_MSTA | I2CR_MTX); + writeb(temp, base + IMX_I2C_I2CR); + i2c_imx->stopped = 1; + } + if (cpu_is_mx1()) { + /* + * This delay caused by an i.MXL hardware bug. + * If no (or too short) delay, no "STOP" bit will be generated. + */ + udelay(i2c_imx->disable_delay); + } + + if (!i2c_imx->stopped) + i2c_imx_bus_busy(adapter, 0); + + /* Disable I2C controller */ + writeb(0, base + IMX_I2C_I2CR); +} + +static void i2c_imx_set_clk(struct imx_i2c_struct *i2c_imx, + unsigned int rate) +{ + unsigned int i2c_clk_rate; + unsigned int div; + int i; + + /* Divider value calculation */ + i2c_clk_rate = imx_get_i2cclk(); + div = (i2c_clk_rate + rate - 1) / rate; + if (div < i2c_clk_div[0][0]) + i = 0; + else if (div > i2c_clk_div[ARRAY_SIZE(i2c_clk_div) - 1][0]) + i = ARRAY_SIZE(i2c_clk_div) - 1; + else + for (i = 0; i2c_clk_div[i][0] < div; i++) + ; + + /* Store divider value */ + i2c_imx->ifdr = i2c_clk_div[i][1]; + + /* + * There dummy delay is calculated. + * It should be about one I2C clock period long. + * This delay is used in I2C bus disable function + * to fix chip hardware bug. + */ + i2c_imx->disable_delay = + (500000U * i2c_clk_div[i][0] + (i2c_clk_rate / 2) - 1) / + (i2c_clk_rate / 2); + + dev_dbg(i2c_imx->adapter.dev, "<%s> I2C_CLK=%d, REQ DIV=%d\n", + __func__, i2c_clk_rate, div); + dev_dbg(i2c_imx->adapter.dev, "<%s> IFDR[IC]=0x%x, REAL DIV=%d\n", + __func__, i2c_clk_div[i][1], i2c_clk_div[i][0]); +} + +static int i2c_imx_write(struct i2c_adapter *adapter, struct i2c_msg *msgs) +{ + unsigned long base = adapter->dev->map_base; + int i, result; + + dev_dbg(adapter->dev, + "<%s> write slave address: addr=0x%02x\n", + __func__, msgs->addr << 1); + + /* write slave address */ + writeb(msgs->addr << 1, base + IMX_I2C_I2DR); + + result = i2c_imx_trx_complete(adapter); + if (result) + return result; + result = i2c_imx_acked(adapter); + if (result) + return result; + + /* write data */ + for (i = 0; i < msgs->len; i++) { + dev_dbg(adapter->dev, + "<%s> write byte: B%d=0x%02X\n", + __func__, i, msgs->buf[i]); + writeb(msgs->buf[i], base + IMX_I2C_I2DR); + + result = i2c_imx_trx_complete(adapter); + if (result) + return result; + result = i2c_imx_acked(adapter); + if (result) + return result; + } + return 0; +} + +static int i2c_imx_read(struct i2c_adapter *adapter, struct i2c_msg *msgs) +{ + struct imx_i2c_struct *i2c_imx = to_imx_i2c_struct(adapter); + unsigned long base = adapter->dev->map_base; + int i, result; + unsigned int temp; + + dev_dbg(adapter->dev, + "<%s> write slave address: addr=0x%02x\n", + __func__, (msgs->addr << 1) | 0x01); + + /* write slave address */ + writeb((msgs->addr << 1) | 0x01, base + IMX_I2C_I2DR); + + result = i2c_imx_trx_complete(adapter); + if (result) + return result; + result = i2c_imx_acked(adapter); + if (result) + return result; + + result = i2c_imx_wait_iif(adapter); + if (result) + return result; + + /* setup bus to read data */ + temp = readb(base + IMX_I2C_I2CR); + temp &= ~I2CR_MTX; + if (msgs->len - 1) + temp &= ~I2CR_TXAK; + writeb(temp, base + IMX_I2C_I2CR); + + readb(base + IMX_I2C_I2DR); /* dummy read */ + + /* read data */ + for (i = 0; i < msgs->len; i++) { + result = i2c_imx_trx_complete(adapter); + if (result) + return result; + + if (i == (msgs->len - 1)) { + /* + * It must generate STOP before read I2DR to prevent + * controller from generating another clock cycle + */ + temp = readb(base + IMX_I2C_I2CR); + temp &= ~(I2CR_MSTA | I2CR_MTX); + writeb(temp, base + IMX_I2C_I2CR); + i2c_imx_bus_busy(adapter, 0); + i2c_imx->stopped = 1; + } else if (i == (msgs->len - 2)) { + temp = readb(base + IMX_I2C_I2CR); + temp |= I2CR_TXAK; + writeb(temp, base + IMX_I2C_I2CR); + } + msgs->buf[i] = readb(base + IMX_I2C_I2DR); + + dev_dbg(adapter->dev, "<%s> read byte: B%d=0x%02X\n", + __func__, i, msgs->buf[i]); + } + return 0; +} + +static int i2c_imx_xfer(struct i2c_adapter *adapter, + struct i2c_msg *msgs, int num) +{ + unsigned long base = adapter->dev->map_base; + unsigned int i, temp; + int result; + + /* Start I2C transfer */ + result = i2c_imx_start(adapter); + if (result) + goto fail0; + + /* read/write data */ + for (i = 0; i < num; i++) { + if (i) { + temp = readb(base + IMX_I2C_I2CR); + temp |= I2CR_RSTA; + writeb(temp, base + IMX_I2C_I2CR); + + result = i2c_imx_bus_busy(adapter, 1); + if (result) + goto fail0; + } + i2c_imx_dump_reg(adapter); + + /* write/read data */ + if (msgs[i].flags & I2C_M_RD) + result = i2c_imx_read(adapter, &msgs[i]); + else + result = i2c_imx_write(adapter, &msgs[i]); + } + +fail0: + /* Stop I2C transfer */ + i2c_imx_stop(adapter); + + return (result < 0) ? result : num; +} + +static int __init i2c_imx_probe(struct device_d *pdev) +{ + struct imx_i2c_struct *i2c_imx; + struct i2c_platform_data *pdata; + unsigned long base = pdev->map_base; + int ret; + + pdata = pdev->platform_data; + + i2c_imx = kzalloc(sizeof(struct imx_i2c_struct), GFP_KERNEL); + + /* Setup i2c_imx driver structure */ + i2c_imx->adapter.master_xfer = i2c_imx_xfer; + i2c_imx->adapter.nr = pdev->id; + i2c_imx->adapter.dev = pdev; + + /* Set up clock divider */ + if (pdata && pdata->bitrate) + i2c_imx_set_clk(i2c_imx, pdata->bitrate); + else + i2c_imx_set_clk(i2c_imx, IMX_I2C_BIT_RATE); + + /* Set up chip registers to defaults */ + writeb(0, base + IMX_I2C_I2CR); + writeb(0, base + IMX_I2C_I2SR); + + /* Add I2C adapter */ + ret = i2c_add_numbered_adapter(&i2c_imx->adapter); + if (ret < 0) { + dev_err(pdev, "registration failed\n"); + goto fail; + } + + return 0; + +fail: + kfree(i2c_imx); + return ret; +} + +static struct driver_d i2c_imx_driver = { + .probe = i2c_imx_probe, + .name = DRIVER_NAME, +}; + +static int __init i2c_adap_imx_init(void) +{ + return register_driver(&i2c_imx_driver); +} +device_initcall(i2c_adap_imx_init); diff --git a/drivers/i2c/i2c.c b/drivers/i2c/i2c.c new file mode 100644 index 0000000..a00e53a --- /dev/null +++ b/drivers/i2c/i2c.c @@ -0,0 +1,353 @@ +/* + * Copyright (C) 2009 Marc Kleine-Budde + * + * This file is released under the GPLv2 + * + * Derived from: + * - i2c-core.c - a device driver for the iic-bus interface + * Copyright (C) 1995-99 Simon G. Vogl + * - at24.c - handle most I2C EEPROMs + * Copyright (C) 2005-2007 David Brownell + * Copyright (C) 2008 Wolfram Sang, Pengutronix + * - spi.c - u-boot-v2 SPI Framework + * Copyright (C) 2008 Sascha Hauer, Pengutronix + * - Linux SPI Framework + * Copyright (C) 2005 David Brownell + * + */ + +#include +#include +#include +#include +#include + +#include + +/** + * I2C devices should normally not be created by I2C device drivers; + * that would make them board-specific. Similarly with I2C master + * drivers. Device registration normally goes into like + * arch/.../mach.../board-YYY.c with other readonly (flashable) + * information about mainboard devices. + */ +struct boardinfo { + struct list_head list; + unsigned int bus_num; + unsigned int n_board_info; + struct i2c_board_info board_info[0]; +}; + +static LIST_HEAD(board_list); + + +/** + * i2c_transfer - execute a single or combined I2C message + * @param adap Handle to I2C bus + * @param msgs One or more messages to execute before STOP is + * issued to terminate the operation; each + * message begins with a START. + * + * @param num Number of messages to be executed. + * + * Returns negative errno, else the number of messages executed. + * + * Note that there is no requirement that each message be sent to the + * same slave address, although that is the most common model. + */ +int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) +{ + uint64_t start; + int ret, try; + + /* + * REVISIT the fault reporting model here is weak: + * + * - When we get an error after receiving N bytes from a slave, + * there is no way to report "N". + * + * - When we get a NAK after transmitting N bytes to a slave, + * there is no way to report "N" ... or to let the master + * continue executing the rest of this combined message, if + * that's the appropriate response. + * + * - When for example "num" is two and we successfully complete + * the first message but get an error part way through the + * second, it's unclear whether that should be reported as + * one (discarding status on the second message) or errno + * (discarding status on the first one). + */ + + for (ret = 0; ret < num; ret++) { + dev_dbg(adap->dev, "master_xfer[%d] %c, addr=0x%02x, " + "len=%d\n", ret, (msgs[ret].flags & I2C_M_RD) + ? 'R' : 'W', msgs[ret].addr, msgs[ret].len); + } + + /* Retry automatically on arbitration loss */ + start = get_time_ns(); + for (ret = 0, try = 0; try <= 2; try++) { + ret = adap->master_xfer(adap, msgs, num); + if (ret != -EAGAIN) + break; + if (is_timeout(start, SECOND >> 1)) + break; + } + + return ret; +} +EXPORT_SYMBOL(i2c_transfer); + +/** + * i2c_master_send - issue a single I2C message in master transmit mode + * + * @param client Handle to slave device + * @param buf Data that will be written to the slave + * @param count How many bytes to write + * + * Returns negative errno, or else the number of bytes written. + */ +int i2c_master_send(struct i2c_client *client, const char *buf, int count) +{ + struct i2c_adapter *adap = client->adapter; + struct i2c_msg msg; + int ret; + + msg.addr = client->addr; + msg.len = count; + msg.buf = (char *)buf; + + ret = i2c_transfer(adap, &msg, 1); + + /* + * If everything went ok (i.e. 1 msg transmitted), return + * #bytes transmitted, else error code. + */ + return (ret == 1) ? count : ret; +} +EXPORT_SYMBOL(i2c_master_send); + +/** + * i2c_master_recv - issue a single I2C message in master receive mode + * + * @param client Handle to slave device + * @param buf Where to store data read from slave + * @param count How many bytes to read + * + * Returns negative errno, or else the number of bytes read. + */ +int i2c_master_recv(struct i2c_client *client, char *buf, int count) +{ + struct i2c_adapter *adap = client->adapter; + struct i2c_msg msg; + int ret; + + msg.addr = client->addr; + msg.flags = I2C_M_RD; + msg.len = count; + msg.buf = buf; + + ret = i2c_transfer(adap, &msg, 1); + + /* + * If everything went ok (i.e. 1 msg transmitted), return + * #bytes transmitted, else error code. + */ + return (ret == 1) ? count : ret; +} +EXPORT_SYMBOL(i2c_master_recv); + +int i2c_read_reg(struct i2c_client *client, u32 addr, u8 *buf, u16 count) +{ + u8 msgbuf[2]; + struct i2c_msg msg[] = { + { + .addr = client->addr, + .buf = msgbuf, + }, + { + .addr = client->addr, + .flags = I2C_M_RD, + .buf = buf, + .len = count, + }, + }; + int status, i; + + i = 0; + if (addr & I2C_ADDR_16_BIT) + msgbuf[i++] = addr >> 8; + msgbuf[i++] = addr; + msg->len = i; + + status = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); + dev_dbg(&client->dev, "%s: %zu@%d --> %d\n", __func__, + count, addr, status); + + if (status == ARRAY_SIZE(msg)) + return count; + else if (status >= 0) + return -EIO; + else + return status; +} +EXPORT_SYMBOL(i2c_read_reg); + +int i2c_write_reg(struct i2c_client *client, u32 addr, const u8 *buf, u16 count) +{ + u8 msgbuf[256]; /* FIXME */ + struct i2c_msg msg[] = { + { + .addr = client->addr, + .buf = msgbuf, + .len = count, + } + }; + int status, i; + + i = 0; + if (addr & I2C_ADDR_16_BIT) + msgbuf[i++] = addr >> 8; + msgbuf[i++] = addr; + msg->len += i; + + memcpy(msg->buf + i, buf, count); + + status = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); + dev_dbg(&client->dev, "%s: %u@%d --> %d\n", __func__, + count, addr, status); + + if (status == ARRAY_SIZE(msg)) + return count; + else if (status >= 0) + return -EIO; + else + return status; +} +EXPORT_SYMBOL(i2c_write_reg); + +/** + * i2c_new_device - instantiate one new I2C device + * + * @param adapter Controller to which device is connected + * @param chip Describes the I2C device + * + * On typical mainboards, this is purely internal; and it's not needed + * after board init creates the hard-wired devices. Some development + * platforms may not be able to use i2c_register_board_info though, + * and this is exported so that for example a USB or parport based + * adapter driver could add devices (which it would learn about + * out-of-band). + * + * Returns the new device, or NULL. + */ +struct i2c_client *i2c_new_device(struct i2c_adapter *adapter, + struct i2c_board_info *chip) +{ + struct i2c_client *client; + int status; + + client = xzalloc(sizeof *client); + strcpy(client->dev.name, chip->type); + client->dev.type_data = client; + client->adapter = adapter; + client->addr = chip->addr; + + status = register_device(&client->dev); + +#if 0 + /* drivers may modify this initial i/o setup */ + status = master->setup(client); + if (status < 0) { + printf("can't setup %s, status %d\n", + client->dev.name, status); + goto fail; + } +#endif + + return client; + +#if 0 + fail: + free(proxy); + return NULL; +#endif +} +EXPORT_SYMBOL(i2c_new_device); + +/** + * i2c_register_board_info - register I2C devices for a given board + * + * @param info array of chip descriptors + * @param n how many descriptors are provided + * + * Board-specific early init code calls this (probably during + * arch_initcall) with segments of the I2C device table. + * + * Other code can also call this, e.g. a particular add-on board might + * provide I2C devices through its expansion connector, so code + * initializing that board would naturally declare its I2C devices. + * + */ +int i2c_register_board_info(int bus_num, struct i2c_board_info const *info, unsigned n) +{ + struct boardinfo *bi; + + bi = xmalloc(sizeof(*bi) + n * sizeof(*info)); + + bi->n_board_info = n; + bi->bus_num = bus_num; + memcpy(bi->board_info, info, n * sizeof(*info)); + + list_add_tail(&bi->list, &board_list); + + return 0; +} + +static void scan_boardinfo(struct i2c_adapter *adapter) +{ + struct boardinfo *bi; + + list_for_each_entry(bi, &board_list, list) { + struct i2c_board_info *chip = bi->board_info; + unsigned n; + + if (bi->bus_num != adapter->nr) + continue; + + for (n = bi->n_board_info; n > 0; n--, chip++) { + debug("%s: bus_num: %d, chip->addr 0x%02x\n", __func__, bi->bus_num, chip->addr); + /* + * NOTE: this relies on i2c_new_device to + * issue diagnostics when given bogus inputs + */ + (void) i2c_new_device(adapter, chip); + } + } +} + +/** + * i2c_register_master - register I2C master controller + * + * @param master initialized master, originally from i2c_alloc_master() + * + * I2C master controllers connect to their drivers using some non-I2C + * bus, such as the platform bus. The final stage of probe() in that + * code includes calling i2c_register_master() to hook up to this I2C + * bus glue. + * + * I2C controllers use board specific (often SOC specific) bus + * numbers, and board-specific addressing for I2C devices combines + * those numbers with chip select numbers. Since I2C does not directly + * support dynamic device identification, boards need configuration + * tables telling which chip is at which address. + * + */ +int i2c_add_numbered_adapter(struct i2c_adapter *adapter) +{ + /* populate children from any i2c device tables */ + scan_boardinfo(adapter); + + return 0; +} +EXPORT_SYMBOL(i2c_register_master); diff --git a/drivers/i2c/mc13892.c b/drivers/i2c/mc13892.c new file mode 100644 index 0000000..54661d4 --- /dev/null +++ b/drivers/i2c/mc13892.c @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2007 Sascha Hauer, Pengutronix + * 2009 Marc Kleine-Budde + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + */ + +#include +#include +#include +#include +#include + +#include + +#include + +#define DRIVERNAME "mc13892" + +struct mc_priv { + struct cdev cdev; + struct i2c_client *client; +}; + +#define to_mc_priv(a) container_of(a, struct mc_priv, cdev) + +static struct mc_priv *mc_dev; + +struct i2c_client *mc13892_get_client(void) +{ + if (!mc_dev) + return NULL; + + return mc_dev->client; +} + +static u32 mc_read_reg(struct mc_priv *mc, int reg) +{ + u32 buf; + + i2c_read_reg(mc->client, reg, (u8 *)&buf, sizeof(buf)); + + return buf; +} + +static ssize_t mc_read(struct cdev *cdev, void *_buf, size_t count, ulong offset, ulong flags) +{ + struct mc_priv *priv = to_mc_priv(cdev); + int i = count >> 2; + u32 *buf = _buf; + + offset >>= 2; + + while (i) { + *buf = mc_read_reg(priv, offset); + buf++; + i--; + offset++; + } + + return count; +} + +static struct file_operations mc_fops = { + .lseek = dev_lseek_default, + .read = mc_read, +}; + +static int mc_probe(struct device_d *dev) +{ + if (mc_dev) + return -EBUSY; + + mc_dev = xzalloc(sizeof(struct mc_priv)); + mc_dev->cdev.name = DRIVERNAME; + mc_dev->client = to_i2c_client(dev); + mc_dev->cdev.size = 256; + mc_dev->cdev.dev = dev; + mc_dev->cdev.ops = &mc_fops; + + devfs_create(&mc_dev->cdev); + + return 0; +} + +static struct driver_d mc_driver = { + .name = DRIVERNAME, + .probe = mc_probe, +}; + +static int mc_init(void) +{ + register_driver(&mc_driver); + return 0; +} + +device_initcall(mc_init); diff --git a/drivers/i2c/mc9sdz60.c b/drivers/i2c/mc9sdz60.c new file mode 100644 index 0000000..4b1068d --- /dev/null +++ b/drivers/i2c/mc9sdz60.c @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2007 Sascha Hauer, Pengutronix + * 2009 Marc Kleine-Budde + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + */ + +#include +#include +#include +#include +#include + +#include + +#include + +#define DRIVERNAME "mc9sdz60" + +struct mc_priv { + struct cdev cdev; + struct i2c_client *client; +}; + +#define to_mc_priv(a) container_of(a, struct mc_priv, cdev) + +static struct mc_priv *mc_dev; + +struct i2c_client *mc9sdz60_get_client(void) +{ + if (!mc_dev) + return NULL; + + return mc_dev->client; +} + +static u32 mc_read_reg(struct mc_priv *mc, int reg) +{ + u8 buf; + + i2c_read_reg(mc->client, reg, &buf, sizeof(buf)); + + return buf; +} + +static ssize_t mc_read(struct cdev *cdev, void *_buf, size_t count, ulong offset, ulong flags) +{ + struct mc_priv *priv = to_mc_priv(cdev); + int i = count; + u8 *buf = _buf; + + while (i) { + *buf = mc_read_reg(priv, offset); + buf++; + i--; + offset++; + } + + return count; +} + +static struct file_operations mc_fops = { + .lseek = dev_lseek_default, + .read = mc_read, +}; + +static int mc_probe(struct device_d *dev) +{ + if (mc_dev) + return -EBUSY; + + mc_dev = xzalloc(sizeof(struct mc_priv)); + mc_dev->cdev.name = DRIVERNAME; + mc_dev->client = to_i2c_client(dev); + mc_dev->cdev.size = 256; + mc_dev->cdev.dev = dev; + mc_dev->cdev.ops = &mc_fops; + + devfs_create(&mc_dev->cdev); + + return 0; +} + +static struct driver_d mc_driver = { + .name = DRIVERNAME, + .probe = mc_probe, +}; + +static int mc_init(void) +{ + register_driver(&mc_driver); + return 0; +} + +device_initcall(mc_init); diff --git a/include/i2c/i2c.h b/include/i2c/i2c.h new file mode 100644 index 0000000..670898b --- /dev/null +++ b/include/i2c/i2c.h @@ -0,0 +1,124 @@ +/* + * i2c.h - definitions for the u-boot-v2 i2c framework + * + * Copyricht (C) 2009 by Marc Kleine-Budde + * + * This file is released under the GPLv2 + * + * Derived from: + * - i2c.h - i.MX I2C driver header file + * Copyright (c) 2008, Darius Augulis + * - i2c.h - definitions for the i2c-bus interface + * Copyright (C) 1995-2000 Simon G. Vogl + * + */ + +#ifndef I2C_I2C_H +#define I2C_I2C_H + +/* + * struct i2c_platform_data - structure of platform data for MXC I2C driver + * @param bitrate Bus speed measured in Hz + * + */ +struct i2c_platform_data { + int bitrate; +}; + +#define I2C_NAME_SIZE 20 + +#define I2C_M_RD 0x0001 /* read data, from slave to master */ + +/** + * struct i2c_msg - an I2C transaction segment beginning with START + * + * An i2c_msg is the low level representation of one segment of an I2C + * transaction. It is visible to drivers in the @i2c_transfer() + * procedure and to I2C adapter drivers through the + * @i2c_adapter.@master_xfer() method. + * + * All I2C adapters implement the standard rules for I2C transactions. + * Each transaction begins with a START. That is followed by the + * slave address, and a bit encoding read versus write. Then follow + * all the data bytes, The transfer terminates with a NAK, or when all + * those bytes have been transferred and ACKed. If this is the last + * message in a group, it is followed by a STOP. Otherwise it is + * followed by the next @i2c_msg transaction segment, beginning with a + * (repeated) START. + * + */ +struct i2c_msg { + __u8 *buf; /**< The buffer into which data is read, or from which it's written. */ + __u16 addr; /**< Slave address, seven bits */ + __u16 flags; /**< I2C_M_RD is handled by all adapters */ + __u16 len; /**< Number of data bytes in @buf being read from or written to the I2C slave address. */ +}; + + +/** + * i2c_adapter is the structure used to identify a physical i2c bus + * along with the access algorithms necessary to access it. + * + */ +struct i2c_adapter { + struct device_d *dev; /* ptr to device */ + int nr; /* bus number */ + int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num); +}; + + +struct i2c_client { + struct device_d dev; + struct i2c_adapter *adapter; + unsigned short addr; +}; + +#define to_i2c_client(a) container_of(a, struct i2c_client, dev) + + +/** + * struct i2c_board_info - template for device creation + * + * I2C doesn't actually support hardware probing, Drivers commonly + * need more information than that, such as chip type, configuration, + * and so on. + * + * i2c_board_info is used to build tables of information listing I2C + * devices that are present. This information is used to grow the + * driver model tree. For mainboards this is done statically using + * i2c_register_board_info(); bus numbers identify adapters that + * aren't yet available. For add-on boards, i2c_new_device() does this + * dynamically with the adapter already known. + */ +struct i2c_board_info { + char type[I2C_NAME_SIZE]; /**< name of device */ + unsigned short addr; /**< stored in i2c_client.addr */ +}; + +/** + * I2C_BOARD_INFO - macro used to list an i2c device and its address + * @dev_type: identifies the device type + * @dev_addr: the device's address on the bus. + * + * This macro initializes essential fields of a struct i2c_board_info, + * declaring what has been provided on a particular board. Optional + * fields (such as associated irq, or device-specific platform_data) + * are provided using conventional syntax. + */ +#define I2C_BOARD_INFO(dev_type, dev_addr) \ + .type = dev_type, .addr = (dev_addr) + +extern int i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned n); +extern int i2c_add_numbered_adapter(struct i2c_adapter *adapter); + +extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num); +extern int i2c_master_send(struct i2c_client *client, const char *buf, int count); +extern int i2c_master_recv(struct i2c_client *client, char *buf, int count); + + +#define I2C_ADDR_16_BIT (1 << 31) + +extern int i2c_read_reg(struct i2c_client *client, u32 addr, u8 *buf, u16 count); +extern int i2c_write_reg(struct i2c_client *client, u32 addr, const u8 *buf, u16 count); + +#endif /* I2C_I2C_H */ diff --git a/include/i2c/mc13892.h b/include/i2c/mc13892.h new file mode 100644 index 0000000..2f44f6c --- /dev/null +++ b/include/i2c/mc13892.h @@ -0,0 +1,7 @@ +#ifndef __ASM_ARCH_MC13892_H +#define __ASM_ARCH_MC13892_H + +extern struct i2c_client *mc13892_get_client(void); + +#endif /* __ASM_ARCH_MC13892_H */ + diff --git a/include/i2c/mc9sdz60.h b/include/i2c/mc9sdz60.h new file mode 100644 index 0000000..04cfca0 --- /dev/null +++ b/include/i2c/mc9sdz60.h @@ -0,0 +1,7 @@ +#ifndef __ASM_ARCH_MC9SDZ60_H +#define __ASM_ARCH_MC9SDZ60_H + +extern struct i2c_client *mc9sdz60_get_client(void); + +#endif /* __ASM_ARCH_MC9SDZ60_H */ +