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/init.h> 14 #include <linux/kernel.h> 15 #include <linux/delay.h> 16 #include <linux/rtc.h> 17 #include <linux/platform_device.h> 18 #include <linux/module.h> 19 #include <linux/gpio.h> 20 #include <linux/of_gpio.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 int gpio_data, gpio_sclk, gpio_reset; 59 }; 60 61 static int day_of_year[12] = { 0, 31, 59, 90, 120, 151, 181, 62 212, 243, 273, 304, 334 }; 63 64 static void moxart_rtc_write_byte(struct device *dev, u8 data) 65 { 66 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 67 int i; 68 69 for (i = 0; i < 8; i++, data >>= 1) { 70 gpio_set_value(moxart_rtc->gpio_sclk, 0); 71 gpio_set_value(moxart_rtc->gpio_data, ((data & 1) == 1)); 72 udelay(GPIO_RTC_DELAY_TIME); 73 gpio_set_value(moxart_rtc->gpio_sclk, 1); 74 udelay(GPIO_RTC_DELAY_TIME); 75 } 76 } 77 78 static u8 moxart_rtc_read_byte(struct device *dev) 79 { 80 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 81 int i; 82 u8 data = 0; 83 84 for (i = 0; i < 8; i++) { 85 gpio_set_value(moxart_rtc->gpio_sclk, 0); 86 udelay(GPIO_RTC_DELAY_TIME); 87 gpio_set_value(moxart_rtc->gpio_sclk, 1); 88 udelay(GPIO_RTC_DELAY_TIME); 89 if (gpio_get_value(moxart_rtc->gpio_data)) 90 data |= (1 << i); 91 udelay(GPIO_RTC_DELAY_TIME); 92 } 93 return data; 94 } 95 96 static u8 moxart_rtc_read_register(struct device *dev, u8 cmd) 97 { 98 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 99 u8 data; 100 unsigned long flags; 101 102 local_irq_save(flags); 103 104 gpio_direction_output(moxart_rtc->gpio_data, 0); 105 gpio_set_value(moxart_rtc->gpio_reset, 1); 106 udelay(GPIO_RTC_DELAY_TIME); 107 moxart_rtc_write_byte(dev, cmd); 108 gpio_direction_input(moxart_rtc->gpio_data); 109 udelay(GPIO_RTC_DELAY_TIME); 110 data = moxart_rtc_read_byte(dev); 111 gpio_set_value(moxart_rtc->gpio_sclk, 0); 112 gpio_set_value(moxart_rtc->gpio_reset, 0); 113 udelay(GPIO_RTC_DELAY_TIME); 114 115 local_irq_restore(flags); 116 117 return data; 118 } 119 120 static void moxart_rtc_write_register(struct device *dev, u8 cmd, u8 data) 121 { 122 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 123 unsigned long flags; 124 125 local_irq_save(flags); 126 127 gpio_direction_output(moxart_rtc->gpio_data, 0); 128 gpio_set_value(moxart_rtc->gpio_reset, 1); 129 udelay(GPIO_RTC_DELAY_TIME); 130 moxart_rtc_write_byte(dev, cmd); 131 moxart_rtc_write_byte(dev, data); 132 gpio_set_value(moxart_rtc->gpio_sclk, 0); 133 gpio_set_value(moxart_rtc->gpio_reset, 0); 134 udelay(GPIO_RTC_DELAY_TIME); 135 136 local_irq_restore(flags); 137 } 138 139 static int moxart_rtc_set_time(struct device *dev, struct rtc_time *tm) 140 { 141 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 142 143 spin_lock_irq(&moxart_rtc->rtc_lock); 144 145 moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0); 146 moxart_rtc_write_register(dev, GPIO_RTC_YEAR_W, 147 (((tm->tm_year - 100) / 10) << 4) | 148 ((tm->tm_year - 100) % 10)); 149 150 moxart_rtc_write_register(dev, GPIO_RTC_MONTH_W, 151 (((tm->tm_mon + 1) / 10) << 4) | 152 ((tm->tm_mon + 1) % 10)); 153 154 moxart_rtc_write_register(dev, GPIO_RTC_DATE_W, 155 ((tm->tm_mday / 10) << 4) | 156 (tm->tm_mday % 10)); 157 158 moxart_rtc_write_register(dev, GPIO_RTC_HOURS_W, 159 ((tm->tm_hour / 10) << 4) | 160 (tm->tm_hour % 10)); 161 162 moxart_rtc_write_register(dev, GPIO_RTC_MINUTES_W, 163 ((tm->tm_min / 10) << 4) | 164 (tm->tm_min % 10)); 165 166 moxart_rtc_write_register(dev, GPIO_RTC_SECONDS_W, 167 ((tm->tm_sec / 10) << 4) | 168 (tm->tm_sec % 10)); 169 170 moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0x80); 171 172 spin_unlock_irq(&moxart_rtc->rtc_lock); 173 174 dev_dbg(dev, "%s: success tm_year=%d tm_mon=%d\n" 175 "tm_mday=%d tm_hour=%d tm_min=%d tm_sec=%d\n", 176 __func__, tm->tm_year, tm->tm_mon, tm->tm_mday, 177 tm->tm_hour, tm->tm_min, tm->tm_sec); 178 179 return 0; 180 } 181 182 static int moxart_rtc_read_time(struct device *dev, struct rtc_time *tm) 183 { 184 struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev); 185 unsigned char v; 186 187 spin_lock_irq(&moxart_rtc->rtc_lock); 188 189 v = moxart_rtc_read_register(dev, GPIO_RTC_SECONDS_R); 190 tm->tm_sec = (((v & 0x70) >> 4) * 10) + (v & 0x0F); 191 192 v = moxart_rtc_read_register(dev, GPIO_RTC_MINUTES_R); 193 tm->tm_min = (((v & 0x70) >> 4) * 10) + (v & 0x0F); 194 195 v = moxart_rtc_read_register(dev, GPIO_RTC_HOURS_R); 196 if (v & 0x80) { /* 12-hour mode */ 197 tm->tm_hour = (((v & 0x10) >> 4) * 10) + (v & 0x0F); 198 if (v & 0x20) { /* PM mode */ 199 tm->tm_hour += 12; 200 if (tm->tm_hour >= 24) 201 tm->tm_hour = 0; 202 } 203 } else { /* 24-hour mode */ 204 tm->tm_hour = (((v & 0x30) >> 4) * 10) + (v & 0x0F); 205 } 206 207 v = moxart_rtc_read_register(dev, GPIO_RTC_DATE_R); 208 tm->tm_mday = (((v & 0x30) >> 4) * 10) + (v & 0x0F); 209 210 v = moxart_rtc_read_register(dev, GPIO_RTC_MONTH_R); 211 tm->tm_mon = (((v & 0x10) >> 4) * 10) + (v & 0x0F); 212 tm->tm_mon--; 213 214 v = moxart_rtc_read_register(dev, GPIO_RTC_YEAR_R); 215 tm->tm_year = (((v & 0xF0) >> 4) * 10) + (v & 0x0F); 216 tm->tm_year += 100; 217 if (tm->tm_year <= 69) 218 tm->tm_year += 100; 219 220 v = moxart_rtc_read_register(dev, GPIO_RTC_DAY_R); 221 tm->tm_wday = (v & 0x0f) - 1; 222 tm->tm_yday = day_of_year[tm->tm_mon]; 223 tm->tm_yday += (tm->tm_mday - 1); 224 if (tm->tm_mon >= 2) { 225 if (!(tm->tm_year % 4) && (tm->tm_year % 100)) 226 tm->tm_yday++; 227 } 228 229 tm->tm_isdst = 0; 230 231 spin_unlock_irq(&moxart_rtc->rtc_lock); 232 233 return 0; 234 } 235 236 static const struct rtc_class_ops moxart_rtc_ops = { 237 .read_time = moxart_rtc_read_time, 238 .set_time = moxart_rtc_set_time, 239 }; 240 241 static int moxart_rtc_probe(struct platform_device *pdev) 242 { 243 struct moxart_rtc *moxart_rtc; 244 int ret = 0; 245 246 moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL); 247 if (!moxart_rtc) 248 return -ENOMEM; 249 250 moxart_rtc->gpio_data = of_get_named_gpio(pdev->dev.of_node, 251 "gpio-rtc-data", 0); 252 if (!gpio_is_valid(moxart_rtc->gpio_data)) { 253 dev_err(&pdev->dev, "invalid gpio (data): %d\n", 254 moxart_rtc->gpio_data); 255 return moxart_rtc->gpio_data; 256 } 257 258 moxart_rtc->gpio_sclk = of_get_named_gpio(pdev->dev.of_node, 259 "gpio-rtc-sclk", 0); 260 if (!gpio_is_valid(moxart_rtc->gpio_sclk)) { 261 dev_err(&pdev->dev, "invalid gpio (sclk): %d\n", 262 moxart_rtc->gpio_sclk); 263 return moxart_rtc->gpio_sclk; 264 } 265 266 moxart_rtc->gpio_reset = of_get_named_gpio(pdev->dev.of_node, 267 "gpio-rtc-reset", 0); 268 if (!gpio_is_valid(moxart_rtc->gpio_reset)) { 269 dev_err(&pdev->dev, "invalid gpio (reset): %d\n", 270 moxart_rtc->gpio_reset); 271 return moxart_rtc->gpio_reset; 272 } 273 274 spin_lock_init(&moxart_rtc->rtc_lock); 275 platform_set_drvdata(pdev, moxart_rtc); 276 277 ret = devm_gpio_request(&pdev->dev, moxart_rtc->gpio_data, "rtc_data"); 278 if (ret) { 279 dev_err(&pdev->dev, "can't get rtc_data gpio\n"); 280 return ret; 281 } 282 283 ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_sclk, 284 GPIOF_DIR_OUT, "rtc_sclk"); 285 if (ret) { 286 dev_err(&pdev->dev, "can't get rtc_sclk gpio\n"); 287 return ret; 288 } 289 290 ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_reset, 291 GPIOF_DIR_OUT, "rtc_reset"); 292 if (ret) { 293 dev_err(&pdev->dev, "can't get rtc_reset gpio\n"); 294 return ret; 295 } 296 297 moxart_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 298 &moxart_rtc_ops, 299 THIS_MODULE); 300 if (IS_ERR(moxart_rtc->rtc)) { 301 dev_err(&pdev->dev, "devm_rtc_device_register failed\n"); 302 return PTR_ERR(moxart_rtc->rtc); 303 } 304 305 return 0; 306 } 307 308 static const struct of_device_id moxart_rtc_match[] = { 309 { .compatible = "moxa,moxart-rtc" }, 310 { }, 311 }; 312 MODULE_DEVICE_TABLE(of, moxart_rtc_match); 313 314 static struct platform_driver moxart_rtc_driver = { 315 .probe = moxart_rtc_probe, 316 .driver = { 317 .name = "moxart-rtc", 318 .of_match_table = moxart_rtc_match, 319 }, 320 }; 321 module_platform_driver(moxart_rtc_driver); 322 323 MODULE_DESCRIPTION("MOXART RTC driver"); 324 MODULE_LICENSE("GPL"); 325 MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>"); 326