rtc: max77663: Set Alarm wday to its reset value
[linux-2.6.git] / drivers / rtc / rtc-max77663.c
1 /*
2  * drivers/rtc/rtc-max77663.c
3  * Max77663 RTC driver
4  *
5  * Copyright 2011-2012, Maxim Integrated Products, Inc.
6  * Copyright (c) 2011-2012, NVIDIA CORPORATION. All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of the
11  * License, or (at your option) any later version.
12  *
13  */
14 #include <linux/module.h>
15 #include <linux/platform_device.h>
16 #include <linux/slab.h>
17 #include <linux/delay.h>
18 #include <linux/i2c.h>
19 #include <linux/rtc.h>
20 #include <linux/mfd/max77663-core.h>
21
22 /* RTC Registers */
23 #define MAX77663_RTC_IRQ                0x00
24 #define MAX77663_RTC_IRQ_MASK           0x01
25 #define MAX77663_RTC_CTRL_MODE          0x02
26 #define MAX77663_RTC_CTRL               0x03
27 #define MAX77663_RTC_UPDATE0            0x04
28 #define MAX77663_RTC_UPDATE1            0x05
29 #define MAX77663_RTC_SEC                0x07
30 #define MAX77663_RTC_MIN                0x08
31 #define MAX77663_RTC_HOUR               0x09
32 #define MAX77663_RTC_WEEKDAY            0x0A
33 #define MAX77663_RTC_MONTH              0x0B
34 #define MAX77663_RTC_YEAR               0x0C
35 #define MAX77663_RTC_MONTHDAY           0x0D
36 #define MAX77663_RTC_ALARM_SEC1         0x0E
37 #define MAX77663_RTC_ALARM_MIN1         0x0F
38 #define MAX77663_RTC_ALARM_HOUR1        0x10
39 #define MAX77663_RTC_ALARM_WEEKDAY1     0x11
40 #define MAX77663_RTC_ALARM_MONTH1       0x12
41 #define MAX77663_RTC_ALARM_YEAR1        0x13
42 #define MAX77663_RTC_ALARM_MONTHDAY1    0x14
43
44 #define RTC_IRQ_60SEC_MASK              (1 << 0)
45 #define RTC_IRQ_ALARM1_MASK             (1 << 1)
46 #define RTC_IRQ_ALARM2_MASK             (1 << 2)
47 #define RTC_IRQ_SMPL_MASK               (1 << 3)
48 #define RTC_IRQ_1SEC_MASK               (1 << 4)
49 #define RTC_IRQ_MASK                    0x1F
50
51 #define BCD_MODE_MASK                   (1 << 0)
52 #define HR_MODE_MASK                    (1 << 1)
53
54 #define WB_UPDATE_MASK                  (1 << 0)
55 #define FLAG_AUTO_CLEAR_MASK            (1 << 1)
56 #define FREEZE_SEC_MASK                 (1 << 2)
57 #define RTC_WAKE_MASK                   (1 << 3)
58 #define RB_UPDATE_MASK                  (1 << 4)
59
60 #define WB_UPDATE_FLAG_MASK             (1 << 0)
61 #define RB_UPDATE_FLAG_MASK             (1 << 1)
62
63 #define SEC_MASK                        0x7F
64 #define MIN_MASK                        0x7F
65 #define HOUR_MASK                       0x3F
66 #define WEEKDAY_MASK                    0x7F
67 #define MONTH_MASK                      0x1F
68 #define YEAR_MASK                       0xFF
69 #define MONTHDAY_MASK                   0x3F
70
71 #define ALARM_EN_MASK                   0x80
72 #define ALARM_EN_SHIFT                  7
73
74 #define RTC_YEAR_BASE                   100
75 #define RTC_YEAR_MAX                    99
76
77 /* ON/OFF Registers */
78 #define MAX77663_REG_ONOFF_CFG2         0x42
79
80 #define ONOFF_WK_ALARM1_MASK            (1 << 2)
81
82 enum {
83         RTC_SEC,
84         RTC_MIN,
85         RTC_HOUR,
86         RTC_WEEKDAY,
87         RTC_MONTH,
88         RTC_YEAR,
89         RTC_MONTHDAY,
90         RTC_NR
91 };
92
93 struct max77663_rtc {
94         struct rtc_device *rtc;
95         struct device *dev;
96
97         struct mutex io_lock;
98         int irq;
99         u8 irq_mask;
100         bool shutdown_ongoing;
101 };
102
103 static inline struct device *_to_parent(struct max77663_rtc *rtc)
104 {
105         return rtc->dev->parent;
106 }
107
108 static inline int max77663_rtc_update_buffer(struct max77663_rtc *rtc,
109                                              int write)
110 {
111         struct device *parent = _to_parent(rtc);
112         u8 val =  FLAG_AUTO_CLEAR_MASK | RTC_WAKE_MASK;
113         int ret;
114
115         if (write)
116                 val |= WB_UPDATE_MASK;
117         else
118                 val |= RB_UPDATE_MASK;
119
120         dev_dbg(rtc->dev, "rtc_update_buffer: write=%d, addr=0x%x, val=0x%x\n",
121                 write, MAX77663_RTC_UPDATE0, val);
122         ret = max77663_write(parent, MAX77663_RTC_UPDATE0, &val, 1, 1);
123         if (ret < 0) {
124                 dev_err(rtc->dev, "rtc_update_buffer: "
125                         "Failed to get rtc update0\n");
126                 return ret;
127         }
128
129         /*
130          * Must wait 14ms for buffer update.
131          * If the sleeping time is 10us - 20ms, usleep_range() is recommended.
132          * Please refer Documentation/timers/timers-howto.txt.
133          */
134         usleep_range(14000, 14000);
135
136         return 0;
137 }
138
139 static inline int max77663_rtc_write(struct max77663_rtc *rtc, u8 addr,
140                                      void *values, u32 len, int update_buffer)
141 {
142         struct device *parent = _to_parent(rtc);
143         int ret;
144
145         mutex_lock(&rtc->io_lock);
146
147         dev_dbg(rtc->dev, "rtc_write: addr=0x%x, values=0x%x, len=%u, "
148                 "update_buffer=%d\n",
149                 addr, *((u8 *)values), len, update_buffer);
150         ret = max77663_write(parent, addr, values, len, 1);
151         if (ret < 0)
152                 goto out;
153
154         if (update_buffer)
155                 ret = max77663_rtc_update_buffer(rtc, 1);
156
157 out:
158         mutex_unlock(&rtc->io_lock);
159         return ret;
160 }
161
162 static inline int max77663_rtc_read(struct max77663_rtc *rtc, u8 addr,
163                                     void *values, u32 len, int update_buffer)
164 {
165         struct device *parent = _to_parent(rtc);
166         int ret;
167
168         mutex_lock(&rtc->io_lock);
169
170         if (update_buffer) {
171                 ret = max77663_rtc_update_buffer(rtc, 0);
172                 if (ret < 0)
173                         goto out;
174         }
175
176         ret = max77663_read(parent, addr, values, len, 1);
177         dev_dbg(rtc->dev, "rtc_read: addr=0x%x, values=0x%x, len=%u, "
178                 "update_buffer=%d\n",
179                 addr, *((u8 *)values), len, update_buffer);
180
181 out:
182         mutex_unlock(&rtc->io_lock);
183         return ret;
184 }
185
186 static inline int max77663_rtc_reg_to_tm(struct max77663_rtc *rtc, u8 *buf,
187                                          struct rtc_time *tm)
188 {
189         int wday = buf[RTC_WEEKDAY] & WEEKDAY_MASK;
190
191         if (unlikely(!wday)) {
192                 dev_err(rtc->dev,
193                         "rtc_reg_to_tm: Invalid day of week, %d\n", wday);
194                 return -EINVAL;
195         }
196
197         tm->tm_sec = (int)(buf[RTC_SEC] & SEC_MASK);
198         tm->tm_min = (int)(buf[RTC_MIN] & MIN_MASK);
199         tm->tm_hour = (int)(buf[RTC_HOUR] & HOUR_MASK);
200         tm->tm_mday = (int)(buf[RTC_MONTHDAY] & MONTHDAY_MASK);
201         tm->tm_mon = (int)(buf[RTC_MONTH] & MONTH_MASK) - 1;
202         tm->tm_year = (int)(buf[RTC_YEAR] & YEAR_MASK) + RTC_YEAR_BASE;
203         tm->tm_wday = ffs(wday) - 1;
204
205         return 0;
206 }
207
208 static inline int max77663_rtc_tm_to_reg(struct max77663_rtc *rtc, u8 *buf,
209                                          struct rtc_time *tm, int alarm)
210 {
211         u8 alarm_mask = alarm ? ALARM_EN_MASK : 0;
212
213         if (unlikely((tm->tm_year < RTC_YEAR_BASE) ||
214                         (tm->tm_year > RTC_YEAR_BASE + RTC_YEAR_MAX))) {
215                 dev_err(rtc->dev,
216                         "rtc_tm_to_reg: Invalid year, %d\n", tm->tm_year);
217                 return -EINVAL;
218         }
219
220         buf[RTC_SEC] = tm->tm_sec | alarm_mask;
221         buf[RTC_MIN] = tm->tm_min | alarm_mask;
222         buf[RTC_HOUR] = tm->tm_hour | alarm_mask;
223         buf[RTC_MONTHDAY] = tm->tm_mday | alarm_mask;
224         buf[RTC_MONTH] = (tm->tm_mon + 1) | alarm_mask;
225         buf[RTC_YEAR] = (tm->tm_year - RTC_YEAR_BASE) | alarm_mask;
226
227         /* The wday is configured only when disabled alarm. */
228         if (!alarm)
229                 buf[RTC_WEEKDAY] = (1 << tm->tm_wday);
230         else {
231         /* Configure its default reset value 0x01, and not enable it. */
232                 buf[RTC_WEEKDAY] = 0x01;
233         }
234         return 0;
235 }
236
237 static inline int max77663_rtc_irq_mask(struct max77663_rtc *rtc, u8 irq)
238 {
239         struct device *parent = _to_parent(rtc);
240         u8 irq_mask = rtc->irq_mask | irq;
241         int ret = 0;
242
243         ret = max77663_write(parent, MAX77663_RTC_IRQ_MASK, &irq_mask, 1, 1);
244         if (ret < 0) {
245                 dev_err(rtc->dev, "rtc_irq_mask: Failed to set rtc irq mask\n");
246                 goto out;
247         }
248         rtc->irq_mask = irq_mask;
249
250 out:
251         return ret;
252 }
253
254 static inline int max77663_rtc_irq_unmask(struct max77663_rtc *rtc, u8 irq)
255 {
256         struct device *parent = _to_parent(rtc);
257         u8 irq_mask = rtc->irq_mask & ~irq;
258         int ret = 0;
259
260         ret = max77663_write(parent, MAX77663_RTC_IRQ_MASK, &irq_mask, 1, 1);
261         if (ret < 0) {
262                 dev_err(rtc->dev,
263                         "rtc_irq_unmask: Failed to set rtc irq mask\n");
264                 goto out;
265         }
266         rtc->irq_mask = irq_mask;
267
268 out:
269         return ret;
270 }
271
272 static inline int max77663_rtc_do_irq(struct max77663_rtc *rtc)
273 {
274         struct device *parent = _to_parent(rtc);
275         u8 irq_status;
276         int ret;
277
278         ret = max77663_rtc_update_buffer(rtc, 0);
279         if (ret < 0) {
280                 dev_err(rtc->dev, "rtc_irq: Failed to get rtc update buffer\n");
281                 return ret;
282         }
283
284         ret = max77663_read(parent, MAX77663_RTC_IRQ, &irq_status, 1, 1);
285         if (ret < 0) {
286                 dev_err(rtc->dev, "rtc_irq: Failed to get rtc irq status\n");
287                 return ret;
288         }
289
290         dev_dbg(rtc->dev, "rtc_do_irq: irq_mask=0x%02x, irq_status=0x%02x\n",
291                 rtc->irq_mask, irq_status);
292
293         if (!(rtc->irq_mask & RTC_IRQ_ALARM1_MASK) &&
294                         (irq_status & RTC_IRQ_ALARM1_MASK))
295                 rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
296
297         if (!(rtc->irq_mask & RTC_IRQ_1SEC_MASK) &&
298                         (irq_status & RTC_IRQ_1SEC_MASK))
299                 rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_UF);
300
301         return ret;
302 }
303
304 static irqreturn_t max77663_rtc_irq(int irq, void *data)
305 {
306         struct max77663_rtc *rtc = (struct max77663_rtc *)data;
307
308         max77663_rtc_do_irq(rtc);
309
310         return IRQ_HANDLED;
311 }
312
313 static int max77663_rtc_alarm_irq_enable(struct device *dev,
314                                          unsigned int enabled)
315 {
316         struct max77663_rtc *rtc = dev_get_drvdata(dev);
317         int ret = 0;
318
319         if (rtc->irq < 0)
320                 return -ENXIO;
321
322         mutex_lock(&rtc->io_lock);
323
324         /* Handle pending interrupt */
325         ret = max77663_rtc_do_irq(rtc);
326         if (ret < 0)
327                 goto out;
328
329         /* Config alarm interrupt */
330         if (enabled) {
331                 ret = max77663_rtc_irq_unmask(rtc, RTC_IRQ_ALARM1_MASK);
332                 if (ret < 0)
333                         goto out;
334         } else {
335                 ret = max77663_rtc_irq_mask(rtc, RTC_IRQ_ALARM1_MASK);
336                 if (ret < 0)
337                         goto out;
338         }
339 out:
340         mutex_unlock(&rtc->io_lock);
341         return ret;
342 }
343
344 static int max77663_rtc_read_time(struct device *dev, struct rtc_time *tm)
345 {
346         struct max77663_rtc *rtc = dev_get_drvdata(dev);
347         u8 buf[RTC_NR];
348         int ret;
349
350         ret = max77663_rtc_read(rtc, MAX77663_RTC_SEC, buf, sizeof(buf), 1);
351         if (ret < 0) {
352                 dev_err(rtc->dev, "rtc_read_time: Failed to read rtc time\n");
353                 return ret;
354         }
355
356         dev_dbg(rtc->dev, "rtc_read_time: "
357                 "buf: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
358                 buf[RTC_SEC], buf[RTC_MIN], buf[RTC_HOUR], buf[RTC_WEEKDAY],
359                 buf[RTC_MONTH], buf[RTC_YEAR], buf[RTC_MONTHDAY]);
360
361         ret = max77663_rtc_reg_to_tm(rtc, buf, tm);
362         if (ret < 0) {
363                 dev_err(rtc->dev, "rtc_read_time: "
364                         "Failed to convert register format into time format\n");
365                 return ret;
366         }
367
368         dev_dbg(rtc->dev, "rtc_read_time: "
369                 "tm: %d-%02d-%02d %02d:%02d:%02d, wday=%d\n",
370                 tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
371                 tm->tm_sec, tm->tm_wday);
372
373         return ret;
374 }
375
376 static int max77663_rtc_set_time(struct device *dev, struct rtc_time *tm)
377 {
378         struct max77663_rtc *rtc = dev_get_drvdata(dev);
379         u8 buf[RTC_NR];
380         int ret;
381
382         dev_dbg(rtc->dev, "rtc_set_time: "
383                 "tm: %d-%02d-%02d %02d:%02d:%02d, wday=%d\n",
384                 tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min,
385                 tm->tm_sec, tm->tm_wday);
386
387         ret = max77663_rtc_tm_to_reg(rtc, buf, tm, 0);
388         if (ret < 0) {
389                 dev_err(rtc->dev, "rtc_set_time: "
390                         "Failed to convert time format into register format\n");
391                 return ret;
392         }
393
394         dev_dbg(rtc->dev, "rtc_set_time: "
395                 "buf: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
396                 buf[RTC_SEC], buf[RTC_MIN], buf[RTC_HOUR], buf[RTC_WEEKDAY],
397                 buf[RTC_MONTH], buf[RTC_YEAR], buf[RTC_MONTHDAY]);
398
399         return max77663_rtc_write(rtc, MAX77663_RTC_SEC, buf, sizeof(buf), 1);
400 }
401
402 static int max77663_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
403 {
404         struct max77663_rtc *rtc = dev_get_drvdata(dev);
405         u8 buf[RTC_NR];
406         int ret;
407
408         ret = max77663_rtc_read(rtc, MAX77663_RTC_ALARM_SEC1, buf, sizeof(buf),
409                                 1);
410         if (ret < 0) {
411                 dev_err(rtc->dev,
412                         "rtc_read_alarm: Failed to read rtc alarm time\n");
413                 return ret;
414         }
415
416         dev_dbg(rtc->dev, "rtc_read_alarm: "
417                 "buf: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
418                 buf[RTC_SEC], buf[RTC_MIN], buf[RTC_HOUR], buf[RTC_WEEKDAY],
419                 buf[RTC_MONTH], buf[RTC_YEAR], buf[RTC_MONTHDAY]);
420
421         ret = max77663_rtc_reg_to_tm(rtc, buf, &alrm->time);
422         if (ret < 0) {
423                 dev_err(rtc->dev, "rtc_read_alarm: "
424                         "Failed to convert register format into time format\n");
425                 return ret;
426         }
427
428         dev_dbg(rtc->dev, "rtc_read_alarm: "
429                 "tm: %d-%02d-%02d %02d:%02d:%02d, wday=%d\n",
430                 alrm->time.tm_year, alrm->time.tm_mon, alrm->time.tm_mday,
431                 alrm->time.tm_hour, alrm->time.tm_min, alrm->time.tm_sec,
432                 alrm->time.tm_wday);
433
434         if (rtc->irq_mask & RTC_IRQ_ALARM1_MASK)
435                 alrm->enabled = 1;
436         else
437                 alrm->enabled = 0;
438
439         return 0;
440 }
441
442 static int max77663_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
443 {
444         struct max77663_rtc *rtc = dev_get_drvdata(dev);
445         u8 buf[RTC_NR];
446         int ret;
447
448         if (rtc->shutdown_ongoing) {
449                 dev_warn(rtc->dev, "rtc_set_alarm: "
450                          "Device shutdown on-going, skip alarm setting.\n");
451                 return -ESHUTDOWN;
452         }
453         dev_dbg(rtc->dev, "rtc_set_alarm: "
454                 "tm: %d-%02d-%02d %02d:%02d:%02d, wday=%d [%s]\n",
455                 alrm->time.tm_year, alrm->time.tm_mon, alrm->time.tm_mday,
456                 alrm->time.tm_hour, alrm->time.tm_min, alrm->time.tm_sec,
457                 alrm->time.tm_wday, alrm->enabled?"enable":"disable");
458
459         ret = max77663_rtc_tm_to_reg(rtc, buf, &alrm->time, 1);
460         if (ret < 0) {
461                 dev_err(rtc->dev, "rtc_set_alarm: "
462                         "Failed to convert time format into register format\n");
463                 return ret;
464         }
465
466         dev_dbg(rtc->dev, "rtc_set_alarm: "
467                 "buf: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
468                 buf[RTC_SEC], buf[RTC_MIN], buf[RTC_HOUR], buf[RTC_WEEKDAY],
469                 buf[RTC_MONTH], buf[RTC_YEAR], buf[RTC_MONTHDAY]);
470
471         ret = max77663_rtc_write(rtc, MAX77663_RTC_ALARM_SEC1, buf, sizeof(buf),
472                                  1);
473         if (ret < 0) {
474                 dev_err(rtc->dev,
475                         "rtc_set_alarm: Failed to write rtc alarm time\n");
476                 return ret;
477         }
478
479         ret = max77663_rtc_alarm_irq_enable(dev, alrm->enabled);
480         if (ret < 0) {
481                 dev_err(rtc->dev,
482                         "rtc_set_alarm: Failed to enable rtc alarm\n");
483                 return ret;
484         }
485
486         return ret;
487 }
488
489 static const struct rtc_class_ops max77663_rtc_ops = {
490         .read_time = max77663_rtc_read_time,
491         .set_time = max77663_rtc_set_time,
492         .read_alarm = max77663_rtc_read_alarm,
493         .set_alarm = max77663_rtc_set_alarm,
494         .alarm_irq_enable = max77663_rtc_alarm_irq_enable,
495 };
496
497 static int max77663_rtc_preinit(struct max77663_rtc *rtc)
498 {
499         struct device *parent = _to_parent(rtc);
500         u8 val;
501         int ret;
502
503         /* Mask all interrupts */
504         rtc->irq_mask = 0xFF;
505         ret = max77663_rtc_write(rtc, MAX77663_RTC_IRQ_MASK, &rtc->irq_mask, 1,
506                                  0);
507         if (ret < 0) {
508                 dev_err(rtc->dev, "preinit: Failed to set rtc irq mask\n");
509                 return ret;
510         }
511
512         /* Configure Binary mode and 24hour mode */
513         val = HR_MODE_MASK;
514         ret = max77663_rtc_write(rtc, MAX77663_RTC_CTRL, &val, 1, 0);
515         if (ret < 0) {
516                 dev_err(rtc->dev, "preinit: Failed to set rtc control\n");
517                 return ret;
518         }
519
520         /* It should be disabled alarm wakeup to wakeup from sleep
521          * by EN1 input signal */
522         ret = max77663_set_bits(parent, MAX77663_REG_ONOFF_CFG2,
523                                 ONOFF_WK_ALARM1_MASK, 0, 0);
524         if (ret < 0) {
525                 dev_err(rtc->dev, "preinit: Failed to set onoff cfg2\n");
526                 return ret;
527         }
528
529         return 0;
530 }
531
532 static int max77663_rtc_probe(struct platform_device *pdev)
533 {
534         struct max77663_platform_data *parent_pdata =
535                                                 pdev->dev.parent->platform_data;
536         static struct max77663_rtc *rtc;
537         int ret = 0;
538
539         rtc = kzalloc(sizeof(struct max77663_rtc), GFP_KERNEL);
540         if (!rtc) {
541                 dev_err(&pdev->dev, "probe: kzalloc() failed\n");
542                 return -ENOMEM;
543         }
544         rtc->shutdown_ongoing = false;
545         dev_set_drvdata(&pdev->dev, rtc);
546         rtc->dev = &pdev->dev;
547         mutex_init(&rtc->io_lock);
548
549         ret = max77663_rtc_preinit(rtc);
550         if (ret) {
551                 dev_err(&pdev->dev, "probe: Failed to rtc preinit\n");
552                 goto out_kfree;
553         }
554
555         rtc->rtc = rtc_device_register("max77663-rtc", &pdev->dev,
556                                        &max77663_rtc_ops, THIS_MODULE);
557         if (IS_ERR_OR_NULL(rtc->rtc)) {
558                 dev_err(&pdev->dev, "probe: Failed to register rtc\n");
559                 ret = PTR_ERR(rtc->rtc);
560                 goto out_kfree;
561         }
562
563         if (parent_pdata->irq_base < 0)
564                 goto out;
565
566         rtc->irq = parent_pdata->irq_base + MAX77663_IRQ_RTC;
567         ret = request_threaded_irq(rtc->irq, NULL, max77663_rtc_irq,
568                                    IRQF_ONESHOT, "max77663-rtc", rtc);
569         if (ret < 0) {
570                 dev_err(rtc->dev, "probe: Failed to request irq %d\n",
571                         rtc->irq);
572                 rtc->irq = -1;
573         } else {
574                 device_init_wakeup(rtc->dev, 1);
575                 enable_irq_wake(rtc->irq);
576         }
577
578         return 0;
579
580 out_kfree:
581         mutex_destroy(&rtc->io_lock);
582         kfree(rtc->rtc);
583 out:
584         return ret;
585 }
586
587 static int __devexit max77663_rtc_remove(struct platform_device *pdev)
588 {
589         struct max77663_rtc *rtc = dev_get_drvdata(&pdev->dev);
590
591         if (rtc->irq != -1)
592                 free_irq(rtc->irq, rtc);
593
594         rtc_device_unregister(rtc->rtc);
595         mutex_destroy(&rtc->io_lock);
596         kfree(rtc);
597
598         return 0;
599 }
600
601 static void max77663_rtc_shutdown(struct platform_device *pdev)
602 {
603         struct max77663_rtc *rtc = dev_get_drvdata(&pdev->dev);
604         u8 buf[RTC_NR] = { 0x0, 0x0, 0x0, 0x1, 0x1, 0x0, 0x1 };
605
606         rtc->shutdown_ongoing = true;
607         dev_info(rtc->dev, "rtc_shutdown: clean alarm\n");
608         max77663_rtc_write(rtc, MAX77663_RTC_ALARM_SEC1, buf, sizeof(buf), 1);
609         max77663_rtc_alarm_irq_enable(&pdev->dev, 0);
610 }
611
612 static struct platform_driver max77663_rtc_driver = {
613         .probe = max77663_rtc_probe,
614         .remove = __devexit_p(max77663_rtc_remove),
615         .driver = {
616                    .name = "max77663-rtc",
617                    .owner = THIS_MODULE,
618         },
619         .shutdown = max77663_rtc_shutdown,
620 };
621
622 static int __init max77663_rtc_init(void)
623 {
624         return platform_driver_register(&max77663_rtc_driver);
625 }
626 module_init(max77663_rtc_init);
627
628 static void __exit max77663_rtc_exit(void)
629 {
630         platform_driver_unregister(&max77663_rtc_driver);
631 }
632 module_exit(max77663_rtc_exit);
633
634 MODULE_DESCRIPTION("max77663 RTC driver");
635 MODULE_LICENSE("GPL v2");
636 MODULE_VERSION("1.0");