子曰小玖
子曰小玖

SD / eMMC的驱动详解

转自：http://blog.csdn.net/junzhang1122/article/details/50175677


总论

 1.1概念

  • MMC - 多媒体卡
  • SD - 安全数字卡

1.2分类

  • 按存储大小，普通SD卡（<= 2GB，支持FAT12 / FAT16），HCSD卡（> 2GB，<= 32GB，支持FAT32）
  • 按体积大小，普通SD卡，迷你SD卡，微SD卡（TF卡）

1.3速度

  • 默认模式：12.5MB / s1
  • 高速模式：25MB / s的

     .4子系统代码结构

         

     Linux的源码里/司机/ MMC下有三个文件夹，分别存放了SD块设备，核心层和SD主控制器的相关代码，可以通过的Kconfig和Makefile文件获取更多信息。

 

主控制器

    SD卡的控制器芯片，可以看成CPU的代言人，它为CPU分担了完成与SD卡数据通信的任务。

2.1数据结构

     以PXA芯片的SD控制器驱动为例：

代码位于：\核心\ DRIVERS \ MMC \主机\ pxamci.c

[cpp]  查看纯 文本  
  1. //该结构体有自己编写，根据实际项目来编写自己的主机结构体  
  2. struct  pxamci_host {  
  3.  struct  mmc_host * mmc;  
  4.   
  5.  struct  mmc_request * mrq;  
  6.  struct  mmc_command * cmd;  
  7.  struct  mmc_data * data;  
  8.   
  9.  ... ...  
  10. };  

2.1.1 struct mmc_host

     结构体mmc_host定义于/include/linux/mmc/host.c，可以认为是Linux的为SD卡控制器专门准备的一个类，该类里面的成员是所有SD卡控制器都需要的，放之四海而皆准的数据结构，而在PXA芯片控制器的驱动程序pxamci.c中，则为该类具体化了一个对象struct mmc_host * mmc，此mmc指针即指代着该PXA芯片SD卡控制器的一个具体化对象。

[cpp]  查看纯 文本  
  1. struct  mmc_host {  
  2.  const struct  mmc_host_ops * ops;     // SD卡主控制器的操作函数，即该控制器所具备的驱动能力   
  3.   
  4.  const struct  mmc_bus_ops * bus_ops; // SD总线驱动的操作函数，即SD总线所具备的驱动能力   
  5.   
  6.  struct  mmc_ios ios;  //配置时钟，总线，电源，片选，时序等  
  7.   
  8.  结构 mmc_card *卡;  //连接到此主控制器的SD卡设备  
  9.     ... ...  
  10. };  
[cpp]  查看纯 文本  
  1. struct  mmc_host_ops {  
  2.  void  （* request）（struct  mmc_host * host，  struct  mmc_request * req）;  //核心函数，完成主控制器与SD卡设备之间的数据通信  
  3.  void  （* set_ios）（struct  mmc_host * host，  struct  mmc_ios * ios）;  //配置时钟，总线，电源，片选，时序等  
  4.  int  （* get_ro）（struct  mmc_host * host）; //获取GPIO管脚，判断是否是写保护  
  5.  void  （* enable_sdio_irq）（struct  mmc_host * host，  int  enable）; //卡插入与拔出中断  
  6. };  
[cpp]  查看纯 文本  
  1. struct  mmc_bus_ops {  
  2.  void  （* remove）（struct  mmc_host *）;    //拔出SD卡的回调函数  
  3.  void  （* detect）（struct  mmc_host *）;      //探测SD卡是否还在SD总线上的回调函数  
  4.  void  （* suspend）（struct  mmc_host *）;  
  5.  void  （* resume）（struct  mmc_host *）;  
  6. };  
[cpp]  查看纯 文本  
  1. struct  mmc_card {  
  2.  struct  mmc_host * host;  / *此设备所属的主机* /  
  3.  结构 设备开发  /* 装置 */  
  4.  无符号  int  rca;  / *设备的相对卡地址* /  
  5.  unsigned  int   类型;  /* 卡的种类 */  
  6.  无符号  int   状态;  / *（我们）卡状态* /  
  7.  无符号的  int   怪癖;  / *卡怪* *  
  8.  u32 raw_cid [4]; / *原卡CID * /  
  9.  u32 raw_csd [4]; / *原卡CSD * /  
  10.  u32 raw_scr [2]; / *原卡SCR * /  
  11.  struct  mmc_cid cid;  / *卡片识别* /  
  12.  struct  mmc_csd csd;  / *卡特定* /  
  13.  struct  mmc_ext_csd ext_csd; / * mmc v4扩展卡特定* /  
  14.  struct  sd_scr scr;  / *额外的SD信息* /  
  15.  struct  sd_switch_caps sw_caps; / * switch（CMD6）caps * /  unsigned  int   sdio_funcs; / * SDIO功能* /  
  16.  struct  sdio_cccr cccr;  / *普通卡信息* /  
  17.  结构 sdio_cis顺式;  / * common tuple info * /  
  18.    ... ...  
  19. };  

mmc_card结构体内的数据结构主要存放SD卡的信息，其中RCA，CID，CSD，SCR为SD卡内部的32位寄存器。

 

 2.1.2 struct mmc_request

      结构体mmc_request定义于/include/linux/mmc/core.h，它主要存放两大数据结构的指针，分别是CMD和数据，顾名思意，一个为指令，一个为数据，也就是说，mmc_request结构体存储了进行主控制器与sd卡间通信所需要的指令和数据，struct mmc_request，struct mmc_command * cmd，struct mmc_data * data三者之间的关系如下所示， 


[cpp]  查看纯 文本  
  1. struct  mmc_request {  
  2.  struct  mmc_command * cmd;  
  3.   struct  mmc_data * data;  
  4.   struct  mmc_command * stop;  
  5.   
  6.  void    * done_data; / *完成数据* /  
  7.   void    （* done）（struct  mmc_request *）; / *完成功能* /  
  8.  };  

  说到结构体mmc_command和mmc_data，就必须说说SD卡的协议了。

   1）物理结构

     SD卡有9个销脚（微SD为8个，少一个接地销脚），如图所示，

   SD的数据传输方式有两种，普通SD模式和SPI模式，以SD模式为例，9个销脚分别是VDD，VSS，CLK，以及我们需要关注的一根指令线CMD，4根数据线DAT0 〜DAT3。

   2）传输模式

   首先由主机向SD卡发送命令的命令，等待SD卡的回复响应，如果成功收到回复，则进行数据传输。其中，指令线和数据线上传输的指令和数据都要遵循相应的协议格式。

 

   3）指令格式

  

   一条指令命令共48位，其中指令索引指代这些条具具体的指令名称，参数为该指令的参数。

   一条回复响应根据不同的指令有几种不同类型。

[cpp]  查看纯 文本  
  1. struct  mmc_command {  
  2.   u32操作码            //对应命令索引  
  3.   u32 arg                  //对应参数  
  4.   u32 resp [4];           //对应响应  
  5.   无符号  int   标志;  / *预期响应类型* /  
  6.   
  7.  ... ...  
  8.   
  9.  unsigned  int   retries; / *最大重试次数* /  
  10.   无符号  int   错误;  / *命令错误* /  
  11.   
  12.  struct  mmc_data * data;  / *与cmd * /  
  13.   struct  mmc_request * mrq;  / *相关请求* /  
  14.  };   
 4）数据格式

   数据传输按数据线可分为一线传输和四线传输，按数据大小可分为字节传输和块传输（512字节）。

[cpp]  查看纯 文本  
  1. struct  mmc_data {  
  2.   unsigned  int   timeout_ns; / *数据超时（ns，最大80ms）* /  
  3.   unsigned  int   timeout_clks; / *数据超时（以时钟为单位）* /  
  4.   unsigned  int   blksz;  / *数据块大小* /  
  5.   无符号  int   块;  / *块数* /  
  6.   无符号  int   错误;  / *数据错误* /  
  7.   无符号  int   标志;  
  8.   
  9. #define MMC_DATA_WRITE（1 << 8）  
  10.  #define MMC_DATA_READ（1 << 9）  
  11.  #define MMC_DATA_STREAM（1 << 10）  
  12.   
  13.  unsigned  int   bytes_xfered;  
  14.   
  15.  struct  mmc_command * stop;  / *停止命令* /  
  16.   struct  mmc_request * mrq;  / *相关请求* /  
  17.   
  18.  unsigned  int   sg_len;  / *散点表大小* /  
  19.   struct  scatterlist * sg;  / * I / O散列表* /  
  20.  };  

2.2驱动程序

   系统初始化时间扫描平台总线上是否有名为该SD主控制器名字“pxa2xx-mci”的设备，如果有，驱动程序将主控制器挂载到平台总线上，并注册该驱动程序。

[cpp]  查看纯 文本  
  1.  static int  __init pxamci_init（void ）   
  2.  {  
  3.   
  4.   返回 platform_driver_register（＆pxamci_driver）;  
  5.  }  
  6.   
  7. static struct  platform_driver pxamci_driver = {   
  8.   .probe = pxamci_probe，  
  9.   .remove = pxamci_remove，  
  10.   .suspend = pxamci_suspend，  
  11.   .resume = pxamci_resume，  
  12.   .driver = {  
  13.    .name =“pxa2xx-mci”，  
  14.    .owner = THIS_MODULE，  
  15.   }，  
  16.  };   

其中，除去为探头的反操作，暂停和恢复涉及电源管理的内容，本文重点讨论的探针。

SD主控制器驱动程序的初始化函数探针（struct platform_device * pdev），概要地讲，主要完成五大任务，

  • 初始化设备的数据结构，并将数据挂载到pdev-> dev.driver_data下
  • 实现设备驱动的功能函数，如mmc-> ops =＆pxamci_ops;
  • 申请中断函数的request_irq（）
  • 注册设备，即注册的kobject，建立SYS文件，发送UEVENT等
  • 其他需求，如在的/ proc /驱动器下建立用户交互文件等

2.2.1注册设备

    对于设备的注册，所有设备驱动的相关代码都类似

[cpp]  查看纯 文本  
  1. static int  pxamci_probe（struct  platform_device * pdev）   
  2.   
  3. {  
  4.   
  5.   mmc = mmc_alloc_host（sizeof （struct  pxamci_host），＆pdev-> dev）;  
  6.   
  7.   mmc_add_host（MMC）;  
  8.   
  9.   ... ...  
  10.   
  11. }  

这两个函数都由/司机/ MMC /核心核心层下的host.c负责具体实现，

1）mmc_alloc_host

为主设备控制器建立数据结构，建立kobject，并初始化等待队列，工作队列，以及一些控制器的配置。其中，INIT_DELAYED_WORK（＆host-> detect，mmc_rescan）;将探测SD卡的函数mmc_rescan与工作队列 - >检测关联，mmc_rescan是整个SD子系统的核心函数，本文第三部分协议层将对它作重点讨论。

[cpp]  查看纯 文本  
  1. struct  mmc_host * mmc_alloc_host（int  extra，  struct  device * dev）  
  2.  {  
  3.   
  4. / *建立数据结构* /  
  5.   
  6.  struct  mmc_host * host;  
  7.   
  8.  host = kzalloc（sizeof （struct  mmc_host）+ extra，GFP_KERNEL）;  
  9.   
  10. / *建立kobject * /  
  11.   
  12.  host-> parent = dev;  
  13.   host-> class_dev.parent = dev;  
  14.   主机- > class_dev。class  =＆mmc_host_class;  
  15.   device_initialize（主机 - > class_dev）;  
  16.   
  17. / *初始化等待队列，工作队列* /  
  18.   
  19.  init_waitqueue_head（主机 - > WQ）;  
  20.   INIT_DELAYED_WORK（＆host-> detect，mmc_rescan）;  
  21.   
  22.    
  23.   
  24. / *配置控制器* /  
  25.   
  26.  host-> max_hw_segs = 1;  
  27.   host-> max_phys_segs = 1;  
  28.   
  29.  ... ...  
  30.   返回 主机  
  31.  }  

2）mmc_add_host

完成的kobject的注册，并调用mmc_rescan，目的在于在系统初始化的时候就扫描SD总线查看是否存在SD卡。注意到这里的工作队列的延时时间延迟为0，因为系统启动的时候不考虑插拔SD卡，关于这个延迟将在下文讨论。

[cpp]  查看纯 文本  
  1. int  mmc_add_host（struct  mmc_host * host）  
  2.  {  
  3.    device_add（主机 - > class_dev）;  
  4.    mmc_start_host（主机）;  
  5.   
  6.   ... ...  
  7.   
  8. }  
  9.   
  10. void  mmc_start_host（struct  mmc_host * host）  
  11.  {  
  12.   mmc_power_off（主机）;  
  13.   mmc_detect_change（host，0）;  
  14.  }  
  15.   
  16.  void  mmc_detect_change（struct  mmc_host * host，unsigned  long  delay）  
  17.  {  
  18.   mmc_schedule_delayed_work（＆host-> detect，delay）;  
  19.  }  
  20.   
  21.  static int  mmc_schedule_delayed_work（struct  delayed_work * work，unsigned  long  delay）   
  22.  {  
  23.   wake_lock_timeout（＆mmc_delayed_work_wake_lock，HZ * 2）;  
  24.   return  queue_delayed_work（workqueue，work，delay）;  
  25.  }  
2.2.2为设备赋初值
   其实，整个设备驱动的probe（）函数，其本质就是为设备建立起数据结构并对其赋初值.pxamci_probe（struct platform_device * pdev）主要为SD主控制器完成时钟，存储等方面的初始化配置，
[cpp]  查看纯 文本  
  1. static int  pxamci_probe（struct  platform_device * pdev）   
  2.  {  
  3.   
  4.  struct  mmc_host * mmc;  
  5.   struct  pxamci_host * host = NULL;  
  6.   
  7.    
  8.   
  9.  mmc-> ops =＆pxamci_ops;  
  10.   
  11.  mmc-> max_phys_segs = NR_SG;  
  12.   mmc-> max_hw_segs = NR_SG;  
  13.   
  14.  mmc-> max_seg_size = PAGE_SIZE;  
  15.   
  16.  host = mmc_priv（mmc）;  
  17.   host-> mmc = mmc;  
  18.   host-> dma = -1;  
  19.   host-> pdata = pdev-> dev.platform_data;  
  20.   host-> clkrt = CLKRT_OFF;  
  21.   
  22.  host-> clk = clk_get（＆pdev-> dev，  “MMCCLK” ）;  
  23.   host-> clkrate = clk_get_rate（host-> clk）;  
  24.   
  25.  mmc-> caps | = MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED;  
  26.   
  27.  host-> sg_cpu = dma_alloc_coherent（＆pdev-> dev，PAGE_SIZE，＆host-> sg_dma，GFP_KERNEL）;  
  28.   
  29.  host-> dma = pxa_request_dma（DRIVER_NAME，DMA_PRIO_LOW，pxamci_dma_irq，host）;  
  30.   
  31.  ... ...  
  32.   
  33. }  
完成所有赋值后，通过platform_set_drvdata（pdev，mmc）;将数据挂载到pdev-> dev.driver_data。
所有赋值中，我们重点关注从platform_device * pdev里得到的数据.platform_device * pdev是在系统初始化的时间扫描平台总线发现SD主控制器后所得到的数据。
1）得到platform_data数据
先看看platform_device的结构，
[cpp]  查看纯 文本  
  1. struct  platform_device {  
  2.   const char  * name;   
  3.   int   id  
  4.   结构 设备开发  
  5.   u32 num_resources;  
  6.   结构 资源*资源;  
  7.  };  

系统初始化的时候，已经为该SD主控制器的名称，资源等赋上了初值，具体内容如下，

[cpp]  查看纯 文本  
  1. struct  platform_device pxa_device_mci = {  
  2.   .name =  “pxa2xx-mci” ，  
  3.   .id = 0，  
  4.   .dev = {  
  5.    .dma_mask =＆pxamci_dmamask，  
  6.    .coherent_dma_mask = 0xffffffff，  
  7.   }，  
  8.   .nu​​m_resources = ARRAY_SIZE（pxamci_resources），  
  9.   .resource = pxamci_resources，  
  10.  };  
  11.   
  12. 静态结构 资源pxamci_resources [] = {   
  13.   [0] = {  
  14.    .start = 0x41100000，  
  15.    .end = 0x41100fff，  
  16.    .flags = IORESOURCE_MEM，   // SD主控制器芯片的起始地址  
  17.  }，  
  18.   [1] = {  
  19.    .start = IRQ_MMC，           / * #define IRQ_MMC 23 * /  
  20.   
  21.   .end = IRQ_MMC，  
  22.    .flags = IORESOURCE_IRQ，   //申请的中断号  
  23.  }，  
  24.   ... ...  
  25.   
  26. };  

需要注意的是，platform_device数据结构里的名称，id，资源等是所有设备都用的到数据类型，那么设备自身独有的特性如何表现出来呢？事实上，结构体设备专门准备了一个成员的platform_data，就是为了挂载设备的一些特有的数据。（注意与driver_data相区别）

[cpp]  查看纯 文本  
  1. 结构 设备{  
  2.    void   * platform_data; / *平台具体数据，设备核心不碰它* /  
  3.   
  4.   void   * driver_data; / *数据私有的驱动程序* /  
  5.   
  6.   ... ...  
  7.   
  8. }  


看看SD主控制器为什么会有这些特有数据，

[cpp]  查看纯 文本  
  1. static struct  pxamci_platform_data saar_mci_platform_data = {   
  2.  .detect_delay = 50，  
  3.  .ocr_mask = MMC_VDD_32_33 | MMC_VDD_33_34，  
  4.  .init = saar_mci_init，  
  5.  .exit = saar_mci_exit，  
  6. };  

- > detect_delay
   就是刚才提到的工作队列的延时时间，设置为50毫秒，由于各种SD主控制器芯片的性能不同，这个值可能会变化。那么为什么要为工作队列加一个延迟呢？首先，当插入SD卡之后，SD主控制器上的探测引脚会产生一个中断，之后调用中断函数里的工作队列，然后执行工作队列里的mmc_rescan去扫描SD卡，为SD卡上电，发送地址，注册驱动等。考虑到插入SD卡需要一个短时间的过程（有个弹簧卡槽固定住SD卡），如果没有延迟，那么插入SD卡的一瞬间，SD卡还没有完全固定到主板上，系统就开始执行mmc_rescan，那么就很有可能在为SD卡上电，发送地址的过程中出现错误（拔出SD卡同理），因此，必须要有detect_delay这个值。
- > saar_mci_init
这个函数为SD主控制器的探测针脚申请中断，具体内容将在下文中断的一节中讨论。

[cpp]  查看纯 文本  
  1. static int  saar_mci_init（struct  device * dev，irq_handler_t saar_detect_int，  void  * data）   
  2.  {  
  3.   struct  platform_device * pdev = to_platform_device（dev）;  
  4.   int  cd_irq，gpio_cd;  // cd - 卡检测  
  5.   
  6.    
  7.   
  8.  saar_mmc_slot [0] .gpio_cd = mfp_to_gpio（MFP_PIN_GPIO61）;  //将GPIO61设为普通GPIO口  
  9.   
  10.  cd_irq = gpio_to_irq（saar_mmc_slot [pdev-> id] .gpio_cd）;   //将GPIO61转换为中断号  
  11.   
  12.  gpio_request（gpio_cd，  “mmc卡检测” ）;  //申请GPIO61  
  13.   gpio_direction_input（gpio_cd）;  //将GPIO61设为输入类型  
  14.   
  15.  request_irq（cd_irq，saar_detect_int，IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING，  “MMC卡检测” ，数据）;  
  16.   ... ...  
  17.   
  18. }  
得到SD主控制器特有数据后，将其挂载到dev.platform_data下，并最终完成对platform_device * dev的注册。
[cpp]  查看纯 文本  
  1. void  __init pxa_register_device（struct  platform_device * dev，  void  * data）  
  2.  {  
  3.   dev-> dev.platform_data = data;  
  4.   
  5.  platform_device_register（DEV）;  
  6.  }  

2）使用platform_data数据
  下面就看看SD主控制器是如何使用这些在系统初始化的时候就已经得到的platform_device的数据的，
[cpp]  查看纯 文本  
  1. static int  pxamci_probe（struct  platform_device * pdev）   
  2.  {  
  3.   struct  mmc_host * mmc;  
  4.   struct  pxamci_host * host = NULL;  
  5.   struct  resource * r;  
  6.   int  ret，irq;  
  7.   
  8.  r = platform_get_resource（pdev，IORESOURCE_MEM，0）;    //得到控制器芯片的起始地址  
  9.  r = request_mem_region（r-> start，SZ_4K，DRIVER_NAME）; //为芯片申请4k的内存空间  
  10.   
  11.  irq = platform_get_irq（pdev，0）;  //得到芯片的中断号  
  12.  host-> res = r;  
  13.   host-> irq = irq;  
  14.   
  15.  host-> base = ioremap（r-> start，SZ_4K）; //将芯片的物理地址映射为虚拟地址  
  16.   
  17.  ... ...  
  18.   
  19. }  

2.2.3设备驱动的功能函数

   一般情况下，设备驱动里都有一个行为函数结构体，比如字符设备驱动里的struct file_operations * fops，该结构描述了设备所有的工作能力，比如open，read，write等，
[cpp]  查看纯 文本  
  1. struct  file_operations {  
  2.   struct  module * owner;  
  3.   ssize_t（* read）（struct  file *，  char  __user *，  size_t ，loff_t *）;  
  4.   ssize_t（* write）（struct  file *，  const char  __user *，  size_t ，loff_t *）;   
  5.   int  （* open）（struct  inode *，  struct  file *）;  
  6.   
  7.  ... ...  
  8.  };  
同理，SD主控制器驱动程序里也有一个类似的结构struct mmc_host_ops * ops，它描述了该控制器所具备驱动的能力。
[cpp]  查看纯 文本  
  1. static int  pxamci_probe（struct  platform_device * pdev）   
  2.  {  
  3.   
  4.   mmc-> ops =＆pxamci_ops;  
  5.   
  6.   ... ...  
  7.   
  8. }  
  9.   
  10. static const struct  mmc_host_ops pxamci_ops = {    
  11.   .request = pxamci_request，  
  12.   .get_ro = pxamci_get_ro，  
  13.   .set_ios = pxamci_set_ios，  
  14.   .enable_sdio_irq = pxamci_enable_sdio_irq，  
  15.  };  
其中，（* set_ios）为主控制器设置总线和时钟等配置，（* get_ro）得到只读属性，（* enable_sdio_irq）开启SDIO中断，本文重点讨论（*请求）这个回调函数，它是整个SD主控制器驱动的核心，实现了SD主控制器能与SD卡进行通信的能力。
[cpp]  查看纯 文本  
  1. static void  pxamci_request（struct  mmc_host * mmc，  struct  mmc_request * mrq）   
  2.  {  
  3.   struct  pxamci_host * host = mmc_priv（mmc）; unsigned  int  cmdat;  
  4.   
  5.   
  6.    
  7.   
  8.  set_mmc_cken（host，1）;  
  9.   
  10.  host-> mrq = mrq;  
  11.   
  12.  cmdat = host-> cmdat;  
  13.   host-> cmdat＆=〜CMDAT_INIT;  
  14.   
  15.  if  （mrq-> data）{  
  16.    pxamci_setup_data（host，mrq-> data）;  
  17.   
  18.   cmdat＆=〜CMDAT_BUSY;  
  19.    cmdat | = CMDAT_DATAEN | CMDAT_DMAEN;  
  20.    if  （mrq-> data-> flags＆MMC_DATA_WRITE）  
  21.     cmdat | = CMDAT_WRITE;  
  22.   
  23.   if  （mrq-> data-> flags＆MMC_DATA_STREAM）  
  24.     cmdat | = CMDAT_STREAM;  
  25.   }  
  26.   
  27.  pxamci_start_cmd（host，mrq-> cmd，cmdat）;  
  28.  }  
其中，pxamci_setup_data（）实现数据传输，pxamci_start_cmd（）实现指令传输。

至此，我们必须去接触SD主控制器的芯片手册了。

首先，SD主控制器由一系列32位寄存器组成。通过软件的方式，即对寄存器赋值，来控制SD主控制器，进而扮演SD主控制器的角色与SD卡取得通信。

1）cmdat
  根据主控制器的芯片手册，寄存器MMC_CMDAT控制命令和数据的传输，具体内容如下，
结合对寄存器MMC_CMDAT的描述，分析代码，
[cpp]  查看纯 文本  
  1. host-> cmdat＆=〜CMDAT_INIT;               //非初始化状态  
  2.   
  3. if  （mrq-> data）{                                        //如果存在数据需要传输  
  4.  pxamci_setup_data（host，mrq-> data）;  //实现主控制器与SD卡之间数据的传输  
  5.   
  6.  cmdat＆=〜CMDAT_BUSY;                      //没有忙碌忙信号  
  7.  cmdat | = CMDAT_DATAEN | CMDAT_DMAEN;   //有数据传输，使用DMA  
  8.   if  （mrq-> data-> flags＆MMC_DATA_WRITE）      
  9.   
  10.   cmdat | = CMDAT_WRITE;                               //设置为写数据  
  11.   
  12.  if  （mrq-> data-> flags＆MMC_DATA_STREAM）  
  13.    cmdat | = CMDAT_STREAM;                             //设置为数据流流模式  
2）pxamci_setup_data通过DMA实现主控制器与SD卡之间数据的传输
[cpp]  查看纯 文本  
  1. static void  pxamci_setup_data（struct  pxamci_host * host，  struct  mmc_data * data）   
  2.  {  
  3.   host-> data = data;  
  4.   
  5.  writel（data-> blocks，host-> base + MMC_NOB）;     //设置块的数量  
  6.  writel（data-> blksz，host-> base + MMC_BLKLEN）;  //设置一个块的大小（一般为512byte）  
  7.   
  8.   if  （data-> flags＆MMC_DATA_READ）{  
  9.    host-> dma_dir = DMA_FROM_DEVICE;  
  10.    dcmd = DCMD_INCTRGADDR | DCMD_FLOWTRG;  
  11.    DRCMR（host-> dma_drcmrtx）= 0;  
  12.    DRCMR（host-> dma_drcmrrx）= host-> dma | DRCMR_MAPVLD;  
  13.   }  else  {  
  14.    host-> dma_dir = DMA_TO_DEVICE;  
  15.    dcmd = DCMD_INCSRCADDR | DCMD_FLOWSRC;  
  16.    DRCMR（host-> dma_drcmrrx）= 0;  
  17.    DRCMR（host-> dma_drcmrtx）= host-> dma | DRCMR_MAPVLD;  
  18.   }  
  19.   
  20.  dcmd | = DCMD_BURST32 | DCMD_WIDTH1;  
  21.   
  22.  host-> dma_len = dma_map_sg（mmc_dev（host-> mmc），data-> sg，data-> sg_len，host-> dma_dir）;  
  23.   
  24.  for  （i = 0; i dma_len; i ++）{  
  25.    unsigned  int  length = sg_dma_len（＆data-> sg [i]）;  
  26.    host-> sg_cpu [i] .dcmd = dcmd | 长度;  
  27.    if  （length＆31）  
  28.     host-> sg_cpu [i] .dcmd | = DCMD_ENDIRQEN;  
  29.    if  （data-> flags＆MMC_DATA_READ）{  
  30.     host-> sg_cpu [i] .dsadr = host-> res-> start + MMC_RXFIFO;  
  31.     host-> sg_cpu [i] .dtadr = sg_dma_address（＆data-> sg [i]）;  
  32.    }  else  {  
  33.     host-> sg_cpu [i] .dsadr = sg_dma_address（＆data-> sg [i]）;  
  34.     host-> sg_cpu [i] .dtadr = host-> res-> start + MMC_TXFIFO;  
  35.    }  
  36.    host-> sg_cpu [i] .ddadr = host-> sg_dma +（i + 1）*  
  37.       sizeof （struct  pxa_dma_desc）;  
  38.   }  
  39.   host-> sg_cpu [host-> dma_len - 1] .ddadr = DDADR_STOP;  
  40.   WMB（）;  
  41.   
  42.  DDADR（host-> dma）= host-> sg_dma;  
  43.   DCSR（host-> dma）= DCSR_RUN;  
  44.  }  
为（）循环里的内容是整个SD卡主控制器设备驱动的实质，通过DMA的方式实现主控制器与SD卡之间数据的读写操作。
3）pxamci_start_cmd实现主控制器与SD卡之间指令的传输
[cpp]  查看纯 文本  
  1. static void  pxamci_start_cmd（struct  pxamci_host * host，  struct  mmc_command * cmd，unsigned  int  cmdat）   
  2.  {  
  3.   host-> cmd = cmd;  
  4.   
  5.  if  （cmd-> flags＆MMC_RSP_BUSY）  
  6.    cmdat | = CMDAT_BUSY;  
  7.   
  8. #define RSP_TYPE（x）（（x）＆〜（MMC_RSP_BUSY | MMC_RSP_OPCODE））  
  9.   switch  （RSP_TYPE（mmc_resp_type（cmd）））{  
  10.   情况 RSP_TYPE（MMC_RSP_R1）：  / * r1，r1b，r6，r7 * /  
  11.    cmdat | = CMDAT_RESP_SHORT;  
  12.    打破;  
  13.   情况 RSP_TYPE（MMC_RSP_R3）：  
  14.    cmdat | = CMDAT_RESP_R3;  
  15.    打破;  
  16.   情况 RSP_TYPE（MMC_RSP_R2）：  
  17.    cmdat | = CMDAT_RESP_R2;  
  18.    打破;  
  19.   默认值：  
  20.    打破;  
  21.   }  
  22.   
  23.  writel（cmd-> opcode，host-> base + MMC_CMD）;  
  24.   writel（cmd-> arg >> 16，host-> base + MMC_ARGH）;  
  25.   writel（cmd-> arg＆0xffff，host-> base + MMC_ARGL）;  
  26.   writel（cmdat，host-> base + MMC_CMDAT）;  
  27.   
  28.  pxamci_start_clock（主机）;  
  29.   
  30.  pxamci_enable_irq（host，END_CMD_RES）;  
  31.  }  
- >响应类型
  根据SD卡的协议，当SD卡收到从控制器发来的CMD指令后，SD卡会发出响应相应，而响应的类型分为R1，R1B，R2，R3，R6，R7，这些类型分别对应不同的指令，各自的数据包结构也不同（具体内容参考SD卡协议）这里，通过RSP_TYPE对指令CMD的操作码的解析得到相对应的效应初探类型，再通过SWICH赋给寄存器MMC_CMDAT对应的[1： 0]位。
- >将指令和参数写入寄存器
  4行写1（）是整个SD卡主控制器设备驱动的实质，通过对主控制器芯片寄存器MMC_CMD，MMC_ARGH，MMC_ARGL，MMC_CMDAT的设置，实现主控制器发送指令到SD卡的功能。
4）调用（*请求）
 以上通过pxamci_request（）实现了主控制器的通信功能，之后只需通过host-> ops-> request（host，mrq）;回调函数即可。
协议层里，每条指令都会通过mmc_wait_for_req（host，＆mrq）调用到host-> ops-> request（host，mrq）来发送指令和数据。
[cpp]  查看纯 文本  
  1. / * core / core.c * /  
  2.   
  3. void  mmc_wait_for_req（struct  mmc_host * host，  struct  mmc_request * mrq）  
  4.  {  
  5.   DECLARE_COMPLETION_ONSTACK（完成）;  
  6.   
  7.  mrq-> done_data =＆complete;  
  8.   mrq-> done = mmc_wait_done;  
  9.   
  10.  mmc_start_request（host，mrq）;  
  11.   
  12.  wait_for_completion（完整）;  
  13.  }  
  14.   
  15. mmc_start_request（struct  mmc_host * host，  struct  mmc_request * mrq）  
  16.  {  
  17.   ... ...  
  18.   
  19.  host-> ops-> request（host，mrq）;  
  20.  }  
2.2.4申请中断
  pxamci_probe（struct platform_device * pdev）中有两个中断，一个为SD主控制器芯片内电路固有的内部中断，另一个为探测引脚的探测到外部有SD卡插拔引起的中断
1）由主控芯片内部电路引起的中断
  request_irq（host-> irq，pxamci_irq，0，“pxa2xx-mci”，host）;
回顾一下，宿主> IRQ就是刚才从platform_device里得到的中断号，
 irq = platform_get_irq（pdev，0）;
 host-> irq = irq;
接下来，pxamci_irq便是为该中断主机 - > IRQ申请的中断函数，
[cpp]  查看纯 文本  
  1. static  irqreturn_t pxamci_irq（int  irq，  void  * devid）  
  2.  {  
  3.   struct  pxamci_host * host = devid;   //得到主控制器的数据  
  4.  无符号  int  ireg; int  processed = 0;  
  5.   ireg = readl（host-> base + MMC_I_REG）＆〜readl（host-> base + MMC_I_MASK）;  //读取中断寄存器的值  
  6.   
  7.  if  （ireg）{  
  8.    unsigned stat = readl（host-> base + MMC_STAT）;  //读取状态寄存器的值  
  9.   
  10.   if  （ireg＆END_CMD_RES）  
  11.     已处理| = pxamci_cmd_done（host，stat）;  
  12.    if  （ireg＆DATA_TRAN_DONE）  
  13.     已处理| = pxamci_data_done（host，stat）;  
  14.    if  （ireg＆SDIO_INT）{  
  15.     mmc_signal_sdio_irq（主机 - > MMC）;  
  16.    }  
  17.   }  
  18.   
  19.  返回 IRQ_RETVAL（已处理）;  
  20.   
  21. }  

当调用（* request），即host-> ops-> request（host，mrq），即上文中的pxamci_request（）后，控制器与SD卡之间开始进行一次指令或数据传输，通信完毕后，主控芯片将产生一个内部中断，以告知此次指令或数据传输完毕。这个中断的具体值将保存在一个名为MMC_I_REG的中断寄存器中以供读取，中断寄存器MMC_I_REG中相关描述如下，

 

如果中断寄存器MMC_I_REG中的第0位有值，则意味着数据传输完成，执行pxamci_cmd_done（host，stat）;
如果中断寄存器MMC_I_REG中的第2位有值，则意味着指令传输完成，执行pxamci_data_done（host，stat）;
其中stat是从状态寄存器MMC_STAT中读取的值，在代码里主要起到处理错误状态的作用
- > pxamci_cmd_done收到结束指令的内部中断信号，主控制器从SD卡那里得到响应，结束这次传输指令
这里需要注意，寄存器MMC_RES里已经存放了来自SD卡发送过来的响应，以供读取。
[cpp]  查看纯 文本  
  1. static int  pxamci_cmd_done（struct  pxamci_host * host，unsigned  int  stat）   
  2.  {  
  3.   struct  mmc_command * cmd = host-> cmd;  
  4.   
  5.  cmd-> resp [i] = readl（host-> base + MMC_RES）＆0xffff;    
  6.   
  7.  if  （stat＆STAT_TIME_OUT_RESPONSE）{  
  8.    cmd-> error = -ETIMEDOUT;  
  9.   }  else if  （stat＆STAT_RES_CRC_ERR && cmd-> flags＆MMC_RSP_CRC）{   
  10.   
  11.    cmd-> error = -EILSEQ;  
  12.   
  13. }   
  14.  pxamci_disable_irq（host，END_CMD_RES）;  
  15.   if  （host-> data &&！cmd-> error）{  
  16.    pxamci_enable_irq（主机，DATA_TRAN_DONE）;  
  17.   }  else  {  
  18.    pxamci_finish_request（host，host-> mrq）; //结束一次传输，清空主控制器中的指令和数据  
  19.  }  
  20.   
  21.  返回 1;  
  22.  }  
- > pxamci_data_done收到结束数据的内部中断信号，得到传输数据的大小，结束这次数据传输
[cpp]  查看纯 文本  
  1. static int  pxamci_data_done（struct  pxamci_host * host，unsigned  int  stat）   
  2. {  
  3.  struct  mmc_data * data = host-> data;  
  4.   
  5. DCSR（host-> dma）= 0;  
  6.  dma_unmap_sg（mmc_dev（host-> mmc），data-> sg，host-> dma_len，host-> dma_dir）;  
  7.   
  8. if  （stat＆STAT_READ_TIME_OUT）  
  9.   data-> error = -ETIMEDOUT;  
  10.  else if  （stat＆（STAT_CRC_READ_ERROR | STAT_CRC_WRITE_ERROR））   
  11.   data-> error = -EILSEQ;  
  12.   
  13. if  （！data-> error）  
  14.   data-> bytes_xfered = data-> blocks * data-> blksz;  //数据传输量=块的数量*每个块的大小（一般为512字节）  
  15.  其他  
  16.   data-> bytes_xfered = 0;  
  17.   
  18. pxamci_disable_irq（host，DATA_TRAN_DONE）;  
  19.   
  20. host-> data = NULL;  
  21.  pxamci_finish_request（host，host-> mrq）;  
  22.  ... ...  
  23.   
  24.   
  25. static void  pxamci_finish_request（struct  pxamci_host * host，  struct  mmc_request * mrq）   
  26. {  
  27.  host-> mrq = NULL;  
  28.  host-> cmd = NULL;  
  29.  host-> data = NULL;  
  30.  mmc_request_done（host-> mmc，mrq）;  
  31.  set_mmc_cken（host，0）;  
  32.  unset_dvfm_constraint（）;  
  33. }  
  34.   
  35. * drivers / mmc / core / core.c * /  
  36. void  mmc_request_done（struct  mmc_host * host，  struct  mmc_request * mrq）  
  37. {  
  38.   
  39.   ... ...  
  40.    if  （mrq-> done）  
  41.    mrq->完成（MRQ）;  
  42. }   
这里用到了完成量完成，LDD3上是这样说的，完成量是一个任务的轻量级机制，允许一个线程告知另一个线程工作已经完成。这里的一个线程就是内部中断处理函数，它是结束主控制器与SD卡间通信的线程，通过mrq->完成（MRQ）; 即完成（mrq-> done_data）;告知另一个线程 - 回调（*请求）实现主控制器与SD卡进行通信的线程，通信已经完毕。
[cpp]  查看纯 文本  
  1. void  mmc_wait_for_req（struct  mmc_host * host，  struct  mmc_request * mrq）  
  2.  {  
  3.   DECLARE_COMPLETION_ONSTACK（完成）;  
  4.   
  5.   
  6.  mrq-> done_data =＆complete;  
  7.   mrq-> done = mmc_wait_done;  
  8.   
  9.  mmc_start_request（host，mrq）;  
  10.   
  11.  wait_for_completion（完整）;  
  12.  }  
  13.   
  14. static void  mmc_wait_done（struct  mmc_request * mrq）   
  15.  {  
  16.   完整（mrq-> done_data）;  
  17.  }  
2）探测引脚引起的中断
  如果（host-> pdata && host-> pdata-> init）
   host-> pdata-> init（＆pdev-> dev，pxamci_detect_irq，mmc）;
 该初始化（）回调函数就是刚才提到的系统初始化时通过saar_mci_init（）实现的， 
[cpp]  查看纯 文本  
  1. static int  saar_mci_init（struct  device * dev，irq_handler_t saar_detect_int，  void  * data）   
  2.  {  
  3.   
  4.  request_irq（cd_irq，saar_detect_int，IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING，  “MMC卡检测” ，数据）;  
  5.   ... ...  
  6.   
  7. }  
其中，cd_irq是通过GPIO转换得到的中断号，pxamci_detect_irq便是该中断实现的函数，之前已经提到过mmc_detect_change，它将最终调用queue_delayed_work执行工作队列里的mmc_rescan函数。
[cpp]  查看纯 文本  
  1. static  irqreturn_t pxamci_detect_irq（int  irq，  void  * devid）  
  2.  {  
  3.   struct  pxamci_host * host = mmc_priv（devid）;  
  4.   
  5.  mmc_detect_change（devid，host-> pdata-> detect_delay）;  
  6.   返回 IRQ_HANDLED;  
  7.  }  
当有SD卡插入或拔出时，硬件主控制器芯片的探测销脚产生外部中断，进入中断处理函数，执行工作队列里的mmc_rescan，扫描SD总线，对插入或拔出SD卡作相应的处理。下文协议层将讨论mmc_rescan（）。
   协议层

   Linux的在内核源码的驱动程序/ MMC /核心文件夹下为我们的提供了一系列SD卡的接口服务函数。可以查看Makefile文件如下，

[cpp]  查看纯 文本  
  1. obj - $（CONFIG_MMC）+ = mmc_core.o  
  2. mmc_core-y：= core.o bus.o host.o \  
  3.                    mmc.o mmc_ops.o sd.o sd_ops.o \  
  4.                    sdio.o sdio_ops.o sdio_bus.o \  
  5.                    sdio_cis.o sdio_io.o sdio_irq.o \  
  6.                    quirks.o cd-gpio.o  

可见，核心文件夹下有针对总线的服务bus.c，针对主控制器的服务host.c，针对SD卡的服务sd.c，sd_ops.c等等。

其中，最为核心的一个函数便是之前提到的位于core.c的mmc_rescan，概括来讲，主要完成两项任务，即

  • 扫描SD总线，插入SD卡
  • 扫描SD总线，拔出SD卡

3.1插入SD卡

插入SD卡，主控制器产生中断，进入中断处理函数，处理工作队列，执行mmc_rescan。

[cpp]  查看纯 文本  
  1. void  mmc_rescan（struct  work_struct * work）  
  2.  {  
  3.   struct  mmc_host * host = container_of（work，  struct  mmc_host，detect.work）; //得到mmc_host的数据  
  4.  / * 
  5.    *首先我们搜索SDIO ... 
  6.    * /  
  7.   err = mmc_send_io_op_cond（host，0，＆ocr）;  
  8.   if  （！err）{  
  9.    if  （mmc_attach_sdio（host，ocr））  
  10.     mmc_power_off（主机）;  
  11.    转到 出来;  
  12.   }  
  13.   
  14.  / * 
  15.    * ...然后正常SD ... 
  16.    * /  
  17.   err = mmc_send_app_op_cond（host，0，＆ocr）;  
  18.   if  （！err）{  
  19.    if  （mmc_attach_sd（host，ocr））  
  20.     mmc_power_off（主机）;  
  21.    转到 出来;  
  22.   }  
  23.   
  24.  / * 
  25.    * ...最后MMC。 
  26.    * /  
  27.   err = mmc_send_op_cond（host，0，＆ocr）;  
  28.   if  （！err）{  
  29.    if  （mmc_attach_mmc（host，ocr））  
  30.     mmc_power_off（主机）;  
  31.    转到 出来;  
  32.   }  
  33.   
  34.   ... ...  
  35.   
  36. }  

插入SD卡，mmc_rescan扫描SD总线上是否存在SD卡，具体的实现方法就是通过向SD卡上电，看是否能成功，以普通SD卡为例，为普通SD卡上电的函数mmc_send_app_op_cond（主机， 0，＆ocr）;如果上电成功，则返回0，即执行if（）里的mmc_attach_sd（）进行总线与SD卡的绑定如果上电失败，则返回非0值，跳过if（）尝试其他上电的方法。那么，上电方法究竟有何不同呢？具体看看mmc_send_app_op_cond（）的实现过程，

[cpp]  查看纯 文本  
  1. int  mmc_send_app_op_cond（struct  mmc_host * host，u32 ocr，u32 * rocr）  
  2.  {  
  3.   struct  mmc_command cmd;  
  4.   cmd.opcode = SD_APP_OP_COND;    / * #define SD_APP_OP_COND 41 * /  
  5.   mmc_wait_for_app_cmd（host，NULL，＆cmd，MMC_CMD_RETRIES）;  
  6.   
  7.  ... ...  
  8.   
  9. }  
  10.  int  mmc_wait_for_app_cmd（struct  mmc_host * host，  struct  mmc_card * card，  struct  mmc_command * cmd，  int  retries）  
  11.  {  
  12.   
  13.   mmc_app_cmd（主机，卡）;   / * #define MMC_APP_CMD 55 * /  
  14.    mrq.cmd = cmd;  
  15.    cmd-> data = NULL;  
  16.   
  17.   mmc_wait_for_req（host，＆mrq）;  
  18.   
  19.   ... ...  
  20.   
  21. }  

这里的指令SD_APP_OP_COND只有SD2.0的协议支持，也就是说，只有普通SD卡支持，所以也只有普通SD卡能够成功上电。 

        

 

如果上电成功，就开始进行总线与SD卡的绑定，通过mmc_attach_sd（），绑定过程可分为四步，

  • 注册SD总线上的操作函数 - struct mmc_bus_ops mmc_sd_ops
  • 设置主控制器的时钟和总线方式 - 通过回调函数host-> ops-> set_ios（）;
  • 启动SD卡 - 根据协议，完成SD卡启动的各个步骤
  • 注册SD卡设备驱动

3.1.1注册总线上的操作函数

[cpp]  查看纯 文本  
  1.  int  mmc_attach_sd（struct  mmc_host * host，u32 ocr）  
  2.  {  
  3.   mmc_sd_attach_bus_ops（主机）;  
  4.   
  5.  ... ...  
  6.   
  7. }  
  8.   
  9. static void  mmc_sd_attach_bus_ops（struct  mmc_host * host）   
  10.  {  
  11.   const struct  mmc_bus_ops * bus_ops;   
  12.   
  13.  bus_ops =＆mmc_sd_ops;  
  14.   mmc_attach_bus（host，bus_ops）;  
  15.  }  
  16.   
  17. void  mmc_attach_bus（struct  mmc_host * host，  const struct  mmc_bus_ops * ops）   
  18.  {  
  19.   host-> bus_ops = ops;  
  20.   host-> bus_refs = 1;  
  21.   host-> bus_dead = 0;  
  22.   
  23. }  
  24.   
  25. static const struct  mmc_bus_ops mmc_sd_ops = {    
  26.   .remove = mmc_sd_remove，   //拔出SD卡的操作函数  
  27.  .detect = mmc_sd_detect，       //探测SD卡的操作函数  
  28.  .suspend = NULL，  
  29.   .resume = NULL，  
  30.   .power_restore = mmc_sd_power_restore，   //重新启动SD卡的操作函数  
  31. };  
这里的mmc_sd_detect和mmc_sd_remove就是拔出SD卡所需要用到的函数，下文将详细讨论。这里需要注意的是，插入SD卡的时候，并不执行mmc_sd_detect和mmc_sd_remove这两个函数，但是会注册它们，也就是说，这两个函数的功能已经实现，将来可以使用。

3.1.2设置时钟和总线

[cpp]  查看纯 文本  
  1.  int  mmc_attach_sd（struct  mmc_host * host，u32 ocr）  
  2.  {  
  3.    host-> ocr = mmc_select_voltage（host，ocr）;  
  4.   
  5.   ... ...  
  6.   
  7. }  
  8.   
  9. u32 mmc_select_voltage（struct  mmc_host * host，u32 ocr）  
  10.  {  
  11.    mmc_set_ios（主机）;  
  12.   
  13.   ... ...  
  14.  }  
  15.  static inline void  mmc_set_ios（struct  mmc_host * host）    
  16.  {  
  17.   struct  mmc_ios * ios =＆host-> ios;  
  18.   
  19.  host-> ops-> set_ios（host，ios）;  //设置主控制器时钟和总线的回调函数，具体实现由主控制器驱动完成  
  20. }  
从这里可以体会到回调函数的精髓：协议层里利用回调函数为所有满足该协议的设备提供统一的接口，而具体实现由底层不同的设备驱动各自完成注意到，之所以要定义一些放之四海而皆准的公用的类，比如struct mmc_host，就是需要通过struct mmc_host * host指针作为形参传到协议层所提供的接口函数中，从而得以调用。

3.1.3启动SD卡

[cpp]  查看纯 文本  
  1.  int  mmc_attach_sd（struct  mmc_host * host，u32 ocr）  
  2.  {  
  3.   
  4.   mmc_sd_init_card（host，host-> ocr，NULL）;  
  5.   
  6.   ... ...  
  7.   
  8. }  
mmc_sd_init_card主要完成以下任务，

  • SD卡的启动过程
  • 得到寄存器CID，CSD，SCR，RCA的数据
  • 其他操作比如切换到高速模式，初始化卡

[cpp]  查看纯 文本  
  1. static int  mmc_sd_init_card（struct  mmc_host * host， u32 ocr，  struct mmc_card * oldcard）   
  2.  {  
  3.   
  4.   / * SD卡的启动过程* /  
  5.   
  6.   mmc_go_idle（主机）;  
  7.   
  8.   mmc_send_if_cond（host，ocr）;  
  9.   
  10.   mmc_send_app_op_cond（host，ocr，NULL）;  
  11.   
  12.   mmc_all_send_cid（host，cid）;  
  13.   
  14.   mmc_send_relative_addr（host，＆card-> rca）;  
  15.   
  16.   / *得到寄存器CID，CSD，SCR的数据* /  
  17.   
  18.   mmc_send_csd（card，card-> raw_csd）;  
  19.   
  20.   mmc_decode_csd（卡）;  
  21.   
  22.   mmc_decode_cid（卡）;  
  23.   
  24.   mmc_app_send_scr（card，card-> raw_scr）;  
  25.   
  26.   mmc_decode_scr（卡）;  
  27.   
  28.   / *其它操作* /  
  29.   
  30.   mmc_alloc_card（host，＆sd_type）;  
  31.   
  32.   mmc_select_card（卡）;   
  33.   
  34.   mmc_read_switch（卡）;  
  35.   
  36.   mmc_switch_hs（卡）;  
  37.   
  38.   ... ...  
  39.   
  40. }  

1）SD卡的启动过程

  根据SD2.0协议，SD卡的状态可分为两种模式：卡识别模式（卡识别模式）和数据传输模式（数据传输模式）。这里，我们关注启动SD卡的卡识别模式。

结合代码，

mmc_go_idle（主机）;                     CMD0

  空闲状态

  mmc_send_if_cond（host，ocr）;     CMD8

  mmc_send_app_op_cond（host，ocr，NULL）;       ACMD41

  准备状态

  mmc_all_send_cid（host，cid）;       CMD2

  识别状态

  mmc_send_relative_addr（host，＆card-> rca）;     CMD3

  待机状态

2）寄存器CID，CSD，SCR，RCA

- >发送指令并得到寄存器的值

  当主控制器向SD卡发送cmd指令，比如mmc_send_cid（card，card-> raw_cid），请求得到SD卡CID寄存器的值，当主控制器发送cmd完成后，芯片产生一个内部中断，处理结束cmd的中断函数，之后得到来自SD卡的回应，即CID寄存器的值，存放于host-> cmd-> resp [i]中。关于内部中断处理，参见上文的中断一节里的mmc_wait_for_cmd（）。

mmc_send_cid（card，card-> raw_cid）;这个函数发送了接收CSD寄存器的请求，并且得到了来自SD卡的CSD寄存器的值。

[cpp]  查看纯 文本  
  1. int  mmc_send_cid（struct  mmc_card * card，u32 * cid）  
  2.  {  
  3.     返回 mmc_send_cxd_native（card-> host，card-> rca << 16，cid，MMC_SEND_CID）;  
  4.   
  5. }  
  6.   
  7. static int  mmc_send_cxd_native（struct  mmc_host * host，u32 arg，u32 * cxd，  int  opcode）   
  8.  {  
  9.   cmd.opcode = opcode;  
  10.   cmd.arg = arg;  
  11.   cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;  
  12.   
  13.  mmc_wait_for_cmd（host，＆cmd，MMC_CMD_RETRIES）;  
  14.   
  15.  memcpy（cxd，cmd.resp，sizeof （ u32  ）* 4）;  //得到响应赋给cxd，即card-> raw_cid  
  16.   
  17.  ... ...  
  18.  }  

- >解析寄存器的值

为什么要解析？先来看看寄存器CID在SD卡协议里的定义，它是一个128位的寄存器，存放了关于这块SD卡的基本信息，就像自己的身份证。通过mmc_send_cid（）将这个寄存器的数值赋给了card-> raw_cid（定义u32 raw_cid [4];），为了方便得到具体某一个信息，协议层为我们解析了寄存器里的域，并给卡 - > cid，比如厂商名称，就可以通过卡 - > cid.manfid直接读取到。

[cpp]  查看纯 文本  
  1. static int  mmc_decode_cid（struct  mmc_card * card）   
  2.  {  
  3.    u32 * resp = card-> raw_cid;  
  4.   
  5.   card-> cid.manfid = UNSTUFF_BITS（分别为120，8）;  
  6.    card-> cid.oemid = UNSTUFF_BITS（分别为104，16）;  
  7.    card-> cid.prod_name [0] = UNSTUFF_BITS（resp，96,8）;  
  8.    card-> cid.prod_name [1] = UNSTUFF_BITS（分别为88,8）;  
  9.    card-> cid.prod_name [2] = UNSTUFF_BITS（resp，80,8）;  
  10.    card-> cid.prod_name [3] = UNSTUFF_BITS（resp，72，8）;  
  11.    card-> cid.prod_name [4] = UNSTUFF_BITS（resp，64，8）;  
  12.    card-> cid.prod_name [5] = UNSTUFF_BITS（resp，56，8）;  
  13.    card-> cid.serial = UNSTUFF_BITS（分别为16,32）;  
  14.    卡 - > cid.month = UNSTUFF_BITS（分别为12，4）;  
  15.    card-> cid.year = UNSTUFF_BITS（resp，8，4）+ 1997;  
  16.    返回 0;  
  17.  }  

3.1.4注册SD卡设备驱动

[cpp]  查看纯 文本  
  1. int  mmc_attach_sd（struct  mmc_host * host，u32 ocr）  
  2. {  
  3.   
  4.  / * mmc_alloc_card（host，＆sd_type）; 在mmc_sd_init_card（）已完成* /  
  5.   
  6.  mmc_add_card（主机 - >卡）;  
  7.   
  8.  ... ...  

上文已经提到，设备驱动程序都会通过alloc_xxx（）和add_xxx（）两步来注册驱动，其实质是调用/drivers/base/core.c里的device_initialize（）和device_add（），device_add（）完成建立的kobject，SYS文件，发送UEVENT，等工作。

3.2拔出SD卡

[cpp]  查看纯 文本  
  1. void  mmc_rescan（struct  work_struct * work）  
  2. {  
  3.  struct  mmc_host * host = container_of（work，  struct  mmc_host，detect.work）;  
  4.  mmc_bus_get（主机）;  
  5.   
  6. / *如果有卡注册，请检查是否仍然存在* /  
  7.  if  （（host-> bus_ops！= NULL）&& host-> bus_ops-> detect &&！host-> bus_dead）  
  8.   宿主 - > bus_ops->检测（主机）;  
  9.   
  10. mmc_bus_put（主机）;  
  11.   
  12. ... ...  

这里的mmc_bus_get /放（），为SD总线加上一个自旋锁，规定同时只能有一个线程在SD总线上操作。

3.2.1 bus_ops-> detect（）

mmc_rescan（）扫描SD总线，如果发现主机 - > OPS上赋了值，即之前已有SD卡注册过，就执行bus_ops->检测（）操作去探测SD总线上是否还存在SD卡，如果不存在了，就执行bus_ops->删除（）拔出SD卡。之前已经提到，这个bus_ops->检测（）已在mmc_attach_sd（）注册完成了。

[cpp]  查看纯 文本  
  1. static void  mmc_sd_detect（struct  mmc_host * host）   
  2.  {  
  3.   mmc_claim_host（主机）;  
  4.   
  5.  / * 
  6.    *只需检查我们的卡是否已被删除。 
  7.    * /  
  8.   err = mmc_send_status（host-> card，NULL）;  
  9.   
  10.  mmc_release_host（主机）;  
  11.   
  12.  if  （err）{  
  13.    mmc_sd_remove（主机）;  
  14.   
  15.   mmc_claim_host（主机）;  
  16.    mmc_detach_bus（主机）;  
  17.    mmc_release_host（主机）;  
  18.   }  
  19.  }  

这里的mmc_claim_host（主机）通过set_current_state（TASK_RUNNING）;将当前进程设置为正在运行进程。

mmc_send_status（）发送得到SD卡状态的请求，如果未能得到状态数据，则执行mmc_sd_remove（主机）拔出SD卡。

[cpp]  查看纯 文本  
  1. int  mmc_send_status（struct  mmc_card * card，u32 * status）  
  2.  {  
  3.   struct  mmc_command cmd;  
  4.   
  5.  cmd.opcode = MMC_SEND_STATUS;    / * #define MMC_SEND_STATUS 13 * /  
  6.   cmd.arg = card-> rca << 16;  
  7.   cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;  
  8.   
  9.  err = mmc_wait_for_cmd（card-> host，＆cmd，MMC_CMD_RETRIES）;  
  10.   
  11.  if  （err）                 
  12.    返回 错误           //接收来自SD卡的回复失败，即没有发现SD卡  
  13.  如果 （状态）  
  14.    * status = cmd.resp [0];  
  15.   
  16.  返回 0;  
  17.   
  18. }  
主控制器发送命令CMD13，要求得到SD卡的状态寄存器CSR和SSR。

SD协议规定，状态寄存器CSR是必须的，这个32位寄存器作为R1的一个域返回给主控制器，

状态寄存器SSR作为扩充功能，具体参考SD2.0协议。

3.2.2 bus_ops-> remove（）

拔出SD卡，其实就是注册SD卡驱动的反操作，实质就是执行device_del（）和device_put（）。

[cpp]  查看纯 文本  
  1. static void  mmc_sd_remove（struct  mmc_host * host）   
  2.  {  
  3.   mmc_remove_card（主机 - >卡）;  
  4.   host-> card = NULL;  
  5.  }  
  6.  void  mmc_remove_card（struct  mmc_card * card）  
  7.  {  
  8.   if  （mmc_card_present（card））  
  9.    device_del（卡 - > DEV）;  
  10.   
  11.  put_device（卡 - > DEV）;  
  12.  }  

块设备

首先，必须知道为什么要用到块设备。在linux的下，SD卡通过块块的方式（以512字节为最小单位）进行数据传输，它必须遵从块设备架构。在Linux的块设备层，I / Ø调度者通过请求队列机制负责对块数据的处理。

SD卡子系统分为三层，主设备层，协议层和块设备层。块设备驱动位于/drivers/mmc/card/block.c，主要完成两个任务，

  • 建立设备节点
  • 通过请求队列机制进行数据传输

插入SD卡，注册驱动成功，那么在开发板的目录的/ dev /块下会出现SD卡的设备节点。 

179为主设备号，定义于include / linux / major.h #define MMC_BLOCK_MAJOR 179

179：0代表这块SD卡的设备节点mmcblk0,179：1代表这块SD卡的第一个分区mmcblk0p1，即主分区，如果有第二个分区，那就是179：2，最多可以有7个分区，即179：1〜179：7（定义于block.c alloc_disk（1 << 3）;）。不过，SD卡一般只有一个分区。如果有第二块SD卡插入，将会建立设备节点mmcblk1 （179：8）和mmcblk1p1（179：9）。 

下面通过对块设备驱动block.c的分析，看看SD卡是如何在块设备层建立节点和传输数据的。

4.1数据结构

每个驱动都会有一个数据结构。幸运的是，我们SD卡块设备驱动的数据结构相对简单，在mmc_blk_data里，主要有两个成员，struct gendisk * disk和struct mmc_queue队列。

1）struct gendisk是general disk的缩写，代表个通用的块设备，其中包括块设备的主分区结构struct hd_struct part0，块设备的行为函数struct block_device_operations * fops，以及请求队列struct request_queue * queue等。

2）struct request_queue存放所有I / O调度的算法。

3）struct request请求是I / O调度者调度的对象，其中的结构struct bio是整个请求队列的核心，具体内容请参见LDD3。

4.2块设备驱动

首先浏览一下源码，

[cpp]  查看纯 文本  
  1. static int  __init mmc_blk_init（void ）   
  2.  {  
  3.   register_blkdev（MMC_BLOCK_MAJOR，  “mmc” ）;    //注册主设备号（若注册成功，/ proc / devices的块设备下会出现mmc）  
  4.   mmc_register_driver（＆mmc_driver）;  
  5.   返回 0;  
  6.  }  
  7.   
  8. static struct  mmc_driver mmc_driver = {   
  9.   .drv = {  
  10.    .name =  “mmcblk” ，  
  11.   }，  
  12.   .probe = mmc_blk_probe，  
  13.   .remove = mmc_blk_remove，  
  14.   .suspend = mmc_blk_suspend，  
  15.   .resume = mmc_blk_resume，  
  16.  };  
  17.   
  18. static int  mmc_blk_probe（struct  mmc_card * card）   
  19.  {  
  20.   struct  mmc_blk_data * md;  
  21.   md = mmc_blk_alloc（card）;  
  22.   mmc_blk_set_blksize（md，card）;  
  23.   
  24.  mmc_set_drvdata（card，md）;  
  25.   add_disk（MD->盘）;  
  26.   返回 0;  
  27.   
  28.  ... ...  
  29.   
  30. }  

4.2.1设备驱动的初始化函数

  仍然可以将驱动程序的初始化mmc_blk_probe（struct mmc_card * card）归纳为以下内容，

  • 初始化设备驱动的数据结构mmc_blk_data，并挂载到卡 - > dev.driver_data
  • 实现块备用驱动的功能函数struct block_device_operations * fops
  • 注册设备，即注册的kobject，建立SYS文件，发送UEVENT等
  • 其他需求，如mmc_blk_set_blksize（md，card）;

1）初始化mmc_blk_data

[cpp]  查看纯 文本  
  1. static struct  mmc_blk_data * mmc_blk_alloc（struct  mmc_card * card）   
  2.  {  
  3.   struct  mmc_blk_data * md;  
  4.   md = kzalloc（sizeof （struct  mmc_blk_data），GFP_KERNEL）;  
  5.   
  6.  md-> read_only = mmc_blk_readonly（card）;  
  7.   
  8.  md-> disk = alloc_disk（1 << 3）;   //分配了8个可用设备  
  9.   
  10.  spin_lock_init（MD->锁）;  
  11.   md-> usage = 1;  
  12.   ret = mmc_init_queue（＆md-> queue，card，＆md-> lock）;  
  13.   
  14.  md-> queue.issue_fn = mmc_blk_issue_rq;  
  15.   md-> queue.data = md;  
  16.   
  17.  md-> disk-> major = MMC_BLOCK_MAJOR;  
  18.   md-> disk-> first_minor = devidx << MMC_SHIFT;  
  19.   md-> disk-> fops =＆mmc_bdops;  
  20.   md-> disk-> private_data = md;  
  21.   md-> disk-> queue = md-> queue.queue;  
  22.   md-> disk-> driverfs_dev =＆card-> dev;  
  23.   
  24.  blk_queue_logical_block_size（md-> queue.queue，512）;  
  25.   
  26.  ... ...  
  27.   
  28.  返回 md;  
  29.   
  30. }  

完成初始化后，通过mmc_set_drvdata（card，md）;将数据挂载到card-> dev.driver_data下。

2）功能函数

[cpp]  查看纯 文本  
  1. static const struct  block_device_operations mmc_bdops = {    
  2.   .open = mmc_blk_open，  
  3.   .release = mmc_blk_release，  
  4.   .getgeo = mmc_blk_getgeo，  
  5.   .owner = THIS_MODULE，  
  6.  };  
  7.   
  8. static int  mmc_blk_open（struct  block_device * bdev，fmode_t mode）   
  9.  {  
  10.   struct  mmc_blk_data * md = mmc_blk_get（bdev-> bd_disk）;  
  11.   
  12.  ... ...  
  13.  }  
  14.  struct  block_device {  
  15.   dev_t bd_dev;  / *这是一个搜索键* /  
  16.   struct  inode * bd_inode; /* 会死 */  
  17.   struct  super_block * bd_super;  
  18.   
  19.  ... ...  
  20.  };  

与字符驱动类似，通过dev_t的和inode的找到设备。

3）注册驱动

[cpp]  查看纯 文本  
  1. void  add_disk（struct  gendisk * disk）  
  2.  {  
  3.   blk_register_region（disk_devt（disk），disk-> minors，NULL，exact_match，exact_lock，disk）;  
  4.   register_disk（磁盘）;  
  5.   blk_register_queue（磁盘）;  
  6.   
  7.  ... ...  
  8.   
  9. }  

blk_register_region（）在Linux的中实现了一种利用哈希表管理设备号的机制。

register_disk（）对应alloc_disk（），完成对块设备的注册，其实质是通过register_disk（） - > blkdev_get（） - > __ blkdev_get（） - > rescan_partitions（） - > add_partitions（）添加分区，建立设备节点。

blk_register_queue（）对应blk_init_queue（）完成对请求队列的注册，其实质是通过elv_register_queue（）注册请求队列的算法。

关于块设备更为具体的代码分析可参看Linux的那些事。

4.2.2请求队列

mmc_init_queue申请并初始化一个请求队列，开启负责处理这个请求队列的守护进程。

[cpp]  查看纯 文本  
  1. int  mmc_init_queue（struct  mmc_queue * mq，  struct  mmc_card * card，spinlock_t * lock）  
  2.  {  
  3.   struct  mmc_host * host = card-> host;  
  4.   mq-> card = card;  
  5.   mq-> queue = blk_init_queue（mmc_request，lock）;  
  6.   
  7.  mq-> queue-> queuedata = mq;  
  8.   mq-> req = NULL;  
  9.   
  10.  blk_queue_prep_rq（mq-> queue，mmc_prep_request）;  //注册mmc_prep_request算法  
  11.  blk_queue_ordered（mq-> queue，QUEUE_ORDERED_DRAIN，NULL）;  //注册下令算法  
  12.  mq-> thread  = kthread_run（mmc_queue_thread，mq，  “mmcqd” ）;  
  13.   
  14.    ... ...  
  15.  }  

1）mmc_request

它是处理SD卡通用的申请请求的回调函数，或者说是SD卡申请请求的算法。当CPU处理不忙状态时，会寻找一个请求，并试图执行它。

[cpp]  查看纯 文本  
  1. / * /drivers/mmc/card/queue.c * /  
  2.   
  3. / * 
  4.   *通用MMC请求处理程序。这被称为一个队列 
  5.   *特别主机。当主机不忙时，我们寻找一个请求 
  6.   *在此主机上的任何队列上，并尝试发出。这可能 
  7.   *不是我们被要求处理的队列。 
  8.   * /  
  9.  static void  mmc_request（struct  request_queue * q）   
  10.  {  
  11.   struct  mmc_queue * mq = q-> queuedata;  
  12.   struct  request * req;  
  13.   
  14.  if  （！mq）{  
  15.    while  （（req = blk_fetch_request（q））！= NULL）{  //寻找来自请求队列的一个请求req  
  16.     req-> cmd_flags | = REQ_QUIET;  
  17.     __blk_end_request_all（req，-EIO）;  
  18.    }  
  19.    返回;  
  20.   }  
  21.   
  22.  如果 （！mq-> req）  
  23.    wake_up_process（mq-> thread ）;    //如果队列里没有请求req，唤醒守护进程  
  24. }  

这里我们需要关注这个处理该SD卡请求队列的算法是何时申请的，也就是何时会去申请请求，何时会去唤醒内核线程。

用到回调函数Q-> request_fn有三处

  • 块设备驱动注册请求队列blk_register_queue（）
  • 驱动程序出错，清空请求队列mmc_cleanup_queue（）
  • 实现请求队列机制的blk_fetch_request内部本身

blk_fetch_request（） - > blk_peek_request（） - > __ elv_next_request（） - > blk_do_ordered（） - > ...-> Q-> request_fn

我们不必深究所谓的电梯算法，只要知道，它是使数据得以高效通信的一种算法，算法自身决定何时去唤醒守护进程处理请求。

2）blk_init_queue（）

如果一个块设备希望使用一个标准的请求处理步骤，那就必须使用blk_init_queue（）。这个函数注册了q-> request_fn（这里就是mmc_request），并初始化请求队列的数据结构struct request_queue。

[cpp]  查看纯 文本  
  1. / * 
  2.  
  3.  *调用blk_init_queue（）。那时函数@rfn会被调用 
  4.   *是队列中需要处理的请求。如果设备 
  5.   *支持插件，那么@rfn在请求时可能不会立即被调用 
  6.   *在队列中可用，但可以稍后调用。 
  7.  
  8.  * /   
  9.   
  10.  struct  request_queue * blk_init_queue（request_fn_proc * rfn，spinlock_t * lock）  
  11.  {  
  12.   return  blk_init_queue_node（rfn，lock，-1）;  
  13.  }  

其中的RFN就是请求队列的一个算法，即这里的mmc_request。

[cpp]  查看纯 文本  
  1. struct  request_queue * blk_init_queue_node（request_fn_proc * rfn，spinlock_t * lock，  int  node_id）  
  2.  {  
  3.   struct  request_queue * q = blk_alloc_queue_node（GFP_KERNEL，node_id）;  
  4.   
  5.  q-> request_fn = rfn;  
  6.   q-> prep_rq_fn = NULL;  
  7.   q-> unplug_fn = generic_unplug_device;  
  8.   q-> queue_flags = QUEUE_FLAG_DEFAULT;  
  9.   q-> queue_lock = lock;  
  10.   
  11.  blk_queue_make_request（q，__make_request）;  
  12.   
  13.  if  （！elevator_init（q，NULL））{  
  14.    blk_queue_congestion_threshold（Q）;  
  15.    返回 q  
  16.   }  
  17.   
  18.   ... ...  
  19.   
  20. }  

3）kthead_run（）

注意到mmc_init_queue这个函数的最后，创建并运行一个名为mmcqd的线程，顾名思意，mmc queue deamon它是一个SD卡的处理请求队列的守护进程，或者说内核线程，当系统注册SD卡块设备驱动时，就通过mmc_init_queue（）开启了这个内核线程。

4）mmc_queue_thread 

看看这个内核线程做了些什么，

[cpp]  查看纯 文本  
  1. static int  mmc_queue_thread（void  * d）   
  2.  {  
  3.   struct  mmc_queue * mq = d;  
  4.   struct  request_queue * q = mq-> queue;  
  5.   
  6.  current-> flags | = PF_MEMALLOC;  
  7.   
  8.  向下（MQ-> thread_sem）;  
  9.   
  10.  做 {  
  11.    struct  request * req = NULL;  
  12.   
  13.   spin_lock_irq（Q-> queue_lock）;  
  14.    set_current_state（TASK_INTERRUPTIBLE）;  
  15.    if  （！blk_queue_plugged（q））  
  16.     req = blk_fetch_request（q）;  
  17.   mq-> req = req;  
  18.    spin_unlock_irq（Q-> queue_lock）;  
  19.   
  20.   if  （！req）{  
  21.   
  22.    if  （kthread_should_stop（））{  
  23.      set_current_state（TASK_RUNNING）;  
  24.      打破;  
  25.     }  
  26.     向上（MQ-> thread_sem）;  
  27.     时间表（）;  
  28.     向下（MQ-> thread_sem）;  
  29.     继续;  
  30.    }  
  31.    set_current_state（TASK_RUNNING）;  
  32.   
  33.   mq-> issue_fn（mq，req）;  
  34.  }  而 （1）;  
  35.   
  36.  向上（MQ-> thread_sem）;  
  37.   
  38.  返回 0;  
  39.  }  

首先，这个守护进程是一个，而（1）死循环，如果没有特殊要求，即kthread_should_stop（）指定要把这个内核线程终止掉，那么它将从系统启动开始一直负责处理SD卡的请求队列。

在循环内部，内核线程首先通过set_current_state（TASK_INTERRUPTIBLE）;设置当前线程为可打断的等待线程，进入睡眠状态，等待其他线程唤醒它，这里唤醒它的就是处理SD卡请求的mmc_request，当MQ-> req为空，即当前没有请求正在处理，则通过wake_up_process（mq-> thread）;唤醒内核线程，接着该线程尝试从请求队列里得到一个请求req，

- >如果没有请求，则调用schedule（）交出cpu的使用权让其自由调度，等到系统空闲时，再次得到cpu控制权，并且执行continue;退出当前循环，重新开始新的循环。

- >如果得到了一个请求，则通过set_current_state（TASK_RUNNING）;将内核线程设置为当前正在运行的进程，并调用issue_fn（），即mmc_blk_issue_rq，处理这个请求，实现主控制器与SD卡的数据传输。

5）issue_fn

驱动初始化函数probe（）里的mmc_blk_alloc（）里注册了这个回调函数，md-> queue.issue_fn = mmc_blk_issue_rq ;

这个函数将REQ里的成员解析成为mmc_blk_request里的指令和数据，即mmc_command和mmc_data，然后通过mmc_wait_for_req（）最终实现主控制器与SD卡间的通信。

[cpp]  查看纯 文本  
  1. struct  mmc_blk_request {  
  2.   struct  mmc_request mrq;  
  3.   struct  mmc_command cmd;  
  4.   struct  mmc_command stop;  
  5.   struct  mmc_data数据;  
  6.  };  
  7.  static int  mmc_blk_issue_rq（struct  mmc_queue * mq，  struct  request * req）   
  8.  {  
  9.   

你可能感兴趣的:(EMMC/SD/RAM)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • 【无标题】达瓦达瓦 JhonKI 考研
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
  • 上图为是否色发 JhonKI 考研
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
  • 每日一题——第八十八题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：输入一个9位的无符号整数，判断其是否有重复数字#include#include#includeintmain(){charnum_str[10];printf("请输入一个9位数的无符号数：");scanf_s("%9d",&num_str);if(strlen(num_str)!=9){printf("输入的不是一个9位无符号整数，请重新输入");}else{if(hasDuplicate
  • 143234234123432 JhonKI 考研
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • (179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (158)时序收敛---＞(08)时序收敛八 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (159)时序收敛---＞(09)时序收敛九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (160)时序收敛---＞(10)时序收敛十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (153)时序收敛---＞(03)时序收敛三 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (121)DAC接口---＞(006)基于FPGA实现DAC8811接口 FPGA系统设计指南针 FPGA接口开发(项目实战)fpga开发FPGAIC
    1目录（a）FPGA简介（b）IC简介（c）Verilog简介（d）基于FPGA实现DAC8811接口（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电
  • FPGA复位专题---（3）上电复位？ FPGA系统设计指南针 FPGA系统设计(内训)fpga开发
    （3）上电复位？1目录（a）FPGA简介（b）Verilog简介（c）复位简介（d）上电复位？（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限
  • (182)时序收敛---＞(32)时序收敛三二 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三二（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • matlab mle 优化,MLE+: Matlab Toolbox for Integrated Modeling, Control and Optimization for Buildings... Simon Zhong matlabmle优化
    摘要：FollowingunilateralopticnervesectioninadultPVGhoodedrat,theaxonguidancecueephrin-A2isup-regulatedincaudalbutnotrostralsuperiorcolliculus(SC)andtheEphA5receptorisdown-regulatedinaxotomisedretinalgan
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • 光盘文件系统 (iso9660) 格式解析 穷人小水滴 光盘文件系统iso9660denoGNU/Linuxjavascript
    越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
  • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1) 穷人小水滴 游戏科幻设计
    游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • linux系统服务器下jsp传参数乱码 3213213333332132 javajsplinuxwindowsxml
    在一次解决乱码问题中， 发现jsp在windows下用js原生的方法进行编码没有问题，但是到了linux下就有问题， escape,encodeURI,encodeURIComponent等都解决不了问题 但是我想了下既然原生的方法不行，我用el标签的方式对中文参数进行加密解密总该可以吧。于是用了java的java.net.URLDecoder,结果还是乱码，最后在绝望之际，用了下面的方法解决了
  • Spring 注解区别以及应用 BlueSkator spring
    1. @Autowired @Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean，或者不存在UserDao类型的bean，会抛出 BeanCreationException异常，这时可以通过在该属性上再加一个@Qualifier注解来声明唯一的id解决问题。   2. @Qualifier 当spring中存在至少一个匹
  • printf和sprintf的应用 dcj3sjt126com PHPsprintfprintf
    <?php printf('b: %b <br>c: %c <br>d: %d <bf>f: %f', 80,80, 80, 80); echo '<br />'; printf('%0.2f <br>%+d <br>%0.2f <br>', 8, 8, 1235.456); printf('th
  • config.getInitParameter 171815164 parameter
    web.xml <servlet> <servlet-name>servlet1</servlet-name> <jsp-file>/index.jsp</jsp-file> <init-param> <param-name>str</param-name>
  • Ant标签详解--基础操作 g21121 ant
            Ant的一些核心概念：         build.xml：构建文件是以XML 文件来描述的，默认构建文件名为build.xml。        project：每个构建文
  • [简单]代码片段_数据合并 53873039oycg 代码
            合并规则:删除家长phone为空的记录,若一个家长对应多个孩子,保留一条家长记录,家长id修改为phone,对应关系也要修改。         代码如下:        
  • java 通信技术 云端月影 Java 远程通信技术
    在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等，这些名词之间到底是些什么关系呢，它们背后到底是基于什么原理实现的呢，了解这些是实现分布式服务框架的基础知识，而如果在性能上有高的要求的话，那深入了解这些技术背后的机制就是必须的了，在这篇blog中我们将来
  • string与StringBuilder 性能差距到底有多大 aijuans
              之前也看过一些对string与StringBuilder的性能分析，总感觉这个应该对整体性能不会产生多大的影响，所以就一直没有关注这块！         由于学程序初期最先接触的string拼接，所以就一直没改变过自己的习惯！        
  • 今天碰到 java.util.ConcurrentModificationException 异常 antonyup_2006 java多线程工作IBM
    今天改bug，其中有个实现是要对map进行循环，然后有删除操作，代码如下： Iterator<ListItem> iter = ItemMap.keySet.iterator(); while(iter.hasNext()){ ListItem it = iter.next(); //...一些逻辑操作 ItemMap.remove(it); } 结果运行报Con
  • PL/SQL的类型和JDBC操作数据库 百合不是茶 PL/SQL表标量类型游标PL/SQL记录
    PL/SQL的标量类型:    字符,数字,时间,布尔,%type五中类型的 --标量：数据库中预定义类型的变量 --定义一个变长字符串 v_ename varchar2(10); --定义一个小数,范围 -9999.99~9999.99 v_sal number(6,2); --定义一个小数并给一个初始值为5.4 :=是pl/sql的赋值号
  • Mockito：一个强大的用于 Java 开发的模拟测试框架实例 bijian1013 mockito单元测试
    Mockito框架：         Mockito是一个基于MIT协议的开源java测试框架。         Mockito区别于其他模拟框架的地方主要是允许开发者在没有建立“预期”时验证被测系统的行为。对于mock对象的一个评价是测试系统的测
  • 精通Oracle10编程SQL(10)处理例外 bijian1013 oracle数据库plsql
    /* *处理例外 */ --例外简介 --处理例外-传递例外 declare v_ename emp.ename%TYPE; begin SELECT ename INTO v_ename FROM emp where empno=&no; dbms_output.put_line('雇员名：'||v_ename); exceptio
  • 【Java】Java执行远程机器上Linux命令 bit1129 linux命令
    Java使用ethz通过ssh2执行远程机器Linux上命令，   封装定义Linux机器的环境信息   package com.tom; import java.io.File; public class Env { private String hostaddr; //Linux机器的IP地址 private Integer po
  • java通信之Socket通信基础 白糖_ javasocket网络协议
    正处于网络环境下的两个程序，它们之间通过一个交互的连接来实现数据通信。每一个连接的通信端叫做一个Socket。一个完整的Socket通信程序应该包含以下几个步骤： ①创建Socket； ②打开连接到Socket的输入输出流； ④按照一定的协议对Socket进行读写操作； ④关闭Socket。   Socket通信分两部分：服务器端和客户端。服务器端必须优先启动，然后等待soc
  • angular.bind boyitech AngularJSangular.bindAngularJS APIbind
    angular.bind 描述：         上下文，函数以及参数动态绑定，返回值为绑定之后的函数. 其中args是可选的动态参数，self在fn中使用this调用。 使用方法：          angular.bind(se
  • java-13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class KickOutBadGuys { /** * 题目：13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。 * Maybe you can find out
  • Redis.conf配置文件及相关项说明（自查备用） Kai_Ge redis
       Redis.conf配置文件及相关项说明 # Redis configuration file example # Note on units: when memory size is needed, it is possible to specifiy # it in the usual form of 1k 5GB 4M and so forth: #
  • [强人工智能]实现大规模拓扑分析是实现强人工智能的前奏 comsci 人工智能
         真不好意思,各位朋友...博客再次更新...      节点数量太少,网络的分析和处理能力肯定不足,在面对机器人控制的需求方面,显得力不从心....      但是,节点数太多,对拓扑数据处理的要求又很高,设计目标也很高,实现起来难度颇大...
  • 记录一些常用的函数 dai_lm java
    public static String convertInputStreamToString(InputStream is) { StringBuilder result = new StringBuilder(); if (is != null) try { InputStreamReader inputReader = new InputStreamRead
  • Hadoop中小规模集群的并行计算缺陷 datamachine mapreducehadoop并行计算
    注：写这篇文章的初衷是因为Hadoop炒得有点太热，很多用户现有数据规模并不适用于Hadoop，但迫于扩容压力和去IOE（Hadoop的廉价扩展的确非常有吸引力）而尝试。尝试永远是件正确的事儿，但有时候不用太突进，可以调优或调需求，发挥现有系统的最大效用为上策。 -----------------------------------------------------------------
  • 小学4年级英语单词背诵第二课 dcj3sjt126com englishword
    egg  蛋 twenty 二十 any 任何 well 健康的，好   twelve 十二 farm 农场 every 每一个 back 向后，回   fast 快速的 whose 谁的 much 许多 flower 花   watch 手表 very 非常，很 sport 运动 Chinese 中国的  
  • 自己实践了github的webhooks, linux上面的权限需要注意 dcj3sjt126com githubwebhook
    环境, 阿里云服务器   1. 本地创建项目, push到github服务器上面   2. 生成www用户的密钥 sudo -u www ssh-keygen -t rsa -C "[email protected]"     3. 将密钥添加到github帐号的SSH_KEYS里面   3. 用www用户执行克隆, 源使
  • Java冒泡排序 蕃薯耀 冒泡排序Java冒泡排序Java排序
    冒泡排序 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 10:40:14 星期二 http://fanshuyao.iteye.com/
  • Excle读取数据转换为实体List【基于apache-poi】 hanqunfeng apache
    1.依赖apache-poi   2.支持xls和xlsx   3.支持按属性名称绑定数据值   4.支持从指定行、列开始读取   5.支持同时读取多个sheet   6.具体使用方式参见org.cpframework.utils.excelreader.CP_ExcelReaderUtilTest.java 比如： Str
  • 3个处于草稿阶段的Javascript API介绍 jackyrong JavaScript
    原文： http://www.sitepoint.com/3-new-javascript-apis-may-want-follow/?utm_source=html5weekly&utm_medium=email   本文中，介绍3个仍然处于草稿阶段，但应该值得关注的Javascript API. 1) Web Alarm API   &
  • 6个创建Web应用程序的高效PHP框架 lampcy Web框架PHP
    以下是创建Web应用程序的PHP框架，有coder bay网站整理推荐： 1. CakePHP CakePHP是一个PHP快速开发框架，它提供了一个用于开发、维护和部署应用程序的可扩展体系。CakePHP使用了众所周知的设计模式，如MVC和ORM，降低了开发成本，并减少了开发人员写代码的工作量。 2. CodeIgniter CodeIgniter是一个非常小且功能强大的PHP框架，适合需
  • 评"救市后中国股市新乱象泛起"谣言 nannan408
    首先来看百度百家一位易姓作者的新闻： 三个多星期来股市持续暴跌，跌得投资者及上市公司都处于极度的恐慌和焦虑中，都要寻找自保及规避风险的方式。面对股市之危机，政府突然进入市场救市，希望以此来重建市场信心，以此来扭转股市持续暴跌的预期。而政府进入市场后，由于市场运作方式发生了巨大变化，投资者及上市公司为了自保及为了应对这种变化，中国股市新的乱象也自然产生。 首先，中国股市这两天
  • 页面全屏遮罩的实现 方式 Rainbow702 htmlcss遮罩mask
    之前做了一个页面，在点击了某个按钮之后，要求页面出现一个全屏遮罩，一开始使用了position:absolute来实现的。当时因为画面大小是固定的，不可以resize的，所以，没有发现问题。 最近用了同样的做法做了一个遮罩，但是画面是可以进行resize的，所以就发现了一个问题，当画面被reisze到浏览器出现了滚动条的时候，就发现，用absolute 的做法是有问题的。后来改成fixed定位就
  • 关于angularjs的点滴 tntxia AngularJS
      angular是一个新兴的JS框架，和以往的框架不同的事，Angularjs更注重于js的建模，管理，同时也提供大量的组件帮助用户组建商业化程序，是一种值得研究的JS框架。   Angularjs使我们可以使用MVC的模式来写JS。Angularjs现在由谷歌来维护。   这里我们来简单的探讨一下它的应用。   首先使用Angularjs我
  • Nutz--->>反复新建ioc容器的后果 xiaoxiao1992428 DAOmvcIOCnutz
    问题： public class DaoZ {     public static Dao dao() { // 每当需要使用dao的时候就取一次     Ioc ioc = new NutIoc(new JsonLoader("dao.js"));     return ioc.get(
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他