source: trunk/target/linux/lantiq/patches/910-falcon-i2c.patch @ 26152

Last change on this file since 26152 was 26152, checked in by nbd, 6 years ago

lantiq: add missing #include for the falcon i2c driver

File size: 20.3 KB
  • drivers/i2c/busses/Makefile

    a b  
    7676obj-$(CONFIG_I2C_STUB)          += i2c-stub.o 
    7777obj-$(CONFIG_SCx200_ACB)        += scx200_acb.o 
    7878obj-$(CONFIG_SCx200_I2C)        += scx200_i2c.o 
     79obj-$(CONFIG_I2C_FALCON)        += i2c-falcon.o 
    7980 
    8081ccflags-$(CONFIG_I2C_DEBUG_BUS) := -DDEBUG 
  • drivers/i2c/busses/Kconfig

    a b  
    281281 
    282282comment "I2C system bus drivers (mostly embedded / system-on-chip)" 
    283283 
     284config I2C_FALCON 
     285        tristate "Falcon I2C interface" 
     286#       depends on SOC_FALCON 
     287 
    284288config I2C_AT91 
    285289        tristate "Atmel AT91 I2C Two-Wire interface (TWI)" 
    286290        depends on ARCH_AT91 && EXPERIMENTAL && BROKEN 
  • new file drivers/i2c/busses/i2c-falcon.c

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