来源: 互联网  发布时间: 2014-02-18

DM9000驱动的理解一(dm9000_probe)

//__devinit 内核优化宏，编译器通过这些宏把代码优化放到合适的内存空间，宏__devinit标志设备初始化代码 
static int __devinit
dm9000_probe(struct platform_device *pdev)
{
	//这个platform_data是在板级配置文件中设置的
	struct dm9000_plat_data *pdata = pdev->dev.platform_data;
	struct board_info *db;	/* Point a board information structure */
	//网络设备驱动中两个重要结构体之一，另一个大名鼎鼎的结构体是skbuff
	struct net_device *ndev;
	const unsigned char *mac_src;
	int ret = 0;
	int iosize;
	int i;
	u32 id_val;

	/* Init network device */
	//初始化网络设备结构体net_device，最终是调用了函数alloc_netdev_mq，有时间我想好好分析下这个函数
	ndev = alloc_etherdev(sizeof(struct board_info));
	if (!ndev) 
	{
		//实际上就是printk啦,我忍不住想说linux的一大特点，就是喜欢用满天飞的define给别人起新名字
		dev_err(&pdev->dev, "could not allocate device.\n");
		return -ENOMEM;
	}

	SET_NETDEV_DEV(ndev, &pdev->dev);

	//最后还是printk。。。
	dev_dbg(&pdev->dev, "dm9000_probe()\n");

	/* setup board info structure */
	//让结构体指针指向结构体ndev内的的某个xx(xx还没搞懂是哪个变量或者结构体)
	db = netdev_priv(ndev);

	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);

	//调用platform_get_resource获取资源填充结构体db,这个resource就是在板级配置
	//文件中填充的那个struct resouce.
	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;
	}
	//继续填充结构体db中....,获取一个设备irq，这个irq也是板级配置文件中设置的
	//我的板上的两个dm9000分别分配了190,191.
	db->irq_wake = platform_get_irq(pdev, 1);
	if (db->irq_wake >= 0) {
		dev_dbg(db->dev, "wakeup irq %d\n", db->irq_wake);

		//注册中断函数dm9000_wol_interrupt，中断号为db->irq_wake
		ret = request_irq(db->irq_wake, dm9000_wol_interrupt,
				  IRQF_SHARED, dev_name(db->dev), ndev);
		if (ret) {
			dev_err(db->dev, "cannot get wakeup irq (%d)\n", ret);
		} else {

			/* test to see if irq is really wakeup capable */
			ret = set_irq_wake(db->irq_wake, 1);
			if (ret) {
				dev_err(db->dev, "irq %d cannot set wakeup (%d)\n",
					db->irq_wake, ret);
				ret = 0;
			} else {
				set_irq_wake(db->irq_wake, 0);
				db->wake_supported = 1;
			}
		}
	}
	//计算即将申请内存大小，这个大小是板级配置文件中struct resouce 中.end减去.tart再加1
	//为什么要再加1?
	iosize = resource_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->addr_res->start开始，大小iosize，物理空间映射到虚拟地址空间
	//这段虚拟地址空间开始地址是db->io_addr
	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;
	}
	//以下这段程序操作与上类似，因为dm9000提供了地址和数据两个访问口，所以映射了两个。
	
	iosize = resource_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;
	}

	/* fill in parameters for net-dev structure */
	ndev->base_addr = (unsigned long)db->io_addr;
	ndev->irq	= db->irq_res->start;

	//设置dm9000位宽，根据板级配置文件中struct platform_data设置而定
	//由此可见，linux内核移植很大一部分工作是驱动移植，是必须要在读懂驱动的前提上进行的
	
	/* 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) {
		/* check to see if the driver wants to over-ride the
		 * default IO width */

		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,实际上就是往dm9000寄存器NCR上写1
	dm9000_reset(db);
    //读dm9000id。如果读写时序正确，基本就能读到id.如果读id错误，
    //要么是时序错了，要么就是硬件存在问题，我就遇到过这个坑爹的问题，
    //如果硬件存在故障，这是驱动调试最痛苦痛苦的事情。
	/* try multiple times, DM9000 sometimes gets the read wrong */
	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;
	}

	/* Identify what type of DM9000 we are working on */
	//读dm9000寄存器CHIPR确定类型
	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;
	}

	/* dm9000a/b are capable of hardware checksum offload */
	if (db->type == TYPE_DM9000A || db->type == TYPE_DM9000B) {
		db->can_csum = 1;
		db->rx_csum = 1;
		ndev->features |= NETIF_F_IP_CSUM;
	}

	/* from this point we assume that we have found a DM9000 */

	/* driver system function */
	ether_setup(ndev);

	ndev->netdev_ops	= &dm9000_netdev_ops;
	ndev->watchdog_timeo	= msecs_to_jiffies(watchdog);
	ndev->ethtool_ops	= &dm9000_ethtool_ops;

	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";

	/* try reading the node address from the attached 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);

	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;
}

    

    来源: 互联网  发布时间: 2014-02-18

给对话框设置大小后怎样快捷的关闭对话框
当我们使用如下代码给一个对话框设置大小后，

AlertDialog dialog =
					new AlertDialog.Builder(DrawHomeActivity.this)
					.setTitle("标题").setView(view).show();

			WindowManager.LayoutParams params = dialog.getWindow()
					.getAttributes();
			params.width = 900;
			params.height = 500;
			dialog.getWindow().setAttributes(params);
			dialog.setCanceledOnTouchOutside(true);

发现要关闭对话框，只能按Back键，而没法像之前没有设置大小时触控对话框范围外就可关闭来得简单。

在网上搜索了发现加上以下语句就可方便的关闭：

dialog.setCanceledOnTouchOutside(true); 即当触控到对话框以外，关闭对话框。

    

    来源: 互联网  发布时间: 2014-02-18

libgdx 环境搭建

一、 开发包下载

1） libgdx 开发包下载： google code（最新 libgdx-0.9.7.zip    2012.11.12）

2） libgdx 主干源码下载： github tags

二、 环境搭建

 1） 添加开发jar包

libgdx的android开发包主要有 gdx.jar， gdx-backend-android.jar，以及 armeabi 和 armeabi-v7a （区别）

解压libgdx -x.x.x.zip 文件， 可以看到以下目录树：

开发libgdx时，把画蓝色横线的开发包拷贝到自己的Android项目libs目录下，效果图如下：

2） 添加源码jar包

开发过程中，可能需要链接查看libgdx源码，因此需要添加 gdx-backend-android-sources.jar 和 gdx-sources.jar 源码包

添加步骤： 点击libgdx开发jar包中的引用函数——》查看源码——》Attach Source... ——》 选择上图 gdx-backend-android-sources.jar 和 gdx-sources.jar 源码包

3） 在自己的项目myLibgdx，添加完开发包jar和源码包jar后，其效果如下：

三、 简单示例

1） 新建Activity

在自己项目myLibgdx中， 新建一个MainActivity，继承于libgdx父类 AndroidApplication

public class MainActivity extends AndroidApplication {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		initialize(new MyGame(), false);
	}
}

2） 自定义 MyGame 

上面 MainActivity 的 initialize() 中，使用了自定义的 MyGame 类，其实现 libgdx 父类接口 ApplicationListener ， 详细定义如下：

public class MyGame implements ApplicationListener {
	private SpriteBatch batch;		// 初始化游戏精灵
	private BitmapFont bf;			// 初始化字体绘制
	
	@Override
	public void create() {					// 创建
		batch = new SpriteBatch();
		bf = new BitmapFont();
		bf.setColor(Color.RED);
		bf.setScale(1.0f);
	}

	@Override
	public void render() {					// 渲染
		Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
		Gdx.gl.glClearColor(0, 0, 0, 0);
		batch.begin();
		bf.draw(batch, "hello libgdx", Gdx.graphics.getWidth()/2, Gdx.graphics.getHeight()/2);
		batch.end();		
	}

	@Override
	public void resize(int arg0, int arg1) {	// 布局调整
	}

	@Override
	public void pause() {				// 暂停
	}

	@Override
	public void resume() {				// 恢复
	}

	@Override
	public void dispose() {				// 销毁
		bf.dispose();
		batch.dispose();
	}
}

运行结果：

源码下载 

四、 libgdx生命周期

通过上面的简单示例，libgdx 运行流程已全部展示出来了，具体流程如下：

1） 主MainActivity，继承于libgdx父类 AndroidApplication， 而 AndroidApplication 又继承Android 基本的Activity并实现了libgdx自定义的接口类 Application， 关系如下：

public class AndroidApplication extends Activity implements Application 

2） 自定义 MyGame，实现 libgdx 父类接口 ApplicationListener， 而ApplicationListener 接口如下：

public class MyGame implements ApplicationListener {
   public void create () {
   }

   public void resize (int width, int height) { 
   }

   public void render () {        
   }

   public void pause () { 
   }

   public void resume () {
   }

   public void dispose () { 
   }
}

逻辑流程如下：

逻辑流程的功能描述：

方法名

功能描述

create()

应用创建时，被调用且只调用一次

resize(int width, int height)

游戏屏幕每次重置大小且不在暂停状态时调用此方法，在create()后仅调用一次，参数是屏幕被重置后的新宽度和高度（像素）

render()

每次渲染发生时，游戏循环调用此方法。游戏逻辑更新常在此方法中，即循环刷新绘制游戏的逻辑画面

pause()

在android中当Home键按下或重新进入程序时调用，这是一个保存游戏状态的好时刻，resume()不一定会被调用

resume()

这个方法仅在android中调用，当应用从pause状态重新获取焦点时resume

dispose()

当应用销毁destroyed时，调用此方法，在pause()之后

 

libgdx 应用开发的逻辑流程图：

五、 总结

从上文的示例和流程图可以看出，libgdx 游戏开发步骤如下：

1） AndriodApplication，继承自Android 的基类 Activity， 起到了一个Activity的作用，但是我们并不在这个“Activity”中做太多的工作，当然可以做一些保存Context上下文之类的工作，如 onSaveInstanceState(), onRestoreInstanceState()等

2） libgdx开发中实际的显示工作，是交给一个实现了ApplicationListener接口的类来完成，它有所需要的所有功能：创建，渲染（刷新），暂停，恢复，销毁等。所以实际的情况是，我们在游戏中的大部分绘图工作都是放在这个页面进行的

参考推荐：

libgdx 概述

The Life-Cycle（libgdx wiki）

libgdx游戏引擎教程 ApplicationListener

android游戏开发框架libgdx 开发框架总观