drivers/rtc/rtc-moxart.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * MOXA ART RTC driver.
0004  *
0005  * Copyright (C) 2013 Jonas Jensen
0006  *
0007  * Jonas Jensen <jonas.jensen@gmail.com>
0008  *
0009  * Based on code from
0010  * Moxa Technology Co., Ltd. <www.moxa.com>
0011  */
0012
0013 #include <linux/init.h>
0014 #include <linux/kernel.h>
0015 #include <linux/delay.h>
0016 #include <linux/rtc.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/module.h>
0019 #include <linux/gpio.h>
0020 #include <linux/of_gpio.h>
0021
0022 #define GPIO_RTC_RESERVED           0x0C
0023 #define GPIO_RTC_DATA_SET           0x10
0024 #define GPIO_RTC_DATA_CLEAR         0x14
0025 #define GPIO_RTC_PIN_PULL_ENABLE        0x18
0026 #define GPIO_RTC_PIN_PULL_TYPE          0x1C
0027 #define GPIO_RTC_INT_ENABLE         0x20
0028 #define GPIO_RTC_INT_RAW_STATE          0x24
0029 #define GPIO_RTC_INT_MASKED_STATE       0x28
0030 #define GPIO_RTC_INT_MASK           0x2C
0031 #define GPIO_RTC_INT_CLEAR          0x30
0032 #define GPIO_RTC_INT_TRIGGER            0x34
0033 #define GPIO_RTC_INT_BOTH           0x38
0034 #define GPIO_RTC_INT_RISE_NEG           0x3C
0035 #define GPIO_RTC_BOUNCE_ENABLE          0x40
0036 #define GPIO_RTC_BOUNCE_PRE_SCALE       0x44
0037 #define GPIO_RTC_PROTECT_W          0x8E
0038 #define GPIO_RTC_PROTECT_R          0x8F
0039 #define GPIO_RTC_YEAR_W             0x8C
0040 #define GPIO_RTC_YEAR_R             0x8D
0041 #define GPIO_RTC_DAY_W              0x8A
0042 #define GPIO_RTC_DAY_R              0x8B
0043 #define GPIO_RTC_MONTH_W            0x88
0044 #define GPIO_RTC_MONTH_R            0x89
0045 #define GPIO_RTC_DATE_W             0x86
0046 #define GPIO_RTC_DATE_R             0x87
0047 #define GPIO_RTC_HOURS_W            0x84
0048 #define GPIO_RTC_HOURS_R            0x85
0049 #define GPIO_RTC_MINUTES_W          0x82
0050 #define GPIO_RTC_MINUTES_R          0x83
0051 #define GPIO_RTC_SECONDS_W          0x80
0052 #define GPIO_RTC_SECONDS_R          0x81
0053 #define GPIO_RTC_DELAY_TIME         8
0054
0055 struct moxart_rtc {
0056     struct rtc_device *rtc;
0057     spinlock_t rtc_lock;
0058     int gpio_data, gpio_sclk, gpio_reset;
0059 };
0060
0061 static int day_of_year[12] =    { 0, 31, 59, 90, 120, 151, 181,
0062                   212, 243, 273, 304, 334 };
0063
0064 static void moxart_rtc_write_byte(struct device *dev, u8 data)
0065 {
0066     struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
0067     int i;
0068
0069     for (i = 0; i < 8; i++, data >>= 1) {
0070         gpio_set_value(moxart_rtc->gpio_sclk, 0);
0071         gpio_set_value(moxart_rtc->gpio_data, ((data & 1) == 1));
0072         udelay(GPIO_RTC_DELAY_TIME);
0073         gpio_set_value(moxart_rtc->gpio_sclk, 1);
0074         udelay(GPIO_RTC_DELAY_TIME);
0075     }
0076 }
0077
0078 static u8 moxart_rtc_read_byte(struct device *dev)
0079 {
0080     struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
0081     int i;
0082     u8 data = 0;
0083
0084     for (i = 0; i < 8; i++) {
0085         gpio_set_value(moxart_rtc->gpio_sclk, 0);
0086         udelay(GPIO_RTC_DELAY_TIME);
0087         gpio_set_value(moxart_rtc->gpio_sclk, 1);
0088         udelay(GPIO_RTC_DELAY_TIME);
0089         if (gpio_get_value(moxart_rtc->gpio_data))
0090             data |= (1 << i);
0091         udelay(GPIO_RTC_DELAY_TIME);
0092     }
0093     return data;
0094 }
0095
0096 static u8 moxart_rtc_read_register(struct device *dev, u8 cmd)
0097 {
0098     struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
0099     u8 data;
0100     unsigned long flags;
0101
0102     local_irq_save(flags);
0103
0104     gpio_direction_output(moxart_rtc->gpio_data, 0);
0105     gpio_set_value(moxart_rtc->gpio_reset, 1);
0106     udelay(GPIO_RTC_DELAY_TIME);
0107     moxart_rtc_write_byte(dev, cmd);
0108     gpio_direction_input(moxart_rtc->gpio_data);
0109     udelay(GPIO_RTC_DELAY_TIME);
0110     data = moxart_rtc_read_byte(dev);
0111     gpio_set_value(moxart_rtc->gpio_sclk, 0);
0112     gpio_set_value(moxart_rtc->gpio_reset, 0);
0113     udelay(GPIO_RTC_DELAY_TIME);
0114
0115     local_irq_restore(flags);
0116
0117     return data;
0118 }
0119
0120 static void moxart_rtc_write_register(struct device *dev, u8 cmd, u8 data)
0121 {
0122     struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
0123     unsigned long flags;
0124
0125     local_irq_save(flags);
0126
0127     gpio_direction_output(moxart_rtc->gpio_data, 0);
0128     gpio_set_value(moxart_rtc->gpio_reset, 1);
0129     udelay(GPIO_RTC_DELAY_TIME);
0130     moxart_rtc_write_byte(dev, cmd);
0131     moxart_rtc_write_byte(dev, data);
0132     gpio_set_value(moxart_rtc->gpio_sclk, 0);
0133     gpio_set_value(moxart_rtc->gpio_reset, 0);
0134     udelay(GPIO_RTC_DELAY_TIME);
0135
0136     local_irq_restore(flags);
0137 }
0138
0139 static int moxart_rtc_set_time(struct device *dev, struct rtc_time *tm)
0140 {
0141     struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
0142
0143     spin_lock_irq(&moxart_rtc->rtc_lock);
0144
0145     moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0);
0146     moxart_rtc_write_register(dev, GPIO_RTC_YEAR_W,
0147                   (((tm->tm_year - 100) / 10) << 4) |
0148                   ((tm->tm_year - 100) % 10));
0149
0150     moxart_rtc_write_register(dev, GPIO_RTC_MONTH_W,
0151                   (((tm->tm_mon + 1) / 10) << 4) |
0152                   ((tm->tm_mon + 1) % 10));
0153
0154     moxart_rtc_write_register(dev, GPIO_RTC_DATE_W,
0155                   ((tm->tm_mday / 10) << 4) |
0156                   (tm->tm_mday % 10));
0157
0158     moxart_rtc_write_register(dev, GPIO_RTC_HOURS_W,
0159                   ((tm->tm_hour / 10) << 4) |
0160                   (tm->tm_hour % 10));
0161
0162     moxart_rtc_write_register(dev, GPIO_RTC_MINUTES_W,
0163                   ((tm->tm_min / 10) << 4) |
0164                   (tm->tm_min % 10));
0165
0166     moxart_rtc_write_register(dev, GPIO_RTC_SECONDS_W,
0167                   ((tm->tm_sec / 10) << 4) |
0168                   (tm->tm_sec % 10));
0169
0170     moxart_rtc_write_register(dev, GPIO_RTC_PROTECT_W, 0x80);
0171
0172     spin_unlock_irq(&moxart_rtc->rtc_lock);
0173
0174     dev_dbg(dev, "%s: success tm_year=%d tm_mon=%d\n"
0175         "tm_mday=%d tm_hour=%d tm_min=%d tm_sec=%d\n",
0176         __func__, tm->tm_year, tm->tm_mon, tm->tm_mday,
0177         tm->tm_hour, tm->tm_min, tm->tm_sec);
0178
0179     return 0;
0180 }
0181
0182 static int moxart_rtc_read_time(struct device *dev, struct rtc_time *tm)
0183 {
0184     struct moxart_rtc *moxart_rtc = dev_get_drvdata(dev);
0185     unsigned char v;
0186
0187     spin_lock_irq(&moxart_rtc->rtc_lock);
0188
0189     v = moxart_rtc_read_register(dev, GPIO_RTC_SECONDS_R);
0190     tm->tm_sec = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
0191
0192     v = moxart_rtc_read_register(dev, GPIO_RTC_MINUTES_R);
0193     tm->tm_min = (((v & 0x70) >> 4) * 10) + (v & 0x0F);
0194
0195     v = moxart_rtc_read_register(dev, GPIO_RTC_HOURS_R);
0196     if (v & 0x80) { /* 12-hour mode */
0197         tm->tm_hour = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
0198         if (v & 0x20) { /* PM mode */
0199             tm->tm_hour += 12;
0200             if (tm->tm_hour >= 24)
0201                 tm->tm_hour = 0;
0202         }
0203     } else { /* 24-hour mode */
0204         tm->tm_hour = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
0205     }
0206
0207     v = moxart_rtc_read_register(dev, GPIO_RTC_DATE_R);
0208     tm->tm_mday = (((v & 0x30) >> 4) * 10) + (v & 0x0F);
0209
0210     v = moxart_rtc_read_register(dev, GPIO_RTC_MONTH_R);
0211     tm->tm_mon = (((v & 0x10) >> 4) * 10) + (v & 0x0F);
0212     tm->tm_mon--;
0213
0214     v = moxart_rtc_read_register(dev, GPIO_RTC_YEAR_R);
0215     tm->tm_year = (((v & 0xF0) >> 4) * 10) + (v & 0x0F);
0216     tm->tm_year += 100;
0217     if (tm->tm_year <= 69)
0218         tm->tm_year += 100;
0219
0220     v = moxart_rtc_read_register(dev, GPIO_RTC_DAY_R);
0221     tm->tm_wday = (v & 0x0f) - 1;
0222     tm->tm_yday = day_of_year[tm->tm_mon];
0223     tm->tm_yday += (tm->tm_mday - 1);
0224     if (tm->tm_mon >= 2) {
0225         if (!(tm->tm_year % 4) && (tm->tm_year % 100))
0226             tm->tm_yday++;
0227     }
0228
0229     tm->tm_isdst = 0;
0230
0231     spin_unlock_irq(&moxart_rtc->rtc_lock);
0232
0233     return 0;
0234 }
0235
0236 static const struct rtc_class_ops moxart_rtc_ops = {
0237     .read_time  = moxart_rtc_read_time,
0238     .set_time   = moxart_rtc_set_time,
0239 };
0240
0241 static int moxart_rtc_probe(struct platform_device *pdev)
0242 {
0243     struct moxart_rtc *moxart_rtc;
0244     int ret = 0;
0245
0246     moxart_rtc = devm_kzalloc(&pdev->dev, sizeof(*moxart_rtc), GFP_KERNEL);
0247     if (!moxart_rtc)
0248         return -ENOMEM;
0249
0250     moxart_rtc->gpio_data = of_get_named_gpio(pdev->dev.of_node,
0251                           "gpio-rtc-data", 0);
0252     if (!gpio_is_valid(moxart_rtc->gpio_data)) {
0253         dev_err(&pdev->dev, "invalid gpio (data): %d\n",
0254             moxart_rtc->gpio_data);
0255         return moxart_rtc->gpio_data;
0256     }
0257
0258     moxart_rtc->gpio_sclk = of_get_named_gpio(pdev->dev.of_node,
0259                           "gpio-rtc-sclk", 0);
0260     if (!gpio_is_valid(moxart_rtc->gpio_sclk)) {
0261         dev_err(&pdev->dev, "invalid gpio (sclk): %d\n",
0262             moxart_rtc->gpio_sclk);
0263         return moxart_rtc->gpio_sclk;
0264     }
0265
0266     moxart_rtc->gpio_reset = of_get_named_gpio(pdev->dev.of_node,
0267                            "gpio-rtc-reset", 0);
0268     if (!gpio_is_valid(moxart_rtc->gpio_reset)) {
0269         dev_err(&pdev->dev, "invalid gpio (reset): %d\n",
0270             moxart_rtc->gpio_reset);
0271         return moxart_rtc->gpio_reset;
0272     }
0273
0274     spin_lock_init(&moxart_rtc->rtc_lock);
0275     platform_set_drvdata(pdev, moxart_rtc);
0276
0277     ret = devm_gpio_request(&pdev->dev, moxart_rtc->gpio_data, "rtc_data");
0278     if (ret) {
0279         dev_err(&pdev->dev, "can't get rtc_data gpio\n");
0280         return ret;
0281     }
0282
0283     ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_sclk,
0284                     GPIOF_DIR_OUT, "rtc_sclk");
0285     if (ret) {
0286         dev_err(&pdev->dev, "can't get rtc_sclk gpio\n");
0287         return ret;
0288     }
0289
0290     ret = devm_gpio_request_one(&pdev->dev, moxart_rtc->gpio_reset,
0291                     GPIOF_DIR_OUT, "rtc_reset");
0292     if (ret) {
0293         dev_err(&pdev->dev, "can't get rtc_reset gpio\n");
0294         return ret;
0295     }
0296
0297     moxart_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
0298                            &moxart_rtc_ops,
0299                            THIS_MODULE);
0300     if (IS_ERR(moxart_rtc->rtc)) {
0301         dev_err(&pdev->dev, "devm_rtc_device_register failed\n");
0302         return PTR_ERR(moxart_rtc->rtc);
0303     }
0304
0305     return 0;
0306 }
0307
0308 static const struct of_device_id moxart_rtc_match[] = {
0309     { .compatible = "moxa,moxart-rtc" },
0310     { },
0311 };
0312 MODULE_DEVICE_TABLE(of, moxart_rtc_match);
0313
0314 static struct platform_driver moxart_rtc_driver = {
0315     .probe  = moxart_rtc_probe,
0316     .driver = {
0317         .name       = "moxart-rtc",
0318         .of_match_table = moxart_rtc_match,
0319     },
0320 };
0321 module_platform_driver(moxart_rtc_driver);
0322
0323 MODULE_DESCRIPTION("MOXART RTC driver");
0324 MODULE_LICENSE("GPL");
0325 MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");