rtc: Use dev_get_drvdata() · tjh.dev/kernel@527bd75

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

rtc: Use dev_get_drvdata()

Using dev_get_drvdata directly.

Cc: Alessandro Zummo <a.zummo@towertech.it>
Cc: Alexandre Belloni <alexandre.belloni@bootlin.com>
Cc: linux-rtc@vger.kernel.org
Signed-off-by: Kefeng Wang <wangkefeng.wang@huawei.com>
Signed-off-by: Alexandre Belloni <alexandre.belloni@bootlin.com>

authored by

Kefeng Wang and committed by

Alexandre Belloni 7 years ago 527bd754 c8889bb6

+21 -38

6 changed files

expand all

drivers

rtc

rtc-hid-sensor-time.c

rtc-pxa.c

rtc-rk808.c

rtc-tx4939.c

rtc-wm831x.c

rtc-wm8350.c

+1 -2

drivers/rtc/rtc-hid-sensor-time.c

··· 205 205 static int hid_rtc_read_time(struct device *dev, struct rtc_time *tm) 206 206 { 207 207 unsigned long flags; 208 - struct hid_time_state *time_state = 209 - platform_get_drvdata(to_platform_device(dev)); 208 + struct hid_time_state *time_state = dev_get_drvdata(dev); 210 209 int ret; 211 210 212 211 reinit_completion(&time_state->comp_last_time);

+1 -2

drivers/rtc/rtc-pxa.c

··· 145 145 146 146 static irqreturn_t pxa_rtc_irq(int irq, void *dev_id) 147 147 { 148 - struct platform_device *pdev = to_platform_device(dev_id); 149 - struct pxa_rtc *pxa_rtc = platform_get_drvdata(pdev); 148 + struct pxa_rtc *pxa_rtc = dev_get_drvdata(dev_id); 150 149 u32 rtsr; 151 150 unsigned long events = 0; 152 151

+2 -4

drivers/rtc/rtc-rk808.c

··· 336 336 /* Turn off the alarm if it should not be a wake source. */ 337 337 static int rk808_rtc_suspend(struct device *dev) 338 338 { 339 - struct platform_device *pdev = to_platform_device(dev); 340 - struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev); 339 + struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 341 340 342 341 if (device_may_wakeup(dev)) 343 342 enable_irq_wake(rk808_rtc->irq); ··· 349 350 */ 350 351 static int rk808_rtc_resume(struct device *dev) 351 352 { 352 - struct platform_device *pdev = to_platform_device(dev); 353 - struct rk808_rtc *rk808_rtc = dev_get_drvdata(&pdev->dev); 353 + struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); 354 354 355 355 if (device_may_wakeup(dev)) 356 356 disable_irq_wake(rk808_rtc->irq);

+6 -11

drivers/rtc/rtc-tx4939.c

··· 42 42 spinlock_t lock; 43 43 }; 44 44 45 - static struct tx4939rtc_plat_data *get_tx4939rtc_plat_data(struct device *dev) 46 - { 47 - return platform_get_drvdata(to_platform_device(dev)); 48 - } 49 - 50 45 static int tx4939_rtc_cmd(struct tx4939_rtc_reg __iomem *rtcreg, int cmd) 51 46 { 52 47 int i = 0; ··· 59 64 60 65 static int tx4939_rtc_set_time(struct device *dev, struct rtc_time *tm) 61 66 { 62 - struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev); 67 + struct tx4939rtc_plat_data *pdata = dev_get_drvdata(dev); 63 68 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg; 64 69 unsigned long secs = rtc_tm_to_time64(tm); 65 70 int i, ret; ··· 84 89 85 90 static int tx4939_rtc_read_time(struct device *dev, struct rtc_time *tm) 86 91 { 87 - struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev); 92 + struct tx4939rtc_plat_data *pdata = dev_get_drvdata(dev); 88 93 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg; 89 94 int i, ret; 90 95 unsigned long sec; ··· 110 115 111 116 static int tx4939_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 112 117 { 113 - struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev); 118 + struct tx4939rtc_plat_data *pdata = dev_get_drvdata(dev); 114 119 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg; 115 120 int i, ret; 116 121 unsigned long sec; ··· 135 140 136 141 static int tx4939_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 137 142 { 138 - struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev); 143 + struct tx4939rtc_plat_data *pdata = dev_get_drvdata(dev); 139 144 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg; 140 145 int i, ret; 141 146 unsigned long sec; ··· 165 170 166 171 static int tx4939_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 167 172 { 168 - struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev); 173 + struct tx4939rtc_plat_data *pdata = dev_get_drvdata(dev); 169 174 170 175 spin_lock_irq(&pdata->lock); 171 176 tx4939_rtc_cmd(pdata->rtcreg, ··· 177 182 178 183 static irqreturn_t tx4939_rtc_interrupt(int irq, void *dev_id) 179 184 { 180 - struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev_id); 185 + struct tx4939rtc_plat_data *pdata = dev_get_drvdata(dev_id); 181 186 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg; 182 187 unsigned long events = RTC_IRQF; 183 188

+7 -11

drivers/rtc/rtc-wm831x.c

··· 346 346 /* Turn off the alarm if it should not be a wake source. */ 347 347 static int wm831x_rtc_suspend(struct device *dev) 348 348 { 349 - struct platform_device *pdev = to_platform_device(dev); 350 - struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev); 349 + struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev); 351 350 int ret, enable; 352 351 353 - if (wm831x_rtc->alarm_enabled && device_may_wakeup(&pdev->dev)) 352 + if (wm831x_rtc->alarm_enabled && device_may_wakeup(dev)) 354 353 enable = WM831X_RTC_ALM_ENA; 355 354 else 356 355 enable = 0; ··· 357 358 ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL, 358 359 WM831X_RTC_ALM_ENA, enable); 359 360 if (ret != 0) 360 - dev_err(&pdev->dev, "Failed to update RTC alarm: %d\n", ret); 361 + dev_err(dev, "Failed to update RTC alarm: %d\n", ret); 361 362 362 363 return 0; 363 364 } ··· 367 368 */ 368 369 static int wm831x_rtc_resume(struct device *dev) 369 370 { 370 - struct platform_device *pdev = to_platform_device(dev); 371 - struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev); 371 + struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev); 372 372 int ret; 373 373 374 374 if (wm831x_rtc->alarm_enabled) { 375 375 ret = wm831x_rtc_start_alarm(wm831x_rtc); 376 376 if (ret != 0) 377 - dev_err(&pdev->dev, 378 - "Failed to restart RTC alarm: %d\n", ret); 377 + dev_err(dev, "Failed to restart RTC alarm: %d\n", ret); 379 378 } 380 379 381 380 return 0; ··· 382 385 /* Unconditionally disable the alarm */ 383 386 static int wm831x_rtc_freeze(struct device *dev) 384 387 { 385 - struct platform_device *pdev = to_platform_device(dev); 386 - struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev); 388 + struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev); 387 389 int ret; 388 390 389 391 ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL, 390 392 WM831X_RTC_ALM_ENA, 0); 391 393 if (ret != 0) 392 - dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", ret); 394 + dev_err(dev, "Failed to stop RTC alarm: %d\n", ret); 393 395 394 396 return 0; 395 397 }

+4 -8

drivers/rtc/rtc-wm8350.c

··· 340 340 #ifdef CONFIG_PM_SLEEP 341 341 static int wm8350_rtc_suspend(struct device *dev) 342 342 { 343 - struct platform_device *pdev = to_platform_device(dev); 344 - struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev); 343 + struct wm8350 *wm8350 = dev_get_drvdata(dev); 345 344 int ret = 0; 346 345 u16 reg; 347 346 ··· 350 351 reg & WM8350_RTC_ALMSTS) { 351 352 ret = wm8350_rtc_stop_alarm(wm8350); 352 353 if (ret != 0) 353 - dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", 354 - ret); 354 + dev_err(dev, "Failed to stop RTC alarm: %d\n", ret); 355 355 } 356 356 357 357 return ret; ··· 358 360 359 361 static int wm8350_rtc_resume(struct device *dev) 360 362 { 361 - struct platform_device *pdev = to_platform_device(dev); 362 - struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev); 363 + struct wm8350 *wm8350 = dev_get_drvdata(dev); 363 364 int ret; 364 365 365 366 if (wm8350->rtc.alarm_enabled) { 366 367 ret = wm8350_rtc_start_alarm(wm8350); 367 368 if (ret != 0) 368 - dev_err(&pdev->dev, 369 - "Failed to restart RTC alarm: %d\n", ret); 369 + dev_err(dev, "Failed to restart RTC alarm: %d\n", ret); 370 370 } 371 371 372 372 return 0;