git.oblomov.eu Git - linux-2.6/blob - drivers/i2c/busses/i2c-stu300.c

   1 /*
   2  * Copyright (C) 2007-2009 ST-Ericsson AB
   3  * License terms: GNU General Public License (GPL) version 2
   4  * ST DDC I2C master mode driver, used in e.g. U300 series platforms.
   5  * Author: Linus Walleij <linus.walleij@stericsson.com>
   6  * Author: Jonas Aaberg <jonas.aberg@stericsson.com>
   7  */
   8 #include <linux/init.h>
   9 #include <linux/module.h>
  10 #include <linux/platform_device.h>
  11 #include <linux/delay.h>
  12 #include <linux/i2c.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/completion.h>
  15 #include <linux/err.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/clk.h>
  18 #include <linux/io.h>
  19
  20 /* the name of this kernel module */
  21 #define NAME "stu300"
  22
  23 /* CR (Control Register) 8bit (R/W) */
  24 #define I2C_CR                                  (0x00000000)
  25 #define I2C_CR_RESET_VALUE                      (0x00)
  26 #define I2C_CR_RESET_UMASK                      (0x00)
  27 #define I2C_CR_DDC1_ENABLE                      (0x80)
  28 #define I2C_CR_TRANS_ENABLE                     (0x40)
  29 #define I2C_CR_PERIPHERAL_ENABLE                (0x20)
  30 #define I2C_CR_DDC2B_ENABLE                     (0x10)
  31 #define I2C_CR_START_ENABLE                     (0x08)
  32 #define I2C_CR_ACK_ENABLE                       (0x04)
  33 #define I2C_CR_STOP_ENABLE                      (0x02)
  34 #define I2C_CR_INTERRUPT_ENABLE                 (0x01)
  35 /* SR1 (Status Register 1) 8bit (R/-) */
  36 #define I2C_SR1                                 (0x00000004)
  37 #define I2C_SR1_RESET_VALUE                     (0x00)
  38 #define I2C_SR1_RESET_UMASK                     (0x00)
  39 #define I2C_SR1_EVF_IND                         (0x80)
  40 #define I2C_SR1_ADD10_IND                       (0x40)
  41 #define I2C_SR1_TRA_IND                         (0x20)
  42 #define I2C_SR1_BUSY_IND                        (0x10)
  43 #define I2C_SR1_BTF_IND                         (0x08)
  44 #define I2C_SR1_ADSL_IND                        (0x04)
  45 #define I2C_SR1_MSL_IND                         (0x02)
  46 #define I2C_SR1_SB_IND                          (0x01)
  47 /* SR2 (Status Register 2) 8bit (R/-) */
  48 #define I2C_SR2                                 (0x00000008)
  49 #define I2C_SR2_RESET_VALUE                     (0x00)
  50 #define I2C_SR2_RESET_UMASK                     (0x40)
  51 #define I2C_SR2_MASK                            (0xBF)
  52 #define I2C_SR2_SCLFAL_IND                      (0x80)
  53 #define I2C_SR2_ENDAD_IND                       (0x20)
  54 #define I2C_SR2_AF_IND                          (0x10)
  55 #define I2C_SR2_STOPF_IND                       (0x08)
  56 #define I2C_SR2_ARLO_IND                        (0x04)
  57 #define I2C_SR2_BERR_IND                        (0x02)
  58 #define I2C_SR2_DDC2BF_IND                      (0x01)
  59 /* CCR (Clock Control Register) 8bit (R/W) */
  60 #define I2C_CCR                                 (0x0000000C)
  61 #define I2C_CCR_RESET_VALUE                     (0x00)
  62 #define I2C_CCR_RESET_UMASK                     (0x00)
  63 #define I2C_CCR_MASK                            (0xFF)
  64 #define I2C_CCR_FMSM                            (0x80)
  65 #define I2C_CCR_CC_MASK                         (0x7F)
  66 /* OAR1 (Own Address Register 1) 8bit (R/W) */
  67 #define I2C_OAR1                                (0x00000010)
  68 #define I2C_OAR1_RESET_VALUE                    (0x00)
  69 #define I2C_OAR1_RESET_UMASK                    (0x00)
  70 #define I2C_OAR1_ADD_MASK                       (0xFF)
  71 /* OAR2 (Own Address Register 2) 8bit (R/W) */
  72 #define I2C_OAR2                                (0x00000014)
  73 #define I2C_OAR2_RESET_VALUE                    (0x40)
  74 #define I2C_OAR2_RESET_UMASK                    (0x19)
  75 #define I2C_OAR2_MASK                           (0xE6)
  76 #define I2C_OAR2_FR_25_10MHZ                    (0x00)
  77 #define I2C_OAR2_FR_10_1667MHZ                  (0x20)
  78 #define I2C_OAR2_FR_1667_2667MHZ                (0x40)
  79 #define I2C_OAR2_FR_2667_40MHZ                  (0x60)
  80 #define I2C_OAR2_FR_40_5333MHZ                  (0x80)
  81 #define I2C_OAR2_FR_5333_66MHZ                  (0xA0)
  82 #define I2C_OAR2_FR_66_80MHZ                    (0xC0)
  83 #define I2C_OAR2_FR_80_100MHZ                   (0xE0)
  84 #define I2C_OAR2_FR_MASK                        (0xE0)
  85 #define I2C_OAR2_ADD_MASK                       (0x06)
  86 /* DR (Data Register) 8bit (R/W) */
  87 #define I2C_DR                                  (0x00000018)
  88 #define I2C_DR_RESET_VALUE                      (0x00)
  89 #define I2C_DR_RESET_UMASK                      (0xFF)
  90 #define I2C_DR_D_MASK                           (0xFF)
  91 /* ECCR (Extended Clock Control Register) 8bit (R/W) */
  92 #define I2C_ECCR                                (0x0000001C)
  93 #define I2C_ECCR_RESET_VALUE                    (0x00)
  94 #define I2C_ECCR_RESET_UMASK                    (0xE0)
  95 #define I2C_ECCR_MASK                           (0x1F)
  96 #define I2C_ECCR_CC_MASK                        (0x1F)
  97
  98 /*
  99  * These events are more or less responses to commands
 100  * sent into the hardware, presumably reflecting the state
 101  * of an internal state machine.
 102  */
 103 enum stu300_event {
 104         STU300_EVENT_NONE = 0,
 105         STU300_EVENT_1,
 106         STU300_EVENT_2,
 107         STU300_EVENT_3,
 108         STU300_EVENT_4,
 109         STU300_EVENT_5,
 110         STU300_EVENT_6,
 111         STU300_EVENT_7,
 112         STU300_EVENT_8,
 113         STU300_EVENT_9
 114 };
 115
 116 enum stu300_error {
 117         STU300_ERROR_NONE = 0,
 118         STU300_ERROR_ACKNOWLEDGE_FAILURE,
 119         STU300_ERROR_BUS_ERROR,
 120         STU300_ERROR_ARBITRATION_LOST
 121 };
 122
 123 /* timeout waiting for the controller to respond */
 124 #define STU300_TIMEOUT (msecs_to_jiffies(1000))
 125
 126 /*
 127  * The number of address send athemps tried before giving up.
 128  * If the first one failes it seems like 5 to 8 attempts are required.
 129  */
 130 #define NUM_ADDR_RESEND_ATTEMPTS 10
 131
 132 /* I2C clock speed, in Hz 0-400kHz*/
 133 static unsigned int scl_frequency = 100000;
 134 module_param(scl_frequency, uint,  0644);
 135
 136 /**
 137  * struct stu300_dev - the stu300 driver state holder
 138  * @pdev: parent platform device
 139  * @adapter: corresponding I2C adapter
 140  * @phybase: location of I/O area in memory
 141  * @physize: size of I/O area in memory
 142  * @clk: hardware block clock
 143  * @irq: assigned interrupt line
 144  * @cmd_issue_lock: this locks the following cmd_ variables
 145  * @cmd_complete: acknowledge completion for an I2C command
 146  * @cmd_event: expected event coming in as a response to a command
 147  * @cmd_err: error code as response to a command
 148  * @speed: current bus speed in Hz
 149  * @msg_index: index of current message
 150  * @msg_len: length of current message
 151  */
 152 struct stu300_dev {
 153         struct platform_device  *pdev;
 154         struct i2c_adapter      adapter;
 155         resource_size_t         phybase;
 156         resource_size_t         physize;
 157         void __iomem            *virtbase;
 158         struct clk              *clk;
 159         int                     irq;
 160         spinlock_t              cmd_issue_lock;
 161         struct completion       cmd_complete;
 162         enum stu300_event       cmd_event;
 163         enum stu300_error       cmd_err;
 164         unsigned int            speed;
 165         int                     msg_index;
 166         int                     msg_len;
 167 };
 168
 169 /* Local forward function declarations */
 170 static int stu300_init_hw(struct stu300_dev *dev);
 171
 172 /*
 173  * The block needs writes in both MSW and LSW in order
 174  * for all data lines to reach their destination.
 175  */
 176 static inline void stu300_wr8(u32 value, void __iomem *address)
 177 {
 178         writel((value << 16) | value, address);
 179 }
 180
 181 /*
 182  * This merely masks off the duplicates which appear
 183  * in bytes 1-3. You _MUST_ use 32-bit bus access on this
 184  * device, else it will not work.
 185  */
 186 static inline u32 stu300_r8(void __iomem *address)
 187 {
 188         return readl(address) & 0x000000FFU;
 189 }
 190
 191 /*
 192  * Tells whether a certain event or events occurred in
 193  * response to a command. The events represent states in
 194  * the internal state machine of the hardware. The events
 195  * are not very well described in the hardware
 196  * documentation and can only be treated as abstract state
 197  * machine states.
 198  *
 199  * @ret 0 = event has not occurred, any other value means
 200  * the event occurred.
 201  */
 202 static int stu300_event_occurred(struct stu300_dev *dev,
 203                                    enum stu300_event mr_event) {
 204         u32 status1;
 205         u32 status2;
 206
 207         /* What event happened? */
 208         status1 = stu300_r8(dev->virtbase + I2C_SR1);
 209         if (!(status1 & I2C_SR1_EVF_IND))
 210                 /* No event at all */
 211                 return 0;
 212         status2 = stu300_r8(dev->virtbase + I2C_SR2);
 213
 214         switch (mr_event) {
 215         case STU300_EVENT_1:
 216                 if (status1 & I2C_SR1_ADSL_IND)
 217                         return 1;
 218                 break;
 219         case STU300_EVENT_2:
 220         case STU300_EVENT_3:
 221         case STU300_EVENT_7:
 222         case STU300_EVENT_8:
 223                 if (status1 & I2C_SR1_BTF_IND) {
 224                         if (status2 & I2C_SR2_AF_IND)
 225                                 dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
 226                         else if (status2 & I2C_SR2_BERR_IND)
 227                                 dev->cmd_err = STU300_ERROR_BUS_ERROR;
 228                         return 1;
 229                 }
 230                 break;
 231         case STU300_EVENT_4:
 232                 if (status2 & I2C_SR2_STOPF_IND)
 233                         return 1;
 234                 break;
 235         case STU300_EVENT_5:
 236                 if (status1 & I2C_SR1_SB_IND)
 237                         /* Clear start bit */
 238                         return 1;
 239                 break;
 240         case STU300_EVENT_6:
 241                 if (status2 & I2C_SR2_ENDAD_IND) {
 242                         /* First check for any errors */
 243                         if (status2 & I2C_SR2_AF_IND)
 244                                 dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
 245                         return 1;
 246                 }
 247                 break;
 248         case STU300_EVENT_9:
 249                 if (status1 & I2C_SR1_ADD10_IND)
 250                         return 1;
 251                 break;
 252         default:
 253                 break;
 254         }
 255         if (status2 & I2C_SR2_ARLO_IND)
 256                 dev->cmd_err = STU300_ERROR_ARBITRATION_LOST;
 257         return 0;
 258 }
 259
 260 static irqreturn_t stu300_irh(int irq, void *data)
 261 {
 262         struct stu300_dev *dev = data;
 263         int res;
 264
 265         /* See if this was what we were waiting for */
 266         spin_lock(&dev->cmd_issue_lock);
 267         if (dev->cmd_event != STU300_EVENT_NONE) {
 268                 res = stu300_event_occurred(dev, dev->cmd_event);
 269                 if (res || dev->cmd_err != STU300_ERROR_NONE) {
 270                         u32 val;
 271
 272                         complete(&dev->cmd_complete);
 273                         /* Block any multiple interrupts */
 274                         val = stu300_r8(dev->virtbase + I2C_CR);
 275                         val &= ~I2C_CR_INTERRUPT_ENABLE;
 276                         stu300_wr8(val, dev->virtbase + I2C_CR);
 277                 }
 278         }
 279         spin_unlock(&dev->cmd_issue_lock);
 280         return IRQ_HANDLED;
 281 }
 282
 283 /*
 284  * Sends a command and then waits for the bits masked by *flagmask*
 285  * to go high or low by IRQ awaiting.
 286  */
 287 static int stu300_start_and_await_event(struct stu300_dev *dev,
 288                                           u8 cr_value,
 289                                           enum stu300_event mr_event)
 290 {
 291         int ret;
 292
 293         if (unlikely(irqs_disabled())) {
 294                 /* TODO: implement polling for this case if need be. */
 295                 WARN(1, "irqs are disabled, cannot poll for event\n");
 296                 return -EIO;
 297         }
 298
 299         /* Lock command issue, fill in an event we wait for */
 300         spin_lock_irq(&dev->cmd_issue_lock);
 301         init_completion(&dev->cmd_complete);
 302         dev->cmd_err = STU300_ERROR_NONE;
 303         dev->cmd_event = mr_event;
 304         spin_unlock_irq(&dev->cmd_issue_lock);
 305
 306         /* Turn on interrupt, send command and wait. */
 307         cr_value |= I2C_CR_INTERRUPT_ENABLE;
 308         stu300_wr8(cr_value, dev->virtbase + I2C_CR);
 309         ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
 310                                                         STU300_TIMEOUT);
 311
 312         if (ret < 0) {
 313                 dev_err(&dev->pdev->dev,
 314                        "wait_for_completion_interruptible_timeout() "
 315                        "returned %d waiting for event %04x\n", ret, mr_event);
 316                 return ret;
 317         }
 318
 319         if (ret == 0) {
 320                 dev_err(&dev->pdev->dev, "controller timed out "
 321                        "waiting for event %d, reinit hardware\n", mr_event);
 322                 (void) stu300_init_hw(dev);
 323                 return -ETIMEDOUT;
 324         }
 325
 326         if (dev->cmd_err != STU300_ERROR_NONE) {
 327                 dev_err(&dev->pdev->dev, "controller (start) "
 328                        "error %d waiting for event %d, reinit hardware\n",
 329                        dev->cmd_err, mr_event);
 330                 (void) stu300_init_hw(dev);
 331                 return -EIO;
 332         }
 333
 334         return 0;
 335 }
 336
 337 /*
 338  * This waits for a flag to be set, if it is not set on entry, an interrupt is
 339  * configured to wait for the flag using a completion.
 340  */
 341 static int stu300_await_event(struct stu300_dev *dev,
 342                                 enum stu300_event mr_event)
 343 {
 344         int ret;
 345         u32 val;
 346
 347         if (unlikely(irqs_disabled())) {
 348                 /* TODO: implement polling for this case if need be. */
 349                 dev_err(&dev->pdev->dev, "irqs are disabled on this "
 350                         "system!\n");
 351                 return -EIO;
 352         }
 353
 354         /* Is it already here? */
 355         spin_lock_irq(&dev->cmd_issue_lock);
 356         dev->cmd_err = STU300_ERROR_NONE;
 357         if (stu300_event_occurred(dev, mr_event)) {
 358                 spin_unlock_irq(&dev->cmd_issue_lock);
 359                 goto exit_await_check_err;
 360         }
 361         init_completion(&dev->cmd_complete);
 362         dev->cmd_err = STU300_ERROR_NONE;
 363         dev->cmd_event = mr_event;
 364
 365         /* Turn on the I2C interrupt for current operation */
 366         val = stu300_r8(dev->virtbase + I2C_CR);
 367         val |= I2C_CR_INTERRUPT_ENABLE;
 368         stu300_wr8(val, dev->virtbase + I2C_CR);
 369
 370         /* Twice paranoia (possible HW glitch) */
 371         stu300_wr8(val, dev->virtbase + I2C_CR);
 372
 373         /* Check again: is it already here? */
 374         if (unlikely(stu300_event_occurred(dev, mr_event))) {
 375                 /* Disable IRQ again. */
 376                 val &= ~I2C_CR_INTERRUPT_ENABLE;
 377                 stu300_wr8(val, dev->virtbase + I2C_CR);
 378                 spin_unlock_irq(&dev->cmd_issue_lock);
 379                 goto exit_await_check_err;
 380         }
 381
 382         /* Unlock the command block and wait for the event to occur */
 383         spin_unlock_irq(&dev->cmd_issue_lock);
 384         ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
 385                                                         STU300_TIMEOUT);
 386
 387         if (ret < 0) {
 388                 dev_err(&dev->pdev->dev,
 389                        "wait_for_completion_interruptible_timeout()"
 390                        "returned %d waiting for event %04x\n", ret, mr_event);
 391                 return ret;
 392         }
 393
 394         if (ret == 0) {
 395                 if (mr_event != STU300_EVENT_6) {
 396                         dev_err(&dev->pdev->dev, "controller "
 397                                 "timed out waiting for event %d, reinit "
 398                                 "hardware\n", mr_event);
 399                         (void) stu300_init_hw(dev);
 400                 }
 401                 return -ETIMEDOUT;
 402         }
 403
 404  exit_await_check_err:
 405         if (dev->cmd_err != STU300_ERROR_NONE) {
 406                 if (mr_event != STU300_EVENT_6) {
 407                         dev_err(&dev->pdev->dev, "controller "
 408                                 "error (await_event) %d waiting for event %d, "
 409                                "reinit hardware\n", dev->cmd_err, mr_event);
 410                         (void) stu300_init_hw(dev);
 411                 }
 412                 return -EIO;
 413         }
 414
 415         return 0;
 416 }
 417
 418 /*
 419  * Waits for the busy bit to go low by repeated polling.
 420  */
 421 #define BUSY_RELEASE_ATTEMPTS 10
 422 static int stu300_wait_while_busy(struct stu300_dev *dev)
 423 {
 424         unsigned long timeout;
 425         int i;
 426
 427         for (i = 0; i < BUSY_RELEASE_ATTEMPTS; i++) {
 428                 timeout = jiffies + STU300_TIMEOUT;
 429
 430                 while (!time_after(jiffies, timeout)) {
 431                         /* Is not busy? */
 432                         if ((stu300_r8(dev->virtbase + I2C_SR1) &
 433                              I2C_SR1_BUSY_IND) == 0)
 434                                 return 0;
 435                         msleep(1);
 436                 }
 437
 438                 dev_err(&dev->pdev->dev, "transaction timed out "
 439                         "waiting for device to be free (not busy). "
 440                        "Attempt: %d\n", i+1);
 441
 442                 dev_err(&dev->pdev->dev, "base address = "
 443                         "0x%08x, reinit hardware\n", (u32) dev->virtbase);
 444
 445                 (void) stu300_init_hw(dev);
 446         }
 447
 448         dev_err(&dev->pdev->dev, "giving up after %d attempts "
 449                 "to reset the bus.\n",  BUSY_RELEASE_ATTEMPTS);
 450
 451         return -ETIMEDOUT;
 452 }
 453
 454 struct stu300_clkset {
 455         unsigned long rate;
 456         u32 setting;
 457 };
 458
 459 static const struct stu300_clkset stu300_clktable[] = {
 460         { 0, 0xFFU },
 461         { 2500000, I2C_OAR2_FR_25_10MHZ },
 462         { 10000000, I2C_OAR2_FR_10_1667MHZ },
 463         { 16670000, I2C_OAR2_FR_1667_2667MHZ },
 464         { 26670000, I2C_OAR2_FR_2667_40MHZ },
 465         { 40000000, I2C_OAR2_FR_40_5333MHZ },
 466         { 53330000, I2C_OAR2_FR_5333_66MHZ },
 467         { 66000000, I2C_OAR2_FR_66_80MHZ },
 468         { 80000000, I2C_OAR2_FR_80_100MHZ },
 469         { 100000000, 0xFFU },
 470 };
 471
 472 static int stu300_set_clk(struct stu300_dev *dev, unsigned long clkrate)
 473 {
 474
 475         u32 val;
 476         int i = 0;
 477
 478         /* Locate the apropriate clock setting */
 479         while (i < ARRAY_SIZE(stu300_clktable) &&
 480                stu300_clktable[i].rate < clkrate)
 481                 i++;
 482
 483         if (stu300_clktable[i].setting == 0xFFU) {
 484                 dev_err(&dev->pdev->dev, "too %s clock rate requested "
 485                         "(%lu Hz).\n", i ? "high" : "low", clkrate);
 486                 return -EINVAL;
 487         }
 488
 489         stu300_wr8(stu300_clktable[i].setting,
 490                    dev->virtbase + I2C_OAR2);
 491
 492         dev_dbg(&dev->pdev->dev, "Clock rate %lu Hz, I2C bus speed %d Hz "
 493                 "virtbase %p\n", clkrate, dev->speed, dev->virtbase);
 494
 495         if (dev->speed > 100000)
 496                 /* Fast Mode I2C */
 497                 val = ((clkrate/dev->speed)-9)/3;
 498         else
 499                 /* Standard Mode I2C */
 500                 val = ((clkrate/dev->speed)-7)/2;
 501
 502         /* According to spec the divider must be > 2 */
 503         if (val < 0x002) {
 504                 dev_err(&dev->pdev->dev, "too low clock rate (%lu Hz).\n",
 505                         clkrate);
 506                 return -EINVAL;
 507         }
 508
 509         /* We have 12 bits clock divider only! */
 510         if (val & 0xFFFFF000U) {
 511                 dev_err(&dev->pdev->dev, "too high clock rate (%lu Hz).\n",
 512                         clkrate);
 513                 return -EINVAL;
 514         }
 515
 516         if (dev->speed > 100000) {
 517                 /* CC6..CC0 */
 518                 stu300_wr8((val & I2C_CCR_CC_MASK) | I2C_CCR_FMSM,
 519                            dev->virtbase + I2C_CCR);
 520                 dev_dbg(&dev->pdev->dev, "set clock divider to 0x%08x, "
 521                         "Fast Mode I2C\n", val);
 522         } else {
 523                 /* CC6..CC0 */
 524                 stu300_wr8((val & I2C_CCR_CC_MASK),
 525                            dev->virtbase + I2C_CCR);
 526                 dev_dbg(&dev->pdev->dev, "set clock divider to "
 527                         "0x%08x, Standard Mode I2C\n", val);
 528         }
 529
 530         /* CC11..CC7 */
 531         stu300_wr8(((val >> 7) & 0x1F),
 532                    dev->virtbase + I2C_ECCR);
 533
 534         return 0;
 535 }
 536
 537
 538 static int stu300_init_hw(struct stu300_dev *dev)
 539 {
 540         u32 dummy;
 541         unsigned long clkrate;
 542         int ret;
 543
 544         /* Disable controller */
 545         stu300_wr8(0x00, dev->virtbase + I2C_CR);
 546         /*
 547          * Set own address to some default value (0x00).
 548          * We do not support slave mode anyway.
 549          */
 550         stu300_wr8(0x00, dev->virtbase + I2C_OAR1);
 551         /*
 552          * The I2C controller only operates properly in 26 MHz but we
 553          * program this driver as if we didn't know. This will also set the two
 554          * high bits of the own address to zero as well.
 555          * There is no known hardware issue with running in 13 MHz
 556          * However, speeds over 200 kHz are not used.
 557          */
 558         clkrate = clk_get_rate(dev->clk);
 559         ret = stu300_set_clk(dev, clkrate);
 560         if (ret)
 561                 return ret;
 562         /*
 563          * Enable block, do it TWICE (hardware glitch)
 564          * Setting bit 7 can enable DDC mode. (Not used currently.)
 565          */
 566         stu300_wr8(I2C_CR_PERIPHERAL_ENABLE,
 567                                   dev->virtbase + I2C_CR);
 568         stu300_wr8(I2C_CR_PERIPHERAL_ENABLE,
 569                                   dev->virtbase + I2C_CR);
 570         /* Make a dummy read of the status register SR1 & SR2 */
 571         dummy = stu300_r8(dev->virtbase + I2C_SR2);
 572         dummy = stu300_r8(dev->virtbase + I2C_SR1);
 573
 574         return 0;
 575 }
 576
 577
 578
 579 /* Send slave address. */
 580 static int stu300_send_address(struct stu300_dev *dev,
 581                                  struct i2c_msg *msg, int resend)
 582 {
 583         u32 val;
 584         int ret;
 585
 586         if (msg->flags & I2C_M_TEN)
 587                 /* This is probably how 10 bit addresses look */
 588                 val = (0xf0 | (((u32) msg->addr & 0x300) >> 7)) &
 589                         I2C_DR_D_MASK;
 590         else
 591                 val = ((msg->addr << 1) & I2C_DR_D_MASK);
 592
 593         if (msg->flags & I2C_M_RD) {
 594                 /* This is the direction bit */
 595                 val |= 0x01;
 596                 if (resend)
 597                         dev_dbg(&dev->pdev->dev, "read resend\n");
 598         } else if (resend)
 599                 dev_dbg(&dev->pdev->dev, "write resend\n");
 600         stu300_wr8(val, dev->virtbase + I2C_DR);
 601
 602         /* For 10bit addressing, await 10bit request (EVENT 9) */
 603         if (msg->flags & I2C_M_TEN) {
 604                 ret = stu300_await_event(dev, STU300_EVENT_9);
 605                 /*
 606                  * The slave device wants a 10bit address, send the rest
 607                  * of the bits (the LSBits)
 608                  */
 609                 val = msg->addr & I2C_DR_D_MASK;
 610                 /* This clears "event 9" */
 611                 stu300_wr8(val, dev->virtbase + I2C_DR);
 612                 if (ret != 0)
 613                         return ret;
 614         }
 615         /* FIXME: Why no else here? two events for 10bit?
 616          * Await event 6 (normal) or event 9 (10bit)
 617          */
 618
 619         if (resend)
 620                 dev_dbg(&dev->pdev->dev, "await event 6\n");
 621         ret = stu300_await_event(dev, STU300_EVENT_6);
 622
 623         /*
 624          * Clear any pending EVENT 6 no matter what happend during
 625          * await_event.
 626          */
 627         val = stu300_r8(dev->virtbase + I2C_CR);
 628         val |= I2C_CR_PERIPHERAL_ENABLE;
 629         stu300_wr8(val, dev->virtbase + I2C_CR);
 630
 631         return ret;
 632 }
 633
 634 static int stu300_xfer_msg(struct i2c_adapter *adap,
 635                              struct i2c_msg *msg, int stop)
 636 {
 637         u32 cr;
 638         u32 val;
 639         u32 i;
 640         int ret;
 641         int attempts = 0;
 642         struct stu300_dev *dev = i2c_get_adapdata(adap);
 643
 644
 645         clk_enable(dev->clk);
 646
 647         /* Remove this if (0) to trace each and every message. */
 648         if (0) {
 649                 dev_dbg(&dev->pdev->dev, "I2C message to: 0x%04x, len: %d, "
 650                         "flags: 0x%04x, stop: %d\n",
 651                         msg->addr, msg->len, msg->flags, stop);
 652         }
 653
 654         /* Zero-length messages are not supported by this hardware */
 655         if (msg->len == 0) {
 656                 ret = -EINVAL;
 657                 goto exit_disable;
 658         }
 659
 660         /*
 661          * For some reason, sending the address sometimes fails when running
 662          * on  the 13 MHz clock. No interrupt arrives. This is a work around,
 663          * which tries to restart and send the address up to 10 times before
 664          * really giving up. Usually 5 to 8 attempts are enough.
 665          */
 666         do {
 667                 if (attempts)
 668                         dev_dbg(&dev->pdev->dev, "wait while busy\n");
 669                 /* Check that the bus is free, or wait until some timeout */
 670                 ret = stu300_wait_while_busy(dev);
 671                 if (ret != 0)
 672                         goto exit_disable;
 673
 674                 if (attempts)
 675                         dev_dbg(&dev->pdev->dev, "re-int hw\n");
 676                 /*
 677                  * According to ST, there is no problem if the clock is
 678                  * changed between 13 and 26 MHz during a transfer.
 679                  */
 680                 ret = stu300_init_hw(dev);
 681                 if (ret)
 682                         goto exit_disable;
 683
 684                 /* Send a start condition */
 685                 cr = I2C_CR_PERIPHERAL_ENABLE;
 686                 /* Setting the START bit puts the block in master mode */
 687                 if (!(msg->flags & I2C_M_NOSTART))
 688                         cr |= I2C_CR_START_ENABLE;
 689                 if ((msg->flags & I2C_M_RD) && (msg->len > 1))
 690                         /* On read more than 1 byte, we need ack. */
 691                         cr |= I2C_CR_ACK_ENABLE;
 692                 /* Check that it gets through */
 693                 if (!(msg->flags & I2C_M_NOSTART)) {
 694                         if (attempts)
 695                                 dev_dbg(&dev->pdev->dev, "send start event\n");
 696                         ret = stu300_start_and_await_event(dev, cr,
 697                                                              STU300_EVENT_5);
 698                 }
 699
 700                 if (attempts)
 701                         dev_dbg(&dev->pdev->dev, "send address\n");
 702
 703                 if (ret == 0)
 704                         /* Send address */
 705                         ret = stu300_send_address(dev, msg, attempts != 0);
 706
 707                 if (ret != 0) {
 708                         attempts++;
 709                         dev_dbg(&dev->pdev->dev, "failed sending address, "
 710                                 "retrying. Attempt: %d msg_index: %d/%d\n",
 711                                attempts, dev->msg_index, dev->msg_len);
 712                 }
 713
 714         } while (ret != 0 && attempts < NUM_ADDR_RESEND_ATTEMPTS);
 715
 716         if (attempts < NUM_ADDR_RESEND_ATTEMPTS && attempts > 0) {
 717                 dev_dbg(&dev->pdev->dev, "managed to get address "
 718                        "through after %d attempts\n", attempts);
 719         } else if (attempts == NUM_ADDR_RESEND_ATTEMPTS) {
 720                 dev_dbg(&dev->pdev->dev, "I give up, tried %d times "
 721                        "to resend address.\n",
 722                        NUM_ADDR_RESEND_ATTEMPTS);
 723                 goto exit_disable;
 724         }
 725
 726         if (msg->flags & I2C_M_RD) {
 727                 /* READ: we read the actual bytes one at a time */
 728                 for (i = 0; i < msg->len; i++) {
 729                         if (i == msg->len-1) {
 730                                 /*
 731                                  * Disable ACK and set STOP condition before
 732                                  * reading last byte
 733                                  */
 734                                 val = I2C_CR_PERIPHERAL_ENABLE;
 735
 736                                 if (stop)
 737                                         val |= I2C_CR_STOP_ENABLE;
 738
 739                                 stu300_wr8(val,
 740                                            dev->virtbase + I2C_CR);
 741                         }
 742                         /* Wait for this byte... */
 743                         ret = stu300_await_event(dev, STU300_EVENT_7);
 744                         if (ret != 0)
 745                                 goto exit_disable;
 746                         /* This clears event 7 */
 747                         msg->buf[i] = (u8) stu300_r8(dev->virtbase + I2C_DR);
 748                 }
 749         } else {
 750                 /* WRITE: we send the actual bytes one at a time */
 751                 for (i = 0; i < msg->len; i++) {
 752                         /* Write the byte */
 753                         stu300_wr8(msg->buf[i],
 754                                    dev->virtbase + I2C_DR);
 755                         /* Check status */
 756                         ret = stu300_await_event(dev, STU300_EVENT_8);
 757                         /* Next write to DR will clear event 8 */
 758                         if (ret != 0) {
 759                                 dev_err(&dev->pdev->dev, "error awaiting "
 760                                        "event 8 (%d)\n", ret);
 761                                 goto exit_disable;
 762                         }
 763                 }
 764                 /* Check NAK */
 765                 if (!(msg->flags & I2C_M_IGNORE_NAK)) {
 766                         if (stu300_r8(dev->virtbase + I2C_SR2) &
 767                             I2C_SR2_AF_IND) {
 768                                 dev_err(&dev->pdev->dev, "I2C payload "
 769                                        "send returned NAK!\n");
 770                                 ret = -EIO;
 771                                 goto exit_disable;
 772                         }
 773                 }
 774                 if (stop) {
 775                         /* Send stop condition */
 776                         val = I2C_CR_PERIPHERAL_ENABLE;
 777                         val |= I2C_CR_STOP_ENABLE;
 778                         stu300_wr8(val, dev->virtbase + I2C_CR);
 779                 }
 780         }
 781
 782         /* Check that the bus is free, or wait until some timeout occurs */
 783         ret = stu300_wait_while_busy(dev);
 784         if (ret != 0) {
 785                 dev_err(&dev->pdev->dev, "timout waiting for transfer "
 786                        "to commence.\n");
 787                 goto exit_disable;
 788         }
 789
 790         /* Dummy read status registers */
 791         val = stu300_r8(dev->virtbase + I2C_SR2);
 792         val = stu300_r8(dev->virtbase + I2C_SR1);
 793         ret = 0;
 794
 795  exit_disable:
 796         /* Disable controller */
 797         stu300_wr8(0x00, dev->virtbase + I2C_CR);
 798         clk_disable(dev->clk);
 799         return ret;
 800 }
 801
 802 static int stu300_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
 803                          int num)
 804 {
 805         int ret = -1;
 806         int i;
 807         struct stu300_dev *dev = i2c_get_adapdata(adap);
 808         dev->msg_len = num;
 809         for (i = 0; i < num; i++) {
 810                 /*
 811                  * Another driver appears to send stop for each message,
 812                  * here we only do that for the last message. Possibly some
 813                  * peripherals require this behaviour, then their drivers
 814                  * have to send single messages in order to get "stop" for
 815                  * each message.
 816                  */
 817                 dev->msg_index = i;
 818
 819                 ret = stu300_xfer_msg(adap, &msgs[i], (i == (num - 1)));
 820                 if (ret != 0) {
 821                         num = ret;
 822                         break;
 823                 }
 824         }
 825
 826         return num;
 827 }
 828
 829 static u32 stu300_func(struct i2c_adapter *adap)
 830 {
 831         /* This is the simplest thing you can think of... */
 832         return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
 833 }
 834
 835 static const struct i2c_algorithm stu300_algo = {
 836         .master_xfer    = stu300_xfer,
 837         .functionality  = stu300_func,
 838 };
 839
 840 static int __init
 841 stu300_probe(struct platform_device *pdev)
 842 {
 843         struct stu300_dev *dev;
 844         struct i2c_adapter *adap;
 845         struct resource *res;
 846         int bus_nr;
 847         int ret = 0;
 848
 849         dev = kzalloc(sizeof(struct stu300_dev), GFP_KERNEL);
 850         if (!dev) {
 851                 dev_err(&pdev->dev, "could not allocate device struct\n");
 852                 ret = -ENOMEM;
 853                 goto err_no_devmem;
 854         }
 855
 856         bus_nr = pdev->id;
 857         dev->clk = clk_get(&pdev->dev, NULL);
 858         if (IS_ERR(dev->clk)) {
 859                 ret = PTR_ERR(dev->clk);
 860                 dev_err(&pdev->dev, "could not retrieve i2c bus clock\n");
 861                 goto err_no_clk;
 862         }
 863
 864         dev->pdev = pdev;
 865         platform_set_drvdata(pdev, dev);
 866
 867         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 868         if (!res) {
 869                 ret = -ENOENT;
 870                 goto err_no_resource;
 871         }
 872
 873         dev->phybase = res->start;
 874         dev->physize = resource_size(res);
 875
 876         if (request_mem_region(dev->phybase, dev->physize,
 877                                NAME " I/O Area") == NULL) {
 878                 ret = -EBUSY;
 879                 goto err_no_ioregion;
 880         }
 881
 882         dev->virtbase = ioremap(dev->phybase, dev->physize);
 883         dev_dbg(&pdev->dev, "initialize bus device I2C%d on virtual "
 884                 "base %p\n", bus_nr, dev->virtbase);
 885         if (!dev->virtbase) {
 886                 ret = -ENOMEM;
 887                 goto err_no_ioremap;
 888         }
 889
 890         dev->irq = platform_get_irq(pdev, 0);
 891         if (request_irq(dev->irq, stu300_irh, IRQF_DISABLED,
 892                         NAME, dev)) {
 893                 ret = -EIO;
 894                 goto err_no_irq;
 895         }
 896
 897         dev->speed = scl_frequency;
 898
 899         clk_enable(dev->clk);
 900         ret = stu300_init_hw(dev);
 901         clk_disable(dev->clk);
 902
 903         if (ret != 0) {
 904                 dev_err(&dev->pdev->dev, "error initializing hardware.\n");
 905                 goto err_init_hw;
 906         }
 907
 908         /* IRQ event handling initialization */
 909         spin_lock_init(&dev->cmd_issue_lock);
 910         dev->cmd_event = STU300_EVENT_NONE;
 911         dev->cmd_err = STU300_ERROR_NONE;
 912
 913         adap = &dev->adapter;
 914         adap->owner = THIS_MODULE;
 915         /* DDC class but actually often used for more generic I2C */
 916         adap->class = I2C_CLASS_DDC;
 917         strncpy(adap->name, "ST Microelectronics DDC I2C adapter",
 918                 sizeof(adap->name));
 919         adap->nr = bus_nr;
 920         adap->algo = &stu300_algo;
 921         adap->dev.parent = &pdev->dev;
 922         i2c_set_adapdata(adap, dev);
 923
 924         /* i2c device drivers may be active on return from add_adapter() */
 925         ret = i2c_add_numbered_adapter(adap);
 926         if (ret) {
 927                 dev_err(&dev->pdev->dev, "failure adding ST Micro DDC "
 928                        "I2C adapter\n");
 929                 goto err_add_adapter;
 930         }
 931         return 0;
 932
 933  err_add_adapter:
 934  err_init_hw:
 935         free_irq(dev->irq, dev);
 936  err_no_irq:
 937         iounmap(dev->virtbase);
 938  err_no_ioremap:
 939         release_mem_region(dev->phybase, dev->physize);
 940  err_no_ioregion:
 941         platform_set_drvdata(pdev, NULL);
 942  err_no_resource:
 943         clk_put(dev->clk);
 944  err_no_clk:
 945         kfree(dev);
 946  err_no_devmem:
 947         dev_err(&pdev->dev, "failed to add " NAME " adapter: %d\n",
 948                 pdev->id);
 949         return ret;
 950 }
 951
 952 #ifdef CONFIG_PM
 953 static int stu300_suspend(struct platform_device *pdev, pm_message_t state)
 954 {
 955         struct stu300_dev *dev = platform_get_drvdata(pdev);
 956
 957         /* Turn off everything */
 958         stu300_wr8(0x00, dev->virtbase + I2C_CR);
 959         return 0;
 960 }
 961
 962 static int stu300_resume(struct platform_device *pdev)
 963 {
 964         int ret = 0;
 965         struct stu300_dev *dev = platform_get_drvdata(pdev);
 966
 967         clk_enable(dev->clk);
 968         ret = stu300_init_hw(dev);
 969         clk_disable(dev->clk);
 970
 971         if (ret != 0)
 972                 dev_err(&pdev->dev, "error re-initializing hardware.\n");
 973         return ret;
 974 }
 975 #else
 976 #define stu300_suspend NULL
 977 #define stu300_resume NULL
 978 #endif
 979
 980 static int __exit
 981 stu300_remove(struct platform_device *pdev)
 982 {
 983         struct stu300_dev *dev = platform_get_drvdata(pdev);
 984
 985         i2c_del_adapter(&dev->adapter);
 986         /* Turn off everything */
 987         stu300_wr8(0x00, dev->virtbase + I2C_CR);
 988         free_irq(dev->irq, dev);
 989         iounmap(dev->virtbase);
 990         release_mem_region(dev->phybase, dev->physize);
 991         clk_put(dev->clk);
 992         platform_set_drvdata(pdev, NULL);
 993         kfree(dev);
 994         return 0;
 995 }
 996
 997 static struct platform_driver stu300_i2c_driver = {
 998         .driver = {
 999                 .name   = NAME,
1000                 .owner  = THIS_MODULE,
1001         },
1002         .remove         = __exit_p(stu300_remove),
1003         .suspend        = stu300_suspend,
1004         .resume         = stu300_resume,
1005
1006 };
1007
1008 static int __init stu300_init(void)
1009 {
1010         return platform_driver_probe(&stu300_i2c_driver, stu300_probe);
1011 }
1012
1013 static void __exit stu300_exit(void)
1014 {
1015         platform_driver_unregister(&stu300_i2c_driver);
1016 }
1017
1018 /*
1019  * The systems using this bus often have very basic devices such
1020  * as regulators on the I2C bus, so this needs to be loaded early.
1021  * Therefore it is registered in the subsys_initcall().
1022  */
1023 subsys_initcall(stu300_init);
1024 module_exit(stu300_exit);
1025
1026 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
1027 MODULE_DESCRIPTION("ST Micro DDC I2C adapter (" NAME ")");
1028 MODULE_LICENSE("GPL");
1029 MODULE_ALIAS("platform:" NAME);