gmane.linux.drivers.i2c

[PATCH RFC v3 1/3] i2c: i2c-bfin-twi: convert to devm_* API

Libo Chen — 2013-05-23T12:00:05

peripheral_request_list has got free if any one faild, so no need to free again in err case.
aovid this, convert them to devm_* API

Signed-off-by: Libo Chen <libo.chen-hv44wF8Li93QT0dZR+AlfA< at >public.gmane.org>
---
 drivers/i2c/busses/i2c-bfin-twi.c |   38 +++++++++---------------------------
 1 files changed, 10 insertions(+), 28 deletions(-)

diff --git a/drivers/i2c/busses/i2c-bfin-twi.c b/drivers/i2c/busses/i2c-bfin-twi.c
index 05080c4..2b99c48 100644
--- a/drivers/i2c/busses/i2c-bfin-twi.c
+++ b/drivers/i2c/busses/i2c-bfin-twi.c
< at >< at > -621,35 +621,27 < at >< at > static int i2c_bfin_twi_probe(struct platform_device *pdev)
 int rc;
 unsigned int clkhilow;
 
-iface = kzalloc(sizeof(struct bfin_twi_iface), GFP_KERNEL);
+iface = devm_kzalloc(&pdev->dev, sizeof(struct bfin_twi_iface),
+GFP_KERNEL);
 if (!iface) {
 dev_err(&pdev->dev, "Cannot allocate memory\n");
-rc = -ENOMEM;
-goto out_error_nomem;
+return -ENOMEM;
 }
 
 spin_lock_init(&(iface->lock));
 
 /* Find and map our resources */
 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-if (res == NULL) {
-dev_err(&pdev->dev, "Cannot get IORESOURCE_MEM\n");
-rc = -ENOENT;
-goto out_error_get_res;
-}
-
-iface->regs_base = ioremap(res->start, resource_size(res));
-if (iface->regs_base == NULL) {
+iface->regs_base = devm_ioremap_resource(&pdev->dev, res);
+if (IS_ERR(iface->regs_base)) {
 dev_err(&pdev->dev, "Cannot map IO\n");
-rc = -ENXIO;
-goto out_error_ioremap;
+return -ENXIO;
 }
 
 iface->irq = platform_get_irq(pdev, 0);
 if (iface->irq < 0) {
 dev_err(&pdev->dev, "No IRQ specified\n");
-rc = -ENOENT;
-goto out_error_no_irq;
+return -ENOENT;
 }
 
 p_adap = &iface->adap;
< at >< at > -666,10 +658,10 < at >< at > static int i2c_bfin_twi_probe(struct platform_device *pdev)
 "i2c-bfin-twi");
 if (rc) {
 dev_err(&pdev->dev, "Can't setup pin mux!\n");
-goto out_error_pin_mux;
+return rc;
 }
 
-rc = request_irq(iface->irq, bfin_twi_interrupt_entry,
+rc = devm_request_irq(&pdev->dev, iface->irq, bfin_twi_interrupt_entry,
 0, pdev->name, iface);
 if (rc) {
 dev_err(&pdev->dev, "Can't get IRQ %d !\n", iface->irq);
< at >< at > -707,16 +699,9 < at >< at > static int i2c_bfin_twi_probe(struct platform_device *pdev)
 return 0;
 
 out_error_add_adapter:
-free_irq(iface->irq, iface);
 out_error_req_irq:
-out_error_no_irq:
 peripheral_free_list((unsigned short *)pdev->dev.platform_data);
-out_error_pin_mux:
-iounmap(iface->regs_base);
-out_error_ioremap:
-out_error_get_res:
-kfree(iface);
-out_error_nomem:
+
 return rc;
 }
 
< at >< at > -725,10 +710,7 < at >< at > static int i2c_bfin_twi_remove(struct platform_device *pdev)
 struct bfin_twi_iface *iface = platform_get_drvdata(pdev);
 
 i2c_del_adapter(&(iface->adap));
-free_irq(iface->irq, iface);
 peripheral_free_list((unsigned short *)pdev->dev.platform_data);
-iounmap(iface->regs_base);
-kfree(iface);
 
 return 0;
 }

[PATCH RFC v3 3/3] i2c: pxa: use module_platform_driver() replace init/exit

Libo Chen — 2013-05-23T12:00:11

use module_platform_driver() macro to replace the module init/exit

Signed-off-by: Libo Chen <libo.chen-hv44wF8Li93QT0dZR+AlfA< at >public.gmane.org>
---
 drivers/i2c/busses/i2c-pxa.c |   10 +---------
 1 files changed, 1 insertions(+), 9 deletions(-)

diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index 7b10102..e9c3524 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
< at >< at > -1242,15 +1242,7 < at >< at > static struct platform_driver i2c_pxa_driver = {
 .id_table= i2c_pxa_id_table,
 };
 
-static int __init i2c_adap_pxa_init(void)
-{
-return platform_driver_register(&i2c_pxa_driver);
-}
-
-static void __exit i2c_adap_pxa_exit(void)
-{
-platform_driver_unregister(&i2c_pxa_driver);
-}
+module_platform_driver(i2c_pxa_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:pxa2xx-i2c");

[PATCH] i2c: use platform_{get,set}_drvdata()

Jingoo Han — 2013-05-23T10:22:40

Use the wrapper functions for getting and setting the driver data using
platform_device instead of using dev_{get,set}_drvdata() with &pdev->dev,
so we can directly pass a struct platform_device.

Signed-off-by: Jingoo Han <jg1.han-Sze3O3UU22JBDgjK7y7TUQ< at >public.gmane.org>
---
 drivers/i2c/busses/i2c-cpm.c     |    4 ++--
 drivers/i2c/busses/i2c-ibm_iic.c |    4 ++--
 drivers/i2c/busses/i2c-mpc.c     |    4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/drivers/i2c/busses/i2c-cpm.c b/drivers/i2c/busses/i2c-cpm.c
index 3823623..eccf5c2 100644
--- a/drivers/i2c/busses/i2c-cpm.c
+++ b/drivers/i2c/busses/i2c-cpm.c
< at >< at > -646,7 +646,7 < at >< at > static int cpm_i2c_probe(struct platform_device *ofdev)
 
 cpm->ofdev = ofdev;
 
-dev_set_drvdata(&ofdev->dev, cpm);
+platform_set_drvdata(ofdev, cpm);
 
 cpm->adap = cpm_ops;
 i2c_set_adapdata(&cpm->adap, cpm);
< at >< at > -689,7 +689,7 < at >< at > out_free:
 
 static int cpm_i2c_remove(struct platform_device *ofdev)
 {
-struct cpm_i2c *cpm = dev_get_drvdata(&ofdev->dev);
+struct cpm_i2c *cpm = platform_get_drvdata(ofdev);
 
 i2c_del_adapter(&cpm->adap);
 
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 405a2e2..973f516 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
< at >< at > -705,7 +705,7 < at >< at > static int iic_probe(struct platform_device *ofdev)
 return -ENOMEM;
 }
 
-dev_set_drvdata(&ofdev->dev, dev);
+platform_set_drvdata(ofdev, dev);
 
 dev->vaddr = of_iomap(np, 0);
 if (dev->vaddr == NULL) {
< at >< at > -782,7 +782,7 < at >< at > error_cleanup:
  */
 static int iic_remove(struct platform_device *ofdev)
 {
-struct ibm_iic_private *dev = dev_get_drvdata(&ofdev->dev);
+struct ibm_iic_private *dev = platform_get_drvdata(ofdev);
 
 i2c_del_adapter(&dev->adap);
 
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index 5e705ee..7607dc0 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
< at >< at > -679,7 +679,7 < at >< at > static int fsl_i2c_probe(struct platform_device *op)
 }
 dev_info(i2c->dev, "timeout %u us\n", mpc_ops.timeout * 1000000 / HZ);
 
-dev_set_drvdata(&op->dev, i2c);
+platform_set_drvdata(op, i2c);
 
 i2c->adap = mpc_ops;
 i2c_set_adapdata(&i2c->adap, i2c);
< at >< at > -707,7 +707,7 < at >< at > static int fsl_i2c_probe(struct platform_device *op)
 
 static int fsl_i2c_remove(struct platform_device *op)
 {
-struct mpc_i2c *i2c = dev_get_drvdata(&op->dev);
+struct mpc_i2c *i2c = platform_get_drvdata(op);
 
 i2c_del_adapter(&i2c->adap);

i2cget with 16-bit address, 16-bit data

Craig McQueen — 2013-05-23T04:27:20

I'm trying to read data from a SGTL5000 audio CODEC, which has 16-bit addresses and 16-bit wide data registers.

Unless I'm missing something, it looks impossible to read these registers using i2cget, because it only supports 8-bit addresses. Is there any other similar tool, or should I patch i2cget to support 16-bit addresses?

Regards,
Craig McQueen

[PATCH] i2c: designware: prevent signals from aborting I2C transfers

Mika Westerberg — 2013-05-22T10:03:11

If a process receives signal while it is waiting for I2C transfer to
complete, an error is returned to the caller and the transfer is aborted.
This can cause the driver to fail subsequent transfers. Also according to
commit d295a86eab2 (i2c: mv64xxx: work around signals causing I2C
transactions to be aborted) I2C drivers aren't supposed to abort
transactions on signals.

To prevent this switch to use wait_for_completion_timeout() instead of
wait_for_completion_interruptible_timeout() in the designware I2C driver.

Signed-off-by: Mika Westerberg <mika.westerberg-VuQAYsv1563Yd54FQh9/CA< at >public.gmane.org>
---
 drivers/i2c/busses/i2c-designware-core.c |    5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/drivers/i2c/busses/i2c-designware-core.c b/drivers/i2c/busses/i2c-designware-core.c
index c41ca63..db20a28 100644
--- a/drivers/i2c/busses/i2c-designware-core.c
+++ b/drivers/i2c/busses/i2c-designware-core.c
< at >< at > -580,14 +580,13 < at >< at > i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
 i2c_dw_xfer_init(dev);
 
 /* wait for tx to complete */
-ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete, HZ);
+ret = wait_for_completion_timeout(&dev->cmd_complete, HZ);
 if (ret == 0) {
 dev_err(dev->dev, "controller timed out\n");
 i2c_dw_init(dev);
 ret = -ETIMEDOUT;
 goto done;
-} else if (ret < 0)
-goto done;
+}
 
 if (dev->msg_err) {
 ret = dev->msg_err;

[PATCH 1/2] drivers/macintosh: Remove obsolete cleanup for clientdata

Wolfram Sang — 2013-05-21T18:45:40

A few new i2c-drivers came into the kernel which clear the clientdata-pointer
on exit or error. This is obsolete meanwhile, the core will do it.

Signed-off-by: Wolfram Sang <wsa-z923LK4zBo2bacvFa/9K2g< at >public.gmane.org>
---
 drivers/macintosh/windfarm_smu_sat.c |    1 -
 1 file changed, 1 deletion(-)

diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index d87f5ee..ad6223e 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
< at >< at > -343,7 +343,6 < at >< at > static int wf_sat_remove(struct i2c_client *client)
 wf_unregister_sensor(&sens->sens);
 }
 sat->i2c = NULL;
-i2c_set_clientdata(client, NULL);
 kref_put(&sat->ref, wf_sat_release);
 
 return 0;

[PULL REQUEST] i2c for 3.10

Wolfram Sang — 2013-05-21T18:11:20

Linus,

please pull the bugfixes for the i2c subsystem. Those should have been
in rc1 but I missed it due to working on devm longer than expected.
There is one ID addition, since we are touching the driver anyhow. And
the feature bit documentation is one outcome of a debug session and will
make it easier for users to work around problems. The rest is typical
driver bugfixes.

Please pull.

Thanks,

   Wolfram


The following changes since commit f722406faae2d073cc1d01063d1123c35425939e:

  Linux 3.10-rc1 (2013-05-11 17:14:08 -0700)

are available in the git repository at:

  git://git.kernel.org/pub/scm/linux/kernel/git/wsa/linux.git i2c/for-current

for you to fetch changes up to e9b526fe704812364bca07edd15eadeba163ebfb:

  i2c: suppress lockdep warning on delete_device (2013-05-17 22:49:45 +0200)

----------------------------------------------------------------
Alexander Sverdlin (1):
      i2c: suppress lockdep warning on delete_device

Jean Delvare (1):
      i2c: i801: Document feature bits in modinfo

Josef Ahmad (1):
      i2c: designware: fix RX FIFO overrun

Mika Westerberg (2):
      i2c: designware: always clear interrupts before enabling them
      i2c: designware: add Intel BayTrail ACPI ID

Russell King (1):
      i2c: mv64xxx: work around signals causing I2C transactions to be aborted

 drivers/i2c/busses/i2c-designware-core.c    |   14 ++++++++++++--
 drivers/i2c/busses/i2c-designware-core.h    |    2 ++
 drivers/i2c/busses/i2c-designware-platdrv.c |    1 +
 drivers/i2c/busses/i2c-i801.c               |    6 +++++-
 drivers/i2c/busses/i2c-mv64xxx.c            |    8 ++++----
 drivers/i2c/i2c-core.c                      |    3 ++-
 6 files changed, 26 insertions(+), 8 deletions(-)

[PATCH] i2c: i2c-designware: Fix compilation warning

EUNBONG SONG — 2013-05-20T23:55:50

Fix the following compilation warning when CONFIG_PM_RUNTIME is not enabled:

drivers/i2c/busses/i2c-designware-pcidrv.c:188: warning: 'i2c_dw_pci_runtime_idle' defined but not used

Signed-off-by: EunBong Song <eunb.song< at >samsung.com>
---
 drivers/i2c/busses/i2c-designware-pcidrv.c |    2 ++
 1 file changed, 2 insertions(+)

diff --git a/drivers/i2c/busses/i2c-designware-pcidrv.c b/drivers/i2c/busses/i2c-designware-pcidrv.c
index f6ed06c..2b5d3a6 100644
--- a/drivers/i2c/busses/i2c-designware-pcidrv.c
+++ b/drivers/i2c/busses/i2c-designware-pcidrv.c
< at >< at > -185,6 +185,7 < at >< at > static int i2c_dw_pci_resume(struct device *dev)
 return 0;
 }
 
+#ifdef CONFIG_PM_RUNTIME
 static int i2c_dw_pci_runtime_idle(struct device *dev)
 {
 int err = pm_schedule_suspend(dev, 500);
< at >< at > -194,6 +195,7 < at >< at > static int i2c_dw_pci_runtime_idle(struct device *dev)
 return 0;
 return -EBUSY;
 }
+#endif
 
 static const struct dev_pm_ops i2c_dw_pm_ops = {
 .resume         = i2c_dw_pci_resume,

Скрытые материалы

лидуля — 2013-05-20T05:05:24

  Убыстренное обучение. постичь британский язык сегодня понятно любому . Проделать свою практику поразнообразнее, вспыхнуть достойным делом. Купить можно здесь: http://goo.gl/5GUPp .

[PATCH] i2c-piix4 - Add support for secondary SMBus on AMD SB800 and AMD FCH chipsets

Rudolf Marek — 2013-05-17T22:46:05

Hello all,

Attached patch adds support for secondary SMBus of AMD SB800 and new AMD FCH 
chipsets. The base address of secondary SMBus is different from SB700 and it is 
stored on similar place as SB800 primary SMBus.

More verbose info:

Probing function was just modified to read the SMBus base from address 0x28 or 
from original 0x2c. The secondary bus does not provide IRQ information.

I think the SB700 has same secondary controller, so revision/IRQ information 
should not be printed too. This can be fixed in some other patch.

Chipset datasheet can be found here: 
http://support.amd.com/us/Embedded_TechDocs/45482.pdf

Tested on SB800 and FCH boards.

Tested-by: Paul Menzel <paulepanter-Rn4VEauK+AKRv+LV9MX5uipxlwaOVQ5f< at >public.gmane.org>
ASRock E350M1 with SB800

Signed-off-by: Rudolf Marek <r.marek-/xGekIyIa4Ap1Coe8Ar9gA< at >public.gmane.org>

Thanks
Rudolf

[PATCH] i2c: suppress lockdep warning on delete_device

Alexander Sverdlin — 2013-05-17T12:56:35

i2c: suppress lockdep warning on delete_device

Since commit 846f99749ab68bbc7f75c74fec305de675b1a1bf the following lockdep
warning is thrown in case i2c device is removed (via delete_device sysfs
attribute) which contains subdevices (e.g. i2c multiplexer):

=============================================
[ INFO: possible recursive locking detected ]
3.8.7-0-sampleversion-fct #8 Tainted: G           O
---------------------------------------------
bash/3743 is trying to acquire lock:
  (s_active#110){++++.+}, at: [<ffffffff802b3048>] sysfs_hash_and_remove+0x58/0xc8

but task is already holding lock:
  (s_active#110){++++.+}, at: [<ffffffff802b3cb8>] sysfs_write_file+0xc8/0x208

other info that might help us debug this:
  Possible unsafe locking scenario:

        CPU0
        ----
   lock(s_active#110);
   lock(s_active#110);

  *** DEADLOCK ***

  May be due to missing lock nesting notation

4 locks held by bash/3743:
  #0:  (&buffer->mutex){+.+.+.}, at: [<ffffffff802b3c3c>] sysfs_write_file+0x4c/0x208
  #1:  (s_active#110){++++.+}, at: [<ffffffff802b3cb8>] sysfs_write_file+0xc8/0x208
  #2:  (&adap->userspace_clients_lock/1){+.+.+.}, at: [<ffffffff80454a18>] i2c_sysfs_delete_device+0x90/0x238
  #3:  (&__lockdep_no_validate__){......}, at: [<ffffffff803dcc24>] device_release_driver+0x24/0x48

stack backtrace:
Call Trace:
[<ffffffff80575cc8>] dump_stack+0x8/0x34
[<ffffffff801b50fc>] __lock_acquire+0x161c/0x2110
[<ffffffff801b5c3c>] lock_acquire+0x4c/0x70
[<ffffffff802b60cc>] sysfs_addrm_finish+0x19c/0x1e0
[<ffffffff802b3048>] sysfs_hash_and_remove+0x58/0xc8
[<ffffffff802b7d8c>] sysfs_remove_group+0x64/0x148
[<ffffffff803d990c>] device_remove_attrs+0x9c/0x1a8
[<ffffffff803d9b1c>] device_del+0x104/0x1d8
[<ffffffff803d9c18>] device_unregister+0x28/0x70
[<ffffffff8045505c>] i2c_del_adapter+0x1cc/0x328
[<ffffffff8045802c>] i2c_del_mux_adapter+0x14/0x38
[<ffffffffc025c108>] pca954x_remove+0x90/0xe0 [pca954x]
[<ffffffff804542f8>] i2c_device_remove+0x80/0xe8
[<ffffffff803dca9c>] __device_release_driver+0x74/0xf8
[<ffffffff803dcc2c>] device_release_driver+0x2c/0x48
[<ffffffff803dbc14>] bus_remove_device+0x13c/0x1d8
[<ffffffff803d9b24>] device_del+0x10c/0x1d8
[<ffffffff803d9c18>] device_unregister+0x28/0x70
[<ffffffff80454b08>] i2c_sysfs_delete_device+0x180/0x238
[<ffffffff802b3cd4>] sysfs_write_file+0xe4/0x208
[<ffffffff8023ddc4>] vfs_write+0xbc/0x160
[<ffffffff8023df6c>] SyS_write+0x54/0xd8
[<ffffffff8013d424>] handle_sys64+0x44/0x64

The problem is already known for USB and PCI subsystems. The reason is that
delete_device attribute is defined statically in i2c-core.c and used for all
devices in i2c subsystem.

Discussion of original USB problem:
http://lkml.indiana.edu/hypermail/linux/kernel/1204.3/01160.html

Commit 356c05d58af05d582e634b54b40050c73609617b introduced new macro to suppress
lockdep warnings for this special case and included workaround for USB code.

LKML discussion of the workaround:
http://lkml.indiana.edu/hypermail/linux/kernel/1205.1/03634.html

As i2c case is in principle the same, the same workaround could be used here.

Signed-off-by: Alexander Sverdlin <alexander.sverdlin-OYasijW0DpE< at >public.gmane.org>
Cc: Eric W. Biederman <ebiederm-aS9lmoZGLiVWk0Htik3J/w< at >public.gmane.org>
Cc: Tejun Heo <tj-DgEjT+Ai2ygdnm+yROfE0A< at >public.gmane.org>
Cc: Alan Stern <stern-nwvwT67g6+6dFdvTe/nMLpVzexx5G7lz< at >public.gmane.org>
Cc: Peter Zijlstra <peterz-wEGCiKHe2LqWVfeAwA7xHQ< at >public.gmane.org>
Cc: Greg Kroah-Hartman <gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r< at >public.gmane.org>
---

--- linux-next.orig/drivers/i2c/i2c-core.c
+++ linux-next/drivers/i2c/i2c-core.c
< at >< at > -892,7 +892,8 < at >< at > i2c_sysfs_delete_device(struct device *d
  }

  static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
-static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
+static DEVICE_ATTR_IGNORE_LOCKDEP(delete_device, S_IWUSR, NULL,
+                                  i2c_sysfs_delete_device);

  static struct attribute *i2c_adapter_attrs[] = {
  &dev_attr_name.attr,

i2c beginner question

Dirk Reske — 2013-05-16T21:13:39

Hallo,

I have to collect data from multiple external i2c devices.
My question is, what is the correct way?

1: Open i2-device-file, set slave address, read data, close i2c device 
file and go on with the next one
2: keep the i2c device file open all the time, and change slave address 
before every access to device
3: ???

greets
Dirk

[PATCH] I2C-mv64xxx.c: work around signals causing I2C transactions to be aborted

Russell King — 2013-05-15T14:33:10

Do not use interruptible waits in an I2C driver; if a process uses
signals (eg, Xorg uses SIGALRM and SIGPIPE) then these signals can
cause the I2C driver to abort a transaction in progress by another
driver, which can cause that driver to fail.  I2C drivers are not
expected to abort transactions on signals.

Cc: <stable-u79uwXL29TY76Z2rM5mHXA< at >public.gmane.org>
Signed-off-by: Russell King <rmk+kernel-lFZ/pmaqli7XmaaqVzeoHQ< at >public.gmane.org>
Tested-by: Russell King <rmk+kernel-lFZ/pmaqli7XmaaqVzeoHQ< at >public.gmane.org>
---
Mark Greer seems to be unreachable now; the address in this driver no
longer works, and there is no maintainer entry.  This patch has been
run on my Cubox (Marvell Dove) for quite a number of months without
ill effect.

 drivers/i2c/busses/i2c-mv64xxx.c |    8 ++++----
 1 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index 2e9d567..44d8045 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
< at >< at > -252,7 +252,7 < at >< at > mv64xxx_i2c_do_action(struct mv64xxx_i2c_data *drv_data)
 writel(drv_data->cntl_bits,
 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
 drv_data->block = 0;
-wake_up_interruptible(&drv_data->waitq);
+wake_up(&drv_data->waitq);
 break;
 
 case MV64XXX_I2C_ACTION_CONTINUE:
< at >< at > -300,7 +300,7 < at >< at > mv64xxx_i2c_do_action(struct mv64xxx_i2c_data *drv_data)
 writel(drv_data->cntl_bits | MV64XXX_I2C_REG_CONTROL_STOP,
 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
 drv_data->block = 0;
-wake_up_interruptible(&drv_data->waitq);
+wake_up(&drv_data->waitq);
 break;
 
 case MV64XXX_I2C_ACTION_INVALID:
< at >< at > -315,7 +315,7 < at >< at > mv64xxx_i2c_do_action(struct mv64xxx_i2c_data *drv_data)
 writel(drv_data->cntl_bits | MV64XXX_I2C_REG_CONTROL_STOP,
 drv_data->reg_base + MV64XXX_I2C_REG_CONTROL);
 drv_data->block = 0;
-wake_up_interruptible(&drv_data->waitq);
+wake_up(&drv_data->waitq);
 break;
 }
 }
< at >< at > -381,7 +381,7 < at >< at > mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
 unsigned longflags;
 charabort = 0;
 
-time_left = wait_event_interruptible_timeout(drv_data->waitq,
+time_left = wait_event_timeout(drv_data->waitq,
 !drv_data->block, drv_data->adapter.timeout);
 
 spin_lock_irqsave(&drv_data->lock, flags);

[PATCH] i2c-i801: Document feature bits in modinfo

Jean Delvare — 2013-05-15T12:44:10

Duplicate the feature bits documentation in modinfo, as not every user
will read the driver's source code or documentation file.

Signed-off-by: Jean Delvare <khali-PUYAD+kWke1g9hUCZPvPmw< at >public.gmane.org>
---
 drivers/i2c/busses/i2c-i801.c |    6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

--- linux-3.10-rc1.orig/drivers/i2c/busses/i2c-i801.c2013-04-29 02:36:01.000000000 +0200
+++ linux-3.10-rc1/drivers/i2c/busses/i2c-i801.c2013-05-15 12:42:11.573297161 +0200
< at >< at > -231,7 +231,11 < at >< at > static const char *i801_feature_names[]
 
 static unsigned int disable_features;
 module_param(disable_features, uint, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(disable_features, "Disable selected driver features");
+MODULE_PARM_DESC(disable_features, "Disable selected driver features:\n"
+"\t\t  0x01  disable SMBus PEC\n"
+"\t\t  0x02  disable the block buffer\n"
+"\t\t  0x08  disable the I2C block read functionality\n"
+"\t\t  0x10  don't use interrupts ");
 
 /* Make sure the SMBus host is ready to start transmitting.
    Return 0 if it is, -EBUSY if it is not. */

[PATCH v2] i2c: core: make it possible to match a pure device tree driver

Linus Walleij — 2013-05-13T20:18:21

This tries to address an issue found when writing an MFD driver
for the Nomadik STw481x PMICs: as the platform is using device
tree exclusively I want to specify the driver matching like
this:

static const struct of_device_id stw481x_match[] = {
{ .compatible = "st,stw4810", },
{ .compatible = "st,stw4811", },
{},
};

static struct i2c_driver stw481x_driver = {
.driver = {
.name= "stw481x",
.of_match_table = stw481x_match,
},
.probe= stw481x_probe,
.remove= stw481x_remove,
};

However that turns out not to be possible: the I2C probe code
is written so that the probe() call is always passed a match
from i2c_match_id() using non-devicetree matches.

This is probably why most devices using device tree for I2C
clients currently will pass no .of_match_table *at all* but
instead just use .id_table from struct i2c_driver to match
the device. As you realize that means that the whole idea with
compatible strings is discarded, and that is why we find strange
device tree I2C device compatible strings like "product" instead
of "vendor,product" as you could expect.

Let's figure out how to fix this before the mess spreads. This
patch will allow probeing devices with only an of_match_table
as per above, and will pass NULL as the second argument to the
probe() function. If the driver wants to deduce secondary info
from the struct of_device_id .data field, it has to call
of_match_device() on its own match table in the probe function
device tree probe path.

If drivers define both an .of_match_table *AND* a i2c_driver
.id_table, the .of_match_table will take precedence, just
as is done in the i2c_device_match() function in i2c-core.c.

I2C devices probed from device tree should subsequently be
fixed to handle the case where of_match_table() is
used (I think none of them do that today), and platforms should
fix their device trees to use compatible strings for I2C devices
instead of setting the name to Linux device driver names as is
done in multiple cases today.

Cc: Rob Herring <rob.herring-bsGFqQB8/DxBDgjK7y7TUQ< at >public.gmane.org>
Cc: Grant Likely <grant.likely-QSEj5FYQhm4dnm+yROfE0A< at >public.gmane.org>
Signed-off-by: Linus Walleij <linus.walleij-QSEj5FYQhm4dnm+yROfE0A< at >public.gmane.org>
---
ChangeLog v1->v2:
- Use of_match_device() to determine if there is a DT match in
  the probe code. If there is a match we pass NULL for the
  id_table match parameter.
---
 drivers/i2c/i2c-core.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 6b63cc7..17cd22a 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
< at >< at > -240,7 +240,7 < at >< at > static int i2c_device_probe(struct device *dev)
 return 0;
 
 driver = to_i2c_driver(dev->driver);
-if (!driver->probe || !driver->id_table)
+if (!driver->probe || (!driver->id_table && !dev->driver->of_match_table))
 return -ENODEV;
 client->driver = driver;
 if (!device_can_wakeup(&client->dev))
< at >< at > -248,7 +248,12 < at >< at > static int i2c_device_probe(struct device *dev)
 client->flags & I2C_CLIENT_WAKE);
 dev_dbg(dev, "probe\n");
 
-status = driver->probe(client, i2c_match_id(driver->id_table, client));
+if (of_match_device(dev->driver->of_match_table, dev))
+/* Device tree matching */
+status = driver->probe(client, NULL);
+else
+/* Fall back to matching the id_table */
+status = driver->probe(client, i2c_match_id(driver->id_table, client));
 if (status) {
 client->driver = NULL;
 i2c_set_clientdata(client, NULL);

[PATCH 1/2] i2c-designware: always clear interrupts before enabling them

Mika Westerberg — 2013-05-13T10:54:30

If the I2C bus is put to a low power state by an ACPI method it might pull
the SDA line low (as its power is removed). Once the bus is put to full
power state again, the SDA line is pulled back to high. This transition
looks like a STOP condition from the controller point-of-view which sets
STOP detected bit in its status register causing the driver to fail
subsequent transfers.

Fix this by always clearing all interrupts before we start a transfer.

Signed-off-by: Mika Westerberg <mika.westerberg-VuQAYsv1563Yd54FQh9/CA< at >public.gmane.org>
---
 drivers/i2c/busses/i2c-designware-core.c |    3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/i2c/busses/i2c-designware-core.c b/drivers/i2c/busses/i2c-designware-core.c
index 21fbb34..7a89ca5 100644
--- a/drivers/i2c/busses/i2c-designware-core.c
+++ b/drivers/i2c/busses/i2c-designware-core.c
< at >< at > -383,7 +383,8 < at >< at > static void i2c_dw_xfer_init(struct dw_i2c_dev *dev)
 /* Enable the adapter */
 __i2c_dw_enable(dev, true);
 
-/* Enable interrupts */
+/* Clear and enable interrupts */
+i2c_dw_clear_int(dev);
 dw_writel(dev, DW_IC_INTR_DEFAULT_MASK, DW_IC_INTR_MASK);
 }

[PATCH] i2c: core: make it possible to match a pure device tree driver

Linus Walleij — 2013-05-12T22:26:23

This tries to address an issue found when writing an MFD driver
for the Nomadik STw481x PMICs: as the platform is using device
tree exclusively I want to specify the driver matching like
this:

static const struct of_device_id stw481x_match[] = {
{ .compatible = "st,stw4810", },
{ .compatible = "st,stw4811", },
{},
};

static struct i2c_driver stw481x_driver = {
.driver = {
.name= "stw481x",
.of_match_table = stw481x_match,
},
.probe= stw481x_probe,
.remove= stw481x_remove,
};

However that turns out not to be possible: the I2C probe code
is written so that the probe() call is always passed a match
from i2c_match_id() using non-devicetree matches.

This is probably why most devices using device tree for I2C
clients currently will pass no .of_match_table *at all* but
instead just use .id_table from struct i2c_driver to match
the device. As you realize that means that the whole idea with
compatible strings is discarded, and that is why we find strange
device tree I2C device compatible strings like "product" instead
of "vendor,product" as you could expect.

Let's figure out how to fix this before the mess spreads. This
patch will allow probeing devices with only an of_match_table
as per above, and will pass NULL as the second argument to the
probe() function. If the driver wants to deduce secondary info
from the struct of_device_id .data field, it has to call
of_match_device() on its own match table in the probe function
device tree probe path.

If drivers define both an .of_match_table *AND* a i2c_driver
.id_table, the .of_match_table will take precedence, just
as is done in the i2c_device_match() function in i2c-core.c.

I2C devices probed from device tree should subsequently be
fixed to handle the case where of_match_table() is
used (I think none of them do that today), and platforms should
fix their device trees to use compatible strings for I2C devices
instead of setting the name to Linux device driver names as is
done in multiple cases today.

Cc: Rob Herring <rob.herring-bsGFqQB8/DxBDgjK7y7TUQ< at >public.gmane.org>
Cc: Grant Likely <grant.likely-QSEj5FYQhm4dnm+yROfE0A< at >public.gmane.org>
Signed-off-by: Linus Walleij <linus.walleij-QSEj5FYQhm4dnm+yROfE0A< at >public.gmane.org>
---
I would need some device tree core people to confirm that I am
on the right track with this. I was soooo confused when I found
that .of_match_table could not be used with I2C devices...
---
 drivers/i2c/i2c-core.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 6b63cc7..30b5bb2 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
< at >< at > -240,7 +240,7 < at >< at > static int i2c_device_probe(struct device *dev)
 return 0;
 
 driver = to_i2c_driver(dev->driver);
-if (!driver->probe || !driver->id_table)
+if (!driver->probe || (!driver->id_table && !dev->driver->of_match_table))
 return -ENODEV;
 client->driver = driver;
 if (!device_can_wakeup(&client->dev))
< at >< at > -248,7 +248,12 < at >< at > static int i2c_device_probe(struct device *dev)
 client->flags & I2C_CLIENT_WAKE);
 dev_dbg(dev, "probe\n");
 
-status = driver->probe(client, i2c_match_id(driver->id_table, client));
+if (dev->driver->of_match_table)
+/* Device tree matching */
+status = driver->probe(client, NULL);
+else
+/* Fall back to matching the id_table */
+status = driver->probe(client, i2c_match_id(driver->id_table, client));
 if (status) {
 client->driver = NULL;
 i2c_set_clientdata(client, NULL);

[PATCH] i2c: vt8500: Add support for I2C bus on Wondermedia SoCs

Tony Prisk — 2013-05-12T09:23:54

This patch adds support for the I2C bus controllers found on Wondermedia
8xxx-series SoCs. Only master-mode is supported.

Signed-off-by: Tony Prisk <linux-ci5G2KO2hbZ+pU9mqzGVBQ< at >public.gmane.org>
---
 .../devicetree/bindings/i2c/i2c-vt8500.txt         |   24 +
 MAINTAINERS                                        |    1 +
 drivers/i2c/busses/Kconfig                         |   10 +
 drivers/i2c/busses/Makefile                        |    1 +
 drivers/i2c/busses/i2c-wmt.c                       |  488 ++++++++++++++++++++
 5 files changed, 524 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/i2c/i2c-vt8500.txt
 create mode 100644 drivers/i2c/busses/i2c-wmt.c

diff --git a/Documentation/devicetree/bindings/i2c/i2c-vt8500.txt b/Documentation/devicetree/bindings/i2c/i2c-vt8500.txt
new file mode 100644
index 0000000..94a425e
--- /dev/null
+++ b/Documentation/devicetree/bindings/i2c/i2c-vt8500.txt
< at >< at > -0,0 +1,24 < at >< at >
+* Wondermedia I2C Controller
+
+Required properties :
+
+ - compatible : should be "wm,wm8505-i2c"
+ - reg : Offset and length of the register set for the device
+ - interrupts : <IRQ> where IRQ is the interrupt number
+ - clocks : phandle to the I2C clock source
+
+Optional properties :
+
+ - clock-frequency : desired I2C bus clock frequency in Hz.
+Valid values are 100000 and 400000.
+Default to 100000 if not specified, or invalid value.
+
+Example :
+
+i2c_0: i2c< at >d8280000 {
+compatible = "wm,wm8505-i2c";
+reg = <0xd8280000 0x1000>;
+interrupts = <19>;
+clocks = <&clki2c0>;
+clock-frequency = <400000>;
+};
diff --git a/MAINTAINERS b/MAINTAINERS
index 3d7782b..44ea994 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
< at >< at > -1285,6 +1285,7 < at >< at > S:Maintained
 F:arch/arm/mach-vt8500/
 F:drivers/clocksource/vt8500_timer.c
 F:drivers/gpio/gpio-vt8500.c
+F:drivers/i2c/busses/i2c-wmt.c
 F:drivers/mmc/host/wmt-sdmmc.c
 F:drivers/pwm/pwm-vt8500.c
 F:drivers/rtc/rtc-vt8500.c
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 631736e..89e7ec2 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
< at >< at > -724,6 +724,16 < at >< at > config I2C_VERSATILE
   This driver can also be built as a module.  If so, the module
   will be called i2c-versatile.
 
+config I2C_WMT
+tristate "Wondermedia WM8xxx SoC I2C bus support"
+depends on ARCH_VT8500
+help
+  Say yes if you want to support the I2C bus on Wondermedia 8xxx-series
+  SoCs.
+
+  This driver can also be built as a module. If so, the module will be
+  called i2c-wmt.
+
 config I2C_OCTEON
 tristate "Cavium OCTEON I2C bus support"
 depends on CPU_CAVIUM_OCTEON
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 8f4fc23..3ba94a9 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
< at >< at > -71,6 +71,7 < at >< at > obj-$(CONFIG_I2C_SIRF)+= i2c-sirf.o
 obj-$(CONFIG_I2C_STU300)+= i2c-stu300.o
 obj-$(CONFIG_I2C_TEGRA)+= i2c-tegra.o
 obj-$(CONFIG_I2C_VERSATILE)+= i2c-versatile.o
+obj-$(CONFIG_I2C_WMT)+= i2c-wmt.o
 obj-$(CONFIG_I2C_OCTEON)+= i2c-octeon.o
 obj-$(CONFIG_I2C_XILINX)+= i2c-xiic.o
 obj-$(CONFIG_I2C_XLR)+= i2c-xlr.o
diff --git a/drivers/i2c/busses/i2c-wmt.c b/drivers/i2c/busses/i2c-wmt.c
new file mode 100644
index 0000000..5cebb29
--- /dev/null
+++ b/drivers/i2c/busses/i2c-wmt.c
< at >< at > -0,0 +1,488 < at >< at >
+/*
+ *  Wondermedia I2C Master Mode Driver
+ *
+ *  Copyright (C) 2012 Tony Prisk <linux-ci5G2KO2hbZ+pU9mqzGVBQ< at >public.gmane.org>
+ *
+ *  Derived from GPLv2+ licensed source:
+ *  - Copyright (C) 2008 WonderMedia Technologies, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2, or
+ *  (at your option) any later version. as published by the Free Software
+ *  Foundation
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_i2c.h>
+#include <linux/of_irq.h>
+#include <linux/platform_device.h>
+
+#define REG_CR0x00
+#define REG_TCR0x02
+#define REG_CSR0x04
+#define REG_ISR0x06
+#define REG_IMR0x08
+#define REG_CDR0x0A
+#define REG_TR0x0C
+#define REG_MCR0x0E
+#define REG_SLAVE_CR0x10
+#define REG_SLAVE_SR0x12
+#define REG_SLAVE_ISR0x14
+#define REG_SLAVE_IMR0x16
+#define REG_SLAVE_DR0x18
+#define REG_SLAVE_TR0x1A
+
+/* REG_CR Bit fields */
+#define CR_TX_NEXT_ACK0x0000
+#define CR_ENABLE0x0001
+#define CR_TX_NEXT_NO_ACK0x0002
+#define CR_TX_END0x0004
+#define CR_CPU_RDY0x0008
+#define SLAV_MODE_SEL0x8000
+
+/* REG_TCR Bit fields */
+#define TCR_STANDARD_MODE0x0000
+#define TCR_MASTER_WRITE0x0000
+#define TCR_HS_MODE0x2000
+#define TCR_MASTER_READ0x4000
+#define TCR_FAST_MODE0x8000
+#define TCR_SLAVE_ADDR_MASK0x007F
+
+/* REG_ISR Bit fields */
+#define ISR_NACK_ADDR0x0001
+#define ISR_BYTE_END0x0002
+#define ISR_SCL_TIMEOUT0x0004
+#define ISR_WRITE_ALL0x0007
+
+/* REG_IMR Bit fields */
+#define IMR_ENABLE_ALL0x0007
+
+/* REG_CSR Bit fields */
+#define CSR_RCV_NOT_ACK0x0001
+#define CSR_RCV_ACK_MASK0x0001
+#define CSR_READY_MASK0x0002
+
+/* REG_TR */
+#define SCL_TIMEOUT(x)(((x) & 0xFF) << 16)
+#define TR_STD0x0064
+#define TR_HS0x0019
+
+#define I2C_MODE_STANDARD0
+#define I2C_MODE_FAST1
+
+struct wmt_i2c_dev {
+struct i2c_adapteradapter;
+struct completioncomplete;
+struct device*dev;
+void __iomem*base;
+struct clk*clk;
+intmode;
+intirq;
+u16cmd_status;
+};
+
+static int wmt_i2c_wait_bus_not_busy(struct wmt_i2c_dev *i2c_dev)
+{
+u16 val;
+int i;
+int ret = 0;
+
+for (i = 0; i < 100000; i++) {
+val = readw(i2c_dev->base + REG_CSR);
+if (val & CSR_READY_MASK)
+break;
+
+udelay(1);
+}
+if (i >= 9999999)
+ret = -EBUSY;
+
+return ret;
+}
+
+static int wmt_check_status(struct wmt_i2c_dev *i2c_dev)
+{
+int ret = 0;
+
+if (i2c_dev->cmd_status & ISR_NACK_ADDR)
+ret = -EIO;
+
+if (i2c_dev->cmd_status & ISR_SCL_TIMEOUT)
+ret = -ETIMEDOUT;
+
+return ret;
+}
+
+static int wmt_i2c_write(struct i2c_adapter *adap, struct i2c_msg *pmsg,
+   int restart, int last)
+{
+struct wmt_i2c_dev *i2c_dev = i2c_get_adapdata(adap);
+u16 val, tcr_val;
+int ret, wait_result;
+int xfer_len = 0;
+
+if (!restart) {
+ret = wmt_i2c_wait_bus_not_busy(i2c_dev);
+if (ret < 0)
+return ret;
+}
+
+if (pmsg->len == 0) {
+/*
+ * We still need to run through the while (..) once, so
+ * start at -1 and break out early from the loop
+ */
+xfer_len = -1;
+writew(0, i2c_dev->base + REG_CDR);
+} else {
+writew(pmsg->buf[0] & 0xFF, i2c_dev->base + REG_CDR);
+}
+
+if (!restart) {
+val = readw(i2c_dev->base + REG_CR);
+val &= ~CR_TX_END;
+writew(val, i2c_dev->base + REG_CR);
+
+val = readw(i2c_dev->base + REG_CR);
+val |= CR_CPU_RDY;
+writew(val, i2c_dev->base + REG_CR);
+}
+
+init_completion(&i2c_dev->complete);
+
+if (i2c_dev->mode == I2C_MODE_STANDARD)
+tcr_val = TCR_STANDARD_MODE;
+else
+tcr_val = TCR_FAST_MODE;
+
+tcr_val |= (TCR_MASTER_WRITE | (pmsg->addr & TCR_SLAVE_ADDR_MASK));
+
+writew(tcr_val, i2c_dev->base + REG_TCR);
+
+if (restart) {
+val = readw(i2c_dev->base + REG_CR);
+val |= CR_CPU_RDY;
+writew(val, i2c_dev->base + REG_CR);
+}
+
+while (xfer_len < pmsg->len) {
+wait_result = wait_for_completion_timeout(&i2c_dev->complete,
+  500 * HZ / 1000);
+
+if (wait_result == 0)
+return -ETIMEDOUT;
+
+ret = wmt_check_status(i2c_dev);
+if (ret)
+return ret;
+
+xfer_len++;
+
+val = readw(i2c_dev->base + REG_CSR);
+if ((val & CSR_RCV_ACK_MASK) == CSR_RCV_NOT_ACK) {
+dev_dbg(i2c_dev->dev, "write RCV NACK error\n");
+return -EIO;
+}
+
+if (pmsg->len == 0) {
+val = CR_TX_END | CR_CPU_RDY | CR_ENABLE;
+writew(val, i2c_dev->base + REG_CR);
+break;
+}
+
+if (xfer_len == pmsg->len) {
+if (last != 1)
+writew(CR_ENABLE, i2c_dev->base + REG_CR);
+} else {
+writew(pmsg->buf[xfer_len] & 0xFF, i2c_dev->base +
+REG_CDR);
+writew(CR_CPU_RDY | CR_ENABLE, i2c_dev->base + REG_CR);
+}
+}
+
+return 0;
+}
+
+static int wmt_i2c_read(struct i2c_adapter *adap, struct i2c_msg *pmsg,
+  int restart, int last)
+{
+struct wmt_i2c_dev *i2c_dev = i2c_get_adapdata(adap);
+u16 val, tcr_val;
+int ret, wait_result;
+u32 xfer_len = 0;
+
+if (!restart) {
+ret = wmt_i2c_wait_bus_not_busy(i2c_dev);
+if (ret < 0)
+return ret;
+}
+
+val = readw(i2c_dev->base + REG_CR);
+val &= ~CR_TX_END;
+writew(val, i2c_dev->base + REG_CR);
+
+val = readw(i2c_dev->base + REG_CR);
+val &= ~CR_TX_NEXT_NO_ACK;
+writew(val, i2c_dev->base + REG_CR);
+
+if (!restart) {
+val = readw(i2c_dev->base + REG_CR);
+val |= CR_CPU_RDY;
+writew(val, i2c_dev->base + REG_CR);
+}
+
+if (pmsg->len == 1) {
+val = readw(i2c_dev->base + REG_CR);
+val |= CR_TX_NEXT_NO_ACK;
+writew(val, i2c_dev->base + REG_CR);
+}
+
+init_completion(&i2c_dev->complete);
+
+if (i2c_dev->mode == I2C_MODE_STANDARD)
+tcr_val = TCR_STANDARD_MODE;
+else
+tcr_val = TCR_FAST_MODE;
+
+tcr_val |= TCR_MASTER_READ | (pmsg->addr & TCR_SLAVE_ADDR_MASK);
+
+writew(tcr_val, i2c_dev->base + REG_TCR);
+
+if (restart) {
+val = readw(i2c_dev->base + REG_CR);
+val |= CR_CPU_RDY;
+writew(val, i2c_dev->base + REG_CR);
+}
+
+while (xfer_len < pmsg->len) {
+wait_result = wait_for_completion_timeout(&i2c_dev->complete,
+  500 * HZ / 1000);
+
+if (!wait_result)
+return -ETIMEDOUT;
+
+ret = wmt_check_status(i2c_dev);
+if (ret)
+return ret;
+
+pmsg->buf[xfer_len] = readw(i2c_dev->base + REG_CDR) >> 8;
+xfer_len++;
+
+if (xfer_len == pmsg->len - 1) {
+val = readw(i2c_dev->base + REG_CR);
+val |= (CR_TX_NEXT_NO_ACK | CR_CPU_RDY);
+writew(val, i2c_dev->base + REG_CR);
+} else {
+val = readw(i2c_dev->base + REG_CR);
+val |= CR_CPU_RDY;
+writew(val, i2c_dev->base + REG_CR);
+}
+}
+
+return 0;
+}
+
+static int wmt_i2c_xfer(struct i2c_adapter *adap,
+struct i2c_msg msgs[],
+int num)
+{
+struct i2c_msg *pmsg;
+int i, is_last, restart;
+int ret = 0;
+
+for (i = 0; ret >= 0 && i < num; i++) {
+is_last = ((i + 1) == num);
+restart = (i != 0);
+
+pmsg = &msgs[i];
+if (pmsg->flags & I2C_M_NOSTART)
+restart = 1;
+if (pmsg->flags & I2C_M_RD)
+ret = wmt_i2c_read(adap, pmsg, restart, is_last);
+else
+ret = wmt_i2c_write(adap, pmsg, restart, is_last);
+}
+
+return (ret < 0) ? ret : i;
+}
+
+static u32 wmt_i2c_func(struct i2c_adapter *adap)
+{
+return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART;
+}
+
+static const struct i2c_algorithm wmt_i2c_algo = {
+.master_xfer= wmt_i2c_xfer,
+.functionality= wmt_i2c_func,
+};
+
+static irqreturn_t wmt_i2c_isr(int irq, void *data)
+{
+struct wmt_i2c_dev *i2c_dev = data;
+
+/* save the status and write-clear it */
+i2c_dev->cmd_status = readw(i2c_dev->base + REG_ISR);
+writew(i2c_dev->cmd_status, i2c_dev->base + REG_ISR);
+
+complete(&i2c_dev->complete);
+
+return IRQ_HANDLED;
+}
+
+static int wmt_i2c_reset_hardware(struct wmt_i2c_dev *i2c_dev)
+{
+int err;
+
+err = clk_prepare_enable(i2c_dev->clk);
+if (err) {
+dev_err(i2c_dev->dev, "failed to enable clock\n");
+return err;
+}
+
+err = clk_set_rate(i2c_dev->clk, 20000000);
+if (err) {
+dev_err(i2c_dev->dev, "failed to set clock = 20Mhz\n");
+return err;
+}
+
+writew(0, i2c_dev->base + REG_CR);
+writew(12, i2c_dev->base + REG_MCR);
+writew(ISR_WRITE_ALL, i2c_dev->base + REG_ISR);
+writew(IMR_ENABLE_ALL, i2c_dev->base + REG_IMR);
+writew(CR_ENABLE, i2c_dev->base + REG_CR);
+readw(i2c_dev->base + REG_CSR);/* read clear */
+writew(ISR_WRITE_ALL, i2c_dev->base + REG_ISR);
+
+if (i2c_dev->mode == I2C_MODE_STANDARD)
+writew(SCL_TIMEOUT(128) | TR_STD, i2c_dev->base + REG_TR);
+else
+writew(SCL_TIMEOUT(128) | TR_HS, i2c_dev->base + REG_TR);
+
+return 0;
+}
+
+static int wmt_i2c_probe(struct platform_device *pdev)
+{
+struct device_node *np = pdev->dev.of_node;
+struct wmt_i2c_dev *i2c_dev;
+struct i2c_adapter *adap;
+struct resource *res;
+int err;
+u32 clk_rate;
+
+if (!np) {
+dev_err(&pdev->dev, "device node not found\n");
+return -ENODEV;
+}
+
+i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL);
+if (!i2c_dev) {
+dev_err(&pdev->dev, "device memory allocation failed\n");
+return -ENOMEM;
+}
+
+res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+i2c_dev->base = devm_ioremap_resource(&pdev->dev, res);
+if (IS_ERR(i2c_dev->base))
+return PTR_ERR(i2c_dev->base);
+
+i2c_dev->irq = irq_of_parse_and_map(np, 0);
+if (!i2c_dev->irq) {
+dev_err(&pdev->dev, "irq missing or invalid\n");
+return -EINVAL;
+}
+
+i2c_dev->clk = of_clk_get(np, 0);
+if (IS_ERR(i2c_dev->clk)) {
+dev_err(&pdev->dev, "unable to request clock\n");
+return PTR_ERR(i2c_dev->clk);
+}
+
+i2c_dev->mode = I2C_MODE_STANDARD;
+err = of_property_read_u32(np, "clock-frequency", &clk_rate);
+if ((!err) && (clk_rate == 400000))
+i2c_dev->mode = I2C_MODE_FAST;
+
+i2c_dev->dev = &pdev->dev;
+
+err = devm_request_irq(&pdev->dev, i2c_dev->irq, wmt_i2c_isr, 0,
+"i2c", i2c_dev);
+if (err) {
+dev_err(&pdev->dev, "failed to request irq %i\n", i2c_dev->irq);
+return err;
+}
+
+adap = &i2c_dev->adapter;
+i2c_set_adapdata(adap, i2c_dev);
+strlcpy(adap->name, "WMT I2C adapter", sizeof(adap->name));
+adap->owner = THIS_MODULE;
+adap->class = I2C_CLASS_HWMON;
+adap->algo = &wmt_i2c_algo;
+adap->dev.parent = &pdev->dev;
+adap->dev.of_node = pdev->dev.of_node;
+adap->nr = of_alias_get_id(pdev->dev.of_node, "i2c");
+
+err = wmt_i2c_reset_hardware(i2c_dev);
+if (err) {
+dev_err(&pdev->dev, "error initializing hardware\n");
+return err;
+}
+
+if (adap->nr < 0)
+err = i2c_add_adapter(adap);
+else
+err = i2c_add_numbered_adapter(adap);
+
+if (err) {
+dev_err(&pdev->dev, "failed to add adapter\n");
+return err;
+}
+
+platform_set_drvdata(pdev, i2c_dev);
+
+of_i2c_register_devices(adap);
+
+return 0;
+}
+
+static int wmt_i2c_remove(struct platform_device *pdev)
+{
+struct wmt_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
+
+/* Disable interrupts, clock and delete adapter */
+writew(0, i2c_dev->base + REG_IMR);
+clk_disable_unprepare(i2c_dev->clk);
+i2c_del_adapter(&i2c_dev->adapter);
+
+return 0;
+}
+
+static struct of_device_id wmt_i2c_dt_ids[] = {
+{ .compatible = "wm,wm8505-i2c" },
+{ /* Sentinel */ },
+};
+
+static struct platform_driver wmt_i2c_driver = {
+.probe= wmt_i2c_probe,
+.remove= wmt_i2c_remove,
+.driver= {
+.name= "wmt-i2c",
+.owner= THIS_MODULE,
+.of_match_table = wmt_i2c_dt_ids,
+},
+};
+
+module_platform_driver(wmt_i2c_driver);
+
+MODULE_DESCRIPTION("Wondermedia I2C master-mode bus adapter");
+MODULE_AUTHOR("Tony Prisk <linux-ci5G2KO2hbZ+pU9mqzGVBQ< at >public.gmane.org>");
+MODULE_LICENSE("GPL v2");
+MODULE_DEVICE_TABLE(of, wmt_i2c_dt_ids);

презент устроен поражать

oksana87739 — 2013-05-12T08:49:10

   Заходите по ссылке: http://snurl.com/270kbc4 Всякий отпрыск будет счастлив унаследовать этакой дар.

Claims Requirements

2013-05-11T03:38:51

This is to inform you that you have been
selected for a cash prize of £1,000,000
(British Pounds) held on the 8th of May
2013 in London (United Kingdom). The
selection process was carried out through
random selection in Our computerized email
selection system (ESS) London Uk.

You have therefore been approved to claim
a total sum of 1 Million Pounds,(One Million Pounds)
in cash credited to fileKTU/ 9023118308/03.

Claims Requirements:

1.Full Name
2.Full Address
3.Marital Status
4.Occupation
5.Age
6.Sex
7.Nationality
8.Country Of Residence
9.Telephone Number

Agent Name: Mr. Fred Peters
Tel: +447031989477
 +447031963824
Email: mr.fredpetersclaimsagent037-3ZxEkuqjL73QT0dZR+AlfA< at >public.gmane.org

Вы сподручны на основательней

Topaz777 — 2013-05-09T22:08:32

Вам когда - нибудь доставалось присутствовать в такой ситуации, когда Вы не могли сфокусироваться на цели, Все свободное время рассеивались на разнообразные детали. не знали как уйти из тяжелой ситуации, как перебороть препятствие. знали, ровно надо Это явно свершить, а улетучивалась мотивация. По ссылке: http://tinyurl.com/c2epbkb Мы знаем как поспособствовать Вам достичь успеха! и не имеет значения, каковую задачу Вы перед собой делаете – заменить работу, начать бизнес аль исхудать на |0 кил. Таковы ситуации ведомы любым.