source: trunk/target/linux/lantiq/patches-3.0/120-falcon-i2c.patch @ 28308

Last change on this file since 28308 was 28308, checked in by blogic, 5 years ago

[lantiq]

  • rebase 3.0 patches
  • fold some fixes into existing patches
File size: 20.6 KB
  • drivers/i2c/busses/Makefile

    a b obj-$(CONFIG_I2C_SIBYTE) += i2c-sibyte.o 
    8282obj-$(CONFIG_I2C_STUB)          += i2c-stub.o 
    8383obj-$(CONFIG_SCx200_ACB)        += scx200_acb.o 
    8484obj-$(CONFIG_SCx200_I2C)        += scx200_i2c.o 
     85obj-$(CONFIG_I2C_FALCON)        += i2c-falcon.o 
    8586 
    8687ccflags-$(CONFIG_I2C_DEBUG_BUS) := -DDEBUG 
  • drivers/i2c/busses/Kconfig

    a b config I2C_POWERMAC 
    284284 
    285285comment "I2C system bus drivers (mostly embedded / system-on-chip)" 
    286286 
     287config I2C_FALCON 
     288        tristate "Falcon I2C interface" 
     289#       depends on SOC_FALCON 
     290 
    287291config I2C_AT91 
    288292        tristate "Atmel AT91 I2C Two-Wire interface (TWI)" 
    289293        depends on ARCH_AT91 && EXPERIMENTAL && BROKEN 
  • new file drivers/i2c/busses/i2c-falcon.c

    - +  
     1/* 
     2 * Lantiq FALC(tm) ON - I2C bus adapter 
     3 * 
     4 * Parts based on i2c-designware.c and other i2c drivers from Linux 2.6.33 
     5 * 
     6 * This program is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU General Public License as published by 
     8 * the Free Software Foundation; either version 2 of the License, or 
     9 * (at your option) any later version. 
     10 * 
     11 * This program is distributed in the hope that it will be useful, 
     12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     14 * GNU General Public License for more details. 
     15 * 
     16 * You should have received a copy of the GNU General Public License 
     17 * along with this program; if not, write to the Free Software 
     18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
     19 */ 
     20 
     21/* #define DEBUG */ 
     22 
     23#include <linux/kernel.h> 
     24#include <linux/module.h> 
     25#include <linux/delay.h> 
     26#include <linux/slab.h> /* for kzalloc, kfree */ 
     27#include <linux/i2c.h> 
     28#include <linux/clk.h> 
     29#include <linux/errno.h> 
     30#include <linux/sched.h> 
     31#include <linux/err.h> 
     32#include <linux/interrupt.h> 
     33#include <linux/platform_device.h> 
     34#include <linux/io.h> 
     35#include <linux/gpio.h> 
     36 
     37#include <falcon/lantiq_soc.h> 
     38 
     39/* CURRENT ISSUES: 
     40 * - no high speed support 
     41 * - supports only master mode 
     42 * - ten bit mode is not tested (no slave devices) 
     43 */ 
     44 
     45/* mapping for access macros */ 
     46#define reg_r32(reg)            __raw_readl(reg) 
     47#define reg_w32(val, reg)       __raw_writel(val, reg) 
     48#define reg_w32_mask(clear, set, reg)   \ 
     49                                reg_w32((reg_r32(reg) & ~(clear)) | (set), reg) 
     50#define reg_r32_table(reg, idx) reg_r32(&((uint32_t *)&reg)[idx]) 
     51#define reg_w32_table(val, reg, idx) reg_w32(val, &((uint32_t *)&reg)[idx]) 
     52#define i2c     (priv->membase) 
     53#include <falcon/i2c_reg.h> 
     54 
     55#define DRV_NAME "i2c-falcon" 
     56#define DRV_VERSION "1.01" 
     57 
     58#define FALCON_I2C_BUSY_TIMEOUT         20 /* ms */ 
     59 
     60#ifdef DEBUG 
     61#define FALCON_I2C_XFER_TIMEOUT         25*HZ 
     62#else 
     63#define FALCON_I2C_XFER_TIMEOUT         HZ 
     64#endif 
     65#if defined(DEBUG) && 0 
     66#define PRINTK(arg...) printk(arg) 
     67#else 
     68#define PRINTK(arg...) do {} while (0) 
     69#endif 
     70 
     71#define FALCON_I2C_IMSC_DEFAULT_MASK    (I2C_IMSC_I2C_P_INT_EN | \ 
     72                                         I2C_IMSC_I2C_ERR_INT_EN) 
     73 
     74#define FALCON_I2C_ARB_LOST     (1 << 0) 
     75#define FALCON_I2C_NACK         (1 << 1) 
     76#define FALCON_I2C_RX_UFL       (1 << 2) 
     77#define FALCON_I2C_RX_OFL       (1 << 3) 
     78#define FALCON_I2C_TX_UFL       (1 << 4) 
     79#define FALCON_I2C_TX_OFL       (1 << 5) 
     80 
     81struct falcon_i2c { 
     82        struct mutex mutex; 
     83 
     84        enum { 
     85                FALCON_I2C_MODE_100     = 1, 
     86                FALCON_I2C_MODE_400     = 2, 
     87                FALCON_I2C_MODE_3400    = 3 
     88        } mode;                         /* current speed mode */ 
     89 
     90        struct clk *clk;                /* clock input for i2c hardware block */ 
     91        struct gpon_reg_i2c __iomem *membase;   /* base of mapped registers */ 
     92        int irq_lb, irq_b, irq_err, irq_p;      /* last burst, burst, error, 
     93                                                   protocol IRQs */ 
     94 
     95        struct i2c_adapter adap; 
     96        struct device *dev; 
     97 
     98        struct completion       cmd_complete; 
     99 
     100        /* message transfer data */ 
     101        /* current message */ 
     102        struct i2c_msg          *current_msg; 
     103        /* number of messages to handle */ 
     104        int                     msgs_num; 
     105        /* current buffer */ 
     106        u8                      *msg_buf; 
     107        /* remaining length of current buffer */ 
     108        u32                     msg_buf_len; 
     109        /* error status of the current transfer */ 
     110        int                     msg_err; 
     111 
     112        /* master status codes */ 
     113        enum { 
     114                STATUS_IDLE, 
     115                STATUS_ADDR,    /* address phase */ 
     116                STATUS_WRITE, 
     117                STATUS_READ, 
     118                STATUS_READ_END, 
     119                STATUS_STOP 
     120        } status; 
     121}; 
     122 
     123static irqreturn_t falcon_i2c_isr(int irq, void *dev_id); 
     124 
     125static inline void enable_burst_irq(struct falcon_i2c *priv) 
     126{ 
     127        i2c_w32_mask(0, I2C_IMSC_LBREQ_INT_EN | I2C_IMSC_BREQ_INT_EN, imsc); 
     128} 
     129static inline void disable_burst_irq(struct falcon_i2c *priv) 
     130{ 
     131        i2c_w32_mask(I2C_IMSC_LBREQ_INT_EN | I2C_IMSC_BREQ_INT_EN, 0, imsc); 
     132} 
     133 
     134static void prepare_msg_send_addr(struct falcon_i2c *priv) 
     135{ 
     136        struct i2c_msg *msg = priv->current_msg; 
     137        int rd = !!(msg->flags & I2C_M_RD);     /* extends to 0 or 1 */ 
     138        u16 addr = msg->addr; 
     139 
     140        /* new i2c_msg */ 
     141        priv->msg_buf = msg->buf; 
     142        priv->msg_buf_len = msg->len; 
     143        if (rd) 
     144                priv->status = STATUS_READ; 
     145        else 
     146                priv->status = STATUS_WRITE; 
     147 
     148        /* send slave address */ 
     149        if (msg->flags & I2C_M_TEN) { 
     150                i2c_w32(0xf0 | ((addr & 0x300) >> 7) | rd, txd); 
     151                i2c_w32(addr & 0xff, txd); 
     152        } else 
     153                i2c_w32((addr & 0x7f) << 1 | rd, txd); 
     154} 
     155 
     156static void set_tx_len(struct falcon_i2c *priv) 
     157{ 
     158        struct i2c_msg *msg = priv->current_msg; 
     159        int len = (msg->flags & I2C_M_TEN) ? 2 : 1; 
     160 
     161        PRINTK("set_tx_len %cX\n", (msg->flags & I2C_M_RD)?'R':'T'); 
     162 
     163        priv->status = STATUS_ADDR; 
     164 
     165        if (!(msg->flags & I2C_M_RD)) { 
     166                len += msg->len; 
     167        } else { 
     168                /* set maximum received packet size (before rx int!) */ 
     169                i2c_w32(msg->len, mrps_ctrl); 
     170        } 
     171        i2c_w32(len, tps_ctrl); 
     172        enable_burst_irq(priv); 
     173} 
     174 
     175static int falcon_i2c_hw_init(struct i2c_adapter *adap) 
     176{ 
     177        struct falcon_i2c *priv = i2c_get_adapdata(adap); 
     178 
     179        /* disable bus */ 
     180        i2c_w32_mask(I2C_RUN_CTRL_RUN_EN, 0, run_ctrl); 
     181 
     182#ifndef DEBUG 
     183        /* set normal operation clock divider */ 
     184        i2c_w32(1 << I2C_CLC_RMC_OFFSET, clc); 
     185#else 
     186        /* for debugging a higher divider value! */ 
     187        i2c_w32(0xF0 << I2C_CLC_RMC_OFFSET, clc); 
     188#endif 
     189 
     190        /* set frequency */ 
     191        if (priv->mode == FALCON_I2C_MODE_100) { 
     192                dev_dbg(priv->dev, "set standard mode (100 kHz)\n"); 
     193                i2c_w32(0, fdiv_high_cfg); 
     194                i2c_w32((1 << I2C_FDIV_CFG_INC_OFFSET) | 
     195                        (499 << I2C_FDIV_CFG_DEC_OFFSET), 
     196                        fdiv_cfg); 
     197        } else if (priv->mode == FALCON_I2C_MODE_400) { 
     198                dev_dbg(priv->dev, "set fast mode (400 kHz)\n"); 
     199                i2c_w32(0, fdiv_high_cfg); 
     200                i2c_w32((1 << I2C_FDIV_CFG_INC_OFFSET) | 
     201                        (124 << I2C_FDIV_CFG_DEC_OFFSET), 
     202                        fdiv_cfg); 
     203        } else if (priv->mode == FALCON_I2C_MODE_3400) { 
     204                dev_dbg(priv->dev, "set high mode (3.4 MHz)\n"); 
     205                i2c_w32(0, fdiv_cfg); 
     206                /* TODO recalculate value for 100MHz input */ 
     207                i2c_w32((41 << I2C_FDIV_HIGH_CFG_INC_OFFSET) | 
     208                        (152 << I2C_FDIV_HIGH_CFG_DEC_OFFSET), 
     209                        fdiv_high_cfg); 
     210        } else { 
     211                dev_warn(priv->dev, "unknown mode\n"); 
     212                return -ENODEV; 
     213        } 
     214 
     215        /* configure fifo */ 
     216        i2c_w32(I2C_FIFO_CFG_TXFC | /* tx fifo as flow controller */ 
     217                I2C_FIFO_CFG_RXFC | /* rx fifo as flow controller */ 
     218                I2C_FIFO_CFG_TXFA_TXFA2 | /* tx fifo 4-byte aligned */ 
     219                I2C_FIFO_CFG_RXFA_RXFA2 | /* rx fifo 4-byte aligned */ 
     220                I2C_FIFO_CFG_TXBS_TXBS0 | /* tx fifo burst size is 1 word */ 
     221                I2C_FIFO_CFG_RXBS_RXBS0,  /* rx fifo burst size is 1 word */ 
     222                fifo_cfg); 
     223 
     224        /* configure address */ 
     225        i2c_w32(I2C_ADDR_CFG_SOPE_EN |  /* generate stop when no more data in the 
     226                                           fifo */ 
     227                I2C_ADDR_CFG_SONA_EN |  /* generate stop when NA received */ 
     228                I2C_ADDR_CFG_MnS_EN |   /* we are master device */ 
     229                0,                      /* our slave address (not used!) */ 
     230                addr_cfg); 
     231 
     232        /* enable bus */ 
     233        i2c_w32_mask(0, I2C_RUN_CTRL_RUN_EN, run_ctrl); 
     234 
     235        return 0; 
     236} 
     237 
     238static int falcon_i2c_wait_bus_not_busy(struct falcon_i2c *priv) 
     239{ 
     240        int timeout = FALCON_I2C_BUSY_TIMEOUT; 
     241 
     242        while ((i2c_r32(bus_stat) & I2C_BUS_STAT_BS_MASK) 
     243                                 != I2C_BUS_STAT_BS_FREE) { 
     244                if (timeout <= 0) { 
     245                        dev_warn(priv->dev, "timeout waiting for bus ready\n"); 
     246                        return -ETIMEDOUT; 
     247                } 
     248                timeout--; 
     249                mdelay(1); 
     250        } 
     251 
     252        return 0; 
     253} 
     254 
     255static void falcon_i2c_tx(struct falcon_i2c *priv, int last) 
     256{ 
     257        if (priv->msg_buf_len && priv->msg_buf) { 
     258                i2c_w32(*priv->msg_buf, txd); 
     259 
     260                if (--priv->msg_buf_len) 
     261                        priv->msg_buf++; 
     262                else 
     263                        priv->msg_buf = NULL; 
     264        } else 
     265                last = 1; 
     266 
     267        if (last) { 
     268                disable_burst_irq(priv); 
     269        } 
     270} 
     271 
     272static void falcon_i2c_rx(struct falcon_i2c *priv, int last) 
     273{ 
     274        u32 fifo_stat,timeout; 
     275        if (priv->msg_buf_len && priv->msg_buf) { 
     276                timeout = 5000000; 
     277                do { 
     278                        fifo_stat = i2c_r32(ffs_stat); 
     279                } while (!fifo_stat && --timeout); 
     280                if (!timeout) { 
     281                        last = 1; 
     282                        PRINTK("\nrx timeout\n"); 
     283                        goto err; 
     284                } 
     285                while (fifo_stat) { 
     286                        *priv->msg_buf = i2c_r32(rxd); 
     287                        if (--priv->msg_buf_len) 
     288                                priv->msg_buf++; 
     289                        else { 
     290                                priv->msg_buf = NULL; 
     291                                last = 1; 
     292                                break; 
     293                        } 
     294                        #if 0 
     295                        fifo_stat = i2c_r32(ffs_stat); 
     296                        #else 
     297                        /* do not read more than burst size, otherwise no "last 
     298                        burst" is generated and the transaction is blocked! */ 
     299                        fifo_stat = 0; 
     300                        #endif 
     301                } 
     302        } else { 
     303                last = 1; 
     304        } 
     305err: 
     306        if (last) { 
     307                disable_burst_irq(priv); 
     308 
     309                if (priv->status == STATUS_READ_END) { 
     310                        /* do the STATUS_STOP and complete() here, as sometimes 
     311                           the tx_end is already seen before this is finished */ 
     312                        priv->status = STATUS_STOP; 
     313                        complete(&priv->cmd_complete); 
     314                } else { 
     315                        i2c_w32(I2C_ENDD_CTRL_SETEND, endd_ctrl); 
     316                        priv->status = STATUS_READ_END; 
     317                } 
     318        } 
     319} 
     320 
     321static void falcon_i2c_xfer_init(struct falcon_i2c *priv) 
     322{ 
     323        /* enable interrupts */ 
     324        i2c_w32(FALCON_I2C_IMSC_DEFAULT_MASK, imsc); 
     325 
     326        /* trigger transfer of first msg */ 
     327        set_tx_len(priv); 
     328} 
     329 
     330static void dump_msgs(struct i2c_msg msgs[], int num, int rx) 
     331{ 
     332#if defined(DEBUG) 
     333        int i, j; 
     334        printk("Messages %d %s\n", num, rx ? "out" : "in"); 
     335        for (i = 0; i < num; i++) { 
     336                printk("%2d %cX Msg(%d) addr=0x%X: ", i, 
     337                        (msgs[i].flags & I2C_M_RD)?'R':'T', 
     338                        msgs[i].len, msgs[i].addr); 
     339                if (!(msgs[i].flags & I2C_M_RD) || rx) { 
     340                        for (j = 0; j < msgs[i].len; j++) 
     341                                printk("%02X ", msgs[i].buf[j]); 
     342                } 
     343                printk("\n"); 
     344        } 
     345#endif 
     346} 
     347 
     348static void falcon_i2c_release_bus(struct falcon_i2c *priv) 
     349{ 
     350        if ((i2c_r32(bus_stat) & I2C_BUS_STAT_BS_MASK) == I2C_BUS_STAT_BS_BM) 
     351                i2c_w32(I2C_ENDD_CTRL_SETEND, endd_ctrl); 
     352} 
     353 
     354static int falcon_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], 
     355                           int num) 
     356{ 
     357        struct falcon_i2c *priv = i2c_get_adapdata(adap); 
     358        int ret; 
     359 
     360        dev_dbg(priv->dev, "xfer %u messages\n", num); 
     361        dump_msgs(msgs, num, 0); 
     362 
     363        mutex_lock(&priv->mutex); 
     364 
     365        INIT_COMPLETION(priv->cmd_complete); 
     366        priv->current_msg = msgs; 
     367        priv->msgs_num = num; 
     368        priv->msg_err = 0; 
     369        priv->status = STATUS_IDLE; 
     370 
     371        /* wait for the bus to become ready */ 
     372        ret = falcon_i2c_wait_bus_not_busy(priv); 
     373        if (ret) 
     374                goto done; 
     375 
     376        while (priv->msgs_num) { 
     377                /* start the transfers */ 
     378                falcon_i2c_xfer_init(priv); 
     379 
     380                /* wait for transfers to complete */ 
     381                ret = wait_for_completion_interruptible_timeout( 
     382                        &priv->cmd_complete, FALCON_I2C_XFER_TIMEOUT); 
     383                if (ret == 0) { 
     384                        dev_err(priv->dev, "controller timed out\n"); 
     385                        falcon_i2c_hw_init(adap); 
     386                        ret = -ETIMEDOUT; 
     387                        goto done; 
     388                } else if (ret < 0) 
     389                        goto done; 
     390 
     391                if (priv->msg_err) { 
     392                        if (priv->msg_err & FALCON_I2C_NACK) 
     393                                ret = -ENXIO; 
     394                        else 
     395                                ret = -EREMOTEIO; 
     396                        goto done; 
     397                } 
     398                if (--priv->msgs_num) { 
     399                        priv->current_msg++; 
     400                } 
     401        } 
     402        /* no error? */ 
     403        ret = num; 
     404 
     405done: 
     406        falcon_i2c_release_bus(priv); 
     407 
     408        mutex_unlock(&priv->mutex); 
     409 
     410        if (ret>=0) 
     411                dump_msgs(msgs, num, 1); 
     412 
     413        PRINTK("XFER ret %d\n", ret); 
     414        return ret; 
     415} 
     416 
     417static irqreturn_t falcon_i2c_isr_burst(int irq, void *dev_id) 
     418{ 
     419        struct falcon_i2c *priv = dev_id; 
     420        struct i2c_msg *msg = priv->current_msg; 
     421        int last = (irq == priv->irq_lb); 
     422 
     423        if (last) 
     424                PRINTK("LB "); 
     425        else 
     426                PRINTK("B "); 
     427 
     428        if (msg->flags & I2C_M_RD) { 
     429                switch (priv->status) { 
     430                case STATUS_ADDR: 
     431                        PRINTK("X"); 
     432                        prepare_msg_send_addr(priv); 
     433                        disable_burst_irq(priv); 
     434                        break; 
     435                case STATUS_READ: 
     436                case STATUS_READ_END: 
     437                        PRINTK("R"); 
     438                        falcon_i2c_rx(priv, last); 
     439                        break; 
     440                default: 
     441                        disable_burst_irq(priv); 
     442                        printk("Status R %d\n", priv->status); 
     443                        break; 
     444                } 
     445        } else { 
     446                switch (priv->status) { 
     447                case STATUS_ADDR: 
     448                        PRINTK("x"); 
     449                        prepare_msg_send_addr(priv); 
     450                        break; 
     451                case STATUS_WRITE: 
     452                        PRINTK("w"); 
     453                        falcon_i2c_tx(priv, last); 
     454                        break; 
     455                default: 
     456                        disable_burst_irq(priv); 
     457                        printk("Status W %d\n", priv->status); 
     458                        break; 
     459                } 
     460        } 
     461 
     462        i2c_w32(I2C_ICR_BREQ_INT_CLR | I2C_ICR_LBREQ_INT_CLR, icr); 
     463        return IRQ_HANDLED; 
     464} 
     465 
     466static void falcon_i2c_isr_prot(struct falcon_i2c *priv) 
     467{ 
     468        u32 i_pro = i2c_r32(p_irqss); 
     469 
     470        PRINTK("i2c-p"); 
     471 
     472        /* not acknowledge */ 
     473        if (i_pro & I2C_P_IRQSS_NACK) { 
     474                priv->msg_err |= FALCON_I2C_NACK; 
     475                PRINTK(" nack"); 
     476        } 
     477 
     478        /* arbitration lost */ 
     479        if (i_pro & I2C_P_IRQSS_AL) { 
     480                priv->msg_err |= FALCON_I2C_ARB_LOST; 
     481                PRINTK(" arb-lost"); 
     482        } 
     483        /* tx -> rx switch */ 
     484        if (i_pro & I2C_P_IRQSS_RX) 
     485                PRINTK(" rx"); 
     486 
     487        /* tx end */ 
     488        if (i_pro & I2C_P_IRQSS_TX_END) 
     489                PRINTK(" txend"); 
     490        PRINTK("\n"); 
     491 
     492        if (!priv->msg_err) { 
     493                /* tx -> rx switch */ 
     494                if (i_pro & I2C_P_IRQSS_RX) { 
     495                        priv->status = STATUS_READ; 
     496                        enable_burst_irq(priv); 
     497                } 
     498                if (i_pro & I2C_P_IRQSS_TX_END) { 
     499                        if (priv->status == STATUS_READ) 
     500                                priv->status = STATUS_READ_END; 
     501                        else { 
     502                                disable_burst_irq(priv); 
     503                                priv->status = STATUS_STOP; 
     504                        } 
     505                } 
     506        } 
     507 
     508        i2c_w32(i_pro, p_irqsc); 
     509} 
     510 
     511static irqreturn_t falcon_i2c_isr(int irq, void *dev_id) 
     512{ 
     513        u32 i_raw, i_err=0; 
     514        struct falcon_i2c *priv = dev_id; 
     515 
     516        i_raw = i2c_r32(mis); 
     517        PRINTK("i_raw 0x%08X\n", i_raw); 
     518 
     519        /* error interrupt */ 
     520        if (i_raw & I2C_RIS_I2C_ERR_INT_INTOCC) { 
     521                i_err = i2c_r32(err_irqss); 
     522                PRINTK("i_err 0x%08X bus_stat 0x%04X\n", 
     523                        i_err, i2c_r32(bus_stat)); 
     524 
     525                /* tx fifo overflow (8) */ 
     526                if (i_err & I2C_ERR_IRQSS_TXF_OFL) 
     527                        priv->msg_err |= FALCON_I2C_TX_OFL; 
     528 
     529                /* tx fifo underflow (4) */ 
     530                if (i_err & I2C_ERR_IRQSS_TXF_UFL) 
     531                        priv->msg_err |= FALCON_I2C_TX_UFL; 
     532 
     533                /* rx fifo overflow (2) */ 
     534                if (i_err & I2C_ERR_IRQSS_RXF_OFL) 
     535                        priv->msg_err |= FALCON_I2C_RX_OFL; 
     536 
     537                /* rx fifo underflow (1) */ 
     538                if (i_err & I2C_ERR_IRQSS_RXF_UFL) 
     539                        priv->msg_err |= FALCON_I2C_RX_UFL; 
     540 
     541                i2c_w32(i_err, err_irqsc); 
     542        } 
     543 
     544        /* protocol interrupt */ 
     545        if (i_raw & I2C_RIS_I2C_P_INT_INTOCC) 
     546                falcon_i2c_isr_prot(priv); 
     547 
     548        if ((priv->msg_err) || (priv->status == STATUS_STOP)) 
     549                complete(&priv->cmd_complete); 
     550 
     551        return IRQ_HANDLED; 
     552} 
     553 
     554static u32 falcon_i2c_functionality(struct i2c_adapter *adap) 
     555{ 
     556        return  I2C_FUNC_I2C | 
     557                I2C_FUNC_10BIT_ADDR | 
     558                I2C_FUNC_SMBUS_EMUL; 
     559} 
     560 
     561static struct i2c_algorithm falcon_i2c_algorithm = { 
     562        .master_xfer    = falcon_i2c_xfer, 
     563        .functionality  = falcon_i2c_functionality, 
     564}; 
     565 
     566static int __devinit falcon_i2c_probe(struct platform_device *pdev) 
     567{ 
     568        int ret = 0; 
     569        struct falcon_i2c *priv; 
     570        struct i2c_adapter *adap; 
     571        struct resource *mmres, *ioarea, 
     572                        *irqres_lb, *irqres_b, *irqres_err, *irqres_p; 
     573        struct clk *clk; 
     574 
     575        dev_dbg(&pdev->dev, "probing\n"); 
     576 
     577        mmres = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     578        irqres_lb = platform_get_resource_byname(pdev, IORESOURCE_IRQ, 
     579                                                 "i2c_lb"); 
     580        irqres_b = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "i2c_b"); 
     581        irqres_err = platform_get_resource_byname(pdev, IORESOURCE_IRQ, 
     582                                                  "i2c_err"); 
     583        irqres_p = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "i2c_p"); 
     584 
     585        if (!mmres || !irqres_lb || !irqres_b || !irqres_err || !irqres_p) { 
     586                dev_err(&pdev->dev, "no resources\n"); 
     587                return -ENODEV; 
     588        } 
     589 
     590        clk = clk_get(&pdev->dev, "fpi"); 
     591        if (IS_ERR(clk)) { 
     592                dev_err(&pdev->dev, "failed to get fpi clk\n"); 
     593                return -ENOENT; 
     594        } 
     595 
     596        if (clk_get_rate(clk) != 100000000) { 
     597                dev_err(&pdev->dev, "input clock is not 100MHz\n"); 
     598                return -ENOENT; 
     599        } 
     600 
     601        /* allocate private data */ 
     602        priv = kzalloc(sizeof(*priv), GFP_KERNEL); 
     603        if (!priv) { 
     604                dev_err(&pdev->dev, "can't allocate private data\n"); 
     605                return -ENOMEM; 
     606        } 
     607 
     608        adap = &priv->adap; 
     609        i2c_set_adapdata(adap, priv); 
     610        adap->owner = THIS_MODULE; 
     611        adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 
     612        strlcpy(adap->name, DRV_NAME "-adapter", sizeof(adap->name)); 
     613        adap->algo = &falcon_i2c_algorithm; 
     614 
     615        priv->mode = FALCON_I2C_MODE_100; 
     616        priv->clk = clk; 
     617        priv->dev = &pdev->dev; 
     618 
     619        init_completion(&priv->cmd_complete); 
     620        mutex_init(&priv->mutex); 
     621 
     622        ret = ltq_gpio_request(107, 0, 0, 0, DRV_NAME":sda"); 
     623        if (ret) { 
     624                dev_err(&pdev->dev, "I2C gpio 107 (sda) not available\n"); 
     625                ret = -ENXIO; 
     626                goto err_free_priv; 
     627        } 
     628        ret = ltq_gpio_request(108, 0, 0, 0, DRV_NAME":scl"); 
     629        if (ret) { 
     630                gpio_free(107); 
     631                dev_err(&pdev->dev, "I2C gpio 108 (scl) not available\n"); 
     632                ret = -ENXIO; 
     633                goto err_free_priv; 
     634        } 
     635 
     636        ioarea = request_mem_region(mmres->start, resource_size(mmres), 
     637                                         pdev->name); 
     638 
     639        if (ioarea == NULL) { 
     640                dev_err(&pdev->dev, "I2C region already claimed\n"); 
     641                ret = -ENXIO; 
     642                goto err_free_gpio; 
     643        } 
     644 
     645        /* map memory */ 
     646        priv->membase = ioremap_nocache(mmres->start & ~KSEG1, 
     647                resource_size(mmres)); 
     648        if (priv->membase == NULL) { 
     649                ret = -ENOMEM; 
     650                goto err_release_region; 
     651        } 
     652 
     653        priv->irq_lb = irqres_lb->start; 
     654        ret = request_irq(priv->irq_lb, falcon_i2c_isr_burst, IRQF_DISABLED, 
     655                          irqres_lb->name, priv); 
     656        if (ret) { 
     657                dev_err(&pdev->dev, "can't get last burst IRQ %d\n", irqres_lb->start); 
     658                ret = -ENODEV; 
     659                goto err_unmap_mem; 
     660        } 
     661 
     662        priv->irq_b = irqres_b->start; 
     663        ret = request_irq(priv->irq_b, falcon_i2c_isr_burst, IRQF_DISABLED, 
     664                          irqres_b->name, priv); 
     665        if (ret) { 
     666                dev_err(&pdev->dev, "can't get burst IRQ %d\n", irqres_b->start); 
     667                ret = -ENODEV; 
     668                goto err_free_lb_irq; 
     669        } 
     670 
     671        priv->irq_err = irqres_err->start; 
     672        ret = request_irq(priv->irq_err, falcon_i2c_isr, IRQF_DISABLED, 
     673                          irqres_err->name, priv); 
     674        if (ret) { 
     675                dev_err(&pdev->dev, "can't get error IRQ %d\n", irqres_err->start); 
     676                ret = -ENODEV; 
     677                goto err_free_b_irq; 
     678        } 
     679 
     680        priv->irq_p = irqres_p->start; 
     681        ret = request_irq(priv->irq_p, falcon_i2c_isr, IRQF_DISABLED, 
     682                          irqres_p->name, priv); 
     683        if (ret) { 
     684                dev_err(&pdev->dev, "can't get protocol IRQ %d\n", irqres_p->start); 
     685                ret = -ENODEV; 
     686                goto err_free_err_irq; 
     687        } 
     688 
     689        dev_dbg(&pdev->dev, "mapped io-space to %p\n", priv->membase); 
     690        dev_dbg(&pdev->dev, "use IRQs %d, %d, %d, %d\n", irqres_lb->start, 
     691            irqres_b->start, irqres_err->start, irqres_p->start); 
     692 
     693        /* add our adapter to the i2c stack */ 
     694        ret = i2c_add_numbered_adapter(adap); 
     695        if (ret) { 
     696                dev_err(&pdev->dev, "can't register I2C adapter\n"); 
     697                goto err_free_p_irq; 
     698        } 
     699 
     700        platform_set_drvdata(pdev, priv); 
     701        i2c_set_adapdata(adap, priv); 
     702 
     703        /* print module version information */ 
     704        dev_dbg(&pdev->dev, "module id=%u revision=%u\n", 
     705                (i2c_r32(id) & I2C_ID_ID_MASK) >> I2C_ID_ID_OFFSET, 
     706                (i2c_r32(id) & I2C_ID_REV_MASK) >> I2C_ID_REV_OFFSET); 
     707 
     708        /* initialize HW */ 
     709        ret = falcon_i2c_hw_init(adap); 
     710        if (ret) { 
     711                dev_err(&pdev->dev, "can't configure adapter\n"); 
     712                goto err_remove_adapter; 
     713        } 
     714 
     715        dev_info(&pdev->dev, "version %s\n", DRV_VERSION); 
     716 
     717        return 0; 
     718 
     719err_remove_adapter: 
     720        i2c_del_adapter(adap); 
     721        platform_set_drvdata(pdev, NULL); 
     722 
     723err_free_p_irq: 
     724        free_irq(priv->irq_p, priv); 
     725 
     726err_free_err_irq: 
     727        free_irq(priv->irq_err, priv); 
     728 
     729err_free_b_irq: 
     730        free_irq(priv->irq_b, priv); 
     731 
     732err_free_lb_irq: 
     733        free_irq(priv->irq_lb, priv); 
     734 
     735err_unmap_mem: 
     736        iounmap(priv->membase); 
     737 
     738err_release_region: 
     739        release_mem_region(mmres->start, resource_size(mmres)); 
     740 
     741err_free_gpio: 
     742        gpio_free(108); 
     743        gpio_free(107); 
     744 
     745err_free_priv: 
     746        kfree(priv); 
     747 
     748        return ret; 
     749} 
     750 
     751static int __devexit falcon_i2c_remove(struct platform_device *pdev) 
     752{ 
     753        struct falcon_i2c *priv = platform_get_drvdata(pdev); 
     754        struct resource *mmres; 
     755 
     756        /* disable bus */ 
     757        i2c_w32_mask(I2C_RUN_CTRL_RUN_EN, 0, run_ctrl); 
     758 
     759        /* remove driver */ 
     760        platform_set_drvdata(pdev, NULL); 
     761        i2c_del_adapter(&priv->adap); 
     762 
     763        free_irq(priv->irq_lb, priv); 
     764        free_irq(priv->irq_b, priv); 
     765        free_irq(priv->irq_err, priv); 
     766        free_irq(priv->irq_p, priv); 
     767 
     768        iounmap(priv->membase); 
     769 
     770        gpio_free(108); 
     771        gpio_free(107); 
     772 
     773        kfree(priv); 
     774 
     775        mmres = platform_get_resource(pdev, IORESOURCE_MEM, 0); 
     776        release_mem_region(mmres->start, resource_size(mmres)); 
     777 
     778        dev_dbg(&pdev->dev, "removed\n"); 
     779 
     780        return 0; 
     781} 
     782 
     783static struct platform_driver falcon_i2c_driver = { 
     784        .probe  = falcon_i2c_probe, 
     785        .remove = __devexit_p(falcon_i2c_remove), 
     786        .driver = { 
     787                .name   = DRV_NAME, 
     788                .owner  = THIS_MODULE, 
     789        }, 
     790}; 
     791 
     792static int __init falcon_i2c_init(void) 
     793{ 
     794        int ret; 
     795 
     796        ret = platform_driver_register(&falcon_i2c_driver); 
     797 
     798        if (ret) 
     799                pr_debug(DRV_NAME ": can't register platform driver\n"); 
     800 
     801        return ret; 
     802} 
     803 
     804static void __exit falcon_i2c_exit(void) 
     805{ 
     806        platform_driver_unregister(&falcon_i2c_driver); 
     807} 
     808 
     809module_init(falcon_i2c_init); 
     810module_exit(falcon_i2c_exit); 
     811 
     812MODULE_DESCRIPTION("Lantiq FALC(tm) ON - I2C bus adapter"); 
     813MODULE_ALIAS("platform:" DRV_NAME); 
     814MODULE_LICENSE("GPL"); 
     815MODULE_VERSION(DRV_VERSION); 
Note: See TracBrowser for help on using the repository browser.