him411/gl-infra-builder-FUjr
1
0
Fork 0
mirror of https://github.com/FUjr/gl-infra-builder.git synced 2025-12-16 17:15:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
main
gl-infra-builder-FUjr/patches-19.07.8/0108-target-ramips-add-et6326-led-driver-for-GL-MT1300.patch
Jianhui Zhao 639269db54 normalize some directories 
Signed-off-by: Jianhui Zhao <jianhui.zhao@gl-inet.com>
2022-09-19 11:32:55 +08:00

1295 lines
32 KiB
Diff
Raw Permalink Blame History

From 06fb018c751e293a1c29a066e391c206a2224ff4 Mon Sep 17 00:00:00 2001
From: Jianhui Zhao <jianhui.zhao@gl-inet.com>
Date: Sun, 26 Sep 2021 14:37:26 +0800
Subject: [PATCH] target/ramips: add et6326 led driver for GL-MT1300
Signed-off-by: Jianhui Zhao <jianhui.zhao@gl-inet.com>
---
package/kernel/leds-et6326/Makefile | 40 ++
package/kernel/leds-et6326/src/Makefile | 1 +
package/kernel/leds-et6326/src/leds-et6326.c | 501 ++++++++++++++++++
target/linux/ramips/dts/GL-MT1300.dts | 46 +-
target/linux/ramips/image/mt7621.mk | 2 +-
.../0045-i2c-add-mt7621-driver.patch | 464 +++++++---------
6 files changed, 766 insertions(+), 288 deletions(-)
create mode 100644 package/kernel/leds-et6326/Makefile
create mode 100644 package/kernel/leds-et6326/src/Makefile
create mode 100644 package/kernel/leds-et6326/src/leds-et6326.c
diff --git a/package/kernel/leds-et6326/Makefile b/package/kernel/leds-et6326/Makefile
new file mode 100644
index 0000000000..df3ca18462
--- /dev/null
+++ b/package/kernel/leds-et6326/Makefile
@@ -0,0 +1,40 @@
+#
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+include $(INCLUDE_DIR)/kernel.mk
+
+PKG_NAME:=leds-et6326
+PKG_RELEASE:=1
+
+PKG_LICENSE:=GPL-2.0
+
+include $(INCLUDE_DIR)/package.mk
+
+define KernelPackage/leds-et6326
+ SUBMENU:=LED modules
+ TITLE:= ET6326 LED support
+ DEPENDS:=+kmod-i2c-core
+ FILES:=$(PKG_BUILD_DIR)/leds-et6326.ko
+ AUTOLOAD:=$(call AutoLoad,41,leds-et6326,1)
+ KCONFIG:=CONFIG_LEDS_CLASS
+endef
+
+define KernelPackage/leds-et6326/description
+ LED driver for ET6326 RGB LED.
+endef
+
+MAKE_OPTS:= \
+ $(KERNEL_MAKE_FLAGS) \
+ SUBDIRS="$(PKG_BUILD_DIR)"
+
+define Build/Compile
+ $(MAKE) -C "$(LINUX_DIR)" \
+ $(MAKE_OPTS) \
+ modules
+endef
+
+$(eval $(call KernelPackage,leds-et6326))
diff --git a/package/kernel/leds-et6326/src/Makefile b/package/kernel/leds-et6326/src/Makefile
new file mode 100644
index 0000000000..4c707365e7
--- /dev/null
+++ b/package/kernel/leds-et6326/src/Makefile
@@ -0,0 +1 @@
+obj-m += leds-et6326.o
diff --git a/package/kernel/leds-et6326/src/leds-et6326.c b/package/kernel/leds-et6326/src/leds-et6326.c
new file mode 100644
index 0000000000..1326e20994
--- /dev/null
+++ b/package/kernel/leds-et6326/src/leds-et6326.c
@@ -0,0 +1,501 @@
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/leds.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+
+#define ET6326_MAX_LED_NUM 3
+
+#define ET6326_REG_STATUS 0x00
+#define ET6326_REG_FLASH_PERIOD 0x01
+#define ET6326_REG_FLASH_TON1 0x02
+#define ET6326_REG_FLASH_TON2 0x03
+#define ET6326_REG_LED_WORK_MODE 0x04
+#define ET6326_REG_RAMP_RATE 0x05
+#define ET6326_REG_LED1_IOUT 0x06
+#define ET6326_REG_LED2_IOUT 0x07
+#define ET6326_REG_LED3_IOUT 0x08
+
+#define ET6326_MAX_PERIOD 16380 /* ms */
+
+struct et6326_leds_priv;
+
+enum {
+ MODE_ALWAYS_OFF,
+ MODE_ALWAYS_ON,
+ MODE_THREAD
+};
+
+struct et6326_led {
+ struct et6326_leds_priv *priv;
+ struct led_classdev cdev;
+ int mode;
+ u8 mode_mask;
+ u8 on_shift;
+ u8 blink_shift;
+ u8 reg_iout;
+ char name[0];
+};
+
+struct et6326_leds_priv {
+ struct i2c_client *client;
+ struct et6326_led *leds[ET6326_MAX_LED_NUM];
+};
+
+static int et6326_write_byte(struct i2c_client *client, u8 reg, u8 val)
+{
+ uint8_t buf[2] = { reg, val };
+ struct i2c_msg msg = {
+ .addr = client->addr,
+ .len = 2,
+ .buf = buf
+ };
+ int ret;
+
+ ret = i2c_transfer(client->adapter, &msg, 1);
+ if (ret < 0) {
+ dev_err(&client->dev, "%s: reg 0x%x, val 0x%x, err %d\n",
+ __func__, reg, val, ret);
+ return ret;
+ }
+ return 0;
+}
+
+static int et6326_read_byte(struct i2c_client *client, u8 reg)
+{
+ uint8_t buf[] = {reg};
+ int ret;
+
+ struct i2c_msg msgs[] = {
+ {
+ .addr = client->addr,
+ .flags = I2C_M_REV_DIR_ADDR,
+ .len = 1,
+ .buf = buf
+ }, {
+ .addr = client->addr,
+ .flags = I2C_M_RD | I2C_M_NOSTART,
+ .len = 1,
+ .buf = buf
+ }
+ };
+
+ ret = i2c_transfer(client->adapter, msgs, 2);
+ if (ret < 0) {
+ dev_err(&client->dev, "%s: reg 0x%x, err %d\n",
+ __func__, reg, ret);
+ return ret;
+ }
+
+ return buf[0];
+}
+
+static unsigned long et6326_set_period(struct et6326_leds_priv *priv, unsigned long period)
+{
+ int val = period / 128 - 1;
+
+ if (val < 0)
+ val = 0;
+
+ if (val > 127)
+ val = 127;
+
+ if (val != et6326_read_byte(priv->client, ET6326_REG_FLASH_PERIOD))
+ et6326_write_byte(priv->client, ET6326_REG_FLASH_PERIOD, val);
+
+ return (val + 1) * 128;
+}
+
+static void et6326_set_work_mode(struct et6326_led *led, int mode)
+{
+ struct et6326_leds_priv *priv = led->priv;
+ u8 val = et6326_read_byte(priv->client, ET6326_REG_LED_WORK_MODE);
+
+ val &= ~led->mode_mask;
+
+ if (mode == MODE_ALWAYS_ON)
+ val |= (1 << led->on_shift);
+ else if (mode == MODE_THREAD)
+ val |= 1 << led->blink_shift;
+
+ if (val == et6326_read_byte(priv->client, ET6326_REG_LED_WORK_MODE))
+ return;
+
+ led->mode = mode;
+ et6326_write_byte(priv->client, ET6326_REG_LED_WORK_MODE, val);
+}
+
+static void et6326_set_ton1_percentage(struct et6326_leds_priv *priv, u8 val)
+{
+ if (val > 100)
+ val = 100;
+
+ val = 255 * val / 100;
+
+ if (val == et6326_read_byte(priv->client, ET6326_REG_FLASH_TON1))
+ return;
+
+ et6326_write_byte(priv->client, ET6326_REG_FLASH_TON1, val);
+}
+
+static unsigned long et6326_set_ramp(struct et6326_leds_priv *priv, unsigned long val)
+{
+ u8 scaling = 1;
+ u8 reg = 0;
+
+ if (val >= 4096) {
+ if (val > 7680)
+ val = 7680;
+ scaling = 4;
+ } else if (val >= 2048) {
+ scaling = 2;
+ }
+
+ reg = val / 128 / scaling;
+ val = reg * 128 * scaling;
+
+ if (val == 0)
+ val = 2;
+
+ reg |= reg << 4;
+
+ if (reg != et6326_read_byte(priv->client, ET6326_REG_RAMP_RATE))
+ et6326_write_byte(priv->client, ET6326_REG_RAMP_RATE, reg);
+
+ reg = et6326_read_byte(priv->client, ET6326_REG_STATUS) & ~(0x3 << 5);
+ switch (scaling) {
+ case 2:
+ reg |= 1 << 5;
+ break;
+ case 4:
+ reg |= 1 << 6;
+ break;
+ case 8:
+ reg |= 3 << 5;
+ break;
+ default:
+ break;
+ }
+
+ if (reg != et6326_read_byte(priv->client, ET6326_REG_STATUS))
+ et6326_write_byte(priv->client, ET6326_REG_STATUS, reg);
+
+ return val;
+}
+
+static int et6326_set_brightness(struct led_classdev *led_cdev,
+ enum led_brightness value)
+{
+ struct et6326_led *led = container_of(led_cdev, struct et6326_led, cdev);
+ struct et6326_leds_priv *priv = led->priv;
+
+ if (value == LED_OFF)
+ et6326_set_work_mode(led, MODE_ALWAYS_OFF);
+ else if (led->mode == MODE_ALWAYS_OFF)
+ et6326_set_work_mode(led, MODE_ALWAYS_ON);
+
+ et6326_write_byte(priv->client, led->reg_iout, value);
+
+ return 0;
+}
+
+static void et6326_set_gradient(struct led_classdev *led_cdev, bool on)
+{
+ struct et6326_led *led = container_of(led_cdev, struct et6326_led, cdev);
+ struct et6326_leds_priv *priv = led->priv;
+ u8 reg_period = et6326_read_byte(priv->client, ET6326_REG_FLASH_PERIOD);
+ unsigned long t = 0;
+
+ if (on)
+ t = (reg_period + 1) * 128;
+
+ et6326_set_ramp(priv, t);
+}
+
+static int et6326_set_blink(struct led_classdev *led_cdev,
+ unsigned long *delay_on,
+ unsigned long *delay_off)
+{
+ struct et6326_led *led = container_of(led_cdev, struct et6326_led, cdev);
+ struct et6326_leds_priv *priv = led->priv;
+ unsigned long period;
+
+ /* blink with 1 Hz as default if nothing specified */
+ if (!*delay_on && !*delay_off)
+ *delay_on = *delay_off = 500;
+
+ if (*delay_on > ET6326_MAX_PERIOD)
+ *delay_on = ET6326_MAX_PERIOD;
+
+ if (*delay_off > ET6326_MAX_PERIOD - *delay_on)
+ *delay_off = ET6326_MAX_PERIOD - *delay_on;
+
+ period = *delay_on + *delay_off;
+
+ et6326_set_period(priv, period);
+ et6326_set_ton1_percentage(priv, *delay_on * 100 / period);
+
+ et6326_set_work_mode(led, MODE_THREAD);
+ et6326_write_byte(priv->client, led->reg_iout, 0xff);
+
+ if (led_cdev->gradiented)
+ et6326_set_gradient(led_cdev, true);
+
+ return 0;
+}
+
+static int create_led(struct et6326_leds_priv *priv, u32 channel, const char *name)
+{
+ struct device *dev = &priv->client->dev;
+ struct et6326_led *led;
+ bool auto_name = true;
+ int ret;
+
+ if (name && name[0])
+ auto_name = false;
+ else
+ name = "et6326-x";
+
+ led = devm_kzalloc(dev, sizeof(struct et6326_led) + strlen(name) + 1, GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ if (auto_name)
+ snprintf(led->name, strlen(name) + 1, "et6326-%u", channel);
+ else
+ strcpy(led->name, name);
+
+ led->priv = priv;
+ led->cdev.name = led->name;
+ led->cdev.brightness = LED_OFF;
+ led->cdev.brightness_set_blocking = et6326_set_brightness;
+ led->cdev.blink_set = et6326_set_blink;
+ led->cdev.gradient_set = et6326_set_gradient;
+
+ switch (channel) {
+ case 0:
+ led->mode_mask = 0x03;
+ led->on_shift = 0;
+ led->blink_shift = 1;
+ break;
+ case 1:
+ led->mode_mask = (0x03 << 2) | (1 << 6);
+ led->on_shift = 2;
+ led->blink_shift = 3;
+ break;
+ case 2:
+ led->mode_mask = (0x03 << 4) | (1 << 7);
+ led->on_shift = 4;
+ led->blink_shift = 5;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ led->reg_iout = ET6326_REG_LED1_IOUT + channel;
+
+ ret = led_classdev_register(dev, &led->cdev);
+ if (ret < 0) {
+ dev_err(dev, "couldn't register LED '%s' on channel %d\n", led->name, channel);
+ return ret;
+ }
+
+ dev_info(&priv->client->dev, "Created a LED '%s' at channel %d\n", led->name, channel);
+
+ priv->leds[channel] = led;
+
+ return 0;
+}
+
+static int remove_led(struct et6326_leds_priv *priv, u32 channel)
+{
+ struct et6326_led *led;
+
+ if (channel > ET6326_MAX_LED_NUM - 1 || channel < 0)
+ return -EINVAL;
+
+ led = priv->leds[channel];
+
+ if (!led)
+ return -ENODEV;
+
+ et6326_set_brightness(&led->cdev, LED_OFF);
+
+ led_classdev_unregister(&led->cdev);
+
+ dev_info(&priv->client->dev, "LED '%s' was removed\n", led->name);
+
+ priv->leds[channel] = NULL;
+
+ return 0;
+}
+
+static ssize_t et6326_export_store(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct et6326_leds_priv *priv = i2c_get_clientdata(to_i2c_client(dev));
+ u32 channel;
+ int ret;
+ char *name;
+
+ name = strchr(buf, ' ');
+ if (name) {
+ char *ln;
+
+ *name++ = '\0';
+
+ ln = strchr(name, '\n');
+ if (ln)
+ *ln = '\0';
+ }
+
+ ret = sscanf(buf, "%d", &channel);
+ if (ret < 1)
+ return -EINVAL;
+
+ if (priv->leds[channel])
+ return -EBUSY;
+
+ if (channel > ET6326_MAX_LED_NUM - 1 || channel < 0)
+ return -EINVAL;
+
+ ret = create_led(priv, channel, name);
+ if (ret < 0)
+ return ret;
+
+ return len;
+}
+
+static ssize_t et6326_unexport_store(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct et6326_leds_priv *priv = i2c_get_clientdata(to_i2c_client(dev));
+ u32 channel;
+ int ret;
+
+ ret = sscanf(buf, "%u", &channel);
+ if (ret < 1)
+ return -EINVAL;
+
+ ret = remove_led(priv, channel);
+ if (ret)
+ return ret;
+
+ return len;
+}
+
+static DEVICE_ATTR(export, S_IWUSR, NULL, et6326_export_store);
+static DEVICE_ATTR(unexport, S_IWUSR, NULL, et6326_unexport_store);
+
+#ifdef CONFIG_OF
+static void of_create_leds(struct et6326_leds_priv *priv, struct device *dev)
+{
+ struct device_node *child;
+
+ for_each_child_of_node(dev->of_node, child) {
+ const char *name;
+ u32 channel;
+
+ if (of_property_read_u32(child, "channel", &channel)) {
+ dev_err(dev, "%s: invalid channel\n", child->name);
+ continue;
+ }
+
+ of_property_read_string(child, "label", &name);
+
+ create_led(priv, channel, name);
+ }
+}
+#endif
+
+static int et6326_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+ struct device *dev = &client->dev;
+ struct et6326_leds_priv *priv;
+ int ret;
+
+ if (!i2c_check_functionality(client->adapter, I2C_FUNC_NOSTART)) {
+ dev_err(&client->dev,
+ "need i2c bus that supports protocol mangling\n");
+ return -ENODEV;
+ }
+
+ priv = devm_kzalloc(dev, sizeof(struct et6326_leds_priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ priv->client = client;
+ i2c_set_clientdata(client, priv);
+
+ /* Detect ET6326GU */
+ ret = et6326_write_byte(client, ET6326_REG_STATUS, 0x1f);
+ if (ret < 0) {
+ dev_err(dev, "failed to detect device\n");
+ return ret;
+ }
+
+ ret = device_create_file(dev, &dev_attr_export);
+ if (ret)
+ goto err_attr_export;
+
+ ret = device_create_file(dev, &dev_attr_unexport);
+ if (ret)
+ goto err_attr_unexport;
+
+#ifdef CONFIG_OF
+ of_create_leds(priv, dev);
+#endif
+
+ return 0;
+
+err_attr_unexport:
+ device_remove_file(&client->dev, &dev_attr_export);
+err_attr_export:
+ return ret;
+}
+
+static int et6326_remove(struct i2c_client *client)
+{
+ struct et6326_leds_priv *priv = i2c_get_clientdata(client);
+ int i;
+
+ for (i = 0; i < ET6326_MAX_LED_NUM; i++)
+ remove_led(priv, i);
+
+ et6326_write_byte(client, ET6326_REG_STATUS, 0x1f);
+
+ device_remove_file(&client->dev, &dev_attr_export);
+ device_remove_file(&client->dev, &dev_attr_unexport);
+
+ return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id of_et6326_match[] = {
+ { .compatible = "etek,et6326" },
+ {},
+};
+
+MODULE_DEVICE_TABLE(of, of_et6326_match);
+#endif
+
+static const struct i2c_device_id et6326_id[] = {
+ { "et6326", 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, et6326_id);
+
+static struct i2c_driver et6326_i2c_driver = {
+ .driver = {
+ .name = "et6326",
+ .of_match_table = of_match_ptr(of_et6326_match),
+ },
+ .probe = et6326_probe,
+ .remove = et6326_remove,
+ .id_table = et6326_id,
+};
+
+module_i2c_driver(et6326_i2c_driver);
+
+MODULE_DESCRIPTION("ET6326 LED driver");
+MODULE_LICENSE("GPL v2");
diff --git a/target/linux/ramips/dts/GL-MT1300.dts b/target/linux/ramips/dts/GL-MT1300.dts
index 07f9b6986e..491238a886 100755
--- a/target/linux/ramips/dts/GL-MT1300.dts
+++ b/target/linux/ramips/dts/GL-MT1300.dts
@@ -9,6 +9,13 @@
compatible = "glinet,gl-mt1300", "mediatek,mt7621-soc";
model = "GL-MT1300";
+ aliases {
+ led-boot = &led_run;
+ led-failsafe = &led_run;
+ led-running = &led_run;
+ led-upgrade = &led_run;
+ };
+
gl_hw {
compatible = "gl-hw-info";
@@ -33,12 +40,6 @@
bootargs = "console=ttyS0,115200";
};
- palmbus: palmbus@1E000000 {
- i2c@900 {
- status = "okay";
- };
- };
-
keys {
compatible = "gpio-keys-polled";
poll-interval = <20>;
@@ -55,20 +56,6 @@
linux,code = <BTN_0>;
};
};
-
- leds {
- compatible = "gpio-leds";
-
- led_run: blue {
- label = "gl-mt1300:blue";
- gpios = <&gpio0 14 GPIO_ACTIVE_HIGH>;
- };
-
- white {
- label = "gl-mt1300:white";
- gpios = <&gpio0 13 GPIO_ACTIVE_HIGH>;
- };
- };
};
&sdhci {
@@ -151,3 +138,22 @@
};
};
};
+
+&i2c {
+ status = "okay";
+
+ leds@30 {
+ compatible = "etek,et6326";
+ reg = <0x30>;
+
+ led_run: led@0 {
+ channel = <0>;
+ label = "gl-mt1300:blue";
+ };
+
+ led@1 {
+ channel = <1>;
+ label = "gl-mt1300:white";
+ };
+ };
+};
diff --git a/target/linux/ramips/image/mt7621.mk b/target/linux/ramips/image/mt7621.mk
index 708a606b98..b9c819b17e 100644
--- a/target/linux/ramips/image/mt7621.mk
+++ b/target/linux/ramips/image/mt7621.mk
@@ -210,7 +210,7 @@ define Device/gl-mt1300
DEVICE_TITLE := GL-iNet GL-MT1300
DEVICE_PACKAGES := \
kmod-ata-core kmod-ata-ahci kmod-mt76x2 kmod-mt7603 kmod-usb3 \
- kmod-usb-ledtrig-usbport wpad-basic
+ kmod-usb-ledtrig-usbport wpad-basic kmod-leds-et6326
IMAGE/sysupgrade.bin := append-kernel | append-rootfs | pad-rootfs | append-gl-metadata | check-size $$$$(IMAGE_SIZE)
endef
TARGET_DEVICES += gl-mt1300
diff --git a/target/linux/ramips/patches-4.14/0045-i2c-add-mt7621-driver.patch b/target/linux/ramips/patches-4.14/0045-i2c-add-mt7621-driver.patch
index a848085520..c479b61b62 100644
--- a/target/linux/ramips/patches-4.14/0045-i2c-add-mt7621-driver.patch
+++ b/target/linux/ramips/patches-4.14/0045-i2c-add-mt7621-driver.patch
@@ -37,300 +37,248 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
obj-$(CONFIG_I2C_RK3X) += i2c-rk3x.o
--- /dev/null
+++ b/drivers/i2c/busses/i2c-mt7621.c
-@@ -0,0 +1,433 @@
+@@ -0,0 +1,363 @@
++// SPDX-License-Identifier: GPL-2.0
+/*
+ * drivers/i2c/busses/i2c-mt7621.c
+ *
+ * Copyright (C) 2013 Steven Liu <steven_liu@mediatek.com>
+ * Copyright (C) 2016 Michael Lee <igvtee@gmail.com>
++ * Copyright (C) 2018 Jan Breuer <jan.breuer@jaybee.cz>
+ *
+ * Improve driver for i2cdetect from i2c-tools to detect i2c devices on the bus.
+ * (C) 2014 Sittisak <sittisaks@hotmail.com>
-+ *
-+ * This software is licensed under the terms of the GNU General Public
-+ * License version 2, as published by the Free Software Foundation, and
-+ * may be copied, distributed, and modified under those terms.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
+ */
+
-+#include <linux/interrupt.h>
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/reset.h>
++#include <linux/clk.h>
+#include <linux/delay.h>
-+#include <linux/slab.h>
-+#include <linux/init.h>
-+#include <linux/errno.h>
-+#include <linux/platform_device.h>
-+#include <linux/of_platform.h>
+#include <linux/i2c.h>
+#include <linux/io.h>
-+#include <linux/err.h>
-+#include <linux/clk.h>
++#include <linux/iopoll.h>
++#include <linux/module.h>
++#include <linux/of_platform.h>
++#include <linux/reset.h>
+
-+#define REG_SM0CFG0 0x08
-+#define REG_SM0DOUT 0x10
-+#define REG_SM0DIN 0x14
-+#define REG_SM0ST 0x18
-+#define REG_SM0AUTO 0x1C
-+#define REG_SM0CFG1 0x20
-+#define REG_SM0CFG2 0x28
-+#define REG_SM0CTL0 0x40
-+#define REG_SM0CTL1 0x44
-+#define REG_SM0D0 0x50
-+#define REG_SM0D1 0x54
-+#define REG_PINTEN 0x5C
-+#define REG_PINTST 0x60
-+#define REG_PINTCL 0x64
-+
-+/* REG_SM0CFG0 */
-+#define I2C_DEVADDR_MASK 0x7f
-+
-+/* REG_SM0ST */
-+#define I2C_DATARDY BIT(2)
-+#define I2C_SDOEMPTY BIT(1)
-+#define I2C_BUSY BIT(0)
-+
-+/* REG_SM0AUTO */
-+#define READ_CMD BIT(0)
-+
-+/* REG_SM0CFG1 */
-+#define BYTECNT_MAX 64
-+#define SET_BYTECNT(x) (x - 1)
-+
-+/* REG_SM0CFG2 */
-+#define AUTOMODE_EN BIT(0)
-+
-+/* REG_SM0CTL0 */
-+#define ODRAIN_HIGH_SM0 BIT(31)
-+#define VSYNC_SHIFT 28
-+#define VSYNC_MASK 0x3
-+#define VSYNC_PULSE (0x1 << VSYNC_SHIFT)
-+#define VSYNC_RISING (0x2 << VSYNC_SHIFT)
-+#define CLK_DIV_SHIFT 16
-+#define CLK_DIV_MASK 0xfff
-+#define DEG_CNT_SHIFT 8
-+#define DEG_CNT_MASK 0xff
-+#define WAIT_HIGH BIT(6)
-+#define DEG_EN BIT(5)
-+#define CS_STATUA BIT(4)
-+#define SCL_STATUS BIT(3)
-+#define SDA_STATUS BIT(2)
-+#define SM0_EN BIT(1)
-+#define SCL_STRECH BIT(0)
-+
-+/* REG_SM0CTL1 */
-+#define ACK_SHIFT 16
-+#define ACK_MASK 0xff
-+#define PGLEN_SHIFT 8
-+#define PGLEN_MASK 0x7
-+#define SM0_MODE_SHIFT 4
-+#define SM0_MODE_MASK 0x7
-+#define SM0_MODE_START 0x1
-+#define SM0_MODE_WRITE 0x2
-+#define SM0_MODE_STOP 0x3
-+#define SM0_MODE_READ_NACK 0x4
-+#define SM0_MODE_READ_ACK 0x5
-+#define SM0_TRI_BUSY BIT(0)
-+
-+/* timeout waiting for I2C devices to respond (clock streching) */
-+#define TIMEOUT_MS 1000
-+#define DELAY_INTERVAL_US 100
++#define REG_SM0CFG2_REG 0x28
++#define REG_SM0CTL0_REG 0x40
++#define REG_SM0CTL1_REG 0x44
++#define REG_SM0D0_REG 0x50
++#define REG_SM0D1_REG 0x54
++#define REG_PINTEN_REG 0x5c
++#define REG_PINTST_REG 0x60
++#define REG_PINTCL_REG 0x64
++
++/* REG_SM0CFG2_REG */
++#define SM0CFG2_IS_AUTOMODE BIT(0)
++
++/* REG_SM0CTL0_REG */
++#define SM0CTL0_ODRAIN BIT(31)
++#define SM0CTL0_CLK_DIV_MASK (0x7ff << 16)
++#define SM0CTL0_CLK_DIV_MAX 0x7ff
++#define SM0CTL0_CS_STATUS BIT(4)
++#define SM0CTL0_SCL_STATE BIT(3)
++#define SM0CTL0_SDA_STATE BIT(2)
++#define SM0CTL0_EN BIT(1)
++#define SM0CTL0_SCL_STRETCH BIT(0)
++
++/* REG_SM0CTL1_REG */
++#define SM0CTL1_ACK_MASK (0xff << 16)
++#define SM0CTL1_PGLEN_MASK (0x7 << 8)
++#define SM0CTL1_PGLEN(x) ((((x) - 1) << 8) & SM0CTL1_PGLEN_MASK)
++#define SM0CTL1_READ (5 << 4)
++#define SM0CTL1_READ_LAST (4 << 4)
++#define SM0CTL1_STOP (3 << 4)
++#define SM0CTL1_WRITE (2 << 4)
++#define SM0CTL1_START (1 << 4)
++#define SM0CTL1_MODE_MASK (0x7 << 4)
++#define SM0CTL1_TRI BIT(0)
++
++/* timeout waiting for I2C devices to respond */
++#define TIMEOUT_MS 1000
+
+struct mtk_i2c {
+ void __iomem *base;
-+ struct clk *clk;
+ struct device *dev;
+ struct i2c_adapter adap;
-+ u32 cur_clk;
++ u32 bus_freq;
+ u32 clk_div;
+ u32 flags;
++ struct clk *clk;
+};
+
-+static void mtk_i2c_w32(struct mtk_i2c *i2c, u32 val, unsigned reg)
-+{
-+ iowrite32(val, i2c->base + reg);
-+}
-+
-+static u32 mtk_i2c_r32(struct mtk_i2c *i2c, unsigned reg)
-+{
-+ return ioread32(i2c->base + reg);
-+}
-+
-+static int poll_down_timeout(void __iomem *addr, u32 mask)
-+{
-+ unsigned long timeout = jiffies + msecs_to_jiffies(TIMEOUT_MS);
-+
-+ do {
-+ if (!(readl_relaxed(addr) & mask))
-+ return 0;
-+
-+ usleep_range(DELAY_INTERVAL_US, DELAY_INTERVAL_US + 50);
-+ } while (time_before(jiffies, timeout));
-+
-+ return (readl_relaxed(addr) & mask) ? -EAGAIN : 0;
-+}
-+
+static int mtk_i2c_wait_idle(struct mtk_i2c *i2c)
+{
+ int ret;
++ u32 val;
+
-+ ret = poll_down_timeout(i2c->base + REG_SM0ST, I2C_BUSY);
-+ if (ret < 0)
++ ret = readl_relaxed_poll_timeout(i2c->base + REG_SM0CTL1_REG,
++ val, !(val & SM0CTL1_TRI),
++ 10, TIMEOUT_MS * 1000);
++ if (ret)
+ dev_dbg(i2c->dev, "idle err(%d)\n", ret);
+
+ return ret;
+}
+
-+static int poll_up_timeout(void __iomem *addr, u32 mask)
++static void mtk_i2c_reset(struct mtk_i2c *i2c)
+{
-+ unsigned long timeout = jiffies + msecs_to_jiffies(TIMEOUT_MS);
-+ u32 status;
-+
-+ do {
-+ status = readl_relaxed(addr);
-+ if (status & mask)
-+ return 0;
-+ usleep_range(DELAY_INTERVAL_US, DELAY_INTERVAL_US + 50);
-+ } while (time_before(jiffies, timeout));
++ int ret;
+
-+ return -ETIMEDOUT;
++ ret = device_reset(i2c->adap.dev.parent);
++ if (ret)
++ dev_err(i2c->dev, "I2C reset failed!\n");
++
++ /*
++ * Don't set SM0CTL0_ODRAIN as its bit meaning is inverted. To
++ * configure open-drain mode, this bit needs to be cleared.
++ */
++ iowrite32(((i2c->clk_div << 16) & SM0CTL0_CLK_DIV_MASK) | SM0CTL0_EN |
++ SM0CTL0_SCL_STRETCH, i2c->base + REG_SM0CTL0_REG);
++ iowrite32(0, i2c->base + REG_SM0CFG2_REG);
+}
+
-+static int mtk_i2c_wait_rx_done(struct mtk_i2c *i2c)
++static void mtk_i2c_dump_reg(struct mtk_i2c *i2c)
+{
-+ int ret;
-+
-+ ret = poll_up_timeout(i2c->base + REG_SM0ST, I2C_DATARDY);
-+ if (ret < 0)
-+ dev_dbg(i2c->dev, "rx err(%d)\n", ret);
-+
-+ return ret;
++ dev_dbg(i2c->dev,
++ "SM0CFG2 %08x, SM0CTL0 %08x, SM0CTL1 %08x, SM0D0 %08x, SM0D1 %08x\n",
++ ioread32(i2c->base + REG_SM0CFG2_REG),
++ ioread32(i2c->base + REG_SM0CTL0_REG),
++ ioread32(i2c->base + REG_SM0CTL1_REG),
++ ioread32(i2c->base + REG_SM0D0_REG),
++ ioread32(i2c->base + REG_SM0D1_REG));
+}
+
-+static int mtk_i2c_wait_tx_done(struct mtk_i2c *i2c)
++static int mtk_i2c_check_ack(struct mtk_i2c *i2c, u32 expected)
+{
-+ int ret;
++ u32 ack = readl_relaxed(i2c->base + REG_SM0CTL1_REG);
++ u32 ack_expected = (expected << 16) & SM0CTL1_ACK_MASK;
+
-+ ret = poll_up_timeout(i2c->base + REG_SM0ST, I2C_SDOEMPTY);
-+ if (ret < 0)
-+ dev_dbg(i2c->dev, "tx err(%d)\n", ret);
-+
-+ return ret;
++ return ((ack & ack_expected) == ack_expected) ? 0 : -ENXIO;
+}
+
-+static void mtk_i2c_reset(struct mtk_i2c *i2c)
++static int mtk_i2c_master_start(struct mtk_i2c *i2c)
+{
-+ u32 reg;
-+ device_reset(i2c->adap.dev.parent);
-+ barrier();
-+
-+ /* ctrl0 */
-+ reg = ODRAIN_HIGH_SM0 | VSYNC_PULSE | (i2c->clk_div << CLK_DIV_SHIFT) |
-+ WAIT_HIGH | SM0_EN;
-+ mtk_i2c_w32(i2c, reg, REG_SM0CTL0);
++ iowrite32(SM0CTL1_START | SM0CTL1_TRI, i2c->base + REG_SM0CTL1_REG);
++ return mtk_i2c_wait_idle(i2c);
++}
+
-+ /* auto mode */
-+ mtk_i2c_w32(i2c, AUTOMODE_EN, REG_SM0CFG2);
++static int mtk_i2c_master_stop(struct mtk_i2c *i2c)
++{
++ iowrite32(SM0CTL1_STOP | SM0CTL1_TRI, i2c->base + REG_SM0CTL1_REG);
++ return mtk_i2c_wait_idle(i2c);
+}
+
-+static void mtk_i2c_dump_reg(struct mtk_i2c *i2c)
++static int mtk_i2c_master_cmd(struct mtk_i2c *i2c, u32 cmd, int page_len)
+{
-+ dev_dbg(i2c->dev, "cfg0 %08x, dout %08x, din %08x, " \
-+ "status %08x, auto %08x, cfg1 %08x, " \
-+ "cfg2 %08x, ctl0 %08x, ctl1 %08x\n",
-+ mtk_i2c_r32(i2c, REG_SM0CFG0),
-+ mtk_i2c_r32(i2c, REG_SM0DOUT),
-+ mtk_i2c_r32(i2c, REG_SM0DIN),
-+ mtk_i2c_r32(i2c, REG_SM0ST),
-+ mtk_i2c_r32(i2c, REG_SM0AUTO),
-+ mtk_i2c_r32(i2c, REG_SM0CFG1),
-+ mtk_i2c_r32(i2c, REG_SM0CFG2),
-+ mtk_i2c_r32(i2c, REG_SM0CTL0),
-+ mtk_i2c_r32(i2c, REG_SM0CTL1));
++ iowrite32(cmd | SM0CTL1_TRI | SM0CTL1_PGLEN(page_len),
++ i2c->base + REG_SM0CTL1_REG);
++ return mtk_i2c_wait_idle(i2c);
+}
+
+static int mtk_i2c_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
-+ int num)
++ int num)
+{
+ struct mtk_i2c *i2c;
+ struct i2c_msg *pmsg;
-+ int i, j, ret;
++ u16 addr;
++ int i, j, ret, len, page_len;
+ u32 cmd;
++ u32 data[2];
+
+ i2c = i2c_get_adapdata(adap);
+
+ for (i = 0; i < num; i++) {
+ pmsg = &msgs[i];
-+ cmd = 0;
+
-+ dev_dbg(i2c->dev, "addr: 0x%x, len: %d, flags: 0x%x\n",
-+ pmsg->addr, pmsg->len, pmsg->flags);
++ if (pmsg->flags & I2C_M_NOSTART)
++ goto nostart;
+
+ /* wait hardware idle */
-+ if ((ret = mtk_i2c_wait_idle(i2c)))
++ ret = mtk_i2c_wait_idle(i2c);
++ if (ret)
++ goto err_timeout;
++
++ /* start sequence */
++ ret = mtk_i2c_master_start(i2c);
++ if (ret)
+ goto err_timeout;
+
++ /* write address */
+ if (pmsg->flags & I2C_M_TEN) {
-+ dev_dbg(i2c->dev, "10 bits addr not supported\n");
-+ return -EINVAL;
++ /* 10 bits address */
++ addr = 0xf0 | ((pmsg->addr >> 7) & 0x06);
++ addr |= (pmsg->addr & 0xff) << 8;
++ if (pmsg->flags & I2C_M_RD)
++ addr |= 1;
++ iowrite32(addr, i2c->base + REG_SM0D0_REG);
++ ret = mtk_i2c_master_cmd(i2c, SM0CTL1_WRITE, 2);
++ if (ret)
++ goto err_timeout;
+ } else {
+ /* 7 bits address */
-+ mtk_i2c_w32(i2c, pmsg->addr & I2C_DEVADDR_MASK,
-+ REG_SM0CFG0);
++ addr = i2c_8bit_addr_from_msg(pmsg);
++ if (pmsg->flags & I2C_M_REV_DIR_ADDR)
++ addr ^= 1;
++ iowrite32(addr, i2c->base + REG_SM0D0_REG);
++ ret = mtk_i2c_master_cmd(i2c, SM0CTL1_WRITE, 1);
++ if (ret)
++ goto err_timeout;
+ }
+
-+ /* buffer length */
-+ if (pmsg->len == 0) {
-+ dev_dbg(i2c->dev, "length is 0\n");
-+ return -EINVAL;
-+ } else
-+ mtk_i2c_w32(i2c, SET_BYTECNT(pmsg->len),
-+ REG_SM0CFG1);
-+
-+ j = 0;
-+ if (pmsg->flags & I2C_M_RD) {
-+ cmd |= READ_CMD;
-+ /* start transfer */
-+ barrier();
-+ mtk_i2c_w32(i2c, cmd, REG_SM0AUTO);
-+ do {
-+ /* wait */
-+ if ((ret = mtk_i2c_wait_rx_done(i2c)))
-+ goto err_timeout;
-+ /* read data */
-+ if (pmsg->len)
-+ pmsg->buf[j] = mtk_i2c_r32(i2c,
-+ REG_SM0DIN);
-+ j++;
-+ } while (j < pmsg->len);
-+ } else {
-+ do {
-+ /* write data */
-+ if (pmsg->len)
-+ mtk_i2c_w32(i2c, pmsg->buf[j],
-+ REG_SM0DOUT);
-+ /* start transfer */
-+ if (j == 0) {
-+ barrier();
-+ mtk_i2c_w32(i2c, cmd, REG_SM0AUTO);
++ /* check address ACK */
++ if (!(pmsg->flags & I2C_M_IGNORE_NAK)) {
++ ret = mtk_i2c_check_ack(i2c, BIT(0));
++ if (ret)
++ goto err_ack;
++ }
++
++nostart:
++ /* transfer data */
++ for (len = pmsg->len, j = 0; len > 0; len -= 8, j += 8) {
++ page_len = (len >= 8) ? 8 : len;
++
++ if (pmsg->flags & I2C_M_RD) {
++ cmd = (len > 8) ?
++ SM0CTL1_READ : SM0CTL1_READ_LAST;
++ } else {
++ memcpy(data, &pmsg->buf[j], page_len);
++ iowrite32(data[0], i2c->base + REG_SM0D0_REG);
++ iowrite32(data[1], i2c->base + REG_SM0D1_REG);
++ cmd = SM0CTL1_WRITE;
++ }
++
++ ret = mtk_i2c_master_cmd(i2c, cmd, page_len);
++ if (ret)
++ goto err_timeout;
++
++ if (pmsg->flags & I2C_M_RD) {
++ data[0] = ioread32(i2c->base + REG_SM0D0_REG);
++ data[1] = ioread32(i2c->base + REG_SM0D1_REG);
++ memcpy(&pmsg->buf[j], data, page_len);
++ } else {
++ if (!(pmsg->flags & I2C_M_IGNORE_NAK)) {
++ ret = mtk_i2c_check_ack(i2c,
++ (1 << page_len)
++ - 1);
++ if (ret)
++ goto err_ack;
+ }
-+ /* wait */
-+ if ((ret = mtk_i2c_wait_tx_done(i2c)))
-+ goto err_timeout;
-+ j++;
-+ } while (j < pmsg->len);
++ }
+ }
+ }
++
++ ret = mtk_i2c_master_stop(i2c);
++ if (ret)
++ goto err_timeout;
++
+ /* the return value is number of executed messages */
-+ ret = i;
++ return i;
+
-+ return ret;
++err_ack:
++ ret = mtk_i2c_master_stop(i2c);
++ if (ret)
++ goto err_timeout;
++ return -ENXIO;
+
+err_timeout:
+ mtk_i2c_dump_reg(i2c);
@@ -340,7 +288,8 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
+
+static u32 mtk_i2c_func(struct i2c_adapter *a)
+{
-+ return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
++ return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
++ I2C_FUNC_NOSTART | I2C_FUNC_PROTOCOL_MANGLING;
+}
+
+static const struct i2c_algorithm mtk_i2c_algo = {
@@ -355,16 +304,13 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
+
+MODULE_DEVICE_TABLE(of, i2c_mtk_dt_ids);
+
-+static struct i2c_adapter_quirks mtk_i2c_quirks = {
-+ .max_write_len = BYTECNT_MAX,
-+ .max_read_len = BYTECNT_MAX,
-+};
-+
+static void mtk_i2c_init(struct mtk_i2c *i2c)
+{
-+ i2c->clk_div = clk_get_rate(i2c->clk) / i2c->cur_clk;
-+ if (i2c->clk_div > CLK_DIV_MASK)
-+ i2c->clk_div = CLK_DIV_MASK;
++ i2c->clk_div = clk_get_rate(i2c->clk) / i2c->bus_freq - 1;
++ if (i2c->clk_div < 99)
++ i2c->clk_div = 99;
++ if (i2c->clk_div > SM0CTL0_CLK_DIV_MAX)
++ i2c->clk_div = SM0CTL0_CLK_DIV_MAX;
+
+ mtk_i2c_reset(i2c);
+}
@@ -374,22 +320,13 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
+ struct resource *res;
+ struct mtk_i2c *i2c;
+ struct i2c_adapter *adap;
-+ const struct of_device_id *match;
+ int ret;
+
-+ match = of_match_device(i2c_mtk_dt_ids, &pdev->dev);
-+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-+ if (!res) {
-+ dev_err(&pdev->dev, "no memory resource found\n");
-+ return -ENODEV;
-+ }
+
+ i2c = devm_kzalloc(&pdev->dev, sizeof(struct mtk_i2c), GFP_KERNEL);
-+ if (!i2c) {
-+ dev_err(&pdev->dev, "failed to allocate i2c_adapter\n");
++ if (!i2c)
+ return -ENOMEM;
-+ }
+
+ i2c->base = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(i2c->base))
@@ -398,39 +335,43 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
+ i2c->clk = devm_clk_get(&pdev->dev, NULL);
+ if (IS_ERR(i2c->clk)) {
+ dev_err(&pdev->dev, "no clock defined\n");
-+ return -ENODEV;
++ return PTR_ERR(i2c->clk);
++ }
++ ret = clk_prepare_enable(i2c->clk);
++ if (ret) {
++ dev_err(&pdev->dev, "Unable to enable clock\n");
++ return ret;
+ }
-+ clk_prepare_enable(i2c->clk);
++
+ i2c->dev = &pdev->dev;
+
-+ if (of_property_read_u32(pdev->dev.of_node,
-+ "clock-frequency", &i2c->cur_clk))
-+ i2c->cur_clk = 100000;
++ if (of_property_read_u32(pdev->dev.of_node, "clock-frequency",
++ &i2c->bus_freq))
++ i2c->bus_freq = 100000;
++
++ if (i2c->bus_freq == 0) {
++ dev_warn(i2c->dev, "clock-frequency 0 not supported\n");
++ return -EINVAL;
++ }
+
+ adap = &i2c->adap;
+ adap->owner = THIS_MODULE;
-+ adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
+ adap->algo = &mtk_i2c_algo;
+ adap->retries = 3;
+ adap->dev.parent = &pdev->dev;
+ i2c_set_adapdata(adap, i2c);
+ adap->dev.of_node = pdev->dev.of_node;
+ strlcpy(adap->name, dev_name(&pdev->dev), sizeof(adap->name));
-+ adap->quirks = &mtk_i2c_quirks;
+
+ platform_set_drvdata(pdev, i2c);
+
+ mtk_i2c_init(i2c);
+
+ ret = i2c_add_adapter(adap);
-+ if (ret < 0) {
-+ dev_err(&pdev->dev, "failed to add adapter\n");
-+ clk_disable_unprepare(i2c->clk);
++ if (ret < 0)
+ return ret;
-+ }
+
-+ dev_info(&pdev->dev, "clock %uKHz, re-start not support\n",
-+ i2c->cur_clk/1000);
++ dev_info(&pdev->dev, "clock %u kHz\n", i2c->bus_freq / 1000);
+
+ return ret;
+}
@@ -439,8 +380,8 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
+{
+ struct mtk_i2c *i2c = platform_get_drvdata(pdev);
+
-+ i2c_del_adapter(&i2c->adap);
+ clk_disable_unprepare(i2c->clk);
++ i2c_del_adapter(&i2c->adap);
+
+ return 0;
+}
@@ -449,25 +390,14 @@ Signed-off-by: John Crispin <blogic@openwrt.org>
+ .probe = mtk_i2c_probe,
+ .remove = mtk_i2c_remove,
+ .driver = {
-+ .owner = THIS_MODULE,
+ .name = "i2c-mt7621",
+ .of_match_table = i2c_mtk_dt_ids,
+ },
+};
+
-+static int __init i2c_mtk_init (void)
-+{
-+ return platform_driver_register(&mtk_i2c_driver);
-+}
-+subsys_initcall(i2c_mtk_init);
-+
-+static void __exit i2c_mtk_exit (void)
-+{
-+ platform_driver_unregister(&mtk_i2c_driver);
-+}
-+module_exit(i2c_mtk_exit);
++module_platform_driver(mtk_i2c_driver);
+
-+MODULE_AUTHOR("Steven Liu <steven_liu@mediatek.com>");
-+MODULE_DESCRIPTION("MT7621 I2c host driver");
-+MODULE_LICENSE("GPL");
++MODULE_AUTHOR("Steven Liu");
++MODULE_DESCRIPTION("MT7621 I2C host driver");
++MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:MT7621-I2C");
--
2.17.1
Reference in New Issue View Git Blame Copy Permalink