2 * linux/drivers/i2c/busses/i2c-nuc900.c
4 * Copyright (c) 2010 Nuvoton technology corporation.
6 * This driver based on S3C2410 I2C driver of Ben Dooks <ben-Y5A6D6n0/KfQXOPxS62xeg@public.gmane.org>.
7 * Written by Wan ZongShun <mcuos.com-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation;version 2 of the License.
15 #include <linux/kernel.h>
16 #include <linux/module.h>
18 #include <linux/i2c.h>
19 #include <linux/i2c-id.h>
20 #include <linux/init.h>
21 #include <linux/time.h>
22 #include <linux/interrupt.h>
23 #include <linux/delay.h>
24 #include <linux/errno.h>
25 #include <linux/err.h>
26 #include <linux/platform_device.h>
27 #include <linux/clk.h>
28 #include <linux/cpufreq.h>
29 #include <linux/slab.h>
35 /* nuc900 i2c registers offset */
44 /* nuc900 i2c CSR register bits */
48 #define I2CSTART 0x018
50 #define ARBIT_LOST 0x200
51 #define SLAVE_ACK 0x800
53 /* nuc900 i2c CMDR register bits */
55 #define I2C_CMD_START 0x10
56 #define I2C_CMD_STOP 0x08
57 #define I2C_CMD_READ 0x04
58 #define I2C_CMD_WRITE 0x02
59 #define I2C_CMD_NACK 0x01
61 /* i2c controller state */
63 enum nuc900_i2c_state
{
71 /* i2c controller private data */
75 wait_queue_head_t wait
;
83 enum nuc900_i2c_state state
;
88 struct resource
*ioarea
;
89 struct i2c_adapter adap
;
92 /* nuc900_i2c_master_complete
94 * complete the message and wake up the caller, using the given return code,
98 static inline void nuc900_i2c_master_complete(struct nuc900_i2c
*i2c
, int ret
)
100 dev_dbg(i2c
->dev
, "master_complete %d\n", ret
);
112 /* irq enable/disable functions */
114 static inline void nuc900_i2c_disable_irq(struct nuc900_i2c
*i2c
)
118 tmp
= readl(i2c
->regs
+ CSR
);
119 writel(tmp
& ~IRQEN
, i2c
->regs
+ CSR
);
122 static inline void nuc900_i2c_enable_irq(struct nuc900_i2c
*i2c
)
126 tmp
= readl(i2c
->regs
+ CSR
);
127 writel(tmp
| IRQEN
, i2c
->regs
+ CSR
);
131 /* nuc900_i2c_message_start
133 * put the start of a message onto the bus
136 static void nuc900_i2c_message_start(struct nuc900_i2c
*i2c
,
139 unsigned int addr
= (msg
->addr
& 0x7f) << 1;
141 if (msg
->flags
& I2C_M_RD
)
143 writel(addr
& 0xff, i2c
->regs
+ TXR
);
144 writel(I2C_CMD_START
| I2C_CMD_WRITE
, i2c
->regs
+ CMDR
);
147 static inline void nuc900_i2c_stop(struct nuc900_i2c
*i2c
, int ret
)
150 dev_dbg(i2c
->dev
, "STOP\n");
152 /* stop the transfer */
153 i2c
->state
= STATE_STOP
;
154 writel(I2C_CMD_STOP
, i2c
->regs
+ CMDR
);
156 nuc900_i2c_master_complete(i2c
, ret
);
157 nuc900_i2c_disable_irq(i2c
);
160 /* helper functions to determine the current state in the set of
161 * messages we are sending
166 * returns TRUE if the current message is the last in the set
169 static inline int is_lastmsg(struct nuc900_i2c
*i2c
)
171 return i2c
->msg_idx
>= (i2c
->msg_num
- 1);
176 * returns TRUE if we this is the last byte in the current message
179 static inline int is_msglast(struct nuc900_i2c
*i2c
)
181 return i2c
->msg_ptr
== i2c
->msg
->len
-1;
186 * returns TRUE if we reached the end of the current message
189 static inline int is_msgend(struct nuc900_i2c
*i2c
)
191 return i2c
->msg_ptr
>= i2c
->msg
->len
;
194 /* i2c_nuc900_irq_nextbyte
196 * process an interrupt and work out what to do
199 static void i2c_nuc900_irq_nextbyte(struct nuc900_i2c
*i2c
,
200 unsigned long iicstat
)
204 switch (i2c
->state
) {
207 dev_err(i2c
->dev
, "%s: called in STATE_IDLE\n", __func__
);
211 dev_err(i2c
->dev
, "%s: called in STATE_STOP\n", __func__
);
212 nuc900_i2c_disable_irq(i2c
);
216 /* last thing we did was send a start condition on the
217 * bus, or started a new i2c message
220 if (iicstat
& SLAVE_ACK
&&
221 !(i2c
->msg
->flags
& I2C_M_IGNORE_NAK
)) {
222 /* ack was not received... */
224 dev_dbg(i2c
->dev
, "ack was not received\n");
225 nuc900_i2c_stop(i2c
, -ENXIO
);
229 if (i2c
->msg
->flags
& I2C_M_RD
)
230 i2c
->state
= STATE_READ
;
232 i2c
->state
= STATE_WRITE
;
234 /* terminate the transfer if there is nothing to do
235 * as this is used by the i2c probe to find devices.
238 if (is_lastmsg(i2c
) && i2c
->msg
->len
== 0) {
239 nuc900_i2c_stop(i2c
, 0);
243 if (i2c
->state
== STATE_READ
)
246 /* fall through to the write state, as we will need to
247 * send a byte as well
251 /* we are writing data to the device... check for the
252 * end of the message, and if so, work out what to do
255 if (!(i2c
->msg
->flags
& I2C_M_IGNORE_NAK
)) {
256 if (iicstat
& SLAVE_ACK
) {
257 dev_dbg(i2c
->dev
, "WRITE: No Ack\n");
259 nuc900_i2c_stop(i2c
, -ECONNREFUSED
);
266 if (!is_msgend(i2c
)) {
267 byte
= i2c
->msg
->buf
[i2c
->msg_ptr
++];
268 writeb(byte
, i2c
->regs
+ TXR
);
269 writel(I2C_CMD_WRITE
, i2c
->regs
+ CMDR
);
271 } else if (!is_lastmsg(i2c
)) {
272 /* we need to go to the next i2c message */
274 dev_dbg(i2c
->dev
, "WRITE: Next Message\n");
280 /* check to see if we need to do another message */
281 if (i2c
->msg
->flags
& I2C_M_NOSTART
) {
283 if (i2c
->msg
->flags
& I2C_M_RD
) {
284 /* cannot do this, the controller
285 * forces us to send a new START
286 * when we change direction
289 nuc900_i2c_stop(i2c
, -EINVAL
);
294 /* send the new start */
295 nuc900_i2c_message_start(i2c
, i2c
->msg
);
296 i2c
->state
= STATE_START
;
302 nuc900_i2c_stop(i2c
, 0);
307 /* we have a byte of data in the data register, do
308 * something with it, and then work out wether we are
309 * going to do any more read/write
312 byte
= readb(i2c
->regs
+ RXR
);
313 i2c
->msg
->buf
[i2c
->msg_ptr
++] = byte
;
316 if (is_msglast(i2c
)) {
317 /* last byte of buffer */
320 writel(I2C_CMD_READ
| I2C_CMD_NACK
,
323 } else if (is_msgend(i2c
)) {
324 /* ok, we've read the entire buffer, see if there
325 * is anything else we need to do
328 if (is_lastmsg(i2c
)) {
329 /* last message, send stop and complete */
330 dev_dbg(i2c
->dev
, "READ: Send Stop\n");
332 nuc900_i2c_stop(i2c
, 0);
334 /* go to the next transfer */
335 dev_dbg(i2c
->dev
, "READ: Next Transfer\n");
341 writel(I2C_CMD_READ
, i2c
->regs
+ CMDR
);
345 writel(I2C_CMD_READ
, i2c
->regs
+ CMDR
);
354 * top level IRQ servicing routine
357 static irqreturn_t
nuc900_i2c_irq(int irqno
, void *dev_id
)
359 struct nuc900_i2c
*i2c
= dev_id
;
360 unsigned long status
;
362 status
= readl(i2c
->regs
+ CSR
);
363 writel(status
| IRQFLAG
, i2c
->regs
+ CSR
);
365 if (status
& ARBIT_LOST
) {
366 /* deal with arbitration loss */
367 dev_err(i2c
->dev
, "deal with arbitration loss\n");
371 if (i2c
->state
== STATE_IDLE
) {
372 dev_dbg(i2c
->dev
, "IRQ: error i2c->state == IDLE\n");
376 /* pretty much this leaves us with the fact that we've
377 * transmitted or received whatever byte we last sent
380 i2c_nuc900_irq_nextbyte(i2c
, status
);
387 /* nuc900_i2c_set_master
389 * get the i2c bus for a master transaction
392 static int nuc900_i2c_set_master(struct nuc900_i2c
*i2c
)
396 while (timeout
-- > 0) {
397 if (((readl(i2c
->regs
+ SWR
) & I2CSTART
) == I2CSTART
) &&
398 ((readl(i2c
->regs
+ CSR
) & I2CBUSY
) == 0)) {
410 * this starts an i2c transfer
413 static int nuc900_i2c_doxfer(struct nuc900_i2c
*i2c
,
414 struct i2c_msg
*msgs
, int num
)
416 unsigned long iicstat
, timeout
;
420 ret
= nuc900_i2c_set_master(i2c
);
422 dev_err(i2c
->dev
, "cannot get bus (error %d)\n", ret
);
427 spin_lock_irq(&i2c
->lock
);
433 i2c
->state
= STATE_START
;
435 nuc900_i2c_message_start(i2c
, msgs
);
436 spin_unlock_irq(&i2c
->lock
);
438 timeout
= wait_event_timeout(i2c
->wait
, i2c
->msg_num
== 0, HZ
* 5);
442 /* having these next two as dev_err() makes life very
443 * noisy when doing an i2cdetect
447 dev_dbg(i2c
->dev
, "timeout\n");
449 dev_dbg(i2c
->dev
, "incomplete xfer (%d)\n", ret
);
451 /* ensure the stop has been through the bus */
453 dev_dbg(i2c
->dev
, "waiting for bus idle\n");
455 /* first, try busy waiting briefly */
457 iicstat
= readl(i2c
->regs
+ CSR
);
458 } while ((iicstat
& I2CBUSY
) && --spins
);
460 /* if that timed out sleep */
463 iicstat
= readl(i2c
->regs
+ CSR
);
466 if (iicstat
& I2CBUSY
)
467 dev_warn(i2c
->dev
, "timeout waiting for bus idle\n");
475 * first port of call from the i2c bus code when an message needs
476 * transferring across the i2c bus.
479 static int nuc900_i2c_xfer(struct i2c_adapter
*adap
,
480 struct i2c_msg
*msgs
, int num
)
482 struct nuc900_i2c
*i2c
= (struct nuc900_i2c
*)adap
->algo_data
;
486 nuc900_i2c_enable_irq(i2c
);
488 for (retry
= 0; retry
< adap
->retries
; retry
++) {
490 ret
= nuc900_i2c_doxfer(i2c
, msgs
, num
);
495 dev_dbg(i2c
->dev
, "Retrying transmission (%d)\n", retry
);
503 /* declare our i2c functionality */
504 static u32
nuc900_i2c_func(struct i2c_adapter
*adap
)
506 return I2C_FUNC_I2C
| I2C_FUNC_SMBUS_EMUL
| I2C_FUNC_PROTOCOL_MANGLING
;
509 /* i2c bus registration info */
511 static const struct i2c_algorithm nuc900_i2c_algorithm
= {
512 .master_xfer
= nuc900_i2c_xfer
,
513 .functionality
= nuc900_i2c_func
,
518 * called by the bus driver when a suitable device is found
521 static int __devinit
nuc900_i2c_probe(struct platform_device
*pdev
)
523 struct nuc900_i2c
*i2c
;
524 struct nuc900_platform_i2c
*pdata
;
525 struct resource
*res
;
528 pdata
= pdev
->dev
.platform_data
;
530 dev_err(&pdev
->dev
, "no platform data\n");
534 i2c
= kzalloc(sizeof(struct nuc900_i2c
), GFP_KERNEL
);
536 dev_err(&pdev
->dev
, "no memory for state\n");
540 strlcpy(i2c
->adap
.name
, "nuc900-i2c0", sizeof(i2c
->adap
.name
));
541 i2c
->adap
.owner
= THIS_MODULE
;
542 i2c
->adap
.algo
= &nuc900_i2c_algorithm
;
543 i2c
->adap
.retries
= 2;
544 i2c
->adap
.class = I2C_CLASS_HWMON
| I2C_CLASS_SPD
;
546 spin_lock_init(&i2c
->lock
);
547 init_waitqueue_head(&i2c
->wait
);
549 /* find the clock and enable it */
551 i2c
->dev
= &pdev
->dev
;
552 i2c
->clk
= clk_get(&pdev
->dev
, NULL
);
553 if (IS_ERR(i2c
->clk
)) {
554 dev_err(&pdev
->dev
, "cannot get clock\n");
559 dev_dbg(&pdev
->dev
, "clock source %p\n", i2c
->clk
);
561 clk_enable(i2c
->clk
);
563 /* map the registers */
565 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
567 dev_err(&pdev
->dev
, "cannot find IO resource\n");
572 i2c
->ioarea
= request_mem_region(res
->start
, resource_size(res
),
575 if (i2c
->ioarea
== NULL
) {
576 dev_err(&pdev
->dev
, "cannot request IO\n");
581 i2c
->regs
= ioremap(res
->start
, resource_size(res
));
583 if (i2c
->regs
== NULL
) {
584 dev_err(&pdev
->dev
, "cannot map IO\n");
589 dev_dbg(&pdev
->dev
, "registers %p (%p, %p)\n",
590 i2c
->regs
, i2c
->ioarea
, res
);
592 /* setup info block for the i2c core */
594 i2c
->adap
.algo_data
= i2c
;
595 i2c
->adap
.dev
.parent
= &pdev
->dev
;
597 mfp_set_groupg(&pdev
->dev
);
599 clk_get_rate(i2c
->clk
);
601 ret
= (i2c
->clk
.apbfreq
)/(pdata
->bus_freq
* 5) - 1;
602 writel(ret
& 0xffff, i2c
->regs
+ DIVIDER
);
604 /* find the IRQ for this unit (note, this relies on the init call to
605 * ensure no current IRQs pending
608 i2c
->irq
= ret
= platform_get_irq(pdev
, 0);
610 dev_err(&pdev
->dev
, "cannot find IRQ\n");
614 ret
= request_irq(i2c
->irq
, nuc900_i2c_irq
, IRQF_DISABLED
| IRQF_SHARED
,
615 dev_name(&pdev
->dev
), i2c
);
618 dev_err(&pdev
->dev
, "cannot claim IRQ %d\n", i2c
->irq
);
622 /* Note, previous versions of the driver used i2c_add_adapter()
623 * to add the bus at any number. We now pass the bus number via
624 * the platform data, so if unset it will now default to always
628 i2c
->adap
.nr
= pdata
->bus_num
;
630 ret
= i2c_add_numbered_adapter(&i2c
->adap
);
632 dev_err(&pdev
->dev
, "failed to add bus to i2c core\n");
636 platform_set_drvdata(pdev
, i2c
);
638 dev_info(&pdev
->dev
, "%s: NUC900 I2C adapter\n",
639 dev_name(&i2c
->adap
.dev
));
643 free_irq(i2c
->irq
, i2c
);
649 release_resource(i2c
->ioarea
);
653 clk_disable(i2c
->clk
);
663 * called when device is removed from the bus
666 static int __devexit
nuc900_i2c_remove(struct platform_device
*pdev
)
668 struct nuc900_i2c
*i2c
= platform_get_drvdata(pdev
);
670 i2c_del_adapter(&i2c
->adap
);
671 free_irq(i2c
->irq
, i2c
);
673 clk_disable(i2c
->clk
);
678 release_resource(i2c
->ioarea
);
685 static struct platform_driver nuc900_i2c_driver
= {
686 .probe
= nuc900_i2c_probe
,
687 .remove
= __devexit_p(nuc900_i2c_remove
),
689 .owner
= THIS_MODULE
,
690 .name
= "nuc900-i2c0",
694 static int __init
i2c_adap_nuc900_init(void)
696 return platform_driver_register(&nuc900_i2c_driver
);
699 static void __exit
i2c_adap_nuc900_exit(void)
701 platform_driver_unregister(&nuc900_i2c_driver
);
703 subsys_initcall(i2c_adap_nuc900_init
);
704 module_exit(i2c_adap_nuc900_exit
);
706 MODULE_DESCRIPTION("NUC900 I2C Bus driver");
707 MODULE_AUTHOR("Wan ZongShun, <mcuos.com-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>");
708 MODULE_LICENSE("GPL");
709 MODULE_ALIAS("platform:nuc900-i2c0");