1 /* 2 * Provides I2C support for Philips PNX010x/PNX4008 boards. 3 * 4 * Authors: Dennis Kovalev <dkovalev@ru.mvista.com> 5 * Vitaly Wool <vwool@ru.mvista.com> 6 * 7 * 2004-2006 (c) MontaVista Software, Inc. This file is licensed under 8 * the terms of the GNU General Public License version 2. This program 9 * is licensed "as is" without any warranty of any kind, whether express 10 * or implied. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/interrupt.h> 15 #include <linux/ioport.h> 16 #include <linux/delay.h> 17 #include <linux/i2c.h> 18 #include <linux/timer.h> 19 #include <linux/completion.h> 20 #include <linux/platform_device.h> 21 #include <linux/i2c-pnx.h> 22 #include <linux/io.h> 23 #include <linux/err.h> 24 #include <linux/clk.h> 25 #include <linux/slab.h> 26 27 #include <mach/hardware.h> 28 #include <mach/i2c.h> 29 30 #define I2C_PNX_TIMEOUT 10 /* msec */ 31 #define I2C_PNX_SPEED_KHZ 100 32 #define I2C_PNX_REGION_SIZE 0x100 33 34 static inline int wait_timeout(long timeout, struct i2c_pnx_algo_data *data) 35 { 36 while (timeout > 0 && 37 (ioread32(I2C_REG_STS(data)) & mstatus_active)) { 38 mdelay(1); 39 timeout--; 40 } 41 return (timeout <= 0); 42 } 43 44 static inline int wait_reset(long timeout, struct i2c_pnx_algo_data *data) 45 { 46 while (timeout > 0 && 47 (ioread32(I2C_REG_CTL(data)) & mcntrl_reset)) { 48 mdelay(1); 49 timeout--; 50 } 51 return (timeout <= 0); 52 } 53 54 static inline void i2c_pnx_arm_timer(struct i2c_pnx_algo_data *alg_data) 55 { 56 struct timer_list *timer = &alg_data->mif.timer; 57 unsigned long expires = msecs_to_jiffies(I2C_PNX_TIMEOUT); 58 59 if (expires <= 1) 60 expires = 2; 61 62 del_timer_sync(timer); 63 64 dev_dbg(&alg_data->adapter.dev, "Timer armed at %lu plus %lu jiffies.\n", 65 jiffies, expires); 66 67 timer->expires = jiffies + expires; 68 timer->data = (unsigned long)alg_data; 69 70 add_timer(timer); 71 } 72 73 /** 74 * i2c_pnx_start - start a device 75 * @slave_addr: slave address 76 * @adap: pointer to adapter structure 77 * 78 * Generate a START signal in the desired mode. 79 */ 80 static int i2c_pnx_start(unsigned char slave_addr, 81 struct i2c_pnx_algo_data *alg_data) 82 { 83 dev_dbg(&alg_data->adapter.dev, "%s(): addr 0x%x mode %d\n", __func__, 84 slave_addr, alg_data->mif.mode); 85 86 /* Check for 7 bit slave addresses only */ 87 if (slave_addr & ~0x7f) { 88 dev_err(&alg_data->adapter.dev, 89 "%s: Invalid slave address %x. Only 7-bit addresses are supported\n", 90 alg_data->adapter.name, slave_addr); 91 return -EINVAL; 92 } 93 94 /* First, make sure bus is idle */ 95 if (wait_timeout(I2C_PNX_TIMEOUT, alg_data)) { 96 /* Somebody else is monopolizing the bus */ 97 dev_err(&alg_data->adapter.dev, 98 "%s: Bus busy. Slave addr = %02x, cntrl = %x, stat = %x\n", 99 alg_data->adapter.name, slave_addr, 100 ioread32(I2C_REG_CTL(alg_data)), 101 ioread32(I2C_REG_STS(alg_data))); 102 return -EBUSY; 103 } else if (ioread32(I2C_REG_STS(alg_data)) & mstatus_afi) { 104 /* Sorry, we lost the bus */ 105 dev_err(&alg_data->adapter.dev, 106 "%s: Arbitration failure. Slave addr = %02x\n", 107 alg_data->adapter.name, slave_addr); 108 return -EIO; 109 } 110 111 /* 112 * OK, I2C is enabled and we have the bus. 113 * Clear the current TDI and AFI status flags. 114 */ 115 iowrite32(ioread32(I2C_REG_STS(alg_data)) | mstatus_tdi | mstatus_afi, 116 I2C_REG_STS(alg_data)); 117 118 dev_dbg(&alg_data->adapter.dev, "%s(): sending %#x\n", __func__, 119 (slave_addr << 1) | start_bit | alg_data->mif.mode); 120 121 /* Write the slave address, START bit and R/W bit */ 122 iowrite32((slave_addr << 1) | start_bit | alg_data->mif.mode, 123 I2C_REG_TX(alg_data)); 124 125 dev_dbg(&alg_data->adapter.dev, "%s(): exit\n", __func__); 126 127 return 0; 128 } 129 130 /** 131 * i2c_pnx_stop - stop a device 132 * @adap: pointer to I2C adapter structure 133 * 134 * Generate a STOP signal to terminate the master transaction. 135 */ 136 static void i2c_pnx_stop(struct i2c_pnx_algo_data *alg_data) 137 { 138 /* Only 1 msec max timeout due to interrupt context */ 139 long timeout = 1000; 140 141 dev_dbg(&alg_data->adapter.dev, "%s(): entering: stat = %04x.\n", 142 __func__, ioread32(I2C_REG_STS(alg_data))); 143 144 /* Write a STOP bit to TX FIFO */ 145 iowrite32(0xff | stop_bit, I2C_REG_TX(alg_data)); 146 147 /* Wait until the STOP is seen. */ 148 while (timeout > 0 && 149 (ioread32(I2C_REG_STS(alg_data)) & mstatus_active)) { 150 /* may be called from interrupt context */ 151 udelay(1); 152 timeout--; 153 } 154 155 dev_dbg(&alg_data->adapter.dev, "%s(): exiting: stat = %04x.\n", 156 __func__, ioread32(I2C_REG_STS(alg_data))); 157 } 158 159 /** 160 * i2c_pnx_master_xmit - transmit data to slave 161 * @adap: pointer to I2C adapter structure 162 * 163 * Sends one byte of data to the slave 164 */ 165 static int i2c_pnx_master_xmit(struct i2c_pnx_algo_data *alg_data) 166 { 167 u32 val; 168 169 dev_dbg(&alg_data->adapter.dev, "%s(): entering: stat = %04x.\n", 170 __func__, ioread32(I2C_REG_STS(alg_data))); 171 172 if (alg_data->mif.len > 0) { 173 /* We still have something to talk about... */ 174 val = *alg_data->mif.buf++; 175 176 if (alg_data->mif.len == 1) 177 val |= stop_bit; 178 179 alg_data->mif.len--; 180 iowrite32(val, I2C_REG_TX(alg_data)); 181 182 dev_dbg(&alg_data->adapter.dev, "%s(): xmit %#x [%d]\n", 183 __func__, val, alg_data->mif.len + 1); 184 185 if (alg_data->mif.len == 0) { 186 if (alg_data->last) { 187 /* Wait until the STOP is seen. */ 188 if (wait_timeout(I2C_PNX_TIMEOUT, alg_data)) 189 dev_err(&alg_data->adapter.dev, 190 "The bus is still active after timeout\n"); 191 } 192 /* Disable master interrupts */ 193 iowrite32(ioread32(I2C_REG_CTL(alg_data)) & 194 ~(mcntrl_afie | mcntrl_naie | mcntrl_drmie), 195 I2C_REG_CTL(alg_data)); 196 197 del_timer_sync(&alg_data->mif.timer); 198 199 dev_dbg(&alg_data->adapter.dev, 200 "%s(): Waking up xfer routine.\n", 201 __func__); 202 203 complete(&alg_data->mif.complete); 204 } 205 } else if (alg_data->mif.len == 0) { 206 /* zero-sized transfer */ 207 i2c_pnx_stop(alg_data); 208 209 /* Disable master interrupts. */ 210 iowrite32(ioread32(I2C_REG_CTL(alg_data)) & 211 ~(mcntrl_afie | mcntrl_naie | mcntrl_drmie), 212 I2C_REG_CTL(alg_data)); 213 214 /* Stop timer. */ 215 del_timer_sync(&alg_data->mif.timer); 216 dev_dbg(&alg_data->adapter.dev, 217 "%s(): Waking up xfer routine after zero-xfer.\n", 218 __func__); 219 220 complete(&alg_data->mif.complete); 221 } 222 223 dev_dbg(&alg_data->adapter.dev, "%s(): exiting: stat = %04x.\n", 224 __func__, ioread32(I2C_REG_STS(alg_data))); 225 226 return 0; 227 } 228 229 /** 230 * i2c_pnx_master_rcv - receive data from slave 231 * @adap: pointer to I2C adapter structure 232 * 233 * Reads one byte data from the slave 234 */ 235 static int i2c_pnx_master_rcv(struct i2c_pnx_algo_data *alg_data) 236 { 237 unsigned int val = 0; 238 u32 ctl = 0; 239 240 dev_dbg(&alg_data->adapter.dev, "%s(): entering: stat = %04x.\n", 241 __func__, ioread32(I2C_REG_STS(alg_data))); 242 243 /* Check, whether there is already data, 244 * or we didn't 'ask' for it yet. 245 */ 246 if (ioread32(I2C_REG_STS(alg_data)) & mstatus_rfe) { 247 dev_dbg(&alg_data->adapter.dev, 248 "%s(): Write dummy data to fill Rx-fifo...\n", 249 __func__); 250 251 if (alg_data->mif.len == 1) { 252 /* Last byte, do not acknowledge next rcv. */ 253 val |= stop_bit; 254 255 /* 256 * Enable interrupt RFDAIE (data in Rx fifo), 257 * and disable DRMIE (need data for Tx) 258 */ 259 ctl = ioread32(I2C_REG_CTL(alg_data)); 260 ctl |= mcntrl_rffie | mcntrl_daie; 261 ctl &= ~mcntrl_drmie; 262 iowrite32(ctl, I2C_REG_CTL(alg_data)); 263 } 264 265 /* 266 * Now we'll 'ask' for data: 267 * For each byte we want to receive, we must 268 * write a (dummy) byte to the Tx-FIFO. 269 */ 270 iowrite32(val, I2C_REG_TX(alg_data)); 271 272 return 0; 273 } 274 275 /* Handle data. */ 276 if (alg_data->mif.len > 0) { 277 val = ioread32(I2C_REG_RX(alg_data)); 278 *alg_data->mif.buf++ = (u8) (val & 0xff); 279 dev_dbg(&alg_data->adapter.dev, "%s(): rcv 0x%x [%d]\n", 280 __func__, val, alg_data->mif.len); 281 282 alg_data->mif.len--; 283 if (alg_data->mif.len == 0) { 284 if (alg_data->last) 285 /* Wait until the STOP is seen. */ 286 if (wait_timeout(I2C_PNX_TIMEOUT, alg_data)) 287 dev_err(&alg_data->adapter.dev, 288 "The bus is still active after timeout\n"); 289 290 /* Disable master interrupts */ 291 ctl = ioread32(I2C_REG_CTL(alg_data)); 292 ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie | 293 mcntrl_drmie | mcntrl_daie); 294 iowrite32(ctl, I2C_REG_CTL(alg_data)); 295 296 /* Kill timer. */ 297 del_timer_sync(&alg_data->mif.timer); 298 complete(&alg_data->mif.complete); 299 } 300 } 301 302 dev_dbg(&alg_data->adapter.dev, "%s(): exiting: stat = %04x.\n", 303 __func__, ioread32(I2C_REG_STS(alg_data))); 304 305 return 0; 306 } 307 308 static irqreturn_t i2c_pnx_interrupt(int irq, void *dev_id) 309 { 310 struct i2c_pnx_algo_data *alg_data = dev_id; 311 u32 stat, ctl; 312 313 dev_dbg(&alg_data->adapter.dev, 314 "%s(): mstat = %x mctrl = %x, mode = %d\n", 315 __func__, 316 ioread32(I2C_REG_STS(alg_data)), 317 ioread32(I2C_REG_CTL(alg_data)), 318 alg_data->mif.mode); 319 stat = ioread32(I2C_REG_STS(alg_data)); 320 321 /* let's see what kind of event this is */ 322 if (stat & mstatus_afi) { 323 /* We lost arbitration in the midst of a transfer */ 324 alg_data->mif.ret = -EIO; 325 326 /* Disable master interrupts. */ 327 ctl = ioread32(I2C_REG_CTL(alg_data)); 328 ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie | 329 mcntrl_drmie); 330 iowrite32(ctl, I2C_REG_CTL(alg_data)); 331 332 /* Stop timer, to prevent timeout. */ 333 del_timer_sync(&alg_data->mif.timer); 334 complete(&alg_data->mif.complete); 335 } else if (stat & mstatus_nai) { 336 /* Slave did not acknowledge, generate a STOP */ 337 dev_dbg(&alg_data->adapter.dev, 338 "%s(): Slave did not acknowledge, generating a STOP.\n", 339 __func__); 340 i2c_pnx_stop(alg_data); 341 342 /* Disable master interrupts. */ 343 ctl = ioread32(I2C_REG_CTL(alg_data)); 344 ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie | 345 mcntrl_drmie); 346 iowrite32(ctl, I2C_REG_CTL(alg_data)); 347 348 /* Our return value. */ 349 alg_data->mif.ret = -EIO; 350 351 /* Stop timer, to prevent timeout. */ 352 del_timer_sync(&alg_data->mif.timer); 353 complete(&alg_data->mif.complete); 354 } else { 355 /* 356 * Two options: 357 * - Master Tx needs data. 358 * - There is data in the Rx-fifo 359 * The latter is only the case if we have requested for data, 360 * via a dummy write. (See 'i2c_pnx_master_rcv'.) 361 * We therefore check, as a sanity check, whether that interrupt 362 * has been enabled. 363 */ 364 if ((stat & mstatus_drmi) || !(stat & mstatus_rfe)) { 365 if (alg_data->mif.mode == I2C_SMBUS_WRITE) { 366 i2c_pnx_master_xmit(alg_data); 367 } else if (alg_data->mif.mode == I2C_SMBUS_READ) { 368 i2c_pnx_master_rcv(alg_data); 369 } 370 } 371 } 372 373 /* Clear TDI and AFI bits */ 374 stat = ioread32(I2C_REG_STS(alg_data)); 375 iowrite32(stat | mstatus_tdi | mstatus_afi, I2C_REG_STS(alg_data)); 376 377 dev_dbg(&alg_data->adapter.dev, 378 "%s(): exiting, stat = %x ctrl = %x.\n", 379 __func__, ioread32(I2C_REG_STS(alg_data)), 380 ioread32(I2C_REG_CTL(alg_data))); 381 382 return IRQ_HANDLED; 383 } 384 385 static void i2c_pnx_timeout(unsigned long data) 386 { 387 struct i2c_pnx_algo_data *alg_data = (struct i2c_pnx_algo_data *)data; 388 u32 ctl; 389 390 dev_err(&alg_data->adapter.dev, 391 "Master timed out. stat = %04x, cntrl = %04x. Resetting master...\n", 392 ioread32(I2C_REG_STS(alg_data)), 393 ioread32(I2C_REG_CTL(alg_data))); 394 395 /* Reset master and disable interrupts */ 396 ctl = ioread32(I2C_REG_CTL(alg_data)); 397 ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie | mcntrl_drmie); 398 iowrite32(ctl, I2C_REG_CTL(alg_data)); 399 400 ctl |= mcntrl_reset; 401 iowrite32(ctl, I2C_REG_CTL(alg_data)); 402 wait_reset(I2C_PNX_TIMEOUT, alg_data); 403 alg_data->mif.ret = -EIO; 404 complete(&alg_data->mif.complete); 405 } 406 407 static inline void bus_reset_if_active(struct i2c_pnx_algo_data *alg_data) 408 { 409 u32 stat; 410 411 if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_active) { 412 dev_err(&alg_data->adapter.dev, 413 "%s: Bus is still active after xfer. Reset it...\n", 414 alg_data->adapter.name); 415 iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset, 416 I2C_REG_CTL(alg_data)); 417 wait_reset(I2C_PNX_TIMEOUT, alg_data); 418 } else if (!(stat & mstatus_rfe) || !(stat & mstatus_tfe)) { 419 /* If there is data in the fifo's after transfer, 420 * flush fifo's by reset. 421 */ 422 iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset, 423 I2C_REG_CTL(alg_data)); 424 wait_reset(I2C_PNX_TIMEOUT, alg_data); 425 } else if (stat & mstatus_nai) { 426 iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset, 427 I2C_REG_CTL(alg_data)); 428 wait_reset(I2C_PNX_TIMEOUT, alg_data); 429 } 430 } 431 432 /** 433 * i2c_pnx_xfer - generic transfer entry point 434 * @adap: pointer to I2C adapter structure 435 * @msgs: array of messages 436 * @num: number of messages 437 * 438 * Initiates the transfer 439 */ 440 static int 441 i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) 442 { 443 struct i2c_msg *pmsg; 444 int rc = 0, completed = 0, i; 445 struct i2c_pnx_algo_data *alg_data = adap->algo_data; 446 u32 stat = ioread32(I2C_REG_STS(alg_data)); 447 448 dev_dbg(&alg_data->adapter.dev, 449 "%s(): entering: %d messages, stat = %04x.\n", 450 __func__, num, ioread32(I2C_REG_STS(alg_data))); 451 452 bus_reset_if_active(alg_data); 453 454 /* Process transactions in a loop. */ 455 for (i = 0; rc >= 0 && i < num; i++) { 456 u8 addr; 457 458 pmsg = &msgs[i]; 459 addr = pmsg->addr; 460 461 if (pmsg->flags & I2C_M_TEN) { 462 dev_err(&alg_data->adapter.dev, 463 "%s: 10 bits addr not supported!\n", 464 alg_data->adapter.name); 465 rc = -EINVAL; 466 break; 467 } 468 469 alg_data->mif.buf = pmsg->buf; 470 alg_data->mif.len = pmsg->len; 471 alg_data->mif.mode = (pmsg->flags & I2C_M_RD) ? 472 I2C_SMBUS_READ : I2C_SMBUS_WRITE; 473 alg_data->mif.ret = 0; 474 alg_data->last = (i == num - 1); 475 476 dev_dbg(&alg_data->adapter.dev, "%s(): mode %d, %d bytes\n", 477 __func__, alg_data->mif.mode, alg_data->mif.len); 478 479 i2c_pnx_arm_timer(alg_data); 480 481 /* initialize the completion var */ 482 init_completion(&alg_data->mif.complete); 483 484 /* Enable master interrupt */ 485 iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_afie | 486 mcntrl_naie | mcntrl_drmie, 487 I2C_REG_CTL(alg_data)); 488 489 /* Put start-code and slave-address on the bus. */ 490 rc = i2c_pnx_start(addr, alg_data); 491 if (rc < 0) 492 break; 493 494 /* Wait for completion */ 495 wait_for_completion(&alg_data->mif.complete); 496 497 if (!(rc = alg_data->mif.ret)) 498 completed++; 499 dev_dbg(&alg_data->adapter.dev, 500 "%s(): Complete, return code = %d.\n", 501 __func__, rc); 502 503 /* Clear TDI and AFI bits in case they are set. */ 504 if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) { 505 dev_dbg(&alg_data->adapter.dev, 506 "%s: TDI still set... clearing now.\n", 507 alg_data->adapter.name); 508 iowrite32(stat, I2C_REG_STS(alg_data)); 509 } 510 if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_afi) { 511 dev_dbg(&alg_data->adapter.dev, 512 "%s: AFI still set... clearing now.\n", 513 alg_data->adapter.name); 514 iowrite32(stat, I2C_REG_STS(alg_data)); 515 } 516 } 517 518 bus_reset_if_active(alg_data); 519 520 /* Cleanup to be sure... */ 521 alg_data->mif.buf = NULL; 522 alg_data->mif.len = 0; 523 524 dev_dbg(&alg_data->adapter.dev, "%s(): exiting, stat = %x\n", 525 __func__, ioread32(I2C_REG_STS(alg_data))); 526 527 if (completed != num) 528 return ((rc < 0) ? rc : -EREMOTEIO); 529 530 return num; 531 } 532 533 static u32 i2c_pnx_func(struct i2c_adapter *adapter) 534 { 535 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 536 } 537 538 static struct i2c_algorithm pnx_algorithm = { 539 .master_xfer = i2c_pnx_xfer, 540 .functionality = i2c_pnx_func, 541 }; 542 543 #ifdef CONFIG_PM 544 static int i2c_pnx_controller_suspend(struct platform_device *pdev, 545 pm_message_t state) 546 { 547 struct i2c_pnx_algo_data *alg_data = platform_get_drvdata(pdev); 548 549 /* FIXME: shouldn't this be clk_disable? */ 550 clk_enable(alg_data->clk); 551 552 return 0; 553 } 554 555 static int i2c_pnx_controller_resume(struct platform_device *pdev) 556 { 557 struct i2c_pnx_algo_data *alg_data = platform_get_drvdata(pdev); 558 559 return clk_enable(alg_data->clk); 560 } 561 #else 562 #define i2c_pnx_controller_suspend NULL 563 #define i2c_pnx_controller_resume NULL 564 #endif 565 566 static int __devinit i2c_pnx_probe(struct platform_device *pdev) 567 { 568 unsigned long tmp; 569 int ret = 0; 570 struct i2c_pnx_algo_data *alg_data; 571 unsigned long freq; 572 struct i2c_pnx_data *i2c_pnx = pdev->dev.platform_data; 573 574 if (!i2c_pnx || !i2c_pnx->name) { 575 dev_err(&pdev->dev, "%s: no platform data supplied\n", 576 __func__); 577 ret = -EINVAL; 578 goto out; 579 } 580 581 alg_data = kzalloc(sizeof(*alg_data), GFP_KERNEL); 582 if (!alg_data) { 583 ret = -ENOMEM; 584 goto err_kzalloc; 585 } 586 587 platform_set_drvdata(pdev, alg_data); 588 589 strlcpy(alg_data->adapter.name, i2c_pnx->name, 590 sizeof(alg_data->adapter.name)); 591 alg_data->adapter.dev.parent = &pdev->dev; 592 alg_data->adapter.algo = &pnx_algorithm; 593 alg_data->adapter.algo_data = alg_data; 594 alg_data->adapter.nr = pdev->id; 595 alg_data->i2c_pnx = i2c_pnx; 596 597 alg_data->clk = clk_get(&pdev->dev, NULL); 598 if (IS_ERR(alg_data->clk)) { 599 ret = PTR_ERR(alg_data->clk); 600 goto out_drvdata; 601 } 602 603 init_timer(&alg_data->mif.timer); 604 alg_data->mif.timer.function = i2c_pnx_timeout; 605 alg_data->mif.timer.data = (unsigned long)alg_data; 606 607 /* Register I/O resource */ 608 if (!request_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE, 609 pdev->name)) { 610 dev_err(&pdev->dev, 611 "I/O region 0x%08x for I2C already in use.\n", 612 i2c_pnx->base); 613 ret = -ENODEV; 614 goto out_clkget; 615 } 616 617 alg_data->ioaddr = ioremap(i2c_pnx->base, I2C_PNX_REGION_SIZE); 618 if (!alg_data->ioaddr) { 619 dev_err(&pdev->dev, "Couldn't ioremap I2C I/O region\n"); 620 ret = -ENOMEM; 621 goto out_release; 622 } 623 624 ret = clk_enable(alg_data->clk); 625 if (ret) 626 goto out_unmap; 627 628 freq = clk_get_rate(alg_data->clk); 629 630 /* 631 * Clock Divisor High This value is the number of system clocks 632 * the serial clock (SCL) will be high. 633 * For example, if the system clock period is 50 ns and the maximum 634 * desired serial period is 10000 ns (100 kHz), then CLKHI would be 635 * set to 0.5*(f_sys/f_i2c)-2=0.5*(20e6/100e3)-2=98. The actual value 636 * programmed into CLKHI will vary from this slightly due to 637 * variations in the output pad's rise and fall times as well as 638 * the deglitching filter length. 639 */ 640 641 tmp = ((freq / 1000) / I2C_PNX_SPEED_KHZ) / 2 - 2; 642 if (tmp > 0x3FF) 643 tmp = 0x3FF; 644 iowrite32(tmp, I2C_REG_CKH(alg_data)); 645 iowrite32(tmp, I2C_REG_CKL(alg_data)); 646 647 iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data)); 648 if (wait_reset(I2C_PNX_TIMEOUT, alg_data)) { 649 ret = -ENODEV; 650 goto out_clock; 651 } 652 init_completion(&alg_data->mif.complete); 653 654 ret = request_irq(i2c_pnx->irq, i2c_pnx_interrupt, 655 0, pdev->name, alg_data); 656 if (ret) 657 goto out_clock; 658 659 /* Register this adapter with the I2C subsystem */ 660 ret = i2c_add_numbered_adapter(&alg_data->adapter); 661 if (ret < 0) { 662 dev_err(&pdev->dev, "I2C: Failed to add bus\n"); 663 goto out_irq; 664 } 665 666 dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n", 667 alg_data->adapter.name, i2c_pnx->base, i2c_pnx->irq); 668 669 return 0; 670 671 out_irq: 672 free_irq(i2c_pnx->irq, alg_data); 673 out_clock: 674 clk_disable(alg_data->clk); 675 out_unmap: 676 iounmap(alg_data->ioaddr); 677 out_release: 678 release_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE); 679 out_clkget: 680 clk_put(alg_data->clk); 681 out_drvdata: 682 kfree(alg_data); 683 err_kzalloc: 684 platform_set_drvdata(pdev, NULL); 685 out: 686 return ret; 687 } 688 689 static int __devexit i2c_pnx_remove(struct platform_device *pdev) 690 { 691 struct i2c_pnx_algo_data *alg_data = platform_get_drvdata(pdev); 692 struct i2c_pnx_data *i2c_pnx = alg_data->i2c_pnx; 693 694 free_irq(i2c_pnx->irq, alg_data); 695 i2c_del_adapter(&alg_data->adapter); 696 clk_disable(alg_data->clk); 697 iounmap(alg_data->ioaddr); 698 release_mem_region(i2c_pnx->base, I2C_PNX_REGION_SIZE); 699 clk_put(alg_data->clk); 700 kfree(alg_data); 701 platform_set_drvdata(pdev, NULL); 702 703 return 0; 704 } 705 706 static struct platform_driver i2c_pnx_driver = { 707 .driver = { 708 .name = "pnx-i2c", 709 .owner = THIS_MODULE, 710 }, 711 .probe = i2c_pnx_probe, 712 .remove = __devexit_p(i2c_pnx_remove), 713 .suspend = i2c_pnx_controller_suspend, 714 .resume = i2c_pnx_controller_resume, 715 }; 716 717 static int __init i2c_adap_pnx_init(void) 718 { 719 return platform_driver_register(&i2c_pnx_driver); 720 } 721 722 static void __exit i2c_adap_pnx_exit(void) 723 { 724 platform_driver_unregister(&i2c_pnx_driver); 725 } 726 727 MODULE_AUTHOR("Vitaly Wool, Dennis Kovalev <source@mvista.com>"); 728 MODULE_DESCRIPTION("I2C driver for Philips IP3204-based I2C busses"); 729 MODULE_LICENSE("GPL"); 730 MODULE_ALIAS("platform:pnx-i2c"); 731 732 /* We need to make sure I2C is initialized before USB */ 733 subsys_initcall(i2c_adap_pnx_init); 734 module_exit(i2c_adap_pnx_exit); 735