DM9000probe函数解析dm9000.c

dm9000_probe(struct platform_device *pdev)
{
   
  unsigned int oldval_bwscon;//保存位宽等待寄存器
  unsigned int oldval_bankcon4;//保存控制寄存器
 
   
 oldval_bwscon = *((volatile unsigned int *)S3C2410_BWSCON);
 *((volatile unsigned int *)S3C2410_BWSCON) = (oldval_bwscon & ~(3<<16)) /
 | S3C2410_BWSCON_DW4_16 | S3C2410_BWSCON_WS4 | S3C2410_BWSCON_ST4;
 
 oldval_bankcon4 = *((volatile unsigned int *)S3C2410_BANKCON4);
 *((volatile unsigned int *)S3C2410_BANKCON4) = 0x1f7c;

 struct dm9000_plat_data *pdata = pdev->dev.platform_data;//获得单板资源数据，在单板中有定义
 struct board_info *db; //生明一个单板信息结构体

 struct net_device *ndev;//网络设备结构体
 const unsigned char *mac_src;
 int ret = 0;
 int iosize;
 int i;
 u32 id_val;

 /* 初始化网络设备*/
 ndev = alloc_etherdev(sizeof(struct board_info));//申请网络设备
 if (!ndev) {
  dev_err(&pdev->dev, "could not allocate device./n");
  return -ENOMEM;
 }//申请不成功则打印消息

 SET_NETDEV_DEV(ndev, &pdev->dev);//建立网络设备

 dev_dbg(&pdev->dev, "dm9000_probe()/n");

 /* 填充 board_info结构体 */
 db = netdev_priv(ndev);
 memset(db, 0, sizeof(*db));//建立内存

 db->dev = &pdev->dev;
 db->ndev = ndev;

 spin_lock_init(&db->lock);
 mutex_init(&db->addr_lock);

 INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);

 db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);//获得资源地址
 db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);//获得资源内存
 db->irq_res  = platform_get_resource(pdev, IORESOURCE_IRQ, 0);//获得资源中断

 if (db->addr_res == NULL || db->data_res == NULL ||
     db->irq_res == NULL) {
  dev_err(db->dev, "insufficient resources/n");
  ret = -ENOENT;
  goto out;
 }//失败则

 iosize = res_size(db->addr_res);//计算资源大小
 db->addr_req = request_mem_region(db->addr_res->start, iosize,
       pdev->name);//申请上面指明的资源起始和大小

 if (db->addr_req == NULL) {
  dev_err(db->dev, "cannot claim address reg area/n");
  ret = -EIO;
  goto out;
 }//失败则

 db->io_addr = ioremap(db->addr_res->start, iosize);//将刚申请到的资源转化为虚拟地址，使内核读写寄存器

 if (db->io_addr == NULL) {
  dev_err(db->dev, "failed to ioremap address reg/n");
  ret = -EINVAL;
  goto out;
 }

 iosize = res_size(db->data_res);//计算数据资源大小
 db->data_req = request_mem_region(db->data_res->start, iosize,
       pdev->name);申请上面指明的资源数据起始和大小

 if (db->data_req == NULL) {
  dev_err(db->dev, "cannot claim data reg area/n");
  ret = -EIO;
  goto out;
 }

 db->io_data = ioremap(db->data_res->start, iosize);将刚申请到的资源数据转化为虚拟地址，使内核读写寄存器

 if (db->io_data == NULL) {
  dev_err(db->dev, "failed to ioremap data reg/n");
  ret = -EINVAL;
  goto out;
 }

 /* 填充net-dev结构体 */
 ndev->base_addr = (unsigned long)db->io_addr;
 ndev->irq = db->irq_res->start;

 /* ensure at least we have a default set of IO routines */
 dm9000_set_io(db, iosize);

 /* check to see if anything is being over-ridden */
 if (pdata != NULL) {
  /*检查使用的位宽*/

  if (pdata->flags & DM9000_PLATF_8BITONLY)
   dm9000_set_io(db, 1);

  if (pdata->flags & DM9000_PLATF_16BITONLY)
   dm9000_set_io(db, 2);

  if (pdata->flags & DM9000_PLATF_32BITONLY)
   dm9000_set_io(db, 4);

  /* check to see if there are any IO routine
   * over-rides */

  if (pdata->inblk != NULL)
   db->inblk = pdata->inblk;

  if (pdata->outblk != NULL)
   db->outblk = pdata->outblk;

  if (pdata->dumpblk != NULL)
   db->dumpblk = pdata->dumpblk;

  db->flags = pdata->flags;
 }

#ifdef CONFIG_DM9000_FORCE_SIMPLE_PHY_POLL
 db->flags |= DM9000_PLATF_SIMPLE_PHY;
#endif

 dm9000_reset(db);

 /* 重试多次,有时会读错*/
 for (i = 0; i < 8; i++) {
  id_val  = ior(db, DM9000_VIDL);
  id_val |= (u32)ior(db, DM9000_VIDH) << 8;
  id_val |= (u32)ior(db, DM9000_PIDL) << 16;
  id_val |= (u32)ior(db, DM9000_PIDH) << 24;

  if (id_val == DM9000_ID)
   break;
  dev_err(db->dev, "read wrong id 0x%08x/n", id_val);
 }

 if (id_val != DM9000_ID) {
  dev_err(db->dev, "wrong id: 0x%08x/n", id_val);
  ret = -ENODEV;
  goto out;
 }

 /* 确认DM9000类型*/

 id_val = ior(db, DM9000_CHIPR);
 dev_dbg(db->dev, "dm9000 revision 0x%02x/n", id_val);

 switch (id_val) {
 case CHIPR_DM9000A:
  db->type = TYPE_DM9000A;
  break;
 case CHIPR_DM9000B:
  db->type = TYPE_DM9000B;
  break;
 default:
  dev_dbg(db->dev, "ID %02x => defaulting to DM9000E/n", id_val);
  db->type = TYPE_DM9000E;
 }

 /* 网络设备初始化*/

 ether_setup(ndev);

 ndev->open   = &dm9000_open;
 ndev->hard_start_xmit    = &dm9000_start_xmit;
 ndev->tx_timeout         = &dm9000_timeout;
 ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
 ndev->stop   = &dm9000_stop;
 ndev->set_multicast_list = &dm9000_hash_table;
 ndev->ethtool_ops  = &dm9000_ethtool_ops;
 ndev->do_ioctl   = &dm9000_ioctl;

#ifdef CONFIG_NET_POLL_CONTROLLER
 ndev->poll_controller  = &dm9000_poll_controller;
#endif

 db->msg_enable       = NETIF_MSG_LINK;
 db->mii.phy_id_mask  = 0x1f;
 db->mii.reg_num_mask = 0x1f;
 db->mii.force_media  = 0;
 db->mii.full_duplex  = 0;
 db->mii.dev      = ndev;
 db->mii.mdio_read    = dm9000_phy_read;
 db->mii.mdio_write   = dm9000_phy_write;

 mac_src = "eeprom";

 /* 试图从eeprom读取地址*/
 for (i = 0; i < 6; i += 2)
  dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);

 if (!is_valid_ether_addr(ndev->dev_addr) && pdata != NULL) {
  mac_src = "platform data";
  memcpy(ndev->dev_addr, pdata->dev_addr, 6);
 }

 if (!is_valid_ether_addr(ndev->dev_addr)) {
  /* try reading from mac */
  
  mac_src = "chip";
  for (i = 0; i < 6; i++)
   ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
 }

 if (!is_valid_ether_addr(ndev->dev_addr))
  dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
    "set using ifconfig/n", ndev->name);
 printk("now use the default MAC address:08:90:90:90:90:90/n");
 ndev->dev_addr[0] = 0x08;
 ndev->dev_addr[1] = 0x90;
 ndev->dev_addr[2] = 0x90;
 ndev->dev_addr[3] = 0x90;
 ndev->dev_addr[4] = 0x90;
 ndev->dev_addr[5] = 0x90;

 platform_set_drvdata(pdev, ndev);
 ret = register_netdev(ndev);

 if (ret == 0)
  printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %pM (%s)/n",
         ndev->name, dm9000_type_to_char(db->type),
         db->io_addr, db->io_data, ndev->irq,
         ndev->dev_addr, mac_src);
 return 0;

out:
 dev_err(db->dev, "not found (%d)./n", ret);

 dm9000_release_board(pdev, db);
 free_netdev(ndev);

 return ret;
 *((volatile unsigned int *)S3C2410_BWSCON) = oldval_bwscon;
    *((volatile unsigned int *)S3C2410_BANKCON4) = oldval_bankcon4;
}

static int
dm9000_drv_suspend(struct platform_device *dev, pm_message_t state)
{
 struct net_device *ndev = platform_get_drvdata(dev);
 board_info_t *db;

 if (ndev) {
  db = netdev_priv(ndev);
  db->in_suspend = 1;

  if (netif_running(ndev)) {
   netif_device_detach(ndev);
   dm9000_shutdown(ndev);
  }
 }
 return 0;
}

static int
dm9000_drv_resume(struct platform_device *dev)
{
 struct net_device *ndev = platform_get_drvdata(dev);
 board_info_t *db = netdev_priv(ndev);

 if (ndev) {

  if (netif_running(ndev)) {
   dm9000_reset(db);
   dm9000_init_dm9000(ndev);

   netif_device_attach(ndev);
  }

  db->in_suspend = 0;
 }
 return 0;
}

static int __devexit
dm9000_drv_remove(struct platform_device *pdev)
{
 struct net_device *ndev = platform_get_drvdata(pdev);

 platform_set_drvdata(pdev, NULL);

 unregister_netdev(ndev);
 dm9000_release_board(pdev, (board_info_t *) netdev_priv(ndev));
 free_netdev(ndev);  /* free device structure */

 dev_dbg(&pdev->dev, "released and freed device/n");
 return 0;
}

static struct platform_driver dm9000_driver = {
 .driver = {
  .name    = "dm9000",
  .owner  = THIS_MODULE,
 },
 .probe   = dm9000_probe,
 .remove  = __devexit_p(dm9000_drv_remove),
 .suspend = dm9000_drv_suspend,
 .resume  = dm9000_drv_resume,
};