struct platform_device {
const char* name;//設備名稱
intid;
struct devicedev;
u32num_resources;//設備使用各類資源的數量
struct resource* resource;//設備使用的資源

struct platform_device_id*id_entry;
};

* RTC */
static struct resource s3c_rtc_resource[] = {//定義了RTC平臺設備使用的資源，這些資源在驅動中都會用到
[0] = {//IO端口資源范圍
.start = S3C24XX_PA_RTC,
.end = S3C24XX_PA_RTC + 0xff,
.flags = IORESOURCE_MEM,
},
[1] = {//RTC報警中斷資源
.start = IRQ_RTC,
.end = IRQ_RTC,
.flags = IORESOURCE_IRQ,
},
[2] = {//TICK節(jié)拍時間中斷資源
.start = IRQ_TICK,
.end = IRQ_TICK,
.flags = IORESOURCE_IRQ
}
};

struct platform_device s3c_device_rtc = {//定義了RTC平臺設備
.name = "s3c2410-rtc",//設備名稱
.id = -1,
.num_resources = ARRAY_SIZE(s3c_rtc_resource),//資源數量
.resource = s3c_rtc_resource,//引用上面定義的資源
};

EXPORT_SYMBOL(s3c_device_rtc);

static struct platform_device *smdk2440_devices[] __initdata = {
&s3c_device_usb,
&s3c_device_lcd,
&s3c_device_wdt,
&s3c_device_i2c0,
&s3c_device_iis,DE>

&s3c_device_rtc,//這里我們添加上RTC平臺設備，默認是沒添加的
};//平臺設備列表，也就是說我們要使用一個新的平臺設備要先在上面定義，然后加到這個列表中，最后到驅動層去實現該設備的驅動

static void __init smdk2440_machine_init(void)
{
s3c24xx_fb_set_platdata(&smdk2440_fb_info);
s3c_i2c0_set_platdata(NULL);
//將上面列表中的平臺設備添加到系統(tǒng)總線中
platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));
smdk_machine_init();
}

#include
#include
#include
#include
#include

/*RTC平臺驅動結構體，平臺驅動結構體定義在platform_device.h中，該結構體內的接口函數在第②、④步中實現*/
static struct platform_driver rtc_driver =
{
.probe= rtc_probe, /*RTC探測函數，在第②步中實現*/
.remove= __devexit_p(rtc_remove),/*RTC移除函數,在第④步實現,為何使用__devexit_p,在該函數實現的地方再講*/
.suspend = rtc_suspend, /*RTC掛起函數，在第④步中實現*/
.resume= rtc_resume, /*RTC恢復函數，在第④步中實現*/
.driver=
{
/*注意這里的名稱一定要和系統(tǒng)中定義平臺設備的地方一致，這樣才能把平臺設備與該平臺設備的驅動關聯起來*/
.name= "s3c2410-rtc",
.owner= THIS_MODULE,
},
};

static int __init rtc_init(void)
{
/*將RTC注冊成平臺設備驅動*/
return platform_driver_register(&rtc_driver);
}

static void __exit rtc_exit(void)
{
/*注銷RTC平臺設備驅動*/
platform_driver_unregister(&rtc_driver);
}

module_init(rtc_init);
module_exit(rtc_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Huang Gang");
MODULE_DESCRIPTION("My2440 RTC driver");

#include
#include
#include
#include
#include

/*定義了一個用來保存RTC的IO端口占用的IO空間和經過虛擬映射后的內存地址*/
static struct resource *rtc_mem;
static void __iomem *rtc_base;

/*定義了兩個變量來保存RTC報警中斷號和TICK節(jié)拍時間中斷號，NO_IRQ宏定義在irq.h中*/
static int rtc_alarmno = NO_IRQ;
static int rtc_tickno = NO_IRQ;

/*申明并初始化一個自旋鎖rtc_pie_lock，對RTC資源進行互斥訪問*/
static DEFINE_SPINLOCK(rtc_pie_lock);

/*RTC平臺驅動探測函數，注意這里為什么要使用一個__devinit，也到rtc_remove實現的地方一起講*/
static int __devinit rtc_probe(struct platform_device *pdev)
{
int ret;
struct rtc_device *rtc; /*定義一個RTC設備類，rtc_device定義在rtc.h中*/
struct resource *res; /*定義一個資源，用來保存獲取的RTC的資源*/

/*在系統(tǒng)定義的RTC平臺設備中獲取RTC報警中斷號
platform_get_irq定義在platform_device.h中*/
rtc_alarmno = platform_get_irq(pdev, 0);
if (rtc_alarmno < 0)
{
/*獲取RTC報警中斷號不成功錯誤處理
dev_err定義在device.h中，在platform_device.h中已經引用，所以這里就不需再引用了*/
dev_err(&pdev->dev, "no irq for alarmn");
return -ENOENT;
}

//在系統(tǒng)定義的RTC平臺設備中獲取TICK節(jié)拍時間中斷號
rtc_tickno = platform_get_irq(pdev, 1);
if (rtc_tickno < 0)
{
/*獲取TICK節(jié)拍時間中斷號不成功錯誤處理*/
dev_err(&pdev->dev, "no irq for rtc tickn");
return -ENOENT;
}

/*獲取RTC平臺設備所使用的IO端口資源，注意這個IORESOURCE_MEM標志和RTC平臺設備定義中的一致*/
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL)
{
/*錯誤處理*/
dev_err(&pdev->dev, "failed to get memory region resourcen");
return -ENOENT;
}

/*申請RTC的IO端口資源所占用的IO空間(要注意理解IO空間和內存空間的區(qū)別),
request_mem_region定義在ioport.h中*/
rtc_mem = request_mem_region(res->start, res->end - res->start + 1, pdev->name);
if (rtc_mem == NULL)
{
/*錯誤處理*/
dev_err(&pdev->dev, "failed to reserve memory regionn");
ret = -ENOENT;
goto err_nores;
}

/*將RTC的IO端口占用的這段IO空間映射到內存的虛擬地址，ioremap定義在io.h中。
注意：IO空間要映射后才能使用，以后對虛擬地址的操作就是對IO空間的操作，*/
rtc_base = ioremap(res->start, res->end - res->start + 1);
if (rtc_base == NULL)
{
/*錯誤處理*/
dev_err(&pdev->dev, "failed ioremap()n");
ret = -EINVAL;
goto err_nomap;
}

/*好了，通過上面的步驟已經將RTC的資源都準備好了，下面就開始使用啦*/

/*這兩個函數開始對RTC寄存器操作，定義都在下面*/
rtc_enable(pdev, 1); /*對RTC的實時時鐘控制寄存器RTCCON進行操作(功能是初始化或者使能RTC)*/
rtc_setfreq(&pdev->dev, 1);/*對RTC的節(jié)拍時間計數寄存器TICNT的0-6位進行操作，即：節(jié)拍時間計數值的設定*/

/*device_init_wakeup該函數定義在pm_wakeup.h中，定義如下：
static inline void device_init_wakeup(struct device *dev, int val){
dev->power.can_wakeup = dev->power.should_wakeup = !!val;
}
顯然這個函數是讓驅動支持電源管理的,這里只要知道,can_wakeup為1時表明這個設備可以被喚醒,設備驅動為了支持
Linux中的電源管理,有責任調用device_init_wakeup()來初始化can_wakeup，而should_wakeup則是在設備的電源狀態(tài)
發(fā)生變化的時候被device_may_wakeup()用來測試,測試它該不該變化，因此can_wakeup表明的是一種能力，
而should_wakeup表明的是有了這種能力以后去不去做某件事。好了，我們沒有必要深入研究電源管理的內容了，
要不就扯遠了，電源管理以后再講*/
device_init_wakeup(&pdev->dev, 1);

/*將RTC注冊為RTC設備類，RTC設備類在RTC驅動核心部分中由系統(tǒng)定義好的，
注意rtcops這個參數是一個結構體，該結構體的作用和里面的接口函數實現在第③步中。
rtc_device_register函數在rtc.h中定義，在drivers/rtc/class.c中實現*/
rtc = rtc_device_register("my2440", &pdev->dev, &rtcops, THIS_MODULE);
if (IS_ERR(rtc))
{
/*錯誤處理*/
dev_err(&pdev->dev, "cannot attach rtcn");
ret = PTR_ERR(rtc);
goto err_nortc;
}

/*設置RTC節(jié)拍時間計數寄存器TICNT的節(jié)拍時間計數值的用戶最大相對值，
這里你可能不理解這句，沒關系，等你看到rtc_setfreq函數實現后自然就明白了*/
rtc->max_user_freq = 128;

/*將RTC設備類的數據傳遞給系統(tǒng)平臺設備。
platform_set_drvdata是定義在platform_device.h的宏，如下：
#define platform_set_drvdata(_dev,data)dev_set_drvdata(&(_dev)->dev, (data))
而dev_set_drvdata又被定義在include/linux/device.h中，如下：
static inline void dev_set_drvdata (struct device *dev, void *data){
dev->driver_data = data;
}*/
platform_set_drvdata(pdev, rtc);

return 0;

//以下是上面錯誤處理的跳轉點
err_nortc:
rtc_enable(pdev, 0);
iounmap(rtc_base);

err_nomap:
release_resource(rtc_mem);

err_nores:
return ret;
}

/*該函數主要是初始化或者使能RTC，
以下RTC的各種寄存器的宏定義在arch/arm/plat-s3c/include/plat/regs-rtc.h中，
各寄存器的用途和設置請參考S3C2440數據手冊的第十七章實時時鐘部分*/
static void rtc_enable(struct platform_device *pdev, int flag)
{
unsigned int tmp;

/*RTC的實時時鐘控制寄存器RTCCON共有4個位，各位的初始值均為0，根據數據手冊介紹第0位(即：RCTEN位)
可以控制CPU和RTC之間的所有接口(即RTC使能功能)，所以在系統(tǒng)復位后應該將RTCCON寄存器的第0為置為1；
在關閉電源前，又應該將該位清零，以避免無意的寫RTC寄存器*/
if (!flag)
{
/*當flag=0時(即屬于關閉電源前的情況)，RTCCON寄存器清零第一位*/
tmp = readb(rtc_base + S3C2410_RTCCON); /*讀取RTCCON寄存器的值*/
/* tmp & ~S3C2410_RTCCON_RTCEN = 0 即屏蔽RTC使能*/
writeb(tmp & ~S3C2410_RTCCON_RTCEN, rtc_base + S3C2410_RTCCON);

tmp = readb(rtc_base + S3C2410_TICNT); /*讀取TICNT寄存器的值*/
/* tmp & ~S3C2410_TICNT_ENABLE后第7位為0，即屏蔽節(jié)拍時間中斷使能*/
writeb(tmp & ~S3C2410_TICNT_ENABLE, rtc_base + S3C2410_TICNT);
}
else
{
/*當flag!=0時(即屬于系統(tǒng)復位后的情況)，使能RTC*/
if ((readb(rtc_base + S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0)
{
dev_info(&pdev->dev, "rtc disabled, re-enablingn");
tmp = readb(rtc_base + S3C2410_RTCCON);
writeb(tmp | S3C2410_RTCCON_RTCEN, rtc_base + S3C2410_RTCCON);
}

if ((readb(rtc_base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL))
{
dev_info(&pdev->dev, "removing RTCCON_CNTSELn");
tmp = readb(rtc_base + S3C2410_RTCCON);
writeb(tmp & ~S3C2410_RTCCON_CNTSEL, rtc_base + S3C2410_RTCCON);
}

if ((readb(rtc_base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST))
{
dev_info(&pdev->dev, "removing RTCCON_CLKRSTn");
tmp = readb(rtc_base + S3C2410_RTCCON);
writeb(tmp & ~S3C2410_RTCCON_CLKRST, rtc_base + S3C2410_RTCCON);
}
}
}

/*該函數主要是對RTC的節(jié)拍時間計數寄存器TICNT的0-6位進行操作，即：節(jié)拍時間計數值的設定*/
static int rtc_setfreq(struct device *dev, int freq)
{
unsigned int tmp;

if (!is_power_of_2(freq)) /*對freq的值進行檢查*/
return -EINVAL;

spin_lock_irq(&rtc_pie_lock); /*獲取自旋鎖保護臨界區(qū)資源*/

/*讀取節(jié)拍時間計數寄存器TICNT的值*/
tmp = readb(rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;

/*看數據手冊得知，節(jié)拍時間計數值的范圍是1-127，
還記得在rtc_enable函數中設置的rtc->max_user_freq=128嗎？所以這里要減1*/
tmp |= (128 / freq) - 1;

/*將經運算后值寫入節(jié)拍時間計數寄存器TICNT中，這里主要是改變TICNT的第0-6位的值*/
writeb(tmp, rtc_base + S3C2410_TICNT);

spin_unlock_irq(&rtc_pie_lock);/*釋放自旋鎖，即解鎖*/

return 0;
}

#include interrupt.h>
#include

/*rtc_class_ops是RTC設備類在RTC驅動核心部分中定義的對RTC設備類進行操作的結構體，
類似字符設備在驅動中的file_operations對字符設備進行操作的意思。該結構體被定義
在rtc.h中，對RTC的操作主要有打開、關閉、設置或獲取時間、設置或獲取報警、設置節(jié)拍時間計數值等等，
該結構體內接口函數的實現都在下面*/
static const struct rtc_class_ops rtcops = {
.open= rtc_open,
.release = rtc_release,
.irq_set_freq= rtc_setfreq, /*在第②步中已實現*/
.irq_set_state= rtc_setpie,
.read_time= rtc_gettime,
.set_time= rtc_settime,
.read_alarm= rtc_getalarm,
.set_alarm= rtc_setalarm,
};

/*RTC設備類打開接口函數*/
static int rtc_open(struct device *dev)
{
int ret;

/*這里主要的目的是從系統(tǒng)平臺設備中獲取RTC設備類的數據，和RTC探測函數rtc_probe中
的platform_set_drvdata(pdev, rtc)的操作剛好相反。這些都定義在platform_device.h中*/
struct platform_device *pdev = to_platform_device(dev);
struct rtc_device *rtc_dev = platform_get_drvdata(pdev);

/*申請RTC報警中斷服務，中斷號rtc_alarmno在RTC探測函數rtc_probe中已經獲取得，
這里使用的是快速中斷:IRQF_DISABLED。中斷服務程序為:rtc_alarmirq，將RTC設備類rtc_dev做參數傳遞過去了*/
ret = request_irq(rtc_alarmno, rtc_alarmirq, IRQF_DISABLED, "my2440-rtc alarm", rtc_dev);
if (ret)
{
dev_err(dev, "IRQ%d error %dn", rtc_alarmno, ret);
return ret;
}

/*同上面一樣，這里申請的是RTC的TICK節(jié)拍時間中斷服務，服務程序是:rtc_tickirq*/
ret = request_irq(rtc_tickno, rtc_tickirq, IRQF_DISABLED, "my2440-rtc tick", rtc_dev);
if (ret)
{
dev_err(dev, "IRQ%d error %dn", rtc_tickno, ret);
goto tick_err;
}

return ret;

tick_err:/*錯誤處理，注意出現錯誤后也要釋放掉已經申請成功的中斷*/
free_irq(rtc_alarmno, rtc_dev);
return ret;
}

/*RTC報警中斷服務程序*/
static irqreturn_t rtc_alarmirq(int irq, void *argv)
{
struct rtc_device *rdev = argv; /*接收申請中斷時傳遞過來的rtc_dev參數*/

/*當報警中斷到來的時候，去設定RTC中報警的相關信息，具體設定的方法，RTC核心
部分已經在rtc_update_irq接口函數中實現，函數定義實現在interface.c中*/
rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
return IRQ_HANDLED;
}

/*RTC的TICK節(jié)拍時間中斷服務*/
static irqreturn_t rtc_tickirq(int irq, void *argv)
{
struct rtc_device *rdev = argv; /*接收申請中斷時傳遞過來的rtc_dev參數*/

/*節(jié)拍時間中斷到來的時候，去設定RTC中節(jié)拍時間的相關信息，具體設定的方法，RTC核心
部分已經在rtc_update_irq接口函數中實現，函數定義實現在interface.c中*/
rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
return IRQ_HANDLED;
}

/*RTC設備類關閉接口函數*/
static void rtc_release(struct device *dev)
{
/*和rtc_open中的作用相同*/
struct platform_device *pdev = to_platform_device(dev);
struct rtc_device *rtc_dev = platform_get_drvdata(pdev);

/*請見rtc_setpie接口函數中的解釋*/
rtc_setpie(dev, 0);

/*同rtc_open中中斷的申請相對應，在那里申請中斷，這里就釋放中斷*/
free_irq(rtc_alarmno, rtc_dev);
free_irq(rtc_tickno, rtc_dev);
}

/*該函數主要是對RTC的節(jié)拍時間計數寄存器TICNT的第7位進行操作，即：節(jié)拍時間計數的使能功能*/
static int rtc_setpie(struct device *dev, int flag)
{
unsigned int tmp;

spin_lock_irq(&rtc_pie_lock);/*獲取自旋鎖保護臨界區(qū)資源*/

/*讀取節(jié)拍時間計數寄存器TICNT的值*/
tmp = readb(rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;

if (flag)
{
tmp |= S3C2410_TICNT_ENABLE; /*根據標志flag的值來判斷是要使能還是要禁止*/
}

/*將經運算后值寫入節(jié)拍時間計數寄存器TICNT中，這里主要是改變TICNT的第7位的值*/
writeb(tmp, rtc_base + S3C2410_TICNT);

spin_unlock_irq(&rtc_pie_lock);/*釋放自旋鎖，即解鎖*/

return 0;
}

/*讀取RTC中BCD數中的：分、時、日期、月、年、秒*/
static int rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
{
unsigned int have_retried = 0;

retry_get_time:
rtc_tm->tm_min = readb(rtc_base + S3C2410_RTCMIN); /*讀BCD分寄存器RTCMIN*/
rtc_tm->tm_hour = readb(rtc_base + S3C2410_RTCHOUR); /*讀BCD時寄存器RTCHOUR*/
rtc_tm->tm_mday = readb(rtc_base + S3C2410_RTCDATE); /*讀BCD日期寄存器RTCDATE*/
rtc_tm->tm_mon = readb(rtc_base + S3C2410_RTCMON); /*讀BCD月寄存器RTCMON*/
rtc_tm->tm_year = readb(rtc_base + S3C2410_RTCYEAR); /*讀BCD年寄存器RTCYEAR*/
rtc_tm->tm_sec = readb(rtc_base + S3C2410_RTCSEC); /*讀BCD秒寄存器RTCSEC*/

/*我們知道時間是以60為一個周期的，當時、分、秒達到60后，他們的上一級會加1，而自身又從0開始計數
上面我們最后讀的秒，如果讀出來的秒剛好是0，那么前面讀的分、時等就是上一分鐘的，結果就少了一分鐘，
所以就要重新讀取*/
if (rtc_tm->tm_sec == 0 && !have_retried)
{
have_retried = 1;
goto retry_get_time;
}

/*將上面讀取的時間日期值保存到RTC核心定義的時間結構體中，該結構體定義在rtc.h中，
這里的bcd2bin主要是編譯器對返回值相同時進行優(yōu)化處理，定義在bcd.h中*/
rtc_tm->tm_sec= bcd2bin(rtc_tm->tm_sec);
rtc_tm->tm_min= bcd2bin(rtc_tm->tm_min);
rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
rtc_tm->tm_mon= bcd2bin(rtc_tm->tm_mon);
rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);

/*這里為什么要加100年和減1月呢，我們查看數據手冊得知原來是為了區(qū)別1900年和2000年閏年的因素，
1900年不是閏年而2000年是閏年。這時你或許會問那怎么不考慮1800年或2100年??？原因很簡單，因為
我們的RTC時鐘只支持100年的時間范圍，呵呵??！*/
rtc_tm->tm_year += 100;
rtc_tm->tm_mon -= 1;

return 0;
}

/*和上面的rtc_gettime功能相反，將更改后的分、時、日期、月、年、秒寫入RTC中BCD數中*/
static int rtc_settime(struct device *dev, struct rtc_time *tm)
{
/*這里減100年很清楚了吧，因為上面為了區(qū)別1900年和2000年時加了100年*/
int year = tm->tm_year - 100;

/*RTC時鐘只支持100年的時間范圍*/
if (year < 0 || year >= 100) {
dev_err(dev, "rtc only supports 100 yearsn");
return -EINVAL;
}

/*將上面保存到RTC核心定義的時間結構體中的時間日期值寫入對應的寄存器中*/
writeb(bin2bcd(tm->tm_sec), rtc_base + S3C2410_RTCSEC);
writeb(bin2bcd(tm->tm_min), rtc_base + S3C2410_RTCMIN);
writeb(bin2bcd(tm->tm_hour), rtc_base + S3C2410_RTCHOUR);
writeb(bin2bcd(tm->tm_mday), rtc_base + S3C2410_RTCDATE);
writeb(bin2bcd(tm->tm_mon + 1), rtc_base + S3C2410_RTCMON); /*這里加1月也明白了吧*/
writeb(bin2bcd(year), rtc_base + S3C2410_RTCYEAR);

return 0;
}

/*讀取RTC中報警各寄存器的：秒、分、時、月、日期、年的值，保存各值到rtc_time結構體中*/
static int rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
unsigned int alm_en;
struct rtc_time *alm_tm = &alrm->time;

alm_tm->tm_sec = readb(rtc_base + S3C2410_ALMSEC);
alm_tm->tm_min = readb(rtc_base + S3C2410_ALMMIN);
alm_tm->tm_hour = readb(rtc_base + S3C2410_ALMHOUR);
alm_tm->tm_mon = readb(rtc_base + S3C2410_ALMMON);
alm_tm->tm_mday = readb(rtc_base + S3C2410_ALMDATE);
alm_tm->tm_year = readb(rtc_base + S3C2410_ALMYEAR);

/*獲取RTC報警控制寄存器RTCALM的值*/
alm_en = readb(rtc_base + S3C2410_RTCALM);

/*判斷RTCALM值的第6位，來設置RTC的全局報警使能狀態(tài)到RTC核心定義的報警狀態(tài)結構體rtc_wkalrm中*/
alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;

/*判斷如果RTCALM值的第0位的值(秒報警使能)為1時，就設置報警秒的值到rtc_time結構體中*/
if (alm_en & S3C2410_RTCALM_SECEN)
alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
else
alm_tm->tm_sec = 0xff;

/*判斷如果RTCALM值的第1位的值(分報警使能)為1時，就設置報警分的值到rtc_time結構體中*/
if (alm_en & S3C2410_RTCALM_MINEN)
alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
else
alm_tm->tm_min = 0xff;

/*判斷如果RTCALM值的第2位的值(時報警使能)為1時，就設置報警小時的值到rtc_time結構體中*/
if (alm_en & S3C2410_RTCALM_HOUREN)
alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
else
alm_tm->tm_hour = 0xff;

/*判斷如果RTCALM值的第3位的值(日期報警使能)為1時，就設置報警日期的值到rtc_time結構體中*/
if (alm_en & S3C2410_RTCALM_DAYEN)
alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
else
alm_tm->tm_mday = 0xff;

/*判斷如果RTCALM值的第4位的值(月報警使能)為1時，就設置報警月的值到rtc_time結構體中*/
if (alm_en & S3C2410_RTCALM_MONEN)
{
alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
alm_tm->tm_mon -= 1; /*這里為什么要遞減1，我不是很明白？？？？？？？*/
}
else
{
alm_tm->tm_mon = 0xff;
}

/*判斷如果RTCALM值的第5位的值(年報警使能)為1時，就設置報警年的值到rtc_time結構體中*/
if (alm_en & S3C2410_RTCALM_YEAREN)
alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
else
alm_tm->tm_year = 0xffff;

return 0;
}

/*把上面保存到rtc_time結構體中各值寫入RTC中報警各寄存器中*/
static int rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
unsigned int alrm_en;
struct rtc_time *tm = &alrm->time;

/*讀取RTC報警控制寄存器RTCALM的第6位，把全局報警使能的狀態(tài)保存到alrm_en變量中*/
alrm_en = readb(rtc_base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;

/*把RTC報警控制寄存器RTCALM的值設為0，即將全局報警使能和其他報警使能全部關閉*/
writeb(0x00, rtc_base + S3C2410_RTCALM);

if (tm->tm_sec < 60 && tm->tm_sec >= 0)
{
/*上面的alrm_en值只記錄了RTCALM的第6位(全局報警使能的狀態(tài))，這里再加上第0位(秒報警使能的狀態(tài))，
然后將前面保存在rtc_time中報警秒的值寫入報警秒數據寄存器ALMSEC中*/
alrm_en |= S3C2410_RTCALM_SECEN;
writeb(bin2bcd(tm->tm_sec), rtc_base + S3C2410_ALMSEC);
}

if (tm->tm_min < 60 && tm->tm_min >= 0)
{
/*加上第1位(分報警使能的狀態(tài))，
然后將前面保存在rtc_time中報警分的值寫入報警分鐘數據寄存器ALMMIN中*/
alrm_en |= S3C2410_RTCALM_MINEN;
writeb(bin2bcd(tm->tm_min), rtc_base + S3C2410_ALMMIN);
}

if (tm->tm_hour < 24 && tm->tm_hour >= 0)
{
/*加上第2位(時報警使能的狀態(tài))，
然后將前面保存在rtc_time中報警小時的值寫入報警小時數據寄存器ALMHOUR中*/
alrm_en |= S3C2410_RTCALM_HOUREN;
writeb(bin2bcd(tm->tm_hour), rtc_base + S3C2410_ALMHOUR);
}

/*把alrm_en修改過后的值重新寫入RTC報警控制寄存器RTCALM中*/
writeb(alrm_en, rtc_base + S3C2410_RTCALM);

/*請看下面rtc_setaie函數實現部分*/
rtc_setaie(alrm->enabled);

/*根據全局報警使能的狀態(tài)來決定是喚醒RTC報警中斷還是睡眠RTC報警中斷*/
if (alrm->enabled)
enable_irq_wake(rtc_alarmno);
else
disable_irq_wake(rtc_alarmno);

return 0;
}

/*這里主要還是控制RTC報警控制寄存器RTCALM的第6位(全局報警使能狀態(tài))*/
static void rtc_setaie(int flag)
{
unsigned int tmp;

tmp = readb(rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;

if (flag)/*根據標志flag來使能或禁止全局報警*/
tmp |= S3C2410_RTCALM_ALMEN;

writeb(tmp, rtc_base + S3C2410_RTCALM);
}

*注意：這是使用了一個__devexit，還記得在第①步中的__devexit_p和第②步中的__devinit嗎？
我們還是先來講講這個：
在Linux內核中，使用了大量不同的宏來標記具有不同作用的函數和數據結構，
這些宏在include/linux/init.h 頭文件中定義，編譯器通過這些宏可以把代碼優(yōu)化放到合適的內存位置，
以減少內存占用和提高內核效率。__devinit、__devexit就是這些宏之一，在probe()和remove()函數中
應該使用__devinit和__devexit宏。又當remove()函數使用了__devexit宏時，則在驅動結構體中一定要
使用__devexit_p宏來引用remove()，所以在第①步中就用__devexit_p來引用rtc_remove*/
static int __devexit rtc_remove(struct platform_device *dev)
{
/*從系統(tǒng)平臺設備中獲取RTC設備類的數據*/
struct rtc_device *rtc = platform_get_drvdata(dev);

platform_set_drvdata(dev, NULL); /*清空平臺設備中RTC驅動數據*/
rtc_device_unregister(rtc); /*注銷RTC設備類*/

rtc_setpie(&dev->dev, 0); /*禁止RTC節(jié)拍時間計數寄存器TICNT的使能功能*/
rtc_setaie(0); /*禁止RTC報警控制寄存器RTCALM的全局報警使能功能*/

iounmap(rtc_base); /*釋放RTC虛擬地址映射空間*/
release_resource(rtc_mem); /*釋放獲取的RTC平臺設備的資源*/
kfree(rtc_mem); /*銷毀保存RTC平臺設備的資源內存空間*/

return 0;
}

/*對RTC平臺設備驅動電源管理的支持。CONFIG_PM這個宏定義在內核中，
當配置內核時選上電源管理，則RTC平臺驅動的設備掛起和恢復功能均有效，
這時候你應該明白了在第②步中為什么要有device_init_wakeup(&pdev->dev, 1)這句吧??！*/
#ifdef CONFIG_PM

static int ticnt_save; /*定義一個變量來保存掛起時的TICNT值*/

/*RTC平臺驅動的設備掛起接口函數的實現*/
static int rtc_suspend(struct platform_device *pdev, pm_message_t state)
{

ticnt_save = readb(rtc_base + S3C2410_TICNT); /*以節(jié)拍時間計數寄存器TICNT的值為掛起點*/

rtc_enable(pdev, 0); /*掛起了之后就禁止RTC控制使能*/

return 0;
}

/*RTC平臺驅動的設備恢復接口函數的實現*/
static int rtc_resume(struct platform_device *pdev)
{
rtc_enable(pdev, 1); /*恢復之前先使能RTC控制*/

writeb(ticnt_save, rtc_base + S3C2410_TICNT); /*恢復掛起時的TICNT值，RTC節(jié)拍時間繼續(xù)計數*/

return 0;
}

#else /*配置內核時沒選上電源管理,RTC平臺驅動的設備掛起和恢復功能均無效,這兩個函數也就無需實現了*/
#define rtc_suspend NULL
#define rtc_resume NULL
#endif