开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
i2c-keywest.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

i2c-keywest.c：源码内容
  1. /*
  2.     i2c Support for Apple Keywest I2C Bus Controller
  4.     Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
  6.     Original work by
  7.     
  8.     Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
  10.     This program is free software; you can redistribute it and/or modify
  11.     it under the terms of the GNU General Public License as published by
  12.     the Free Software Foundation; either version 2 of the License, or
  13.     (at your option) any later version.
  15.     This program is distributed in the hope that it will be useful,
  16.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.     GNU General Public License for more details.
  20.     You should have received a copy of the GNU General Public License
  21.     along with this program; if not, write to the Free Software
  22.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24.     Changes:
  26.     2001/12/13 BenH New implementation
  27.     2001/12/15 BenH Add support for "byte" and "quick"
  28.                         transfers. Add i2c_xfer routine.
  30.     My understanding of the various modes supported by keywest are:
  32.      - Dumb mode : not implemented, probably direct tweaking of lines
  33.      - Standard mode : simple i2c transaction of type
  34.          S Addr R/W A Data A Data ... T
  35.      - Standard sub mode : combined 8 bit subaddr write with data read
  36.          S Addr R/W A SubAddr A Data A Data ... T
  37.      - Combined mode : Subaddress and Data sequences appended with no stop
  38.          S Addr R/W A SubAddr S Addr R/W A Data A Data ... T
  40.     Currently, this driver uses only Standard mode for i2c xfer, and
  41.     smbus byte & quick transfers ; and uses StandardSub mode for
  42.     other smbus transfers instead of combined as we need that for the
  43.     sound driver to be happy
  44. */
  46. #include <linux/module.h>
  47. #include <linux/config.h>
  48. #include <linux/version.h>
  49. #include <linux/kernel.h>
  50. #include <linux/ioport.h>
  51. #include <linux/pci.h>
  52. #include <linux/types.h>
  53. #include <linux/delay.h>
  54. #include <linux/i2c.h>
  55. #include <linux/init.h>
  56. #include <linux/mm.h>
  57. #include <linux/timer.h>
  58. #include <linux/spinlock.h>
  59. #include <linux/completion.h>
  61. #include <asm/io.h>
  62. #include <asm/prom.h>
  63. #include <asm/machdep.h>
  64. #include <asm/pmac_feature.h>
  66. #include "i2c-keywest.h"
  68. #define DBG(x...) do {
  69. if (debug > 0) 
  70. printk(KERN_DEBUG "KW:" x); 
  71. } while(0)
  74. MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
  75. MODULE_DESCRIPTION("I2C driver for Apple's Keywest");
  76. MODULE_LICENSE("GPL");
  77. MODULE_PARM(probe, "i");
  78. MODULE_PARM(debug, "i");
  79. EXPORT_NO_SYMBOLS;
  81. int probe = 0;
  82. int debug = 0;
  84. static struct keywest_iface *ifaces = NULL;
  87. static void
  88. do_stop(struct keywest_iface* iface, int result)
  89. {
  90. write_reg(reg_control, read_reg(reg_control) | KW_I2C_CTL_STOP);
  91. iface->state = state_stop;
  92. iface->result = result;
  93. }
  95. /* Main state machine for standard & standard sub mode */
  96. static int
  97. handle_interrupt(struct keywest_iface *iface, u8 isr)
  98. {
  99. int ack;
  100. int rearm_timer = 1;
  102. DBG("handle_interrupt(), got: %x, status: %x, state: %dn",
  103. isr, read_reg(reg_status), iface->state);
  104. if (isr == 0 && iface->state != state_stop) {
  105. do_stop(iface, -1);
  106. return rearm_timer;
  107. }
  108. if (isr & KW_I2C_IRQ_STOP && iface->state != state_stop) {
  109. iface->result = -1;
  110. iface->state = state_stop;
  111. }
  112. switch(iface->state) {
  113. case state_addr:
  114. if (!(isr & KW_I2C_IRQ_ADDR)) {
  115. do_stop(iface, -1);
  116. break;
  117. }
  118. ack = read_reg(reg_status);
  119. DBG("ack on set address: %xn", ack);
  120. if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
  121. do_stop(iface, -1);
  122. break;
  123. }
  124. /* Handle rw "quick" mode */
  125. if (iface->datalen == 0)
  126. do_stop(iface, 0);
  127. else if (iface->read_write == I2C_SMBUS_READ) {
  128. iface->state = state_read;
  129. if (iface->datalen > 1)
  130. write_reg(reg_control, read_reg(reg_control)
  131. | KW_I2C_CTL_AAK);
  132. } else {
  133. iface->state = state_write;
  134. DBG("write byte: %xn", *(iface->data));
  135. write_reg(reg_data, *(iface->data++));
  136. iface->datalen--;
  137. }
  139. break;
  140. case state_read:
  141. if (!(isr & KW_I2C_IRQ_DATA)) {
  142. do_stop(iface, -1);
  143. break;
  144. }
  145. *(iface->data++) = read_reg(reg_data);
  146. DBG("read byte: %xn", *(iface->data-1));
  147. iface->datalen--;
  148. if (iface->datalen == 0)
  149. iface->state = state_stop;
  150. else
  151. write_reg(reg_control, 0);
  152. break;
  153. case state_write:
  154. if (!(isr & KW_I2C_IRQ_DATA)) {
  155. do_stop(iface, -1);
  156. break;
  157. }
  158. /* Check ack status */
  159. ack = read_reg(reg_status);
  160. DBG("ack on data write: %xn", ack);
  161. if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
  162. do_stop(iface, -1);
  163. break;
  164. }
  165. if (iface->datalen) {
  166. DBG("write byte: %xn", *(iface->data));
  167. write_reg(reg_data, *(iface->data++));
  168. iface->datalen--;
  169. } else
  170. do_stop(iface, 0);
  171. break;
  173. case state_stop:
  174. if (!(isr & KW_I2C_IRQ_STOP) && (++iface->stopretry) < 10)
  175. do_stop(iface, -1);
  176. else {
  177. rearm_timer = 0;
  178. iface->state = state_idle;
  179. write_reg(reg_control, 0x00);
  180. write_reg(reg_ier, 0x00);
  181. complete(&iface->complete);
  182. }
  183. break;
  184. }
  186. write_reg(reg_isr, isr);
  188. return rearm_timer;
  189. }
  191. /* Interrupt handler */
  192. static void
  193. keywest_irq(int irq, void *dev_id, struct pt_regs *regs)
  194. {
  195. struct keywest_iface *iface = (struct keywest_iface *)dev_id;
  197. spin_lock(&iface->lock);
  198. del_timer(&iface->timeout_timer);
  199. if (handle_interrupt(iface, read_reg(reg_isr))) {
  200. iface->timeout_timer.expires = jiffies + POLL_TIMEOUT;
  201. add_timer(&iface->timeout_timer);
  202. }
  203. spin_unlock(&iface->lock);
  204. }
  206. static void
  207. keywest_timeout(unsigned long data)
  208. {
  209. struct keywest_iface *iface = (struct keywest_iface *)data;
  211. DBG("timeout !n");
  212. spin_lock_irq(&iface->lock);
  213. if (handle_interrupt(iface, read_reg(reg_isr))) {
  214. iface->timeout_timer.expires = jiffies + POLL_TIMEOUT;
  215. add_timer(&iface->timeout_timer);
  216. }
  217. spin_unlock(&iface->lock);
  218. }
  220. /*
  221.  * SMBUS-type transfer entrypoint
  222.  */
  223. static s32
  224. keywest_smbus_xfer( struct i2c_adapter* adap,
  225. u16 addr,
  226. unsigned short flags,
  227. char read_write,
  228. u8 command,
  229. int size,
  230. union i2c_smbus_data* data)
  231. {
  232. struct keywest_chan* chan = (struct keywest_chan*)adap->data;
  233. struct keywest_iface* iface = chan->iface;
  234. int len;
  235. u8* buffer;
  236. u16 cur_word;
  237. int rc = 0;
  239. if (iface->state == state_dead)
  240. return -1;
  242. /* Prepare datas & select mode */
  243. iface->cur_mode &= ~KW_I2C_MODE_MODE_MASK;
  244. switch (size) {
  245.     case I2C_SMBUS_QUICK:
  246.      len = 0;
  247.      buffer = NULL;
  248.      iface->cur_mode |= KW_I2C_MODE_STANDARD;
  249.      break;
  250.     case I2C_SMBUS_BYTE:
  251.      len = 1;
  252.      buffer = &data->byte;
  253.      iface->cur_mode |= KW_I2C_MODE_STANDARD;
  254.      break;
  255.     case I2C_SMBUS_BYTE_DATA:
  256.      len = 1;
  257.      buffer = &data->byte;
  258.      iface->cur_mode |= KW_I2C_MODE_STANDARDSUB;
  259.      break;
  260.     case I2C_SMBUS_WORD_DATA:
  261.      len = 2;
  262.      cur_word = cpu_to_le16(data->word);
  263.      buffer = (u8 *)&cur_word;
  264.      iface->cur_mode |= KW_I2C_MODE_STANDARDSUB;
  265. break;
  266.     case I2C_SMBUS_BLOCK_DATA:
  267.      len = data->block[0];
  268.      buffer = &data->block[1];
  269.      iface->cur_mode |= KW_I2C_MODE_STANDARDSUB;
  270. break;
  271.     default:
  272.      return -1;
  273. }
  275. /* Original driver had this limitation */
  276. if (len > 32)
  277. len = 32;
  279. down(&iface->sem);
  281. DBG("chan: %d, addr: 0x%x, transfer len: %d, read: %dn",
  282. chan->chan_no, addr, len, read_write == I2C_SMBUS_READ);
  284. iface->data = buffer;
  285. iface->datalen = len;
  286. iface->state = state_addr;
  287. iface->result = 0;
  288. iface->stopretry = 0;
  289. iface->read_write = read_write;
  291. /* Setup channel & clear pending irqs */
  292. write_reg(reg_mode, iface->cur_mode | (chan->chan_no << 4));
  293. write_reg(reg_isr, read_reg(reg_isr));
  294. write_reg(reg_status, 0);
  296. /* Set up address and r/w bit */
  297. write_reg(reg_addr,
  298. (addr << 1) | ((read_write == I2C_SMBUS_READ) ? 0x01 : 0x00));
  300. /* Set up the sub address */
  301. if ((iface->cur_mode & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_STANDARDSUB
  302.     || (iface->cur_mode & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_COMBINED)
  303. write_reg(reg_subaddr, command);
  305. /* Arm timeout */
  306. iface->timeout_timer.expires = jiffies + POLL_TIMEOUT;
  307. add_timer(&iface->timeout_timer);
  309. /* Start sending address & enable interrupt*/
  310. write_reg(reg_control, read_reg(reg_control) | KW_I2C_CTL_XADDR);
  311. write_reg(reg_ier, KW_I2C_IRQ_MASK);
  313. wait_for_completion(&iface->complete);
  315. rc = iface->result;
  316. DBG("transfer done, result: %dn", rc);
  318. if (rc == 0 && size == I2C_SMBUS_WORD_DATA && read_write == I2C_SMBUS_READ)
  319.      data->word = le16_to_cpu(cur_word);
  321. /* Release sem */
  322. up(&iface->sem);
  324. return rc;
  325. }
  327. /*
  328.  * Generic i2c master transfer entrypoint
  329.  */
  330. static int
  331. keywest_xfer( struct i2c_adapter *adap,
  332. struct i2c_msg msgs[], 
  333. int num)
  334. {
  335. struct keywest_chan* chan = (struct keywest_chan*)adap->data;
  336. struct keywest_iface* iface = chan->iface;
  337. struct i2c_msg *pmsg;
  338. int i, completed;
  339. int rc = 0;
  341. down(&iface->sem);
  343. /* Set adapter to standard mode */
  344. iface->cur_mode &= ~KW_I2C_MODE_MODE_MASK;
  345. iface->cur_mode |= KW_I2C_MODE_STANDARD;
  347. completed = 0;
  348. for (i = 0; rc >= 0 && i < num;) {
  349. u8 addr;
  351. pmsg = &msgs[i++];
  352. addr = pmsg->addr;
  353. if (pmsg->flags & I2C_M_TEN) {
  354. printk(KERN_ERR "i2c-keywest: 10 bits addr not supported !n");
  355. rc = -EINVAL;
  356. break;
  357. }
  358. DBG("xfer: chan: %d, doing %s %d bytes to 0x%02x - %d of %d messagesn",
  359.      chan->chan_no,
  360.      pmsg->flags & I2C_M_RD ? "read" : "write",
  361.                      pmsg->len, addr, i, num);
  362.     
  363. /* Setup channel & clear pending irqs */
  364. write_reg(reg_mode, iface->cur_mode | (chan->chan_no << 4));
  365. write_reg(reg_isr, read_reg(reg_isr));
  366. write_reg(reg_status, 0);
  368. iface->data = pmsg->buf;
  369. iface->datalen = pmsg->len;
  370. iface->state = state_addr;
  371. iface->result = 0;
  372. iface->stopretry = 0;
  373. if (pmsg->flags & I2C_M_RD)
  374. iface->read_write = I2C_SMBUS_READ;
  375. else
  376. iface->read_write = I2C_SMBUS_WRITE;
  378. /* Set up address and r/w bit */
  379. if (pmsg->flags & I2C_M_REV_DIR_ADDR)
  380. addr ^= 1;
  381. write_reg(reg_addr,
  382. (addr << 1) |
  383. ((iface->read_write == I2C_SMBUS_READ) ? 0x01 : 0x00));
  385. /* Arm timeout */
  386. iface->timeout_timer.expires = jiffies + POLL_TIMEOUT;
  387. add_timer(&iface->timeout_timer);
  389. /* Start sending address & enable interrupt*/
  390. write_reg(reg_control, read_reg(reg_control) | KW_I2C_CTL_XADDR);
  391. write_reg(reg_ier, KW_I2C_IRQ_MASK);
  393. wait_for_completion(&iface->complete);
  395. rc = iface->result;
  396. if (rc == 0)
  397. completed++;
  398. DBG("transfer done, result: %dn", rc);
  399. }
  401. /* Release sem */
  402. up(&iface->sem);
  404. return completed;
  405. }
  407. static u32
  408. keywest_func(struct i2c_adapter * adapter)
  409. {
  410. return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
  411.        I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
  412.        I2C_FUNC_SMBUS_BLOCK_DATA;
  413. }
  415. static void
  416. keywest_inc(struct i2c_adapter *adapter)
  417. {
  418. MOD_INC_USE_COUNT;
  419. }
  421. static void
  422. keywest_dec(struct i2c_adapter *adapter)
  423. {
  424. MOD_DEC_USE_COUNT;
  425. }
  427. /* For now, we only handle combined mode (smbus) */
  428. static struct i2c_algorithm keywest_algorithm = {
  429. name: "Keywest i2c",
  430. id: I2C_ALGO_SMBUS,
  431. smbus_xfer: keywest_smbus_xfer,
  432. master_xfer: keywest_xfer,
  433. functionality: keywest_func,
  434. };
  437. static int
  438. create_iface(struct device_node* np)
  439. {
  440. unsigned long steps, *psteps, *prate;
  441. unsigned bsteps, tsize, i, nchan, addroffset;
  442. struct keywest_iface* iface;
  443. int rc;
  445. psteps = (unsigned long *)get_property(np, "AAPL,address-step", NULL);
  446. steps = psteps ? (*psteps) : 0x10;
  448. /* Hrm... maybe we can be smarter here */
  449. for (bsteps = 0; (steps & 0x01) == 0; bsteps++)
  450. steps >>= 1;
  452. if (!strcmp(np->parent->name, "uni-n")) {
  453. nchan = 2;
  454. addroffset = 3;
  455. } else {
  456. addroffset = 0;
  457. nchan = 1;
  458. }
  460. tsize = sizeof(struct keywest_iface) +
  461. (sizeof(struct keywest_chan) + 4) * nchan;
  462. iface = (struct keywest_iface *) kmalloc(tsize, GFP_KERNEL);
  463. if (iface == NULL) {
  464. printk(KERN_ERR "i2c-keywest: can't allocate inteface !n");
  465. return -ENOMEM;
  466. }
  467. memset(iface, 0, tsize);
  468. init_MUTEX(&iface->sem);
  469. spin_lock_init(&iface->lock);
  470. init_completion(&iface->complete);
  471. iface->bsteps = bsteps;
  472. iface->chan_count = nchan;
  473. iface->state = state_idle;
  474. iface->irq = np->intrs[0].line;
  475. iface->channels = (struct keywest_chan *)
  476. (((unsigned long)(iface + 1) + 3UL) & ~3UL);
  477. iface->base = (unsigned long)ioremap(np->addrs[0].address + addroffset,
  478. np->addrs[0].size);
  479. if (iface->base == 0) {
  480. printk(KERN_ERR "i2c-keywest: can't map inteface !n");
  481. kfree(iface);
  482. return -ENOMEM;
  483. }
  485. init_timer(&iface->timeout_timer);
  486. iface->timeout_timer.function = keywest_timeout;
  487. iface->timeout_timer.data = (unsigned long)iface;
  489. /* Select interface rate */
  490. iface->cur_mode = KW_I2C_MODE_100KHZ;
  491. prate = (unsigned long *)get_property(np, "AAPL,i2c-rate", NULL);
  492. if (prate) switch(*prate) {
  493. case 100:
  494. iface->cur_mode = KW_I2C_MODE_100KHZ;
  495. break;
  496. case 50:
  497. iface->cur_mode = KW_I2C_MODE_50KHZ;
  498. break;
  499. case 25:
  500. iface->cur_mode = KW_I2C_MODE_25KHZ;
  501. break;
  502. default:
  503. printk(KERN_WARNING "i2c-keywest: unknown rate %ldKhz, using 100KHzn",
  504. *prate);
  505. }
  507. /* Select standard mode by default */
  508. iface->cur_mode |= KW_I2C_MODE_STANDARD;
  510. /* Write mode */
  511. write_reg(reg_mode, iface->cur_mode);
  513. /* Switch interrupts off & clear them*/
  514. write_reg(reg_ier, 0x00);
  515. write_reg(reg_isr, KW_I2C_IRQ_MASK);
  517. /* Request chip interrupt */
  518. rc = request_irq(iface->irq, keywest_irq, 0, "keywest i2c", iface);
  519. if (rc) {
  520. printk(KERN_ERR "i2c-keywest: can't get IRQ %d !n", iface->irq);
  521. iounmap((void *)iface->base);
  522. kfree(iface);
  523. return -ENODEV;
  524. }
  526. for (i=0; i<nchan; i++) {
  527. struct keywest_chan* chan = &iface->channels[i];
  528. u8 addr;
  530. sprintf(chan->adapter.name, "%s %d", np->parent->name, i);
  531. chan->iface = iface;
  532. chan->chan_no = i;
  533. chan->adapter.id = I2C_ALGO_SMBUS;
  534. chan->adapter.algo = &keywest_algorithm;
  535. chan->adapter.algo_data = NULL;
  536. chan->adapter.inc_use = keywest_inc;
  537. chan->adapter.dec_use = keywest_dec;
  538. chan->adapter.client_register = NULL;
  539. chan->adapter.client_unregister = NULL;
  540. chan->adapter.data = chan;
  542. rc = i2c_add_adapter(&chan->adapter);
  543. if (rc) {
  544. printk("i2c-keywest.c: Adapter %s registration failedn",
  545. chan->adapter.name);
  546. chan->adapter.data = NULL;
  547. }
  548. if (probe) {
  549. printk("Probe: ");
  550. for (addr = 0x00; addr <= 0x7f; addr++) {
  551. if (i2c_smbus_xfer(&chan->adapter,addr,
  552.     0,0,0,I2C_SMBUS_QUICK,NULL) >= 0)
  553. printk("%02x ", addr);
  554. }
  555. printk("n");
  556. }
  557. }
  559. printk(KERN_INFO "Found KeyWest i2c on "%s", %d channel%s, stepping: %d bitsn",
  560. np->parent->name, nchan, nchan > 1 ? "s" : "", bsteps);
  562. iface->next = ifaces;
  563. ifaces = iface;
  564. return 0;
  565. }
  567. static void
  568. dispose_iface(struct keywest_iface *iface)
  569. {
  570. int i, rc;
  572. ifaces = iface->next;
  574. /* Make sure we stop all activity */
  575. down(&iface->sem);
  576. spin_lock_irq(&iface->lock);
  577. while (iface->state != state_idle) {
  578. spin_unlock_irq(&iface->lock);
  579. set_task_state(current,TASK_UNINTERRUPTIBLE);
  580. schedule_timeout(HZ/10);
  581. spin_lock_irq(&iface->lock);
  582. }
  583. iface->state = state_dead;
  584. spin_unlock_irq(&iface->lock);
  585. free_irq(iface->irq, iface);
  586. up(&iface->sem);
  588. /* Release all channels */
  589. for (i=0; i<iface->chan_count; i++) {
  590. struct keywest_chan* chan = &iface->channels[i];
  591. if (!chan->adapter.data)
  592. continue;
  593. rc = i2c_del_adapter(&chan->adapter);
  594. chan->adapter.data = NULL;
  595. /* We aren't that prepared to deal with this... */
  596. if (rc)
  597. printk("i2c-keywest.c: i2c_del_adapter failed, that's bad !n");
  598. }
  599. iounmap((void *)iface->base);
  600. kfree(iface);
  601. }
  603. static int __init
  604. i2c_keywest_init(void)
  605. {
  606. struct device_node *np;
  607. int rc = -ENODEV;
  609. np = find_compatible_devices("i2c", "keywest");
  610. while (np != 0) {
  611. if (np->n_addrs >= 1 && np->n_intrs >= 1)
  612. rc = create_iface(np);
  613. np = np->next;
  614. }
  615. if (ifaces)
  616. rc = 0;
  617. return rc;
  618. }
  620. static void __exit
  621. i2c_keywest_cleanup(void)
  622. {
  623. while(ifaces)
  624. dispose_iface(ifaces);
  625. }
  627. module_init(i2c_keywest_init);
  628. module_exit(i2c_keywest_cleanup);