i2c-davinci.c (dca3a783400a18e2bf4503b1d4a85c4d0ca1a7e4) i2c-davinci.c (c4df5000413a667fb8c67dd5589d964cc5730d91)
1/*
2 * TI DAVINCI I2C adapter driver.
3 *
4 * Copyright (C) 2006 Texas Instruments.
5 * Copyright (C) 2007 MontaVista Software Inc.
6 *
7 * Updated by Vinod & Sudhakar Feb 2005
8 *

--- 123 unchanged lines hidden (view full) ---

132}
133
134static inline u16 davinci_i2c_read_reg(struct davinci_i2c_dev *i2c_dev, int reg)
135{
136 return __raw_readw(i2c_dev->base + reg);
137}
138
139/* Generate a pulse on the i2c clock pin. */
1/*
2 * TI DAVINCI I2C adapter driver.
3 *
4 * Copyright (C) 2006 Texas Instruments.
5 * Copyright (C) 2007 MontaVista Software Inc.
6 *
7 * Updated by Vinod & Sudhakar Feb 2005
8 *

--- 123 unchanged lines hidden (view full) ---

132}
133
134static inline u16 davinci_i2c_read_reg(struct davinci_i2c_dev *i2c_dev, int reg)
135{
136 return __raw_readw(i2c_dev->base + reg);
137}
138
139/* Generate a pulse on the i2c clock pin. */
140static void generic_i2c_clock_pulse(unsigned int scl_pin)
140static void davinci_i2c_clock_pulse(unsigned int scl_pin)
141{
142 u16 i;
143
144 if (scl_pin) {
145 /* Send high and low on the SCL line */
146 for (i = 0; i < 9; i++) {
147 gpio_set_value(scl_pin, 0);
148 udelay(20);
149 gpio_set_value(scl_pin, 1);
150 udelay(20);
151 }
152 }
153}
154
155/* This routine does i2c bus recovery as specified in the
156 * i2c protocol Rev. 03 section 3.16 titled "Bus clear"
157 */
141{
142 u16 i;
143
144 if (scl_pin) {
145 /* Send high and low on the SCL line */
146 for (i = 0; i < 9; i++) {
147 gpio_set_value(scl_pin, 0);
148 udelay(20);
149 gpio_set_value(scl_pin, 1);
150 udelay(20);
151 }
152 }
153}
154
155/* This routine does i2c bus recovery as specified in the
156 * i2c protocol Rev. 03 section 3.16 titled "Bus clear"
157 */
158static void i2c_recover_bus(struct davinci_i2c_dev *dev)
158static void davinci_i2c_recover_bus(struct davinci_i2c_dev *dev)
159{
160 u32 flag = 0;
161 struct davinci_i2c_platform_data *pdata = dev->pdata;
162
163 dev_err(dev->dev, "initiating i2c bus recovery\n");
164 /* Send NACK to the slave */
165 flag = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
166 flag |= DAVINCI_I2C_MDR_NACK;
167 /* write the data into mode register */
168 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
159{
160 u32 flag = 0;
161 struct davinci_i2c_platform_data *pdata = dev->pdata;
162
163 dev_err(dev->dev, "initiating i2c bus recovery\n");
164 /* Send NACK to the slave */
165 flag = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
166 flag |= DAVINCI_I2C_MDR_NACK;
167 /* write the data into mode register */
168 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
169 generic_i2c_clock_pulse(pdata->scl_pin);
169 davinci_i2c_clock_pulse(pdata->scl_pin);
170 /* Send STOP */
171 flag = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
172 flag |= DAVINCI_I2C_MDR_STP;
173 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
174}
175
176static inline void davinci_i2c_reset_ctrl(struct davinci_i2c_dev *i2c_dev,
177 int val)

--- 106 unchanged lines hidden (view full) ---

284 if (to_cnt <= DAVINCI_I2C_MAX_TRIES) {
285 if (time_after(jiffies, timeout)) {
286 dev_warn(dev->dev,
287 "timeout waiting for bus ready\n");
288 to_cnt++;
289 return -ETIMEDOUT;
290 } else {
291 to_cnt = 0;
170 /* Send STOP */
171 flag = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
172 flag |= DAVINCI_I2C_MDR_STP;
173 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
174}
175
176static inline void davinci_i2c_reset_ctrl(struct davinci_i2c_dev *i2c_dev,
177 int val)

--- 106 unchanged lines hidden (view full) ---

284 if (to_cnt <= DAVINCI_I2C_MAX_TRIES) {
285 if (time_after(jiffies, timeout)) {
286 dev_warn(dev->dev,
287 "timeout waiting for bus ready\n");
288 to_cnt++;
289 return -ETIMEDOUT;
290 } else {
291 to_cnt = 0;
292 i2c_recover_bus(dev);
292 davinci_i2c_recover_bus(dev);
293 i2c_davinci_init(dev);
294 }
295 }
296 if (allow_sleep)
297 schedule_timeout(1);
298 }
299
300 return 0;

--- 73 unchanged lines hidden (view full) ---

374 if (stop && msg->len != 0)
375 flag |= DAVINCI_I2C_MDR_STP;
376 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
377
378 r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
379 dev->adapter.timeout);
380 if (r == 0) {
381 dev_err(dev->dev, "controller timed out\n");
293 i2c_davinci_init(dev);
294 }
295 }
296 if (allow_sleep)
297 schedule_timeout(1);
298 }
299
300 return 0;

--- 73 unchanged lines hidden (view full) ---

374 if (stop && msg->len != 0)
375 flag |= DAVINCI_I2C_MDR_STP;
376 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
377
378 r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
379 dev->adapter.timeout);
380 if (r == 0) {
381 dev_err(dev->dev, "controller timed out\n");
382 i2c_recover_bus(dev);
382 davinci_i2c_recover_bus(dev);
383 i2c_davinci_init(dev);
384 dev->buf_len = 0;
385 return -ETIMEDOUT;
386 }
387 if (dev->buf_len) {
388 /* This should be 0 if all bytes were transferred
389 * or dev->cmd_err denotes an error.
390 * A signal may have aborted the transfer.

--- 247 unchanged lines hidden (view full) ---

638 {},
639};
640MODULE_DEVICE_TABLE(of, davinci_i2c_of_match);
641
642static int davinci_i2c_probe(struct platform_device *pdev)
643{
644 struct davinci_i2c_dev *dev;
645 struct i2c_adapter *adap;
383 i2c_davinci_init(dev);
384 dev->buf_len = 0;
385 return -ETIMEDOUT;
386 }
387 if (dev->buf_len) {
388 /* This should be 0 if all bytes were transferred
389 * or dev->cmd_err denotes an error.
390 * A signal may have aborted the transfer.

--- 247 unchanged lines hidden (view full) ---

638 {},
639};
640MODULE_DEVICE_TABLE(of, davinci_i2c_of_match);
641
642static int davinci_i2c_probe(struct platform_device *pdev)
643{
644 struct davinci_i2c_dev *dev;
645 struct i2c_adapter *adap;
646 struct resource *mem, *irq, *ioarea;
646 struct resource *mem, *irq;
647 int r;
648
649 /* NOTE: driver uses the static register mapping */
650 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
651 if (!mem) {
652 dev_err(&pdev->dev, "no mem resource?\n");
653 return -ENODEV;
654 }
655
656 irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
657 if (!irq) {
658 dev_err(&pdev->dev, "no irq resource?\n");
659 return -ENODEV;
660 }
661
647 int r;
648
649 /* NOTE: driver uses the static register mapping */
650 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
651 if (!mem) {
652 dev_err(&pdev->dev, "no mem resource?\n");
653 return -ENODEV;
654 }
655
656 irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
657 if (!irq) {
658 dev_err(&pdev->dev, "no irq resource?\n");
659 return -ENODEV;
660 }
661
662 ioarea = request_mem_region(mem->start, resource_size(mem),
663 pdev->name);
664 if (!ioarea) {
665 dev_err(&pdev->dev, "I2C region already claimed\n");
666 return -EBUSY;
667 }
668
669 dev = kzalloc(sizeof(struct davinci_i2c_dev), GFP_KERNEL);
662 dev = devm_kzalloc(&pdev->dev, sizeof(struct davinci_i2c_dev),
663 GFP_KERNEL);
670 if (!dev) {
664 if (!dev) {
671 r = -ENOMEM;
672 goto err_release_region;
665 dev_err(&pdev->dev, "Memory allocation failed\n");
666 return -ENOMEM;
673 }
674
675 init_completion(&dev->cmd_complete);
676#ifdef CONFIG_CPU_FREQ
677 init_completion(&dev->xfr_complete);
678#endif
667 }
668
669 init_completion(&dev->cmd_complete);
670#ifdef CONFIG_CPU_FREQ
671 init_completion(&dev->xfr_complete);
672#endif
679 dev->dev = get_device(&pdev->dev);
673 dev->dev = &pdev->dev;
680 dev->irq = irq->start;
681 dev->pdata = dev->dev->platform_data;
682 platform_set_drvdata(pdev, dev);
683
684 if (!dev->pdata && pdev->dev.of_node) {
685 u32 prop;
686
687 dev->pdata = devm_kzalloc(&pdev->dev,
688 sizeof(struct davinci_i2c_platform_data), GFP_KERNEL);
674 dev->irq = irq->start;
675 dev->pdata = dev->dev->platform_data;
676 platform_set_drvdata(pdev, dev);
677
678 if (!dev->pdata && pdev->dev.of_node) {
679 u32 prop;
680
681 dev->pdata = devm_kzalloc(&pdev->dev,
682 sizeof(struct davinci_i2c_platform_data), GFP_KERNEL);
689 if (!dev->pdata) {
690 r = -ENOMEM;
691 goto err_free_mem;
692 }
683 if (!dev->pdata)
684 return -ENOMEM;
685
693 memcpy(dev->pdata, &davinci_i2c_platform_data_default,
694 sizeof(struct davinci_i2c_platform_data));
695 if (!of_property_read_u32(pdev->dev.of_node, "clock-frequency",
696 &prop))
697 dev->pdata->bus_freq = prop / 1000;
698 } else if (!dev->pdata) {
699 dev->pdata = &davinci_i2c_platform_data_default;
700 }
701
686 memcpy(dev->pdata, &davinci_i2c_platform_data_default,
687 sizeof(struct davinci_i2c_platform_data));
688 if (!of_property_read_u32(pdev->dev.of_node, "clock-frequency",
689 &prop))
690 dev->pdata->bus_freq = prop / 1000;
691 } else if (!dev->pdata) {
692 dev->pdata = &davinci_i2c_platform_data_default;
693 }
694
702 dev->clk = clk_get(&pdev->dev, NULL);
703 if (IS_ERR(dev->clk)) {
704 r = -ENODEV;
705 goto err_free_mem;
706 }
695 dev->clk = devm_clk_get(&pdev->dev, NULL);
696 if (IS_ERR(dev->clk))
697 return -ENODEV;
707 clk_prepare_enable(dev->clk);
708
698 clk_prepare_enable(dev->clk);
699
709 dev->base = ioremap(mem->start, resource_size(mem));
710 if (!dev->base) {
711 r = -EBUSY;
712 goto err_mem_ioremap;
700 dev->base = devm_ioremap_resource(&pdev->dev, mem);
701 if (IS_ERR(dev->base)) {
702 r = PTR_ERR(dev->base);
703 goto err_unuse_clocks;
713 }
714
715 i2c_davinci_init(dev);
716
704 }
705
706 i2c_davinci_init(dev);
707
717 r = request_irq(dev->irq, i2c_davinci_isr, 0, pdev->name, dev);
708 r = devm_request_irq(&pdev->dev, dev->irq, i2c_davinci_isr, 0,
709 pdev->name, dev);
718 if (r) {
719 dev_err(&pdev->dev, "failure requesting irq %i\n", dev->irq);
720 goto err_unuse_clocks;
721 }
722
723 r = i2c_davinci_cpufreq_register(dev);
724 if (r) {
725 dev_err(&pdev->dev, "failed to register cpufreq\n");
710 if (r) {
711 dev_err(&pdev->dev, "failure requesting irq %i\n", dev->irq);
712 goto err_unuse_clocks;
713 }
714
715 r = i2c_davinci_cpufreq_register(dev);
716 if (r) {
717 dev_err(&pdev->dev, "failed to register cpufreq\n");
726 goto err_free_irq;
718 goto err_unuse_clocks;
727 }
728
729 adap = &dev->adapter;
730 i2c_set_adapdata(adap, dev);
731 adap->owner = THIS_MODULE;
732 adap->class = I2C_CLASS_HWMON;
733 strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name));
734 adap->algo = &i2c_davinci_algo;
735 adap->dev.parent = &pdev->dev;
736 adap->timeout = DAVINCI_I2C_TIMEOUT;
737 adap->dev.of_node = pdev->dev.of_node;
738
739 adap->nr = pdev->id;
740 r = i2c_add_numbered_adapter(adap);
741 if (r) {
742 dev_err(&pdev->dev, "failure adding adapter\n");
719 }
720
721 adap = &dev->adapter;
722 i2c_set_adapdata(adap, dev);
723 adap->owner = THIS_MODULE;
724 adap->class = I2C_CLASS_HWMON;
725 strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name));
726 adap->algo = &i2c_davinci_algo;
727 adap->dev.parent = &pdev->dev;
728 adap->timeout = DAVINCI_I2C_TIMEOUT;
729 adap->dev.of_node = pdev->dev.of_node;
730
731 adap->nr = pdev->id;
732 r = i2c_add_numbered_adapter(adap);
733 if (r) {
734 dev_err(&pdev->dev, "failure adding adapter\n");
743 goto err_free_irq;
735 goto err_unuse_clocks;
744 }
745 of_i2c_register_devices(adap);
746
747 return 0;
748
736 }
737 of_i2c_register_devices(adap);
738
739 return 0;
740
749err_free_irq:
750 free_irq(dev->irq, dev);
751err_unuse_clocks:
741err_unuse_clocks:
752 iounmap(dev->base);
753err_mem_ioremap:
754 clk_disable_unprepare(dev->clk);
742 clk_disable_unprepare(dev->clk);
755 clk_put(dev->clk);
756 dev->clk = NULL;
743 dev->clk = NULL;
757err_free_mem:
758 put_device(&pdev->dev);
759 kfree(dev);
760err_release_region:
761 release_mem_region(mem->start, resource_size(mem));
762
763 return r;
764}
765
766static int davinci_i2c_remove(struct platform_device *pdev)
767{
768 struct davinci_i2c_dev *dev = platform_get_drvdata(pdev);
744 return r;
745}
746
747static int davinci_i2c_remove(struct platform_device *pdev)
748{
749 struct davinci_i2c_dev *dev = platform_get_drvdata(pdev);
769 struct resource *mem;
770
771 i2c_davinci_cpufreq_deregister(dev);
772
773 i2c_del_adapter(&dev->adapter);
750
751 i2c_davinci_cpufreq_deregister(dev);
752
753 i2c_del_adapter(&dev->adapter);
774 put_device(&pdev->dev);
775
776 clk_disable_unprepare(dev->clk);
754
755 clk_disable_unprepare(dev->clk);
777 clk_put(dev->clk);
778 dev->clk = NULL;
779
780 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, 0);
756 dev->clk = NULL;
757
758 davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, 0);
781 free_irq(dev->irq, dev);
782 iounmap(dev->base);
783 kfree(dev);
784
759
785 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
786 release_mem_region(mem->start, resource_size(mem));
787 return 0;
788}
789
790#ifdef CONFIG_PM
791static int davinci_i2c_suspend(struct device *dev)
792{
793 struct platform_device *pdev = to_platform_device(dev);
794 struct davinci_i2c_dev *i2c_dev = platform_get_drvdata(pdev);

--- 60 unchanged lines hidden --- 		760 return 0;
761}
762
763#ifdef CONFIG_PM
764static int davinci_i2c_suspend(struct device *dev)
765{
766 struct platform_device *pdev = to_platform_device(dev);
767 struct davinci_i2c_dev *i2c_dev = platform_get_drvdata(pdev);

--- 60 unchanged lines hidden ---