1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * MOXA ART RTC driver. 4 * 5 * Copyright (C) 2013 Jonas Jensen 6 * 7 * Jonas Jensen <jonas.jensen@gmail.com> 8 * 9 * Based on code from 10 * Moxa Technology Co., Ltd. <www.moxa.com> 11 */ 12 13 #include <linux/err.h> 14 #include <linux/init.h> 15 #include <linux/kernel.h> 16 #include <linux/delay.h> 17 #include <linux/rtc.h> 18 #include <linux/platform_device.h> 19 #include <linux/module.h> 20 #include <linux/gpio/consumer.h> 21 22 #define GPIO_RTC_RESERVED 0x0C 23 #define GPIO_RTC_DATA_SET 0x10 24 #define GPIO_RTC_DATA_CLEAR 0x14 25 #define GPIO_RTC_PIN_PULL_ENABLE 0x18 26 #define GPIO_RTC_PIN_PULL_TYPE 0x1C 27 #define GPIO_RTC_INT_ENABLE 0x20 28 #define GPIO_RTC_INT_RAW_STATE 0x24 29 #define GPIO_RTC_INT_MASKED_STATE 0x28 30 #define GPIO_RTC_INT_MASK 0x2C 31 #define GPIO_RTC_INT_CLEAR 0x30 32 #define GPIO_RTC_INT_TRIGGER 0x34 33 #define GPIO_RTC_INT_BOTH 0x38 34 #define GPIO_RTC_INT_RISE_NEG 0x3C 35 #define GPIO_RTC_BOUNCE_ENABLE 0x40 36 #define GPIO_RTC_BOUNCE_PRE_SCALE 0x44 37 #define GPIO_RTC_PROTECT_W 0x8E 38 #define GPIO_RTC_PROTECT_R 0x8F 39 #define GPIO_RTC_YEAR_W 0x8C 40 #define GPIO_RTC_YEAR_R 0x8D 41 #define GPIO_RTC_DAY_W 0x8A 42 #define GPIO_RTC_DAY_R 0x8B 43 #define GPIO_RTC_MONTH_W 0x88 44 #define GPIO_RTC_MONTH_R 0x89 45 #define GPIO_RTC_DATE_W 0x86 46 #define GPIO_RTC_DATE_R 0x87 47 #define GPIO_RTC_HOURS_W 0x84 48 #define GPIO_RTC_HOURS_R 0x85 49 #define GPIO_RTC_MINUTES_W 0x82 50 #define GPIO_RTC_MINUTES_R 0x83 51 #define GPIO_RTC_SECONDS_W 0x80 52 #define GPIO_RTC_SECONDS_R 0x81 53 #define GPIO_RTC_DELAY_TIME 8 54 55 struct moxart_rtc { 56 struct rtc_device *rtc; 57 spinlock_t rtc_lock; 58 struct gpio_desc *gpio_data; 59 struct gpio_desc *gpio_sclk; 60 struct gpio_desc *gpio_reset; 61 }; 62 63 static int day_of_year[12] = { 0, 31, 59, 90, 120, 151, 181, 64 212, 243, 273, 304, 334 }; 65 66 static void moxart_rtc_write_byte(struct device *dev, u8 data) 67 { 68 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 69 int i; 70 71 for (i = 0; i < 8; i++, data >>= 1) { 72 gpiod_set_value(moxart_rtc->gpio_sclk, 0); 73 gpiod_set_value(moxart_rtc->gpio_data, ((data & 1) == 1)); 74 udelay(GPIO_RTC_DELAY_TIME); 75 gpiod_set_value(moxart_rtc->gpio_sclk, 1); 76 udelay(GPIO_RTC_DELAY_TIME); 77 } 78 } 79 80 static u8 moxart_rtc_read_byte(struct device *dev) 81 { 82 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 83 int i; 84 u8 data = 0; 85 86 for (i = 0; i < 8; i++) { 87 gpiod_set_value(moxart_rtc->gpio_sclk, 0); 88 udelay(GPIO_RTC_DELAY_TIME); 89 gpiod_set_value(moxart_rtc->gpio_sclk, 1); 90 udelay(GPIO_RTC_DELAY_TIME); 91 if (gpiod_get_value(moxart_rtc->gpio_data)) 92 data |= (1 << i); 93 udelay(GPIO_RTC_DELAY_TIME); 94 } 95 return data; 96 } 97 98 static u8 moxart_rtc_read_register(struct device *dev, u8 cmd) 99 { 100 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 101 u8 data; 102 unsigned long flags; 103 104 local_irq_save(flags); 105 106 gpiod_direction_output(moxart_rtc->gpio_data, 0); 107 gpiod_set_value(moxart_rtc->gpio_reset, 1); 108 udelay(GPIO_RTC_DELAY_TIME); 109 moxart_rtc_write_byte(dev, cmd); 110 gpiod_direction_input(moxart_rtc->gpio_data); 111 udelay(GPIO_RTC_DELAY_TIME); 112 data = moxart_rtc_read_byte(dev); 113 gpiod_set_value(moxart_rtc->gpio_sclk, 0); 114 gpiod_set_value(moxart_rtc->gpio_reset, 0); 115 udelay(GPIO_RTC_DELAY_TIME); 116 117 local_irq_restore(flags); 118 119 return data; 120 } 121 122 static void moxart_rtc_write_register(struct device *dev, u8 cmd, u8 data) 123 { 124 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 125 unsigned long flags; 126 127 local_irq_save(flags); 128 129 gpiod_direction_output(moxart_rtc->gpio_data, 0); 130 gpiod_set_value(moxart_rtc->gpio_reset, 1); 131 udelay(GPIO_RTC_DELAY_TIME); 132 moxart_rtc_write_byte(dev, cmd); 133 moxart_rtc_write_byte(dev, data); 134 gpiod_set_value(moxart_rtc->gpio_sclk, 0); 135 gpiod_set_value(moxart_rtc->gpio_reset, 0); 136 udelay(GPIO_RTC_DELAY_TIME); 137 138 local_irq_restore(flags); 139 } 140 141 static int moxart_rtc_set_time(struct device *dev, struct rtc_time *tm) 142 { 143 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 144 145 spin_lock_irq(&moxart_rtc->rtc_lock); 146 147 moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0); 148 moxart_rtc_write_register(dev, GPIO_RTC_YEAR_W, 149 (((tm->tm_year - 100) / 10) << 4) | 150 ((tm->tm_year - 100) % 10)); 151 152 moxart_rtc_write_register(dev, GPIO_RTC_MONTH_W, 153 (((tm->tm_mon + 1) / 10) << 4) | 154 ((tm->tm_mon + 1) % 10)); 155 156 moxart_rtc_write_register(dev, GPIO_RTC_DATE_W, 157 ((tm->tm_mday / 10) << 4) | 158 (tm->tm_mday % 10)); 159 160 moxart_rtc_write_register(dev, GPIO_RTC_HOURS_W, 161 ((tm->tm_hour / 10) << 4) | 162 (tm->tm_hour % 10)); 163 164 moxart_rtc_write_register(dev, GPIO_RTC_MINUTES_W, 165 ((tm->tm_min / 10) << 4) | 166 (tm->tm_min % 10)); 167 168 moxart_rtc_write_register(dev, GPIO_RTC_SECONDS_W, 169 ((tm->tm_sec / 10) << 4) | 170 (tm->tm_sec % 10)); 171 172 moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0x80); 173 174 spin_unlock_irq(&moxart_rtc->rtc_lock); 175 176 dev_dbg(dev, "%s: success tm_year=%d tm_mon=%d\n" 177 "tm_mday=%d tm_hour=%d tm_min=%d tm_sec=%d\n", 178 __func__, tm->tm_year, tm->tm_mon, tm->tm_mday, 179 tm->tm_hour, tm->tm_min, tm->tm_sec); 180 181 return 0; 182 } 183 184 static int moxart_rtc_read_time(struct device *dev, struct rtc_time *tm) 185 { 186 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 187 unsigned char v; 188 189 spin_lock_irq(&moxart_rtc->rtc_lock); 190 191 v = moxart_rtc_read_register(dev, GPIO_RTC_SECONDS_R); 192 tm->tm_sec = (((v & 0x70) >> 4) * 10) + (v & 0x0F); 193 194 v = moxart_rtc_read_register(dev, GPIO_RTC_MINUTES_R); 195 tm->tm_min = (((v & 0x70) >> 4) * 10) + (v & 0x0F); 196 197 v = moxart_rtc_read_register(dev, GPIO_RTC_HOURS_R); 198 if (v & 0x80) { /* 12-hour mode */ 199 tm->tm_hour = (((v & 0x10) >> 4) * 10) + (v & 0x0F); 200 if (v & 0x20) { /* PM mode */ 201 tm->tm_hour += 12; 202 if (tm->tm_hour >= 24) 203 tm->tm_hour = 0; 204 } 205 } else { /* 24-hour mode */ 206 tm->tm_hour = (((v & 0x30) >> 4) * 10) + (v & 0x0F); 207 } 208 209 v = moxart_rtc_read_register(dev, GPIO_RTC_DATE_R); 210 tm->tm_mday = (((v & 0x30) >> 4) * 10) + (v & 0x0F); 211 212 v = moxart_rtc_read_register(dev, GPIO_RTC_MONTH_R); 213 tm->tm_mon = (((v & 0x10) >> 4) * 10) + (v & 0x0F); 214 tm->tm_mon--; 215 216 v = moxart_rtc_read_register(dev, GPIO_RTC_YEAR_R); 217 tm->tm_year = (((v & 0xF0) >> 4) * 10) + (v & 0x0F); 218 tm->tm_year += 100; 219 if (tm->tm_year <= 69) 220 tm->tm_year += 100; 221 222 v = moxart_rtc_read_register(dev, GPIO_RTC_DAY_R); 223 tm->tm_wday = (v & 0x0f) - 1; 224 tm->tm_yday = day_of_year[tm->tm_mon]; 225 tm->tm_yday += (tm->tm_mday - 1); 226 if (tm->tm_mon >= 2) { 227 if (!(tm->tm_year % 4) && (tm->tm_year % 100)) 228 tm->tm_yday++; 229 } 230 231 tm->tm_isdst = 0; 232 233 spin_unlock_irq(&moxart_rtc->rtc_lock); 234 235 return 0; 236 } 237 238 static const struct rtc_class_ops moxart_rtc_ops = { 239 .read_time = moxart_rtc_read_time, 240 .set_time = moxart_rtc_set_time, 241 }; 242 243 static int moxart_rtc_probe(struct platform_device *pdev) 244 { 245 struct moxart_rtc *moxart_rtc; 246 int ret = 0; 247 248 moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL); 249 if (!moxart_rtc) 250 return -ENOMEM; 251 252 moxart_rtc->gpio_data = devm_gpiod_get(&pdev->dev, "rtc-data", 253 GPIOD_IN); 254 ret = PTR_ERR_OR_ZERO(moxart_rtc->gpio_data); 255 if (ret) { 256 dev_err(&pdev->dev, "can't get rtc data gpio: %d\n", ret); 257 return ret; 258 } 259 260 moxart_rtc->gpio_sclk = devm_gpiod_get(&pdev->dev, "rtc-sclk", 261 GPIOD_ASIS); 262 ret = PTR_ERR_OR_ZERO(moxart_rtc->gpio_sclk); 263 if (ret) { 264 dev_err(&pdev->dev, "can't get rtc sclk gpio: %d\n", ret); 265 return ret; 266 } 267 268 moxart_rtc->gpio_reset = devm_gpiod_get(&pdev->dev, "rtc-reset", 269 GPIOD_ASIS); 270 ret = PTR_ERR_OR_ZERO(moxart_rtc->gpio_reset); 271 if (ret) { 272 dev_err(&pdev->dev, "can't get rtc reset gpio: %d\n", ret); 273 return ret; 274 } 275 276 spin_lock_init(&moxart_rtc->rtc_lock); 277 platform_set_drvdata(pdev, moxart_rtc); 278 279 moxart_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 280 &moxart_rtc_ops, 281 THIS_MODULE); 282 if (IS_ERR(moxart_rtc->rtc)) { 283 dev_err(&pdev->dev, "devm_rtc_device_register failed\n"); 284 return PTR_ERR(moxart_rtc->rtc); 285 } 286 287 return 0; 288 } 289 290 static const struct of_device_id moxart_rtc_match[] = { 291 { .compatible = "moxa,moxart-rtc" }, 292 { }, 293 }; 294 MODULE_DEVICE_TABLE(of, moxart_rtc_match); 295 296 static struct platform_driver moxart_rtc_driver = { 297 .probe = moxart_rtc_probe, 298 .driver = { 299 .name = "moxart-rtc", 300 .of_match_table = moxart_rtc_match, 301 }, 302 }; 303 module_platform_driver(moxart_rtc_driver); 304 305 MODULE_DESCRIPTION("MOXART RTC driver"); 306 MODULE_LICENSE("GPL"); 307 MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>"); 308