linuxBSPmini2440之时钟

 

内核时钟初始化函数是s3c24xx_init_clocks(12000000)。

改函数的从start_kernel-->setup_arch(&command_line)-->paging_init(mdesc)-->devicemaps_init(mdesc)-->if (mdesc->map_io)mdesc->map_io();-->mini2440_map_io-->s3c24xx_init_clocks(12000000).所以此函数是各个部分初始化的起点。

s3c24xx_init_clocks(12000000)定义如下：

--------------------------------------------------------------------------------------------------

void __init s3c24xx_init_clocks(int xtal)
{
 if (xtal == 0)
  xtal = 12*1000*1000;

 if (cpu == NULL)
  panic("s3c24xx_init_clocks: no cpu setup?\n");

 if (cpu->init_clocks == NULL)
  panic("s3c24xx_init_clocks: cpu has no clock init\n");
 else
  (cpu->init_clocks)(xtal);
}

--------------------------------------------------------------------------------------------------

这个函数中看到一个cpu,那么这个变量是什么。看文件plat-s3c/init.c:

static struct cpu_table *cpu;它是一个cpu_table类型的指针。如下是其结构定义：

--------------------------------------------------------------------------------------------------

struct cpu_table {
 unsigned long idcode;
 unsigned long idmask;
 void  (*map_io)(void);
 void  (*init_uarts)(struct s3c2410_uartcfg *cfg, int no);
 void  (*init_clocks)(int xtal);
 int  (*init)(void);
 const char *name;
};

--------------------------------------------------------------------------------------------------

这样就不难理解s3c24xx_init_clocks了。那么这个CPU指针具体指向什么呢。在文件cpu.c中有如下定义：

static const char name_s3c2400[]  = "S3C2400";
static const char name_s3c2410[]  = "S3C2410";
static const char name_s3c2412[]  = "S3C2412";
static const char name_s3c2440[]  = "S3C2440";
static const char name_s3c2442[]  = "S3C2442";
static const char name_s3c2442b[]  = "S3C2442B";
static const char name_s3c2443[]  = "S3C2443";
static const char name_s3c2410a[] = "S3C2410A";
static const char name_s3c2440a[] = "S3C2440A";

static struct cpu_table cpu_ids[] __initdata = {
 {
  .idcode  = 0x32410000,
  .idmask  = 0xffffffff,
  .map_io  = s3c2410_map_io,
  .init_clocks = s3c2410_init_clocks,
  .init_uarts = s3c2410_init_uarts,
  .init  = s3c2410_init,
  .name  = name_s3c2410
 },
 {
  .idcode  = 0x32410002,
  .idmask  = 0xffffffff,
  .map_io  = s3c2410_map_io,
  .init_clocks = s3c2410_init_clocks,
  .init_uarts = s3c2410_init_uarts,
  .init  = s3c2410a_init,
  .name  = name_s3c2410a
 },
 {
  .idcode  = 0x32440000,
  .idmask  = 0xffffffff,
  .map_io  = s3c244x_map_io,
  .init_clocks = s3c244x_init_clocks,
  .init_uarts = s3c244x_init_uarts,
  .init  = s3c2440_init,
  .name  = name_s3c2440
 },
 {
  .idcode  = 0x32440001,
  .idmask  = 0xffffffff,
  .map_io  = s3c244x_map_io,
  .init_clocks = s3c244x_init_clocks,
  .init_uarts = s3c244x_init_uarts,
  .init  = s3c2440_init,
  .name  = name_s3c2440a
 },
 {
  .idcode  = 0x32440aaa,
  .idmask  = 0xffffffff,
  .map_io  = s3c244x_map_io,
  .init_clocks = s3c244x_init_clocks,
  .init_uarts = s3c244x_init_uarts,
  .init  = s3c2442_init,
  .name  = name_s3c2442
 },
 {
  .idcode  = 0x32440aab,
  .idmask  = 0xffffffff,
  .map_io  = s3c244x_map_io,
  .init_clocks = s3c244x_init_clocks,
  .init_uarts = s3c244x_init_uarts,
  .init  = s3c2442_init,
  .name  = name_s3c2442b
 },
 {
  .idcode  = 0x32412001,
  .idmask  = 0xffffffff,
  .map_io  = s3c2412_map_io,
  .init_clocks = s3c2412_init_clocks,
  .init_uarts = s3c2412_init_uarts,
  .init  = s3c2412_init,
  .name  = name_s3c2412,
 },
 {   
  .idcode  = 0x32412003,
  .idmask  = 0xffffffff,
  .map_io  = s3c2412_map_io,
  .init_clocks = s3c2412_init_clocks,
  .init_uarts = s3c2412_init_uarts,
  .init  = s3c2412_init,
  .name  = name_s3c2412,
 },
 {
  .idcode  = 0x32443001,
  .idmask  = 0xffffffff,
  .map_io  = s3c2443_map_io,
  .init_clocks = s3c2443_init_clocks,
  .init_uarts = s3c2443_init_uarts,
  .init  = s3c2443_init,
  .name  = name_s3c2443,
 },
 {
  .idcode  = 0x0,  
  .idmask  = 0xffffffff,
  .map_io  = s3c2400_map_io,
  .init_clocks = s3c2400_init_clocks,
  .init_uarts = s3c2400_init_uarts,
  .init  = s3c2400_init,
  .name  = name_s3c2400
 },
};

在这里，我们只关心.name为.name  = name_s3c2440的数组元素。这里.init_clocks部位NULL，那么函数s3c24xx_init_clocks中的(cpu->init_clocks)(xtal)将被运行。

接着就到了s3c244x.c中的函数s3c244x_init_clocks：

---------------------------------------------------------

void __init s3c244x_init_clocks(int xtal)
{
 

 s3c24xx_register_baseclocks(xtal);
 s3c244x_setup_clocks();
 s3c2410_baseclk_add();
}
--------------------------------------------------------------------------------------------------
在s3c244x_init_clocks函数里，有三个函数

s3c24xx_register_baseclocks(xtal);这个函数用来注册clk_xtal，clk_mpll，clk_upll，clk_f，clk_h，clk_p六个clk类型的时钟。

s3c244x_setup_clocks()是时钟的设置。

s3c2410_baseclk_add()添加不同部件的时钟，以便驱动中使用。后面会相信分析。

下面一个一个来分析他们这三个函数到底做了什么工作。

s3c24xx_register_baseclocks(xtal)函数定义如下：

-------------------------------------------------

int __init s3c24xx_register_baseclocks(unsigned long xtal)
{
 printk(KERN_INFO "S3C24XX Clocks, (c) 2004 Simtec Electronics\n");

 clk_xtal.rate = xtal;

 

 if (s3c24xx_register_clock(&clk_xtal) < 0)
  printk(KERN_ERR "failed to register master xtal\n");

 if (s3c24xx_register_clock(&clk_mpll) < 0)
  printk(KERN_ERR "failed to register mpll clock\n");

 if (s3c24xx_register_clock(&clk_upll) < 0)
  printk(KERN_ERR "failed to register upll clock\n");

 if (s3c24xx_register_clock(&clk_f) < 0)
  printk(KERN_ERR "failed to register cpu fclk\n");

 if (s3c24xx_register_clock(&clk_h) < 0)
  printk(KERN_ERR "failed to register cpu hclk\n");

 if (s3c24xx_register_clock(&clk_p) < 0)
  printk(KERN_ERR "failed to register cpu pclk\n");

 return 0;
}
--------------------------------------------------------

就如上面所说的，这个函数通过调用s3c24xx_register_clock（）一一注册了六个时钟变量clk_xtal，clk_mpll，clk_upll，clk_f，clk_h，clk_p。它们定义在文件plat-s3c的clock.c中：

struct clk clk_xtal = {
 .name  = "xtal",
 .id  = -1,
 .rate  = 0,
 .parent  = NULL,
 .ctrlbit = 0,
};

struct clk clk_ext = {
 .name  = "ext",
 .id  = -1,
};

struct clk clk_epll = {
 .name  = "epll",
 .id  = -1,
};

struct clk clk_mpll = {
 .name  = "mpll",
 .id  = -1,
 .set_rate = clk_default_setrate,
};

struct clk clk_upll = {
 .name  = "upll",
 .id  = -1,
 .parent  = NULL,
 .ctrlbit = 0,
};

struct clk clk_f = {
 .name  = "fclk",
 .id  = -1,
 .rate  = 0,
 .parent  = &clk_mpll,
 .ctrlbit = 0,
 .set_rate = clk_default_setrate,
};

struct clk clk_h = {
 .name  = "hclk",
 .id  = -1,
 .rate  = 0,
 .parent  = NULL,
 .ctrlbit = 0,
 .set_rate = clk_default_setrate,
};

struct clk clk_p = {
 .name  = "pclk",
 .id  = -1,
 .rate  = 0,
 .parent  = NULL,
 .ctrlbit = 0,
 .set_rate = clk_default_setrate,
};

struct clk结构体的定义如下：

---------------------------------------------------------------------------------------

struct clk {
 struct list_head      list;
 struct module        *owner;
 struct clk           *parent;
 const char           *name;
 int        id;
 int        usage;
 unsigned long         rate;
 unsigned long         ctrlbit;

 int      (*enable)(struct clk *, int enable);
 int      (*set_rate)(struct clk *c, unsigned long rate);
 unsigned long     (*get_rate)(struct clk *c);
 unsigned long     (*round_rate)(struct clk *c, unsigned long rate);
 int      (*set_parent)(struct clk *c, struct clk *parent);
};

------------------------------------------------------------------------------------------

注册代码如下：

-------------------------------------------------------------------------------------

int s3c24xx_register_clock(struct clk *clk)
{
 if (clk->enable == NULL)
  clk->enable = clk_null_enable;

 

 
 BUG_ON(clk->list.prev != clk->list.next);

 spin_lock(&clocks_lock);
 list_add(&clk->list, &clocks);
 spin_unlock(&clocks_lock);

 return 0;
}
--------------------------------------------------------
主要看list_add(&clk->list,&clocks).系统中存在一个clocks的列表，这个就是通过list_add()把clk的list添加到这个列表中，从而注册。

 

s3c244x_setup_clocks()函数如下：

---------------------------------------------------------------------------

void __init_or_cpufreq s3c244x_setup_clocks(void)
{
 struct clk *xtal_clk;
 unsigned long clkdiv;
 unsigned long camdiv;
 unsigned long xtal;
 unsigned long hclk, fclk, pclk;
 int hdiv = 1;

 xtal_clk = clk_get(NULL, "xtal");
 xtal = clk_get_rate(xtal_clk);
 clk_put(xtal_clk);

 fclk = s3c24xx_get_pll(__raw_readl(S3C2410_MPLLCON), xtal) * 2;

 clkdiv = __raw_readl(S3C2410_CLKDIVN);
 camdiv = __raw_readl(S3C2440_CAMDIVN);

 

 switch (clkdiv & S3C2440_CLKDIVN_HDIVN_MASK) {
 case S3C2440_CLKDIVN_HDIVN_1:
  hdiv = 1;
  break;

 case S3C2440_CLKDIVN_HDIVN_2:
  hdiv = 2;
  break;

 case S3C2440_CLKDIVN_HDIVN_4_8:
  hdiv = (camdiv & S3C2440_CAMDIVN_HCLK4_HALF) ? 8 : 4;
  break;

 case S3C2440_CLKDIVN_HDIVN_3_6:
  hdiv = (camdiv & S3C2440_CAMDIVN_HCLK3_HALF) ? 6 : 3;
  break;
 }

 hclk = fclk / hdiv;
 pclk = hclk / ((clkdiv & S3C2440_CLKDIVN_PDIVN) ? 2 : 1);

 

 printk("S3C244X: core %ld.ld MHz, memory %ld.ld MHz, peripheral %ld.ld MHz\n",
        print_mhz(fclk), print_mhz(hclk), print_mhz(pclk));

 s3c24xx_setup_clocks(fclk, hclk, pclk);
}
---------------------------------------------------------------------------

在这里有必要简单的说下s3c2440的时钟发生模块

 

主时钟源来自外部晶振（XTIpll）或者外部时钟。用芯片引脚OM[3:2]来选择，一般情况下，OM3和OM2接地，这样，主时钟源即为外部晶振（此时USB时钟源也是外部晶振）。集成电路MPLL产生一个在频率和相位上同步于参考输入信号的输出信号，计算公式为：

Mpll=(2*m*Fin)(p*2^s)

m=M(分频系数M)+8, p=P(分频系数P)+2

              集成电路UPLL的工作原理与MPLL相同。

              M、P、S的值由PLL控制寄存器（MPLLCON和UPLLCON）来设置。

 

              图中的CLKCNTL模块主要由时钟控制寄存器CLKCON和慢速时钟控制寄存器CLKSLOW两个寄存器组成，一方面，它可以控制外围设备的时钟使能，从而实现功耗控制；另一方面，它还可以控制PLL，使FCLK=Mpll或者FCLK=输入时钟（外部晶振或者外部时钟）的分频。

 

              FCLK作为芯片核心ARM920T模块的时钟。

              HCLK也可以为ARM920T提供时钟（当CAMERA时钟分频寄存器的DVS_EN位为1时，HCLK作为ARM核心时钟），HCLK也为内存控制器、中断控制器、LCD控制器、DMA和USB HOST模块提供时钟。

              PCLK为WDT、IIS、IIC、PWM定时器、MMC接口、ADC、UART、GPIO、RTC和SPI提供时钟。

              FCLK、HCLK和PCLK之间的关系由时钟分频控制寄存器CLKDIVN（包括HDIVN和PDIVN两个部分）来决定。

 

              图中的USBCNTL模块主要是为USB host接口和USB设备接口提供正常工作需要的48MHz时钟，UCLK主要有4个状态：

1）刚刚复位时，UCLK为外部晶振或外部时钟。

2）配置UPLL结束后，在UPLL稳定时间内，UCLK为低电平，UPLL稳定时间结束，UCLK为48MHz。

3）CLKSLOW寄存器关闭UPLL，UCLK为外部晶振或者外部时钟。

4）CLKSLOW寄存器打开UPLL，UCLK为48MHz。

 

              图中的POWERCNTL模块主要实现功耗控制的功能。PLL稳定时间由稳定时间寄存器LOCKTIME来控制，此寄存器一般设为0xFFFFFFFF。

 

下面接着函数分析，在函数 s3c244x_setup_clocks（）中用到了clk_get，clk_get_rate，clk_put这些函数，这些都是对时钟机制的一个封装，对外提供的API接口。

在plat-s3c/clock.c中可以看到这些API的定义：

//传入参数dev和dev获取相应的模块的时钟clk结构体

struct clk *clk_get(struct device *dev, const char *id)
{
  struct clk *p;
  struct clk *clk = ERR_PTR(-ENOENT);
  int idno;

  if (dev == NULL || dev->bus != &platform_bus_type)
    idno = -1;
  else
    idno = to_platform_device(dev)->id;

  spin_lock(&clocks_lock);

  list_for_each_entry(p, &clocks, list) {
    if (p->id == idno &&
          strcmp(id, p->name) == 0 &&
          try_module_get(p->owner)) {
      clk = p;
      break;
    }
  }

 

  if (IS_ERR(clk)) {
    list_for_each_entry(p, &clocks, list) {
      if (p->id == -1 && strcmp(id, p->name) == 0 &&
            try_module_get(p->owner)) {
        clk = p;
        break;
      }
    }
  }

  spin_unlock(&clocks_lock);
  return clk;
}

void clk_put(struct clk *clk)
{
  module_put(clk->owner);
}

//启动时钟

int clk_enable(struct clk *clk)
{
  if (IS_ERR(clk) || clk == NULL)
    return -EINVAL;

  clk_enable(clk->parent);

  spin_lock(&clocks_lock);

  if ((clk->usage++) == 0)
    (clk->enable)(clk, 1);

  spin_unlock(&clocks_lock);
  return 0;
}

//禁止时钟，通过调用具体clk的disable

void clk_disable(struct clk *clk)
{
  if (IS_ERR(clk) || clk == NULL)
    return;

  spin_lock(&clocks_lock);

  if ((--clk->usage) == 0)
    (clk->enable)(clk, 0);

  spin_unlock(&clocks_lock);
  clk_disable(clk->parent);
}

unsigned long clk_get_rate(struct clk *clk)
{
  if (IS_ERR(clk))
    return 0;

  if (clk->rate != 0)
    return clk->rate;

  if (clk->get_rate != NULL)
    return (clk->get_rate)(clk);

  if (clk->parent != NULL)
    return clk_get_rate(clk->parent);

  return clk->rate;
}

long clk_round_rate(struct clk *clk, unsigned long rate)
{
  if (!IS_ERR(clk) && clk->round_rate)
    return (clk->round_rate)(clk, rate);

  return rate;
}

int clk_set_rate(struct clk *clk, unsigned long rate)
{
  int ret;

  if (IS_ERR(clk))
    return -EINVAL;

 

  WARN_ON(clk->set_rate == NULL);

  if (clk->set_rate == NULL)
    return -EINVAL;

  spin_lock(&clocks_lock);
  ret = (clk->set_rate)(clk, rate);
  spin_unlock(&clocks_lock);

  return ret;
}

struct clk *clk_get_parent(struct clk *clk)
{
  return clk->parent;
}

int clk_set_parent(struct clk *clk, struct clk *parent)
{
  int ret = 0;

  if (IS_ERR(clk))
    return -EINVAL;

  spin_lock(&clocks_lock);

  if (clk->set_parent)
    ret = (clk->set_parent)(clk, parent);

  spin_unlock(&clocks_lock);

  return ret;
}

EXPORT_SYMBOL(clk_get);
EXPORT_SYMBOL(clk_put);
EXPORT_SYMBOL(clk_enable);
EXPORT_SYMBOL(clk_disable);
EXPORT_SYMBOL(clk_get_rate);
EXPORT_SYMBOL(clk_round_rate);
EXPORT_SYMBOL(clk_set_rate);
EXPORT_SYMBOL(clk_get_parent);
EXPORT_SYMBOL(clk_set_parent);

上面的函数比较简单，都是在clocks这个列表中通过一定的条件获得clk，或者通过获得的clk调用clk结构体里面的定义函数完成相应的功能。

xtal_clk = clk_get(NULL, "xtal");获取xtal即描述晶振的clk结构体。xtal = clk_get_rate(xtal_clk);获得晶振的频率为12MHz,我们可以看到在s3c24xx_register_baseclocks函数中clk_xtal.rate = xtal;实现赋值。

clk_put(xtal_clk);不太理解。好像与模块有关。

fclk = s3c24xx_get_pll(__raw_readl(S3C2410_MPLLCON), xtal) * 2;这个函数通过读取寄存器值在通过公式计算出FCLK的值具体的计算方法看看datasheet。

然后clkdiv = __raw_readl(S3C2410_CLKDIVN);
  camdiv = __raw_readl(S3C2440_CAMDIVN);获得了寄存器CLKDIVN和CAMDIVN的值

寄存器描述如下：

所以接下来的switch()语句得到一个hdiv值来进一步获得hclk和pclk的频率。这两个频率相当重要，作用上面已经提到。最后一个是s3c24xx_setup_clocks（），不知道你们又没留心看有上面提到的clk_upll,clk_mpll,clk_h,clk_f没有初始化他们的频率，那么s3c24xx_setup_clocks（）正是起到了这样的一个作用。s3c244x_setup_clocks（）函数分析完了，接下来是s3c2410_baseclk_add（）函数。从这个函数表面的意思来看，是添加一些基本的时钟。的确如此。这些时钟是一些抽象的概念，板上一个设备对应相应的一个时钟。从本质上看，这些时钟其实都是pclk,hclk,fclk等。只不过是面向对象话得抽象了。那么这些时钟有哪里呢。都是些什么。

文件s3c2410-clock.c中定义了两个数组static struct clk init_clocks[] ，static struct clk init_clocks_disable[]。

---------------------------------------------------------------------------------------

static struct clk init_clocks_disable[] = {
  {
    .name    = "nand",
    .id    = -1,
    .parent    = &clk_h,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_NAND,
  }, {
    .name    = "sdi",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_SDI,
  }, {
    .name    = "adc",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_ADC,
  }, {
    .name    = "i2c",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_IIC,
  }, {
    .name    = "iis",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_IIS,
  }, {
    .name    = "spi",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_SPI,
  }
};

static struct clk init_clocks[] = {
  {
    .name    = "lcd",
    .id    = -1,
    .parent    = &clk_h,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_LCDC,
  }, {
    .name    = "gpio",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_GPIO,
  }, {
    .name    = "usb-host",
    .id    = -1,
    .parent    = &clk_h,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_USBH,
  }, {
    .name    = "usb-device",
    .id    = -1,
    .parent    = &clk_h,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_USBD,
  }, {
    .name    = "timers",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_PWMT,
  }, {
    .name    = "uart",
    .id    = 0,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_UART0,
  }, {
    .name    = "uart",
    .id    = 1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_UART1,
  }, {
    .name    = "uart",
    .id    = 2,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_UART2,
  }, {
    .name    = "rtc",
    .id    = -1,
    .parent    = &clk_p,
    .enable    = s3c2410_clkcon_enable,
    .ctrlbit  = S3C2410_CLKCON_RTC,
  }, {
    .name    = "watchdog",
    .id    = -1,
    .parent    = &clk_p,
    .ctrlbit  = 0,
  }, {
    .name    = "usb-bus-host",
    .id    = -1,
    .parent    = &clk_usb_bus,
  }, {
    .name    = "usb-bus-gadget",
    .id    = -1,
    .parent    = &clk_usb_bus,
  },
}; 

--------------------------------------------------------------------------------------------------

这两个又什么区别呢，init_clocks_disable[]数组里面的时钟在系统启动的时候要关闭的，而init_clocks里面的是要系统启动要初始化的。所以在启动时间我们要谨慎的关闭我们哪些不需要的时钟。就像LCD，如果启动的时候启动时钟打开DMA请求，那么就会出问题。相反启动过后LCD运行着关闭他的时钟也是很危险的。

下面是s3c2410_baseclk_add（）的源码：

--------------------------------------------------------------------------------------------

int __init s3c2410_baseclk_add(void)
{
  unsigned long clkslow = __raw_readl(S3C2410_CLKSLOW);
  unsigned long clkcon  = __raw_readl(S3C2410_CLKCON);
  struct clk *clkp;
  struct clk *xtal;
  int ret;
  int ptr;

  clk_upll.enable = s3c2410_upll_enable;

  if (s3c24xx_register_clock(&clk_usb_bus) < 0)
    printk(KERN_ERR "failed to register usb bus clock\n");

 

  clkp = init_clocks;
  for (ptr = 0; ptr < ARRAY_SIZE(init_clocks); ptr++, clkp++) {
   

    clkp->usage = clkcon & clkp->ctrlbit ? 1 : 0;

    ret = s3c24xx_register_clock(clkp);
    if (ret < 0) {
      printk(KERN_ERR "Failed to register clock %s (%d)\n",
                  clkp->name, ret);
    }
  }

 

 

  clkp = init_clocks_disable;
  for (ptr = 0; ptr < ARRAY_SIZE(init_clocks_disable); ptr++, clkp++) {

    ret = s3c24xx_register_clock(clkp);
    if (ret < 0) {
      printk(KERN_ERR "Failed to register clock %s (%d)\n",
                  clkp->name, ret);
    }

    s3c2410_clkcon_enable(clkp, 0);
  }

 

  xtal = clk_get(NULL, "xtal");

  printk("CLOCK: Slow mode (%ld.%ld MHz), %s, MPLL %s, UPLL %s\n",
              print_mhz(clk_get_rate(xtal) /
      ( 2 * S3C2410_CLKSLOW_GET_SLOWVAL(clkslow))),
              (clkslow & S3C2410_CLKSLOW_SLOW) ? "slow" : "fast",
              (clkslow & S3C2410_CLKSLOW_MPLL_OFF) ? "off" : "on",
              (clkslow & S3C2410_CLKSLOW_UCLK_OFF) ? "off" : "on");

  s3c_pwmclk_init();
  return 0;
}
---------------------------------------------------------------------------------------------

两个for语句分别安装了上面提到的两个数组的时钟，相关的初始化结构体。赋值了clk_upll.enable。最后面初始化和注册了PWM时钟。PWM时钟的注册和其他分开始因为它比较特别。

未完待续......