Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/rtc/rtc-moxart.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us