Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit e1c2f989e691e8e124b57fd7ba4e15e7873b91e5

Authored by Jingoo Han
Committed by Linus Torvalds
1 parent 3a02893f4e
Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch imx_3.14.28_1.0.0_ga

rtc: rtc-rc5t583: use platform_{get,set}_drvdata() 

Use the wrapper functions for getting and setting the driver data using
platform_device instead of using dev_{get,set}_drvdata() with &pdev->dev,
so we can directly pass a struct platform_device.

Signed-off-by: Jingoo Han <jg1.han@samsung.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

drivers/rtc/rtc-rc5t583.c
Diff comments   View file @ e1c2f98
1 /* 1 /*
2 * rtc-rc5t583.c -- RICOH RC5T583 Real Time Clock 2 * rtc-rc5t583.c -- RICOH RC5T583 Real Time Clock
3 * 3 *
4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved. 4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
5 * Author: Venu Byravarasu <vbyravarasu@nvidia.com> 5 * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
6 * 6 *
7 * This program is free software; you can redistribute it and/or modify it 7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License, 8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation. 9 * version 2, as published by the Free Software Foundation.
10 * 10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT 11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details. 14 * more details.
15 * 15 *
16 * You should have received a copy of the GNU General Public License 16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>. */ 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 18
19 #include <linux/kernel.h> 19 #include <linux/kernel.h>
20 #include <linux/errno.h> 20 #include <linux/errno.h>
21 #include <linux/init.h> 21 #include <linux/init.h>
22 #include <linux/module.h> 22 #include <linux/module.h>
23 #include <linux/types.h> 23 #include <linux/types.h>
24 #include <linux/rtc.h> 24 #include <linux/rtc.h>
25 #include <linux/bcd.h> 25 #include <linux/bcd.h>
26 #include <linux/platform_device.h> 26 #include <linux/platform_device.h>
27 #include <linux/interrupt.h> 27 #include <linux/interrupt.h>
28 #include <linux/mfd/rc5t583.h> 28 #include <linux/mfd/rc5t583.h>
29 29
30 struct rc5t583_rtc { 30 struct rc5t583_rtc {
31 struct rtc_device *rtc; 31 struct rtc_device *rtc;
32 /* To store the list of enabled interrupts, during system suspend */ 32 /* To store the list of enabled interrupts, during system suspend */
33 u32 irqen; 33 u32 irqen;
34 }; 34 };
35 35
36 /* Total number of RTC registers needed to set time*/ 36 /* Total number of RTC registers needed to set time*/
37 #define NUM_TIME_REGS (RC5T583_RTC_YEAR - RC5T583_RTC_SEC + 1) 37 #define NUM_TIME_REGS (RC5T583_RTC_YEAR - RC5T583_RTC_SEC + 1)
38 38
39 /* Total number of RTC registers needed to set Y-Alarm*/ 39 /* Total number of RTC registers needed to set Y-Alarm*/
40 #define NUM_YAL_REGS (RC5T583_RTC_AY_YEAR - RC5T583_RTC_AY_MIN + 1) 40 #define NUM_YAL_REGS (RC5T583_RTC_AY_YEAR - RC5T583_RTC_AY_MIN + 1)
41 41
42 /* Set Y-Alarm interrupt */ 42 /* Set Y-Alarm interrupt */
43 #define SET_YAL BIT(5) 43 #define SET_YAL BIT(5)
44 44
45 /* Get Y-Alarm interrupt status*/ 45 /* Get Y-Alarm interrupt status*/
46 #define GET_YAL_STATUS BIT(3) 46 #define GET_YAL_STATUS BIT(3)
47 47
48 static int rc5t583_rtc_alarm_irq_enable(struct device *dev, unsigned enabled) 48 static int rc5t583_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
49 { 49 {
50 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 50 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
51 u8 val; 51 u8 val;
52 52
53 /* Set Y-Alarm, based on 'enabled' */ 53 /* Set Y-Alarm, based on 'enabled' */
54 val = enabled ? SET_YAL : 0; 54 val = enabled ? SET_YAL : 0;
55 55
56 return regmap_update_bits(rc5t583->regmap, RC5T583_RTC_CTL1, SET_YAL, 56 return regmap_update_bits(rc5t583->regmap, RC5T583_RTC_CTL1, SET_YAL,
57 val); 57 val);
58 } 58 }
59 59
60 /* 60 /*
61 * Gets current rc5t583 RTC time and date parameters. 61 * Gets current rc5t583 RTC time and date parameters.
62 * 62 *
63 * The RTC's time/alarm representation is not what gmtime(3) requires 63 * The RTC's time/alarm representation is not what gmtime(3) requires
64 * Linux to use: 64 * Linux to use:
65 * 65 *
66 * - Months are 1..12 vs Linux 0-11 66 * - Months are 1..12 vs Linux 0-11
67 * - Years are 0..99 vs Linux 1900..N (we assume 21st century) 67 * - Years are 0..99 vs Linux 1900..N (we assume 21st century)
68 */ 68 */
69 static int rc5t583_rtc_read_time(struct device *dev, struct rtc_time *tm) 69 static int rc5t583_rtc_read_time(struct device *dev, struct rtc_time *tm)
70 { 70 {
71 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 71 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
72 u8 rtc_data[NUM_TIME_REGS]; 72 u8 rtc_data[NUM_TIME_REGS];
73 int ret; 73 int ret;
74 74
75 ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data, 75 ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data,
76 NUM_TIME_REGS); 76 NUM_TIME_REGS);
77 if (ret < 0) { 77 if (ret < 0) {
78 dev_err(dev, "RTC read time failed with err:%d\n", ret); 78 dev_err(dev, "RTC read time failed with err:%d\n", ret);
79 return ret; 79 return ret;
80 } 80 }
81 81
82 tm->tm_sec = bcd2bin(rtc_data[0]); 82 tm->tm_sec = bcd2bin(rtc_data[0]);
83 tm->tm_min = bcd2bin(rtc_data[1]); 83 tm->tm_min = bcd2bin(rtc_data[1]);
84 tm->tm_hour = bcd2bin(rtc_data[2]); 84 tm->tm_hour = bcd2bin(rtc_data[2]);
85 tm->tm_wday = bcd2bin(rtc_data[3]); 85 tm->tm_wday = bcd2bin(rtc_data[3]);
86 tm->tm_mday = bcd2bin(rtc_data[4]); 86 tm->tm_mday = bcd2bin(rtc_data[4]);
87 tm->tm_mon = bcd2bin(rtc_data[5]) - 1; 87 tm->tm_mon = bcd2bin(rtc_data[5]) - 1;
88 tm->tm_year = bcd2bin(rtc_data[6]) + 100; 88 tm->tm_year = bcd2bin(rtc_data[6]) + 100;
89 89
90 return ret; 90 return ret;
91 } 91 }
92 92
93 static int rc5t583_rtc_set_time(struct device *dev, struct rtc_time *tm) 93 static int rc5t583_rtc_set_time(struct device *dev, struct rtc_time *tm)
94 { 94 {
95 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 95 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
96 unsigned char rtc_data[NUM_TIME_REGS]; 96 unsigned char rtc_data[NUM_TIME_REGS];
97 int ret; 97 int ret;
98 98
99 rtc_data[0] = bin2bcd(tm->tm_sec); 99 rtc_data[0] = bin2bcd(tm->tm_sec);
100 rtc_data[1] = bin2bcd(tm->tm_min); 100 rtc_data[1] = bin2bcd(tm->tm_min);
101 rtc_data[2] = bin2bcd(tm->tm_hour); 101 rtc_data[2] = bin2bcd(tm->tm_hour);
102 rtc_data[3] = bin2bcd(tm->tm_wday); 102 rtc_data[3] = bin2bcd(tm->tm_wday);
103 rtc_data[4] = bin2bcd(tm->tm_mday); 103 rtc_data[4] = bin2bcd(tm->tm_mday);
104 rtc_data[5] = bin2bcd(tm->tm_mon + 1); 104 rtc_data[5] = bin2bcd(tm->tm_mon + 1);
105 rtc_data[6] = bin2bcd(tm->tm_year - 100); 105 rtc_data[6] = bin2bcd(tm->tm_year - 100);
106 106
107 ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data, 107 ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data,
108 NUM_TIME_REGS); 108 NUM_TIME_REGS);
109 if (ret < 0) { 109 if (ret < 0) {
110 dev_err(dev, "RTC set time failed with error %d\n", ret); 110 dev_err(dev, "RTC set time failed with error %d\n", ret);
111 return ret; 111 return ret;
112 } 112 }
113 113
114 return ret; 114 return ret;
115 } 115 }
116 116
117 static int rc5t583_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 117 static int rc5t583_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
118 { 118 {
119 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 119 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
120 unsigned char alarm_data[NUM_YAL_REGS]; 120 unsigned char alarm_data[NUM_YAL_REGS];
121 u32 interrupt_enable; 121 u32 interrupt_enable;
122 int ret; 122 int ret;
123 123
124 ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data, 124 ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data,
125 NUM_YAL_REGS); 125 NUM_YAL_REGS);
126 if (ret < 0) { 126 if (ret < 0) {
127 dev_err(dev, "rtc_read_alarm error %d\n", ret); 127 dev_err(dev, "rtc_read_alarm error %d\n", ret);
128 return ret; 128 return ret;
129 } 129 }
130 130
131 alm->time.tm_min = bcd2bin(alarm_data[0]); 131 alm->time.tm_min = bcd2bin(alarm_data[0]);
132 alm->time.tm_hour = bcd2bin(alarm_data[1]); 132 alm->time.tm_hour = bcd2bin(alarm_data[1]);
133 alm->time.tm_mday = bcd2bin(alarm_data[2]); 133 alm->time.tm_mday = bcd2bin(alarm_data[2]);
134 alm->time.tm_mon = bcd2bin(alarm_data[3]) - 1; 134 alm->time.tm_mon = bcd2bin(alarm_data[3]) - 1;
135 alm->time.tm_year = bcd2bin(alarm_data[4]) + 100; 135 alm->time.tm_year = bcd2bin(alarm_data[4]) + 100;
136 136
137 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, &interrupt_enable); 137 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, &interrupt_enable);
138 if (ret < 0) 138 if (ret < 0)
139 return ret; 139 return ret;
140 140
141 /* check if YALE is set */ 141 /* check if YALE is set */
142 if (interrupt_enable & SET_YAL) 142 if (interrupt_enable & SET_YAL)
143 alm->enabled = 1; 143 alm->enabled = 1;
144 144
145 return ret; 145 return ret;
146 } 146 }
147 147
148 static int rc5t583_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 148 static int rc5t583_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
149 { 149 {
150 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 150 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
151 unsigned char alarm_data[NUM_YAL_REGS]; 151 unsigned char alarm_data[NUM_YAL_REGS];
152 int ret; 152 int ret;
153 153
154 ret = rc5t583_rtc_alarm_irq_enable(dev, 0); 154 ret = rc5t583_rtc_alarm_irq_enable(dev, 0);
155 if (ret) 155 if (ret)
156 return ret; 156 return ret;
157 157
158 alarm_data[0] = bin2bcd(alm->time.tm_min); 158 alarm_data[0] = bin2bcd(alm->time.tm_min);
159 alarm_data[1] = bin2bcd(alm->time.tm_hour); 159 alarm_data[1] = bin2bcd(alm->time.tm_hour);
160 alarm_data[2] = bin2bcd(alm->time.tm_mday); 160 alarm_data[2] = bin2bcd(alm->time.tm_mday);
161 alarm_data[3] = bin2bcd(alm->time.tm_mon + 1); 161 alarm_data[3] = bin2bcd(alm->time.tm_mon + 1);
162 alarm_data[4] = bin2bcd(alm->time.tm_year - 100); 162 alarm_data[4] = bin2bcd(alm->time.tm_year - 100);
163 163
164 ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data, 164 ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data,
165 NUM_YAL_REGS); 165 NUM_YAL_REGS);
166 if (ret) { 166 if (ret) {
167 dev_err(dev, "rtc_set_alarm error %d\n", ret); 167 dev_err(dev, "rtc_set_alarm error %d\n", ret);
168 return ret; 168 return ret;
169 } 169 }
170 170
171 if (alm->enabled) 171 if (alm->enabled)
172 ret = rc5t583_rtc_alarm_irq_enable(dev, 1); 172 ret = rc5t583_rtc_alarm_irq_enable(dev, 1);
173 173
174 return ret; 174 return ret;
175 } 175 }
176 176
177 static irqreturn_t rc5t583_rtc_interrupt(int irq, void *rtc) 177 static irqreturn_t rc5t583_rtc_interrupt(int irq, void *rtc)
178 { 178 {
179 struct device *dev = rtc; 179 struct device *dev = rtc;
180 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 180 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
181 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev); 181 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
182 unsigned long events = 0; 182 unsigned long events = 0;
183 int ret; 183 int ret;
184 u32 rtc_reg; 184 u32 rtc_reg;
185 185
186 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL2, &rtc_reg); 186 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL2, &rtc_reg);
187 if (ret < 0) 187 if (ret < 0)
188 return IRQ_NONE; 188 return IRQ_NONE;
189 189
190 if (rtc_reg & GET_YAL_STATUS) { 190 if (rtc_reg & GET_YAL_STATUS) {
191 events = RTC_IRQF | RTC_AF; 191 events = RTC_IRQF | RTC_AF;
192 /* clear pending Y-alarm interrupt bit */ 192 /* clear pending Y-alarm interrupt bit */
193 rtc_reg &= ~GET_YAL_STATUS; 193 rtc_reg &= ~GET_YAL_STATUS;
194 } 194 }
195 195
196 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, rtc_reg); 196 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, rtc_reg);
197 if (ret) 197 if (ret)
198 return IRQ_NONE; 198 return IRQ_NONE;
199 199
200 /* Notify RTC core on event */ 200 /* Notify RTC core on event */
201 rtc_update_irq(rc5t583_rtc->rtc, 1, events); 201 rtc_update_irq(rc5t583_rtc->rtc, 1, events);
202 202
203 return IRQ_HANDLED; 203 return IRQ_HANDLED;
204 } 204 }
205 205
206 static const struct rtc_class_ops rc5t583_rtc_ops = { 206 static const struct rtc_class_ops rc5t583_rtc_ops = {
207 .read_time = rc5t583_rtc_read_time, 207 .read_time = rc5t583_rtc_read_time,
208 .set_time = rc5t583_rtc_set_time, 208 .set_time = rc5t583_rtc_set_time,
209 .read_alarm = rc5t583_rtc_read_alarm, 209 .read_alarm = rc5t583_rtc_read_alarm,
210 .set_alarm = rc5t583_rtc_set_alarm, 210 .set_alarm = rc5t583_rtc_set_alarm,
211 .alarm_irq_enable = rc5t583_rtc_alarm_irq_enable, 211 .alarm_irq_enable = rc5t583_rtc_alarm_irq_enable,
212 }; 212 };
213 213
214 static int rc5t583_rtc_probe(struct platform_device *pdev) 214 static int rc5t583_rtc_probe(struct platform_device *pdev)
215 { 215 {
216 struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent); 216 struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent);
217 struct rc5t583_rtc *ricoh_rtc; 217 struct rc5t583_rtc *ricoh_rtc;
218 struct rc5t583_platform_data *pmic_plat_data; 218 struct rc5t583_platform_data *pmic_plat_data;
219 int ret; 219 int ret;
220 int irq; 220 int irq;
221 221
222 ricoh_rtc = devm_kzalloc(&pdev->dev, sizeof(struct rc5t583_rtc), 222 ricoh_rtc = devm_kzalloc(&pdev->dev, sizeof(struct rc5t583_rtc),
223 GFP_KERNEL); 223 GFP_KERNEL);
224 if (!ricoh_rtc) 224 if (!ricoh_rtc)
225 return -ENOMEM; 225 return -ENOMEM;
226 226
227 platform_set_drvdata(pdev, ricoh_rtc); 227 platform_set_drvdata(pdev, ricoh_rtc);
228 228
229 /* Clear pending interrupts */ 229 /* Clear pending interrupts */
230 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, 0); 230 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, 0);
231 if (ret < 0) 231 if (ret < 0)
232 return ret; 232 return ret;
233 233
234 /* clear RTC Adjust register */ 234 /* clear RTC Adjust register */
235 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_ADJ, 0); 235 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_ADJ, 0);
236 if (ret < 0) { 236 if (ret < 0) {
237 dev_err(&pdev->dev, "unable to program rtc_adjust reg\n"); 237 dev_err(&pdev->dev, "unable to program rtc_adjust reg\n");
238 return -EBUSY; 238 return -EBUSY;
239 } 239 }
240 240
241 pmic_plat_data = dev_get_platdata(rc5t583->dev); 241 pmic_plat_data = dev_get_platdata(rc5t583->dev);
242 irq = pmic_plat_data->irq_base; 242 irq = pmic_plat_data->irq_base;
243 if (irq <= 0) { 243 if (irq <= 0) {
244 dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n", 244 dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
245 irq); 245 irq);
246 return ret; 246 return ret;
247 } 247 }
248 248
249 irq += RC5T583_IRQ_YALE; 249 irq += RC5T583_IRQ_YALE;
250 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 250 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
251 rc5t583_rtc_interrupt, IRQF_TRIGGER_LOW, 251 rc5t583_rtc_interrupt, IRQF_TRIGGER_LOW,
252 "rtc-rc5t583", &pdev->dev); 252 "rtc-rc5t583", &pdev->dev);
253 if (ret < 0) { 253 if (ret < 0) {
254 dev_err(&pdev->dev, "IRQ is not free.\n"); 254 dev_err(&pdev->dev, "IRQ is not free.\n");
255 return ret; 255 return ret;
256 } 256 }
257 device_init_wakeup(&pdev->dev, 1); 257 device_init_wakeup(&pdev->dev, 1);
258 258
259 ricoh_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, 259 ricoh_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
260 &rc5t583_rtc_ops, THIS_MODULE); 260 &rc5t583_rtc_ops, THIS_MODULE);
261 if (IS_ERR(ricoh_rtc->rtc)) { 261 if (IS_ERR(ricoh_rtc->rtc)) {
262 ret = PTR_ERR(ricoh_rtc->rtc); 262 ret = PTR_ERR(ricoh_rtc->rtc);
263 dev_err(&pdev->dev, "RTC device register: err %d\n", ret); 263 dev_err(&pdev->dev, "RTC device register: err %d\n", ret);
264 return ret; 264 return ret;
265 } 265 }
266 266
267 return 0; 267 return 0;
268 } 268 }
269 269
270 /* 270 /*
271 * Disable rc5t583 RTC interrupts. 271 * Disable rc5t583 RTC interrupts.
272 * Sets status flag to free. 272 * Sets status flag to free.
273 */ 273 */
274 static int rc5t583_rtc_remove(struct platform_device *pdev) 274 static int rc5t583_rtc_remove(struct platform_device *pdev)
275 { 275 {
276 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(&pdev->dev); 276 struct rc5t583_rtc *rc5t583_rtc = platform_get_drvdata(pdev);
277 277
278 rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0); 278 rc5t583_rtc_alarm_irq_enable(&rc5t583_rtc->rtc->dev, 0);
279 return 0; 279 return 0;
280 } 280 }
281 281
282 #ifdef CONFIG_PM_SLEEP 282 #ifdef CONFIG_PM_SLEEP
283 static int rc5t583_rtc_suspend(struct device *dev) 283 static int rc5t583_rtc_suspend(struct device *dev)
284 { 284 {
285 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 285 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
286 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev); 286 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
287 int ret; 287 int ret;
288 288
289 /* Store current list of enabled interrupts*/ 289 /* Store current list of enabled interrupts*/
290 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, 290 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1,
291 &rc5t583_rtc->irqen); 291 &rc5t583_rtc->irqen);
292 return ret; 292 return ret;
293 } 293 }
294 294
295 static int rc5t583_rtc_resume(struct device *dev) 295 static int rc5t583_rtc_resume(struct device *dev)
296 { 296 {
297 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); 297 struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent);
298 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev); 298 struct rc5t583_rtc *rc5t583_rtc = dev_get_drvdata(dev);
299 299
300 /* Restore list of enabled interrupts before suspend */ 300 /* Restore list of enabled interrupts before suspend */
301 return regmap_write(rc5t583->regmap, RC5T583_RTC_CTL1, 301 return regmap_write(rc5t583->regmap, RC5T583_RTC_CTL1,
302 rc5t583_rtc->irqen); 302 rc5t583_rtc->irqen);
303 } 303 }
304 #endif 304 #endif
305 305
306 static SIMPLE_DEV_PM_OPS(rc5t583_rtc_pm_ops, rc5t583_rtc_suspend, 306 static SIMPLE_DEV_PM_OPS(rc5t583_rtc_pm_ops, rc5t583_rtc_suspend,
307 rc5t583_rtc_resume); 307 rc5t583_rtc_resume);
308 308
309 static struct platform_driver rc5t583_rtc_driver = { 309 static struct platform_driver rc5t583_rtc_driver = {
310 .probe = rc5t583_rtc_probe, 310 .probe = rc5t583_rtc_probe,
311 .remove = rc5t583_rtc_remove, 311 .remove = rc5t583_rtc_remove,
312 .driver = { 312 .driver = {
313 .owner = THIS_MODULE, 313 .owner = THIS_MODULE,
314 .name = "rtc-rc5t583", 314 .name = "rtc-rc5t583",
315 .pm = &rc5t583_rtc_pm_ops, 315 .pm = &rc5t583_rtc_pm_ops,
316 }, 316 },
317 }; 317 };
318 318
319 module_platform_driver(rc5t583_rtc_driver); 319 module_platform_driver(rc5t583_rtc_driver);
320 MODULE_ALIAS("platform:rtc-rc5t583"); 320 MODULE_ALIAS("platform:rtc-rc5t583");
321 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>"); 321 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
322 MODULE_LICENSE("GPL v2"); 322 MODULE_LICENSE("GPL v2");
323 323