1 /* drivers/rtc/rtc-s3c.c 2 * 3 * Copyright (c) 2010 Samsung Electronics Co., Ltd. 4 * http://www.samsung.com/ 5 * 6 * Copyright (c) 2004,2006 Simtec Electronics 7 * Ben Dooks, <ben@simtec.co.uk> 8 * http://armlinux.simtec.co.uk/ 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 * S3C2410/S3C2440/S3C24XX Internal RTC Driver 15 */ 16 17 #include <linux/module.h> 18 #include <linux/fs.h> 19 #include <linux/string.h> 20 #include <linux/init.h> 21 #include <linux/platform_device.h> 22 #include <linux/interrupt.h> 23 #include <linux/rtc.h> 24 #include <linux/bcd.h> 25 #include <linux/clk.h> 26 #include <linux/log2.h> 27 #include <linux/slab.h> 28 29 #include <mach/hardware.h> 30 #include <asm/uaccess.h> 31 #include <asm/io.h> 32 #include <asm/irq.h> 33 #include <plat/regs-rtc.h> 34 35 enum s3c_cpu_type { 36 TYPE_S3C2410, 37 TYPE_S3C64XX, 38 }; 39 40 /* I have yet to find an S3C implementation with more than one 41 * of these rtc blocks in */ 42 43 static struct resource *s3c_rtc_mem; 44 45 static struct clk *rtc_clk; 46 static void __iomem *s3c_rtc_base; 47 static int s3c_rtc_alarmno = NO_IRQ; 48 static int s3c_rtc_tickno = NO_IRQ; 49 static enum s3c_cpu_type s3c_rtc_cpu_type; 50 51 static DEFINE_SPINLOCK(s3c_rtc_pie_lock); 52 53 /* IRQ Handlers */ 54 55 static irqreturn_t s3c_rtc_alarmirq(int irq, void *id) 56 { 57 struct rtc_device *rdev = id; 58 59 rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF); 60 61 if (s3c_rtc_cpu_type == TYPE_S3C64XX) 62 writeb(S3C2410_INTP_ALM, s3c_rtc_base + S3C2410_INTP); 63 64 return IRQ_HANDLED; 65 } 66 67 static irqreturn_t s3c_rtc_tickirq(int irq, void *id) 68 { 69 struct rtc_device *rdev = id; 70 71 rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF); 72 73 if (s3c_rtc_cpu_type == TYPE_S3C64XX) 74 writeb(S3C2410_INTP_TIC, s3c_rtc_base + S3C2410_INTP); 75 76 return IRQ_HANDLED; 77 } 78 79 /* Update control registers */ 80 static void s3c_rtc_setaie(int to) 81 { 82 unsigned int tmp; 83 84 pr_debug("%s: aie=%d\n", __func__, to); 85 86 tmp = readb(s3c_rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN; 87 88 if (to) 89 tmp |= S3C2410_RTCALM_ALMEN; 90 91 writeb(tmp, s3c_rtc_base + S3C2410_RTCALM); 92 } 93 94 static int s3c_rtc_setpie(struct device *dev, int enabled) 95 { 96 unsigned int tmp; 97 98 pr_debug("%s: pie=%d\n", __func__, enabled); 99 100 spin_lock_irq(&s3c_rtc_pie_lock); 101 102 if (s3c_rtc_cpu_type == TYPE_S3C64XX) { 103 tmp = readw(s3c_rtc_base + S3C2410_RTCCON); 104 tmp &= ~S3C64XX_RTCCON_TICEN; 105 106 if (enabled) 107 tmp |= S3C64XX_RTCCON_TICEN; 108 109 writew(tmp, s3c_rtc_base + S3C2410_RTCCON); 110 } else { 111 tmp = readb(s3c_rtc_base + S3C2410_TICNT); 112 tmp &= ~S3C2410_TICNT_ENABLE; 113 114 if (enabled) 115 tmp |= S3C2410_TICNT_ENABLE; 116 117 writeb(tmp, s3c_rtc_base + S3C2410_TICNT); 118 } 119 120 spin_unlock_irq(&s3c_rtc_pie_lock); 121 122 return 0; 123 } 124 125 static int s3c_rtc_setfreq(struct device *dev, int freq) 126 { 127 struct platform_device *pdev = to_platform_device(dev); 128 struct rtc_device *rtc_dev = platform_get_drvdata(pdev); 129 unsigned int tmp = 0; 130 131 if (!is_power_of_2(freq)) 132 return -EINVAL; 133 134 spin_lock_irq(&s3c_rtc_pie_lock); 135 136 if (s3c_rtc_cpu_type == TYPE_S3C2410) { 137 tmp = readb(s3c_rtc_base + S3C2410_TICNT); 138 tmp &= S3C2410_TICNT_ENABLE; 139 } 140 141 tmp |= (rtc_dev->max_user_freq / freq)-1; 142 143 writel(tmp, s3c_rtc_base + S3C2410_TICNT); 144 spin_unlock_irq(&s3c_rtc_pie_lock); 145 146 return 0; 147 } 148 149 /* Time read/write */ 150 151 static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm) 152 { 153 unsigned int have_retried = 0; 154 void __iomem *base = s3c_rtc_base; 155 156 retry_get_time: 157 rtc_tm->tm_min = readb(base + S3C2410_RTCMIN); 158 rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR); 159 rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE); 160 rtc_tm->tm_mon = readb(base + S3C2410_RTCMON); 161 rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR); 162 rtc_tm->tm_sec = readb(base + S3C2410_RTCSEC); 163 164 /* the only way to work out wether the system was mid-update 165 * when we read it is to check the second counter, and if it 166 * is zero, then we re-try the entire read 167 */ 168 169 if (rtc_tm->tm_sec == 0 && !have_retried) { 170 have_retried = 1; 171 goto retry_get_time; 172 } 173 174 pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n", 175 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday, 176 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec); 177 178 rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec); 179 rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min); 180 rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour); 181 rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday); 182 rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon); 183 rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year); 184 185 rtc_tm->tm_year += 100; 186 rtc_tm->tm_mon -= 1; 187 188 return rtc_valid_tm(rtc_tm); 189 } 190 191 static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm) 192 { 193 void __iomem *base = s3c_rtc_base; 194 int year = tm->tm_year - 100; 195 196 pr_debug("set time %04d.%02d.%02d %02d:%02d:%02d\n", 197 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday, 198 tm->tm_hour, tm->tm_min, tm->tm_sec); 199 200 /* we get around y2k by simply not supporting it */ 201 202 if (year < 0 || year >= 100) { 203 dev_err(dev, "rtc only supports 100 years\n"); 204 return -EINVAL; 205 } 206 207 writeb(bin2bcd(tm->tm_sec), base + S3C2410_RTCSEC); 208 writeb(bin2bcd(tm->tm_min), base + S3C2410_RTCMIN); 209 writeb(bin2bcd(tm->tm_hour), base + S3C2410_RTCHOUR); 210 writeb(bin2bcd(tm->tm_mday), base + S3C2410_RTCDATE); 211 writeb(bin2bcd(tm->tm_mon + 1), base + S3C2410_RTCMON); 212 writeb(bin2bcd(year), base + S3C2410_RTCYEAR); 213 214 return 0; 215 } 216 217 static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm) 218 { 219 struct rtc_time *alm_tm = &alrm->time; 220 void __iomem *base = s3c_rtc_base; 221 unsigned int alm_en; 222 223 alm_tm->tm_sec = readb(base + S3C2410_ALMSEC); 224 alm_tm->tm_min = readb(base + S3C2410_ALMMIN); 225 alm_tm->tm_hour = readb(base + S3C2410_ALMHOUR); 226 alm_tm->tm_mon = readb(base + S3C2410_ALMMON); 227 alm_tm->tm_mday = readb(base + S3C2410_ALMDATE); 228 alm_tm->tm_year = readb(base + S3C2410_ALMYEAR); 229 230 alm_en = readb(base + S3C2410_RTCALM); 231 232 alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0; 233 234 pr_debug("read alarm %d, %04d.%02d.%02d %02d:%02d:%02d\n", 235 alm_en, 236 1900 + alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday, 237 alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec); 238 239 240 /* decode the alarm enable field */ 241 242 if (alm_en & S3C2410_RTCALM_SECEN) 243 alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec); 244 else 245 alm_tm->tm_sec = -1; 246 247 if (alm_en & S3C2410_RTCALM_MINEN) 248 alm_tm->tm_min = bcd2bin(alm_tm->tm_min); 249 else 250 alm_tm->tm_min = -1; 251 252 if (alm_en & S3C2410_RTCALM_HOUREN) 253 alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour); 254 else 255 alm_tm->tm_hour = -1; 256 257 if (alm_en & S3C2410_RTCALM_DAYEN) 258 alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday); 259 else 260 alm_tm->tm_mday = -1; 261 262 if (alm_en & S3C2410_RTCALM_MONEN) { 263 alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon); 264 alm_tm->tm_mon -= 1; 265 } else { 266 alm_tm->tm_mon = -1; 267 } 268 269 if (alm_en & S3C2410_RTCALM_YEAREN) 270 alm_tm->tm_year = bcd2bin(alm_tm->tm_year); 271 else 272 alm_tm->tm_year = -1; 273 274 return 0; 275 } 276 277 static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) 278 { 279 struct rtc_time *tm = &alrm->time; 280 void __iomem *base = s3c_rtc_base; 281 unsigned int alrm_en; 282 283 pr_debug("s3c_rtc_setalarm: %d, %04d.%02d.%02d %02d:%02d:%02d\n", 284 alrm->enabled, 285 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday, 286 tm->tm_hour, tm->tm_min, tm->tm_sec); 287 288 289 alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN; 290 writeb(0x00, base + S3C2410_RTCALM); 291 292 if (tm->tm_sec < 60 && tm->tm_sec >= 0) { 293 alrm_en |= S3C2410_RTCALM_SECEN; 294 writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC); 295 } 296 297 if (tm->tm_min < 60 && tm->tm_min >= 0) { 298 alrm_en |= S3C2410_RTCALM_MINEN; 299 writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN); 300 } 301 302 if (tm->tm_hour < 24 && tm->tm_hour >= 0) { 303 alrm_en |= S3C2410_RTCALM_HOUREN; 304 writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR); 305 } 306 307 pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en); 308 309 writeb(alrm_en, base + S3C2410_RTCALM); 310 311 s3c_rtc_setaie(alrm->enabled); 312 313 return 0; 314 } 315 316 static int s3c_rtc_proc(struct device *dev, struct seq_file *seq) 317 { 318 unsigned int ticnt; 319 320 if (s3c_rtc_cpu_type == TYPE_S3C64XX) { 321 ticnt = readw(s3c_rtc_base + S3C2410_RTCCON); 322 ticnt &= S3C64XX_RTCCON_TICEN; 323 } else { 324 ticnt = readb(s3c_rtc_base + S3C2410_TICNT); 325 ticnt &= S3C2410_TICNT_ENABLE; 326 } 327 328 seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt ? "yes" : "no"); 329 return 0; 330 } 331 332 static int s3c_rtc_open(struct device *dev) 333 { 334 struct platform_device *pdev = to_platform_device(dev); 335 struct rtc_device *rtc_dev = platform_get_drvdata(pdev); 336 int ret; 337 338 ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq, 339 IRQF_DISABLED, "s3c2410-rtc alarm", rtc_dev); 340 341 if (ret) { 342 dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret); 343 return ret; 344 } 345 346 ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq, 347 IRQF_DISABLED, "s3c2410-rtc tick", rtc_dev); 348 349 if (ret) { 350 dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret); 351 goto tick_err; 352 } 353 354 return ret; 355 356 tick_err: 357 free_irq(s3c_rtc_alarmno, rtc_dev); 358 return ret; 359 } 360 361 static void s3c_rtc_release(struct device *dev) 362 { 363 struct platform_device *pdev = to_platform_device(dev); 364 struct rtc_device *rtc_dev = platform_get_drvdata(pdev); 365 366 /* do not clear AIE here, it may be needed for wake */ 367 368 s3c_rtc_setpie(dev, 0); 369 free_irq(s3c_rtc_alarmno, rtc_dev); 370 free_irq(s3c_rtc_tickno, rtc_dev); 371 } 372 373 static const struct rtc_class_ops s3c_rtcops = { 374 .open = s3c_rtc_open, 375 .release = s3c_rtc_release, 376 .read_time = s3c_rtc_gettime, 377 .set_time = s3c_rtc_settime, 378 .read_alarm = s3c_rtc_getalarm, 379 .set_alarm = s3c_rtc_setalarm, 380 .irq_set_freq = s3c_rtc_setfreq, 381 .irq_set_state = s3c_rtc_setpie, 382 .proc = s3c_rtc_proc, 383 .alarm_irq_enable = s3c_rtc_setaie, 384 }; 385 386 static void s3c_rtc_enable(struct platform_device *pdev, int en) 387 { 388 void __iomem *base = s3c_rtc_base; 389 unsigned int tmp; 390 391 if (s3c_rtc_base == NULL) 392 return; 393 394 if (!en) { 395 tmp = readw(base + S3C2410_RTCCON); 396 if (s3c_rtc_cpu_type == TYPE_S3C64XX) 397 tmp &= ~S3C64XX_RTCCON_TICEN; 398 tmp &= ~S3C2410_RTCCON_RTCEN; 399 writew(tmp, base + S3C2410_RTCCON); 400 401 if (s3c_rtc_cpu_type == TYPE_S3C2410) { 402 tmp = readb(base + S3C2410_TICNT); 403 tmp &= ~S3C2410_TICNT_ENABLE; 404 writeb(tmp, base + S3C2410_TICNT); 405 } 406 } else { 407 /* re-enable the device, and check it is ok */ 408 409 if ((readw(base+S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0) { 410 dev_info(&pdev->dev, "rtc disabled, re-enabling\n"); 411 412 tmp = readw(base + S3C2410_RTCCON); 413 writew(tmp | S3C2410_RTCCON_RTCEN, 414 base + S3C2410_RTCCON); 415 } 416 417 if ((readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)) { 418 dev_info(&pdev->dev, "removing RTCCON_CNTSEL\n"); 419 420 tmp = readw(base + S3C2410_RTCCON); 421 writew(tmp & ~S3C2410_RTCCON_CNTSEL, 422 base + S3C2410_RTCCON); 423 } 424 425 if ((readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)) { 426 dev_info(&pdev->dev, "removing RTCCON_CLKRST\n"); 427 428 tmp = readw(base + S3C2410_RTCCON); 429 writew(tmp & ~S3C2410_RTCCON_CLKRST, 430 base + S3C2410_RTCCON); 431 } 432 } 433 } 434 435 static int __devexit s3c_rtc_remove(struct platform_device *dev) 436 { 437 struct rtc_device *rtc = platform_get_drvdata(dev); 438 439 platform_set_drvdata(dev, NULL); 440 rtc_device_unregister(rtc); 441 442 s3c_rtc_setpie(&dev->dev, 0); 443 s3c_rtc_setaie(0); 444 445 clk_disable(rtc_clk); 446 clk_put(rtc_clk); 447 rtc_clk = NULL; 448 449 iounmap(s3c_rtc_base); 450 release_resource(s3c_rtc_mem); 451 kfree(s3c_rtc_mem); 452 453 return 0; 454 } 455 456 static int __devinit s3c_rtc_probe(struct platform_device *pdev) 457 { 458 struct rtc_device *rtc; 459 struct rtc_time rtc_tm; 460 struct resource *res; 461 int ret; 462 463 pr_debug("%s: probe=%p\n", __func__, pdev); 464 465 /* find the IRQs */ 466 467 s3c_rtc_tickno = platform_get_irq(pdev, 1); 468 if (s3c_rtc_tickno < 0) { 469 dev_err(&pdev->dev, "no irq for rtc tick\n"); 470 return -ENOENT; 471 } 472 473 s3c_rtc_alarmno = platform_get_irq(pdev, 0); 474 if (s3c_rtc_alarmno < 0) { 475 dev_err(&pdev->dev, "no irq for alarm\n"); 476 return -ENOENT; 477 } 478 479 pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n", 480 s3c_rtc_tickno, s3c_rtc_alarmno); 481 482 /* get the memory region */ 483 484 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 485 if (res == NULL) { 486 dev_err(&pdev->dev, "failed to get memory region resource\n"); 487 return -ENOENT; 488 } 489 490 s3c_rtc_mem = request_mem_region(res->start, 491 res->end-res->start+1, 492 pdev->name); 493 494 if (s3c_rtc_mem == NULL) { 495 dev_err(&pdev->dev, "failed to reserve memory region\n"); 496 ret = -ENOENT; 497 goto err_nores; 498 } 499 500 s3c_rtc_base = ioremap(res->start, res->end - res->start + 1); 501 if (s3c_rtc_base == NULL) { 502 dev_err(&pdev->dev, "failed ioremap()\n"); 503 ret = -EINVAL; 504 goto err_nomap; 505 } 506 507 rtc_clk = clk_get(&pdev->dev, "rtc"); 508 if (IS_ERR(rtc_clk)) { 509 dev_err(&pdev->dev, "failed to find rtc clock source\n"); 510 ret = PTR_ERR(rtc_clk); 511 rtc_clk = NULL; 512 goto err_clk; 513 } 514 515 clk_enable(rtc_clk); 516 517 /* check to see if everything is setup correctly */ 518 519 s3c_rtc_enable(pdev, 1); 520 521 pr_debug("s3c2410_rtc: RTCCON=%02x\n", 522 readw(s3c_rtc_base + S3C2410_RTCCON)); 523 524 device_init_wakeup(&pdev->dev, 1); 525 526 /* register RTC and exit */ 527 528 rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops, 529 THIS_MODULE); 530 531 if (IS_ERR(rtc)) { 532 dev_err(&pdev->dev, "cannot attach rtc\n"); 533 ret = PTR_ERR(rtc); 534 goto err_nortc; 535 } 536 537 s3c_rtc_cpu_type = platform_get_device_id(pdev)->driver_data; 538 539 /* Check RTC Time */ 540 541 s3c_rtc_gettime(NULL, &rtc_tm); 542 543 if (rtc_valid_tm(&rtc_tm)) { 544 rtc_tm.tm_year = 100; 545 rtc_tm.tm_mon = 0; 546 rtc_tm.tm_mday = 1; 547 rtc_tm.tm_hour = 0; 548 rtc_tm.tm_min = 0; 549 rtc_tm.tm_sec = 0; 550 551 s3c_rtc_settime(NULL, &rtc_tm); 552 553 dev_warn(&pdev->dev, "warning: invalid RTC value so initializing it\n"); 554 } 555 556 if (s3c_rtc_cpu_type == TYPE_S3C64XX) 557 rtc->max_user_freq = 32768; 558 else 559 rtc->max_user_freq = 128; 560 561 platform_set_drvdata(pdev, rtc); 562 563 s3c_rtc_setfreq(&pdev->dev, 1); 564 565 return 0; 566 567 err_nortc: 568 s3c_rtc_enable(pdev, 0); 569 clk_disable(rtc_clk); 570 clk_put(rtc_clk); 571 572 err_clk: 573 iounmap(s3c_rtc_base); 574 575 err_nomap: 576 release_resource(s3c_rtc_mem); 577 578 err_nores: 579 return ret; 580 } 581 582 #ifdef CONFIG_PM 583 584 /* RTC Power management control */ 585 586 static int ticnt_save, ticnt_en_save; 587 588 static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state) 589 { 590 /* save TICNT for anyone using periodic interrupts */ 591 ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT); 592 if (s3c_rtc_cpu_type == TYPE_S3C64XX) { 593 ticnt_en_save = readw(s3c_rtc_base + S3C2410_RTCCON); 594 ticnt_en_save &= S3C64XX_RTCCON_TICEN; 595 } 596 s3c_rtc_enable(pdev, 0); 597 598 if (device_may_wakeup(&pdev->dev)) 599 enable_irq_wake(s3c_rtc_alarmno); 600 601 return 0; 602 } 603 604 static int s3c_rtc_resume(struct platform_device *pdev) 605 { 606 unsigned int tmp; 607 608 s3c_rtc_enable(pdev, 1); 609 writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT); 610 if (s3c_rtc_cpu_type == TYPE_S3C64XX && ticnt_en_save) { 611 tmp = readw(s3c_rtc_base + S3C2410_RTCCON); 612 writew(tmp | ticnt_en_save, s3c_rtc_base + S3C2410_RTCCON); 613 } 614 615 if (device_may_wakeup(&pdev->dev)) 616 disable_irq_wake(s3c_rtc_alarmno); 617 618 return 0; 619 } 620 #else 621 #define s3c_rtc_suspend NULL 622 #define s3c_rtc_resume NULL 623 #endif 624 625 static struct platform_device_id s3c_rtc_driver_ids[] = { 626 { 627 .name = "s3c2410-rtc", 628 .driver_data = TYPE_S3C2410, 629 }, { 630 .name = "s3c64xx-rtc", 631 .driver_data = TYPE_S3C64XX, 632 }, 633 { } 634 }; 635 636 MODULE_DEVICE_TABLE(platform, s3c_rtc_driver_ids); 637 638 static struct platform_driver s3c_rtc_driver = { 639 .probe = s3c_rtc_probe, 640 .remove = __devexit_p(s3c_rtc_remove), 641 .suspend = s3c_rtc_suspend, 642 .resume = s3c_rtc_resume, 643 .id_table = s3c_rtc_driver_ids, 644 .driver = { 645 .name = "s3c-rtc", 646 .owner = THIS_MODULE, 647 }, 648 }; 649 650 static char __initdata banner[] = "S3C24XX RTC, (c) 2004,2006 Simtec Electronics\n"; 651 652 static int __init s3c_rtc_init(void) 653 { 654 printk(banner); 655 return platform_driver_register(&s3c_rtc_driver); 656 } 657 658 static void __exit s3c_rtc_exit(void) 659 { 660 platform_driver_unregister(&s3c_rtc_driver); 661 } 662 663 module_init(s3c_rtc_init); 664 module_exit(s3c_rtc_exit); 665 666 MODULE_DESCRIPTION("Samsung S3C RTC Driver"); 667 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>"); 668 MODULE_LICENSE("GPL"); 669 MODULE_ALIAS("platform:s3c2410-rtc"); 670