Message ID | 20240601192846.68146-2-gerhard@engleder-embedded.com |
---|---|
State | Changes Requested |
Delegated to: | Andi Shyti |
Headers | show |
Series | I2C controller support for KEBA PLCs | expand |
Hi Gerhard, kernel test robot noticed the following build warnings: [auto build test WARNING on andi-shyti/i2c/i2c-host] [also build test WARNING on char-misc/char-misc-testing char-misc/char-misc-next char-misc/char-misc-linus soc/for-next linus/master v6.10-rc1 next-20240531] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Gerhard-Engleder/i2c-keba-Add-KEBA-I2C-controller-support/20240602-040548 base: git://git.kernel.org/pub/scm/linux/kernel/git/andi.shyti/linux.git i2c/i2c-host patch link: https://lore.kernel.org/r/20240601192846.68146-2-gerhard%40engleder-embedded.com patch subject: [PATCH 1/2] i2c: keba: Add KEBA I2C controller support config: alpha-allyesconfig (https://download.01.org/0day-ci/archive/20240602/202406020634.cfpd5wMw-lkp@intel.com/config) compiler: alpha-linux-gcc (GCC) 13.2.0 reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240602/202406020634.cfpd5wMw-lkp@intel.com/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202406020634.cfpd5wMw-lkp@intel.com/ All warnings (new ones prefixed by >>): >> drivers/i2c/busses/i2c-keba.c:568:34: warning: 'ki2c_devtype' defined but not used [-Wunused-variable] 568 | static struct platform_device_id ki2c_devtype[] = { | ^~~~~~~~~~~~ vim +/ki2c_devtype +568 drivers/i2c/busses/i2c-keba.c 567 > 568 static struct platform_device_id ki2c_devtype[] = { 569 { .name = KI2C }, 570 { } 571 }; 572 MODULE_DEVICE_TABLE(platform, ki2c_devtype); 573
Hi Gerhard, kernel test robot noticed the following build warnings: [auto build test WARNING on andi-shyti/i2c/i2c-host] [also build test WARNING on char-misc/char-misc-testing char-misc/char-misc-next char-misc/char-misc-linus soc/for-next linus/master v6.10-rc1 next-20240531] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Gerhard-Engleder/i2c-keba-Add-KEBA-I2C-controller-support/20240602-040548 base: git://git.kernel.org/pub/scm/linux/kernel/git/andi.shyti/linux.git i2c/i2c-host patch link: https://lore.kernel.org/r/20240601192846.68146-2-gerhard%40engleder-embedded.com patch subject: [PATCH 1/2] i2c: keba: Add KEBA I2C controller support config: hexagon-allyesconfig (https://download.01.org/0day-ci/archive/20240602/202406020713.qwylbUoh-lkp@intel.com/config) compiler: clang version 19.0.0git (https://github.com/llvm/llvm-project bafda89a0944d947fc4b3b5663185e07a397ac30) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240602/202406020713.qwylbUoh-lkp@intel.com/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202406020713.qwylbUoh-lkp@intel.com/ All warnings (new ones prefixed by >>): In file included from drivers/i2c/busses/i2c-keba.c:11: In file included from include/linux/io.h:14: In file included from arch/hexagon/include/asm/io.h:328: include/asm-generic/io.h:548:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] 548 | val = __raw_readb(PCI_IOBASE + addr); | ~~~~~~~~~~ ^ include/asm-generic/io.h:561:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] 561 | val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); | ~~~~~~~~~~ ^ include/uapi/linux/byteorder/little_endian.h:37:51: note: expanded from macro '__le16_to_cpu' 37 | #define __le16_to_cpu(x) ((__force __u16)(__le16)(x)) | ^ In file included from drivers/i2c/busses/i2c-keba.c:11: In file included from include/linux/io.h:14: In file included from arch/hexagon/include/asm/io.h:328: include/asm-generic/io.h:574:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] 574 | val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); | ~~~~~~~~~~ ^ include/uapi/linux/byteorder/little_endian.h:35:51: note: expanded from macro '__le32_to_cpu' 35 | #define __le32_to_cpu(x) ((__force __u32)(__le32)(x)) | ^ In file included from drivers/i2c/busses/i2c-keba.c:11: In file included from include/linux/io.h:14: In file included from arch/hexagon/include/asm/io.h:328: include/asm-generic/io.h:585:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] 585 | __raw_writeb(value, PCI_IOBASE + addr); | ~~~~~~~~~~ ^ include/asm-generic/io.h:595:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] 595 | __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr); | ~~~~~~~~~~ ^ include/asm-generic/io.h:605:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] 605 | __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr); | ~~~~~~~~~~ ^ In file included from drivers/i2c/busses/i2c-keba.c:13: In file included from include/linux/i2c.h:19: In file included from include/linux/regulator/consumer.h:35: In file included from include/linux/suspend.h:5: In file included from include/linux/swap.h:9: In file included from include/linux/memcontrol.h:21: In file included from include/linux/mm.h:2253: include/linux/vmstat.h:514:36: warning: arithmetic between different enumeration types ('enum node_stat_item' and 'enum lru_list') [-Wenum-enum-conversion] 514 | return node_stat_name(NR_LRU_BASE + lru) + 3; // skip "nr_" | ~~~~~~~~~~~ ^ ~~~ >> drivers/i2c/busses/i2c-keba.c:568:34: warning: unused variable 'ki2c_devtype' [-Wunused-variable] 568 | static struct platform_device_id ki2c_devtype[] = { | ^~~~~~~~~~~~ 8 warnings generated. vim +/ki2c_devtype +568 drivers/i2c/busses/i2c-keba.c 567 > 568 static struct platform_device_id ki2c_devtype[] = { 569 { .name = KI2C }, 570 { } 571 }; 572 MODULE_DEVICE_TABLE(platform, ki2c_devtype); 573
Hi Gerhard, kernel test robot noticed the following build warnings: [auto build test WARNING on andi-shyti/i2c/i2c-host] [also build test WARNING on char-misc/char-misc-testing char-misc/char-misc-next char-misc/char-misc-linus soc/for-next linus/master v6.10-rc1 next-20240531] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Gerhard-Engleder/i2c-keba-Add-KEBA-I2C-controller-support/20240602-040548 base: git://git.kernel.org/pub/scm/linux/kernel/git/andi.shyti/linux.git i2c/i2c-host patch link: https://lore.kernel.org/r/20240601192846.68146-2-gerhard%40engleder-embedded.com patch subject: [PATCH 1/2] i2c: keba: Add KEBA I2C controller support config: s390-randconfig-r062-20240603 (https://download.01.org/0day-ci/archive/20240603/202406030504.QcIr6Qaw-lkp@intel.com/config) compiler: s390-linux-gcc (GCC) 13.2.0 If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202406030504.QcIr6Qaw-lkp@intel.com/ cocci warnings: (new ones prefixed by >>) >> drivers/i2c/busses/i2c-keba.c:491:14-15: WARNING comparing pointer to 0 vim +491 drivers/i2c/busses/i2c-keba.c 480 481 static int ki2c_probe(struct platform_device *pdev) 482 { 483 struct i2c_keba_platform_data *pdata; 484 struct device *dev = &pdev->dev; 485 struct i2c_adapter *adap; 486 struct resource *io; 487 struct ki2c *ki2c; 488 int ret; 489 490 pdata = dev->platform_data; > 491 if (pdata == 0) { 492 dev_err(dev, "Platform data not found!\n"); 493 return -ENODEV; 494 } 495 496 ki2c = devm_kzalloc(dev, sizeof(*ki2c), GFP_KERNEL); 497 if (!ki2c) 498 return -ENOMEM; 499 ki2c->pdev = pdev; 500 ki2c->client = devm_kcalloc(dev, pdata->info_size, 501 sizeof(*ki2c->client), GFP_KERNEL); 502 if (!ki2c->client) 503 return -ENOMEM; 504 ki2c->client_size = pdata->info_size; 505 platform_set_drvdata(pdev, ki2c); 506 507 io = platform_get_resource(pdev, IORESOURCE_MEM, 0); 508 ki2c->base = devm_ioremap_resource(dev, io); 509 if (IS_ERR(ki2c->base)) 510 return PTR_ERR(ki2c->base); 511 512 /* enable controller */ 513 iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); 514 515 adap = &ki2c->adapter; 516 strscpy(adap->name, "KEBA I2C adapter", sizeof(adap->name)); 517 adap->owner = THIS_MODULE; 518 adap->class = I2C_CLASS_HWMON; 519 adap->algo = &ki2c_algo; 520 adap->dev.parent = dev; 521 522 i2c_set_adapdata(adap, ki2c); 523 524 /* reset bus before probing I2C devices */ 525 ret = ki2c_reset_bus(ki2c); 526 if (ret) { 527 dev_err(dev, "Failed to reset bus (%d)!\n", ret); 528 goto out_disable; 529 } 530 531 ret = i2c_add_adapter(adap); 532 if (ret) { 533 dev_err(dev, "Failed to add adapter (%d)!\n", ret); 534 goto out_disable; 535 } 536 537 ret = ki2c_register_devices(ki2c, pdata); 538 if (ret) { 539 dev_err(dev, "Failed to register devices (%d)!\n", ret); 540 goto out_delete; 541 } 542 543 return 0; 544 545 out_delete: 546 i2c_del_adapter(adap); 547 out_disable: 548 iowrite8(0, ki2c->base + KI2C_CONTROL_REG); 549 return ret; 550 } 551
Hi Gerhard, On Sat, Jun 01, 2024 at 09:28:45PM +0200, Gerhard Engleder wrote: > From: Gerhard Engleder <eg@keba.com> > > The KEBA I2C controller is found in the system FPGA of KEBA PLC devices. > It is used to connect EEPROMs and hardware monitoring chips. can you please add more information about the device, please? ... > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright (C) KEBA AG 2012 can we update the date here? > + * Copyright (C) KEBA Industrial Automation Gmbh 2024 > + * > + * Driver for KEBA I2C controller FPGA IP core > + */ > + > +#include <linux/module.h> > +#include <linux/platform_device.h> > +#include <linux/io.h> > +#include <linux/iopoll.h> > +#include <linux/i2c.h> > +#include <linux/platform_data/i2c-keba.h> Can you sort them in alphabetical order, please? > +#define KI2C "i2c-keba" > + > +#define KI2C_CAPABILITY_REG 0x02 > +#define KI2C_CONTROL_REG 0x04 > +#define KI2C_CONTROL_DC_REG 0x05 > +#define KI2C_STATUS_REG 0x08 > +#define KI2C_STATUS_DC_REG 0x09 > +#define KI2C_DATA_REG 0x0c > + > +#define KI2C_CAPABILITY_CRYPTO 0x01 This crypto is not used anywhere, did you add it for completness or have you forgotten to use it? > +#define KI2C_CAPABILITY_DC 0x02 > + > +#define KI2C_CONTROL_MEN 0x01 > +#define KI2C_CONTROL_MSTA 0x02 > +#define KI2C_CONTROL_RSTA 0x04 > +#define KI2C_CONTROL_MTX 0x08 > +#define KI2C_CONTROL_TXAK 0x10 > + > +#define KI2C_STATUS_IN_USE 0x01 > +#define KI2C_STATUS_ACK_CYC 0x02 > +#define KI2C_STATUS_RXAK 0x04 > +#define KI2C_STATUS_MCF 0x08 > + > +#define KI2C_DC_SDA 0x01 > +#define KI2C_DC_SCL 0x02 You could eventually make it as: #define REG1_ADDR 0xXX #define REG1_VAL_1 0xXX #define REG1_VAL_2 0xXX #define REG1_VAL_3 0xXX #define REG2_ADDR 0xXX #define REG2_VAL_1 0xXX #define REG2_VAL_2 0xXX #define REG2_VAL_3 0xXX So that it's clear what belongs to what. Not a binding comment, just an aesthetic note. > + > +#define KI2C_INUSE_SLEEP_US (2 * USEC_PER_MSEC) > +#define KI2C_INUSE_TIMEOUT_US (10 * USEC_PER_SEC) > + > +#define KI2C_POLL_DELAY_US 5 > + > +struct ki2c { > + struct platform_device *pdev; > + void __iomem *base; > + struct i2c_adapter adapter; > + > + struct i2c_client **client; > + int client_size; > +}; > + > +static int ki2c_inuse_lock(struct ki2c *ki2c) > +{ > + u8 sts; > + int ret; > + > + /* The I2C controller has an IN_USE bit for locking access to the > + * controller. This enables the use of I2C controller by other none > + * Linux processors. Please use the proper commenting style: /* * Comment line 1 * Comment line 2 * ... * Comment line N */ > + * > + * If the I2C controller is free, then the first read returns > + * IN_USE == 0. After that the I2C controller is locked and further > + * reads of IN_USE return 1. > + * > + * The I2C controller is unlocked by writing 1 into IN_USE. > + */ Basically this is a semaphore. > + ret = readb_poll_timeout(ki2c->base + KI2C_STATUS_REG, > + sts, (sts & KI2C_STATUS_IN_USE) == 0, > + KI2C_INUSE_SLEEP_US, KI2C_INUSE_TIMEOUT_US); we are waiting too long here... the documentaition recommends to use the readb_poll_timeout for less than 10us, while we are waiting 2ms. > + if (ret != 0) > + dev_warn(&ki2c->pdev->dev, "%s err!\n", __func__); > + > + return ret; > +} > + > +static void ki2c_inuse_unlock(struct ki2c *ki2c) > +{ > + /* unlock the controller by writing 1 into IN_USE */ > + iowrite8(KI2C_STATUS_IN_USE, ki2c->base + KI2C_STATUS_REG); > +} > + > +static int ki2c_wait_for_bit(u8 mask, void __iomem *addr, unsigned long timeout) It looks more natural to have "addr" as a first argument. > +{ > + u8 val; > + > + return readb_poll_timeout(addr, val, (val & mask), KI2C_POLL_DELAY_US, > + jiffies_to_usecs(timeout)); > +} > +static int ki2c_get_sda(struct ki2c *ki2c) > +{ > + /* capability KI2C_CAPABILITY_DC required */ > + return (ioread8(ki2c->base + KI2C_STATUS_DC_REG) & KI2C_DC_SDA) != 0; Please avoid using such compact style. > +} > + /* generate clock cycles */ > + ki2c_set_scl(ki2c, val); > + ndelay(KI2C_RECOVERY_NDELAY); > + while (count++ < KI2C_RECOVERY_CLK_CNT * 2) { > + if (val) { > + /* SCL shouldn't be low here */ > + if (!ki2c_get_scl(ki2c)) { > + dev_err(&ki2c->pdev->dev, > + "SCL is stuck low!\n"); > + ret = -EBUSY; > + break; > + } > + > + /* break if SDA is high */ > + if (ki2c_get_sda(ki2c)) > + break; > + } > + > + val = !val; > + ki2c_set_scl(ki2c, val); > + ndelay(KI2C_RECOVERY_NDELAY); I don't know how much sense it makes to wait in ndelays, this is not going to be precise and... are we sure we want to wait atomically here? > + } > + > + if (!ki2c_get_sda(ki2c)) { > + dev_err(&ki2c->pdev->dev, "SDA is still low!\n"); To me this and the above dev_err's are just spamming the dmesg as we are already printing up in the probe function. If we want to have more precision printing, then we need to chose where the dev_err's need to be. > + ret = -EBUSY; > + } > + > + /* reenable controller */ > + iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); ... > + ret = ki2c_wait_for_data_ack(ki2c); > + if (ret < 0) > + /* For EEPROMs this is normal behavior during internal write > + * operation. Please, mind the coding style. > + */ > + dev_dbg(&ki2c->pdev->dev, "%s wait for ACK err at 0x%02x!\n", > + __func__, m->addr); > + > + return ret; > +} ... > +static int ki2c_probe(struct platform_device *pdev) > +{ > + struct i2c_keba_platform_data *pdata; > + struct device *dev = &pdev->dev; > + struct i2c_adapter *adap; > + struct resource *io; > + struct ki2c *ki2c; > + int ret; > + > + pdata = dev->platform_data; > + if (pdata == 0) { > + dev_err(dev, "Platform data not found!\n"); > + return -ENODEV; please use dev_err_probe() Andi ...
Hi Gerhard, kernel test robot noticed the following build warnings: [auto build test WARNING on andi-shyti/i2c/i2c-host] [also build test WARNING on char-misc/char-misc-testing char-misc/char-misc-next char-misc/char-misc-linus soc/for-next linus/master v6.10-rc2 next-20240603] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch#_base_tree_information] url: https://github.com/intel-lab-lkp/linux/commits/Gerhard-Engleder/i2c-keba-Add-KEBA-I2C-controller-support/20240602-040548 base: git://git.kernel.org/pub/scm/linux/kernel/git/andi.shyti/linux.git i2c/i2c-host patch link: https://lore.kernel.org/r/20240601192846.68146-2-gerhard%40engleder-embedded.com patch subject: [PATCH 1/2] i2c: keba: Add KEBA I2C controller support config: csky-randconfig-r121-20240604 (https://download.01.org/0day-ci/archive/20240604/202406040659.nZr6W80c-lkp@intel.com/config) compiler: csky-linux-gcc (GCC) 13.2.0 reproduce: (https://download.01.org/0day-ci/archive/20240604/202406040659.nZr6W80c-lkp@intel.com/reproduce) If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags | Reported-by: kernel test robot <lkp@intel.com> | Closes: https://lore.kernel.org/oe-kbuild-all/202406040659.nZr6W80c-lkp@intel.com/ sparse warnings: (new ones prefixed by >>) >> drivers/i2c/busses/i2c-keba.c:491:22: sparse: sparse: Using plain integer as NULL pointer drivers/i2c/busses/i2c-keba.c:563:36: sparse: sparse: Using plain integer as NULL pointer vim +491 drivers/i2c/busses/i2c-keba.c 480 481 static int ki2c_probe(struct platform_device *pdev) 482 { 483 struct i2c_keba_platform_data *pdata; 484 struct device *dev = &pdev->dev; 485 struct i2c_adapter *adap; 486 struct resource *io; 487 struct ki2c *ki2c; 488 int ret; 489 490 pdata = dev->platform_data; > 491 if (pdata == 0) { 492 dev_err(dev, "Platform data not found!\n"); 493 return -ENODEV; 494 } 495 496 ki2c = devm_kzalloc(dev, sizeof(*ki2c), GFP_KERNEL); 497 if (!ki2c) 498 return -ENOMEM; 499 ki2c->pdev = pdev; 500 ki2c->client = devm_kcalloc(dev, pdata->info_size, 501 sizeof(*ki2c->client), GFP_KERNEL); 502 if (!ki2c->client) 503 return -ENOMEM; 504 ki2c->client_size = pdata->info_size; 505 platform_set_drvdata(pdev, ki2c); 506 507 io = platform_get_resource(pdev, IORESOURCE_MEM, 0); 508 ki2c->base = devm_ioremap_resource(dev, io); 509 if (IS_ERR(ki2c->base)) 510 return PTR_ERR(ki2c->base); 511 512 /* enable controller */ 513 iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); 514 515 adap = &ki2c->adapter; 516 strscpy(adap->name, "KEBA I2C adapter", sizeof(adap->name)); 517 adap->owner = THIS_MODULE; 518 adap->class = I2C_CLASS_HWMON; 519 adap->algo = &ki2c_algo; 520 adap->dev.parent = dev; 521 522 i2c_set_adapdata(adap, ki2c); 523 524 /* reset bus before probing I2C devices */ 525 ret = ki2c_reset_bus(ki2c); 526 if (ret) { 527 dev_err(dev, "Failed to reset bus (%d)!\n", ret); 528 goto out_disable; 529 } 530 531 ret = i2c_add_adapter(adap); 532 if (ret) { 533 dev_err(dev, "Failed to add adapter (%d)!\n", ret); 534 goto out_disable; 535 } 536 537 ret = ki2c_register_devices(ki2c, pdata); 538 if (ret) { 539 dev_err(dev, "Failed to register devices (%d)!\n", ret); 540 goto out_delete; 541 } 542 543 return 0; 544 545 out_delete: 546 i2c_del_adapter(adap); 547 out_disable: 548 iowrite8(0, ki2c->base + KI2C_CONTROL_REG); 549 return ret; 550 } 551
On 04.06.24 00:37, Andi Shyti wrote: > Hi Gerhard, Hello Andi > On Sat, Jun 01, 2024 at 09:28:45PM +0200, Gerhard Engleder wrote: >> From: Gerhard Engleder <eg@keba.com> >> >> The KEBA I2C controller is found in the system FPGA of KEBA PLC devices. >> It is used to connect EEPROMs and hardware monitoring chips. > > can you please add more information about the device, please? I will add more information >> +// SPDX-License-Identifier: GPL-2.0 >> +/* >> + * Copyright (C) KEBA AG 2012 > > can we update the date here? First driver version is from 2012. I will remove that line. >> + * Copyright (C) KEBA Industrial Automation Gmbh 2024 >> + * >> + * Driver for KEBA I2C controller FPGA IP core >> + */ >> + >> +#include <linux/module.h> >> +#include <linux/platform_device.h> >> +#include <linux/io.h> >> +#include <linux/iopoll.h> >> +#include <linux/i2c.h> >> +#include <linux/platform_data/i2c-keba.h> > > Can you sort them in alphabetical order, please? Will be done. >> +#define KI2C "i2c-keba" >> + >> +#define KI2C_CAPABILITY_REG 0x02 >> +#define KI2C_CONTROL_REG 0x04 >> +#define KI2C_CONTROL_DC_REG 0x05 >> +#define KI2C_STATUS_REG 0x08 >> +#define KI2C_STATUS_DC_REG 0x09 >> +#define KI2C_DATA_REG 0x0c >> + >> +#define KI2C_CAPABILITY_CRYPTO 0x01 > > This crypto is not used anywhere, did you add it for completness > or have you forgotten to use it? It is there for completeness/documentation. >> +#define KI2C_CAPABILITY_DC 0x02 >> + >> +#define KI2C_CONTROL_MEN 0x01 >> +#define KI2C_CONTROL_MSTA 0x02 >> +#define KI2C_CONTROL_RSTA 0x04 >> +#define KI2C_CONTROL_MTX 0x08 >> +#define KI2C_CONTROL_TXAK 0x10 >> + >> +#define KI2C_STATUS_IN_USE 0x01 >> +#define KI2C_STATUS_ACK_CYC 0x02 >> +#define KI2C_STATUS_RXAK 0x04 >> +#define KI2C_STATUS_MCF 0x08 >> + >> +#define KI2C_DC_SDA 0x01 >> +#define KI2C_DC_SCL 0x02 > > You could eventually make it as: > > #define REG1_ADDR 0xXX > #define REG1_VAL_1 0xXX > #define REG1_VAL_2 0xXX > #define REG1_VAL_3 0xXX > > #define REG2_ADDR 0xXX > #define REG2_VAL_1 0xXX > #define REG2_VAL_2 0xXX > #define REG2_VAL_3 0xXX > > So that it's clear what belongs to what. Not a binding comment, > just an aesthetic note. I will give it a try. >> + >> +#define KI2C_INUSE_SLEEP_US (2 * USEC_PER_MSEC) >> +#define KI2C_INUSE_TIMEOUT_US (10 * USEC_PER_SEC) >> + >> +#define KI2C_POLL_DELAY_US 5 >> + >> +struct ki2c { >> + struct platform_device *pdev; >> + void __iomem *base; >> + struct i2c_adapter adapter; >> + >> + struct i2c_client **client; >> + int client_size; >> +}; >> + >> +static int ki2c_inuse_lock(struct ki2c *ki2c) >> +{ >> + u8 sts; >> + int ret; >> + >> + /* The I2C controller has an IN_USE bit for locking access to the >> + * controller. This enables the use of I2C controller by other none >> + * Linux processors. > > Please use the proper commenting style: > > /* > * Comment line 1 First driver version is from 2012. I will > * Comment line 2 > * ... > * Comment line N > */ > Sorry, I forgot that only net is using that style. Will be changed for all comments. >> + * >> + * If the I2C controller is free, then the first read returns >> + * IN_USE == 0. After that the I2C controller is locked and further >> + * reads of IN_USE return 1. >> + * >> + * The I2C controller is unlocked by writing 1 into IN_USE. >> + */ > > Basically this is a semaphore. I will enhance the comment. >> + ret = readb_poll_timeout(ki2c->base + KI2C_STATUS_REG, >> + sts, (sts & KI2C_STATUS_IN_USE) == 0, >> + KI2C_INUSE_SLEEP_US, KI2C_INUSE_TIMEOUT_US); > > we are waiting too long here... the documentaition recommends to > use the readb_poll_timeout for less than 10us, while we are > waiting 2ms. I will check if it can be changed. Should be possible. >> + if (ret != 0) >> + dev_warn(&ki2c->pdev->dev, "%s err!\n", __func__); >> + >> + return ret; >> +} >> + >> +static void ki2c_inuse_unlock(struct ki2c *ki2c) >> +{ >> + /* unlock the controller by writing 1 into IN_USE */ >> + iowrite8(KI2C_STATUS_IN_USE, ki2c->base + KI2C_STATUS_REG); >> +} >> + >> +static int ki2c_wait_for_bit(u8 mask, void __iomem *addr, unsigned long timeout) > > It looks more natural to have "addr" as a first argument. I will reorder. >> +{ >> + u8 val; >> + >> + return readb_poll_timeout(addr, val, (val & mask), KI2C_POLL_DELAY_US, >> + jiffies_to_usecs(timeout)); >> +} >> +static int ki2c_get_sda(struct ki2c *ki2c) >> +{ >> + /* capability KI2C_CAPABILITY_DC required */ >> + return (ioread8(ki2c->base + KI2C_STATUS_DC_REG) & KI2C_DC_SDA) != 0; > > Please avoid using such compact style. Will make it more readable. >> +} >> + /* generate clock cycles */ >> + ki2c_set_scl(ki2c, val); >> + ndelay(KI2C_RECOVERY_NDELAY); >> + while (count++ < KI2C_RECOVERY_CLK_CNT * 2) { >> + if (val) { >> + /* SCL shouldn't be low here */ >> + if (!ki2c_get_scl(ki2c)) { >> + dev_err(&ki2c->pdev->dev, >> + "SCL is stuck low!\n"); >> + ret = -EBUSY; >> + break; >> + } >> + >> + /* break if SDA is high */ >> + if (ki2c_get_sda(ki2c)) >> + break; >> + } >> + >> + val = !val; >> + ki2c_set_scl(ki2c, val); >> + ndelay(KI2C_RECOVERY_NDELAY); > > I don't know how much sense it makes to wait in ndelays, this is > not going to be precise and... are we sure we want to wait > atomically here? So far there were no problems so it should be precise enough. Delay is only 5us so sleeping is not necessary. This is done during startup, sleeping would delay startup. >> + } >> + >> + if (!ki2c_get_sda(ki2c)) { >> + dev_err(&ki2c->pdev->dev, "SDA is still low!\n"); > > To me this and the above dev_err's are just spamming the dmesg as > we are already printing up in the probe function. If we want to > have more precision printing, then we need to chose where the > dev_err's need to be. I will improve the error reporting. >> + ret = -EBUSY; >> + } >> + >> + /* reenable controller */ >> + iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); > > ... > >> + ret = ki2c_wait_for_data_ack(ki2c); >> + if (ret < 0) >> + /* For EEPROMs this is normal behavior during internal write >> + * operation. > > Please, mind the coding style. I will do. >> + */ >> + dev_dbg(&ki2c->pdev->dev, "%s wait for ACK err at 0x%02x!\n", >> + __func__, m->addr); >> + >> + return ret; >> +} > > ... > >> +static int ki2c_probe(struct platform_device *pdev) >> +{ >> + struct i2c_keba_platform_data *pdata; >> + struct device *dev = &pdev->dev; >> + struct i2c_adapter *adap; >> + struct resource *io; >> + struct ki2c *ki2c; >> + int ret; >> + >> + pdata = dev->platform_data; >> + if (pdata == 0) { >> + dev_err(dev, "Platform data not found!\n"); >> + return -ENODEV; > > please use dev_err_probe() This function is new to me. I will check. Thank you for your review! Gerhard
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig index fe6e8a1bb607..be2611a33503 100644 --- a/drivers/i2c/busses/Kconfig +++ b/drivers/i2c/busses/Kconfig @@ -770,6 +770,16 @@ config I2C_JZ4780 If you don't know what to do here, say N. +config I2C_KEBA + tristate "KEBA I2C controller support" + depends on HAS_IOMEM + help + This driver supports the I2C controller found in KEBA system FPGA + devices. + + This driver can also be built as a module. If so, the module + will be called i2c-keba. + config I2C_KEMPLD tristate "Kontron COM I2C Controller" depends on MFD_KEMPLD diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile index 3d65934f5eb4..6c3dfa7936c7 100644 --- a/drivers/i2c/busses/Makefile +++ b/drivers/i2c/busses/Makefile @@ -77,6 +77,7 @@ obj-$(CONFIG_I2C_IMX) += i2c-imx.o obj-$(CONFIG_I2C_IMX_LPI2C) += i2c-imx-lpi2c.o obj-$(CONFIG_I2C_IOP3XX) += i2c-iop3xx.o obj-$(CONFIG_I2C_JZ4780) += i2c-jz4780.o +obj-$(CONFIG_I2C_KEBA) += i2c-keba.o obj-$(CONFIG_I2C_KEMPLD) += i2c-kempld.o obj-$(CONFIG_I2C_LPC2K) += i2c-lpc2k.o obj-$(CONFIG_I2C_LS2X) += i2c-ls2x.o diff --git a/drivers/i2c/busses/i2c-keba.c b/drivers/i2c/busses/i2c-keba.c new file mode 100644 index 000000000000..5f76f0ddeccf --- /dev/null +++ b/drivers/i2c/busses/i2c-keba.c @@ -0,0 +1,585 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) KEBA AG 2012 + * Copyright (C) KEBA Industrial Automation Gmbh 2024 + * + * Driver for KEBA I2C controller FPGA IP core + */ + +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/io.h> +#include <linux/iopoll.h> +#include <linux/i2c.h> +#include <linux/platform_data/i2c-keba.h> + +#define KI2C "i2c-keba" + +#define KI2C_CAPABILITY_REG 0x02 +#define KI2C_CONTROL_REG 0x04 +#define KI2C_CONTROL_DC_REG 0x05 +#define KI2C_STATUS_REG 0x08 +#define KI2C_STATUS_DC_REG 0x09 +#define KI2C_DATA_REG 0x0c + +#define KI2C_CAPABILITY_CRYPTO 0x01 +#define KI2C_CAPABILITY_DC 0x02 + +#define KI2C_CONTROL_MEN 0x01 +#define KI2C_CONTROL_MSTA 0x02 +#define KI2C_CONTROL_RSTA 0x04 +#define KI2C_CONTROL_MTX 0x08 +#define KI2C_CONTROL_TXAK 0x10 + +#define KI2C_STATUS_IN_USE 0x01 +#define KI2C_STATUS_ACK_CYC 0x02 +#define KI2C_STATUS_RXAK 0x04 +#define KI2C_STATUS_MCF 0x08 + +#define KI2C_DC_SDA 0x01 +#define KI2C_DC_SCL 0x02 + +#define KI2C_INUSE_SLEEP_US (2 * USEC_PER_MSEC) +#define KI2C_INUSE_TIMEOUT_US (10 * USEC_PER_SEC) + +#define KI2C_POLL_DELAY_US 5 + +struct ki2c { + struct platform_device *pdev; + void __iomem *base; + struct i2c_adapter adapter; + + struct i2c_client **client; + int client_size; +}; + +static int ki2c_inuse_lock(struct ki2c *ki2c) +{ + u8 sts; + int ret; + + /* The I2C controller has an IN_USE bit for locking access to the + * controller. This enables the use of I2C controller by other none + * Linux processors. + * + * If the I2C controller is free, then the first read returns + * IN_USE == 0. After that the I2C controller is locked and further + * reads of IN_USE return 1. + * + * The I2C controller is unlocked by writing 1 into IN_USE. + */ + ret = readb_poll_timeout(ki2c->base + KI2C_STATUS_REG, + sts, (sts & KI2C_STATUS_IN_USE) == 0, + KI2C_INUSE_SLEEP_US, KI2C_INUSE_TIMEOUT_US); + if (ret != 0) + dev_warn(&ki2c->pdev->dev, "%s err!\n", __func__); + + return ret; +} + +static void ki2c_inuse_unlock(struct ki2c *ki2c) +{ + /* unlock the controller by writing 1 into IN_USE */ + iowrite8(KI2C_STATUS_IN_USE, ki2c->base + KI2C_STATUS_REG); +} + +static int ki2c_wait_for_bit(u8 mask, void __iomem *addr, unsigned long timeout) +{ + u8 val; + + return readb_poll_timeout(addr, val, (val & mask), KI2C_POLL_DELAY_US, + jiffies_to_usecs(timeout)); +} + +static int ki2c_wait_for_mcf(struct ki2c *ki2c) +{ + return ki2c_wait_for_bit(KI2C_STATUS_MCF, ki2c->base + KI2C_STATUS_REG, + ki2c->adapter.timeout); +} + +static int ki2c_wait_for_data(struct ki2c *ki2c) +{ + int ret; + + ret = ki2c_wait_for_mcf(ki2c); + if (ret < 0) + return ret; + + return ki2c_wait_for_bit(KI2C_STATUS_ACK_CYC, + ki2c->base + KI2C_STATUS_REG, + ki2c->adapter.timeout); +} + +static int ki2c_wait_for_data_ack(struct ki2c *ki2c) +{ + int ret; + + ret = ki2c_wait_for_data(ki2c); + if (ret < 0) + return ret; + + /* RXAK == 0 means ACK reveived */ + if (ioread8(ki2c->base + KI2C_STATUS_REG) & KI2C_STATUS_RXAK) + return -EIO; + + return 0; +} + +static int ki2c_has_capability(struct ki2c *ki2c, unsigned int cap) +{ + return (ioread8(ki2c->base + KI2C_CAPABILITY_REG) & cap) != 0; +} + +static int ki2c_get_scl(struct ki2c *ki2c) +{ + /* capability KI2C_CAPABILITY_DC required */ + return (ioread8(ki2c->base + KI2C_STATUS_DC_REG) & KI2C_DC_SCL) != 0; +} + +static int ki2c_get_sda(struct ki2c *ki2c) +{ + /* capability KI2C_CAPABILITY_DC required */ + return (ioread8(ki2c->base + KI2C_STATUS_DC_REG) & KI2C_DC_SDA) != 0; +} + +static void ki2c_set_scl(struct ki2c *ki2c, int val) +{ + u8 control_dc; + + /* capability KI2C_CAPABILITY_DC and KI2C_CONTROL_MEN = 0 reqired */ + control_dc = ioread8(ki2c->base + KI2C_CONTROL_DC_REG); + if (val) + control_dc |= KI2C_DC_SCL; + else + control_dc &= ~KI2C_DC_SCL; + iowrite8(control_dc, ki2c->base + KI2C_CONTROL_DC_REG); +} + +/* + * Resetting bus bitwise is done by checking SDA and applying clock cycles as + * long as SDA is low. 9 clock cycles are applied at most. + * + * Clock cycles are generated and ndelay() determines the duration of clock + * cycles. Generated clock rate is 100 KHz and so duration of both clock levels + * is: delay in ns = (10^6 / 100) / 2 + */ +#define KI2C_RECOVERY_CLK_CNT 9 +#define KI2C_RECOVERY_NDELAY 5000 +static int ki2c_reset_bus_bitwise(struct ki2c *ki2c) +{ + int count = 0; + int val = 1; + int ret = 0; + + /* disable I2C controller (MEN = 0) to get direct access to SCL/SDA */ + iowrite8(0, ki2c->base + KI2C_CONTROL_REG); + + /* generate clock cycles */ + ki2c_set_scl(ki2c, val); + ndelay(KI2C_RECOVERY_NDELAY); + while (count++ < KI2C_RECOVERY_CLK_CNT * 2) { + if (val) { + /* SCL shouldn't be low here */ + if (!ki2c_get_scl(ki2c)) { + dev_err(&ki2c->pdev->dev, + "SCL is stuck low!\n"); + ret = -EBUSY; + break; + } + + /* break if SDA is high */ + if (ki2c_get_sda(ki2c)) + break; + } + + val = !val; + ki2c_set_scl(ki2c, val); + ndelay(KI2C_RECOVERY_NDELAY); + } + + if (!ki2c_get_sda(ki2c)) { + dev_err(&ki2c->pdev->dev, "SDA is still low!\n"); + ret = -EBUSY; + } + + /* reenable controller */ + iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); + + return ret; +} + +/* + * Resetting bus bytewise is done by writing start bit, 9 data bits and stop + * bit. + * + * This is not 100% safe. If slave is an EEPROM and a write access was + * interrupted during the ACK cycle, this approach might not be able to recover + * the bus. The reason is, that after the 9 clock cycles the EEPROM will be in + * ACK cycle again and will hold SDA low like it did before the start of the + * routine. Furthermore the EEPROM might get written one additional byte with + * 0xff into it. Thus, use bitwise approach whenever possible, especially when + * EEPROMs are on the bus. + */ +static int ki2c_reset_bus_bytewise(struct ki2c *ki2c) +{ + int ret; + + /* hold data line high for 9 clock cycles */ + iowrite8(0xFF, ki2c->base + KI2C_DATA_REG); + + /* create start condition */ + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MTX | KI2C_CONTROL_MSTA | KI2C_CONTROL_TXAK, + ki2c->base + KI2C_CONTROL_REG); + ret = ki2c_wait_for_mcf(ki2c); + if (ret < 0) + return ret; + + /* create stop condition */ + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MTX | KI2C_CONTROL_TXAK, + ki2c->base + KI2C_CONTROL_REG); + ret = ki2c_wait_for_mcf(ki2c); + + return ret; +} + +static int ki2c_reset_bus(struct ki2c *ki2c) +{ + int ret; + + ret = ki2c_inuse_lock(ki2c); + if (ret < 0) + return ret; + + /* If the I2C controller is capable of direct control of SCL/SDA, then a + * bitwise reset is used. Otherwise fall back to bytewise reset. + */ + if (ki2c_has_capability(ki2c, KI2C_CAPABILITY_DC)) + ret = ki2c_reset_bus_bitwise(ki2c); + else + ret = ki2c_reset_bus_bytewise(ki2c); + + ki2c_inuse_unlock(ki2c); + + return ret; +} + +static void ki2c_write_target_addr(struct ki2c *ki2c, struct i2c_msg *m) +{ + u8 addr; + + addr = m->addr << 1; + /* Bit 0 signals RD/WR */ + if (m->flags & I2C_M_RD) + addr |= 0x01; + + iowrite8(addr, ki2c->base + KI2C_DATA_REG); +} + +static int ki2c_start_addr(struct ki2c *ki2c, struct i2c_msg *m) +{ + int ret; + + /* Store target address byte in the controller. This has to be done + * before sending START condition. + */ + ki2c_write_target_addr(ki2c, m); + + /* enable controller for TX */ + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MTX, + ki2c->base + KI2C_CONTROL_REG); + + /* send START condition and target address byte */ + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MTX | KI2C_CONTROL_MSTA, + ki2c->base + KI2C_CONTROL_REG); + + ret = ki2c_wait_for_data_ack(ki2c); + if (ret < 0) + /* For EEPROMs this is normal behavior during internal write + * operation. + */ + dev_dbg(&ki2c->pdev->dev, "%s wait for ACK err at 0x%02x!\n", + __func__, m->addr); + + return ret; +} + +static int ki2c_repstart_addr(struct ki2c *ki2c, struct i2c_msg *m) +{ + int ret; + + /* repeated start and write is not supported */ + if ((m->flags & I2C_M_RD) == 0) { + dev_warn(&ki2c->pdev->dev, + "Repeated start not supported for writes\n"); + return -EINVAL; + } + + /* send repeated start */ + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MSTA | KI2C_CONTROL_RSTA, + ki2c->base + KI2C_CONTROL_REG); + + ret = ki2c_wait_for_mcf(ki2c); + if (ret < 0) { + dev_warn(&ki2c->pdev->dev, "%s wait for MCF err at 0x%02x!\n", + __func__, m->addr); + return ret; + } + + /* write target-address byte */ + ki2c_write_target_addr(ki2c, m); + + ret = ki2c_wait_for_data_ack(ki2c); + if (ret < 0) + dev_warn(&ki2c->pdev->dev, "%s wait for ACK err at 0x%02x!\n", + __func__, m->addr); + + return ret; +} + +static void ki2c_stop(struct ki2c *ki2c) +{ + iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); + ki2c_wait_for_mcf(ki2c); +} + +static int ki2c_write(struct ki2c *ki2c, const u8 *data, int len) +{ + int ret; + + for (int i = 0; i < len; i++) { + /* write data byte */ + iowrite8(data[i], ki2c->base + KI2C_DATA_REG); + + ret = ki2c_wait_for_data_ack(ki2c); + if (ret < 0) + return ret; + } + + return 0; +} + +static int ki2c_read(struct ki2c *ki2c, u8 *data, int len) +{ + u8 control; + int ret; + + if (len == 0) + return 0; /* nothing to do */ + + control = KI2C_CONTROL_MEN | KI2C_CONTROL_MSTA; + + /* if just one byte => send tx-nack after transfer */ + if (len == 1) + control |= KI2C_CONTROL_TXAK; + + iowrite8(control, ki2c->base + KI2C_CONTROL_REG); + + /* dummy read to start transfer on bus */ + ioread8(ki2c->base + KI2C_DATA_REG); + + for (int i = 0; i < len; i++) { + ret = ki2c_wait_for_data(ki2c); + if (ret < 0) + return ret; + + /* send tx-nack after transfer of last byte */ + if (i == len - 2) + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MSTA | KI2C_CONTROL_TXAK, + ki2c->base + KI2C_CONTROL_REG); + + /* switch to TX on last byte, so that reading DATA-register + * does not trigger another read transfer. + */ + if (i == len - 1) + iowrite8(KI2C_CONTROL_MEN | KI2C_CONTROL_MSTA | KI2C_CONTROL_MTX, + ki2c->base + KI2C_CONTROL_REG); + + /* read byte and start next transfer (if not last byte) */ + data[i] = ioread8(ki2c->base + KI2C_DATA_REG); + } + + return len; +} + +static int ki2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num) +{ + struct ki2c *ki2c = i2c_get_adapdata(adap); + int ret; + + ret = ki2c_inuse_lock(ki2c); + if (ret < 0) + return ret; + + for (int i = 0; i < num; i++) { + struct i2c_msg *m = &msgs[i]; + + if (i == 0) + ret = ki2c_start_addr(ki2c, m); + else + ret = ki2c_repstart_addr(ki2c, m); + if (ret < 0) + break; + + if (m->flags & I2C_M_RD) + ret = ki2c_read(ki2c, m->buf, m->len); + else + ret = ki2c_write(ki2c, m->buf, m->len); + if (ret < 0) + break; + } + + ki2c_stop(ki2c); + + ki2c_inuse_unlock(ki2c); + + return (ret < 0) ? ret : num; +} + +static void ki2c_unregister_devices(struct ki2c *ki2c) +{ + for (int i = 0; i < ki2c->client_size; i++) { + struct i2c_client *client = ki2c->client[i]; + + if (client) + i2c_unregister_device(client); + } +} + +static int ki2c_register_devices(struct ki2c *ki2c, + struct i2c_keba_platform_data *pdata) +{ + /* register all I2C devices from platform_data array */ + for (int i = 0; i < ki2c->client_size; i++) { + struct i2c_client *client; + unsigned short const addr_list[2] = { pdata->info[i].addr, + I2C_CLIENT_END }; + + client = i2c_new_scanned_device(&ki2c->adapter, &pdata->info[i], + addr_list, NULL); + if (!IS_ERR(client)) { + ki2c->client[i] = client; + } else if (PTR_ERR(client) != -ENODEV) { + ki2c_unregister_devices(ki2c); + + return PTR_ERR(client); + } + } + + return 0; +} + +static u32 ki2c_func(struct i2c_adapter *adap) +{ + return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; +} + +static const struct i2c_algorithm ki2c_algo = { + .master_xfer = ki2c_xfer, + .functionality = ki2c_func, +}; + +static int ki2c_probe(struct platform_device *pdev) +{ + struct i2c_keba_platform_data *pdata; + struct device *dev = &pdev->dev; + struct i2c_adapter *adap; + struct resource *io; + struct ki2c *ki2c; + int ret; + + pdata = dev->platform_data; + if (pdata == 0) { + dev_err(dev, "Platform data not found!\n"); + return -ENODEV; + } + + ki2c = devm_kzalloc(dev, sizeof(*ki2c), GFP_KERNEL); + if (!ki2c) + return -ENOMEM; + ki2c->pdev = pdev; + ki2c->client = devm_kcalloc(dev, pdata->info_size, + sizeof(*ki2c->client), GFP_KERNEL); + if (!ki2c->client) + return -ENOMEM; + ki2c->client_size = pdata->info_size; + platform_set_drvdata(pdev, ki2c); + + io = platform_get_resource(pdev, IORESOURCE_MEM, 0); + ki2c->base = devm_ioremap_resource(dev, io); + if (IS_ERR(ki2c->base)) + return PTR_ERR(ki2c->base); + + /* enable controller */ + iowrite8(KI2C_CONTROL_MEN, ki2c->base + KI2C_CONTROL_REG); + + adap = &ki2c->adapter; + strscpy(adap->name, "KEBA I2C adapter", sizeof(adap->name)); + adap->owner = THIS_MODULE; + adap->class = I2C_CLASS_HWMON; + adap->algo = &ki2c_algo; + adap->dev.parent = dev; + + i2c_set_adapdata(adap, ki2c); + + /* reset bus before probing I2C devices */ + ret = ki2c_reset_bus(ki2c); + if (ret) { + dev_err(dev, "Failed to reset bus (%d)!\n", ret); + goto out_disable; + } + + ret = i2c_add_adapter(adap); + if (ret) { + dev_err(dev, "Failed to add adapter (%d)!\n", ret); + goto out_disable; + } + + ret = ki2c_register_devices(ki2c, pdata); + if (ret) { + dev_err(dev, "Failed to register devices (%d)!\n", ret); + goto out_delete; + } + + return 0; + +out_delete: + i2c_del_adapter(adap); +out_disable: + iowrite8(0, ki2c->base + KI2C_CONTROL_REG); + return ret; +} + +static int ki2c_remove(struct platform_device *pdev) +{ + struct ki2c *ki2c = platform_get_drvdata(pdev); + + ki2c_unregister_devices(ki2c); + + i2c_del_adapter(&ki2c->adapter); + + /* disable controller */ + iowrite8(0, ki2c->base + KI2C_CONTROL_REG); + + platform_set_drvdata(pdev, 0); + + return 0; +} + +static struct platform_device_id ki2c_devtype[] = { + { .name = KI2C }, + { } +}; +MODULE_DEVICE_TABLE(platform, ki2c_devtype); + +static struct platform_driver ki2c_driver = { + .driver = { + .name = KI2C, + }, + .probe = ki2c_probe, + .remove = ki2c_remove, +}; +module_platform_driver(ki2c_driver); + +MODULE_AUTHOR("Gerhard Engleder <eg@keba.com>"); +MODULE_DESCRIPTION("KEBA I2C bus controller driver"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/platform_data/i2c-keba.h b/include/linux/platform_data/i2c-keba.h new file mode 100644 index 000000000000..99d54bcb6ed9 --- /dev/null +++ b/include/linux/platform_data/i2c-keba.h @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (C) KEBA AG 2012 + * Copyright (C) KEBA Industrial Automation Gmbh 2024 + * + * Platform data for KEBA I2C controller FPGA IP core + */ + +#ifndef __LINUX_PLATFORM_DATA_I2C_KEBA_H +#define __LINUX_PLATFORM_DATA_I2C_KEBA_H + +/** + * Platform data for KEBA I2C controller + * + * @info I2C devices to be probed + * @info_size size of info array + */ +struct i2c_keba_platform_data { + struct i2c_board_info *info; + int info_size; +}; + +#endif /* __LINUX_PLATFORM_DATA_I2C_KEBA_H */