MEYE
posts - 189,comments - 115,trackbacks - 0
哈佛大学凌晨4点半的景象：哈佛校训： 此刻打盹，你将做梦；而此刻学习，你将圆梦。

哈佛大学凌晨4点半的景象

哈佛校训：
此刻打盹，你将做梦；而此刻学习，你将圆梦。

看到一篇关于哈佛大学学生是如何学习的文章，贴出来与大家共勉之。如果管理员觉得本文不合适放在首页，可以放在其他地方，谢谢！

    哈佛老师经常给学生这样的告诫：如果你想在进入社会后，在任何时候任何场合下都能得心应手并且得到应有的评价，那么你在哈佛的学习期间，就没有晒太阳的时间。


作为闻名于世的学府，哈佛大学培养了许多名人，他们中有33位诺贝尔奖获得者、7位美国总统以及各行各业的职业精英。究竟是什么使哈佛成为精英的摇篮？哈佛学子接受了什么样的精神和理念？这些问题吸引着成千上万的人去探知其中的答案。

哈佛图书馆墙上的20条训言似乎已经给出了答案。短短数语，引发深思，给人启迪。

哈佛图书馆的二十条训言：
1.此刻打盹，你将做梦；而此刻学习，你将圆梦。
2.我荒废的今日，正是昨日殒身之人祈求的明日。
3.觉得为时已晚的时候，恰恰是最早的时候。
4.勿将今日之事拖到明日。
5.学习时的苦痛是暂时的，未学到的痛苦是终生的。
6.学习这件事，不是缺乏时间，而是缺乏努力。
7.幸福或许不排名次，但成功必排名次。
8.学习并不是人生的全部。但既然连人生的一部分―――学习也无法征服，还能做什么呢？
9.请享受无法回避的痛苦。
10.只有比别人更早、更勤奋地努力，才能尝到成功的滋味。
11.谁也不能随随便便成功，它来自彻底的自我管理和毅力。
12.时间在流逝。
13.现在流的口水，将成为明天的眼泪。
14.狗一样地学，绅士一样地玩。
15.今天不走，明天要跑。
16.投资未来的人，是忠于现实的人。
17.受教育程度代表收入。
18.一天过完，不会再来。
19.即使现在，对手也不停地翻动书页。
20.没有艰辛，便无所获。

此刻打盹，你将做梦；而此刻学习，你将圆梦
哈佛老师经常给学生这样的告诫：如果你想在进入社会后，在任何时候任何场合下都能得心应手并且得到应有的评价，那么你在哈佛的学习期间，就没有晒太阳的时间。在哈佛广为流传的一句格言是“忙完秋收忙秋种，学习，学习，再学习。”
人的时间和精力都是有限的，所以，要利用时间抓紧学习，而不是将所有的业余时间都用来打瞌睡。
有的人会这样说：“我只是在业余时间打盹而已，业余时间干吗把自己弄得那么紧张？”爱因斯坦就曾提出：“人的差异在于业余时间。”我的一位在哈佛任教的朋友也告诉我说，只要知道一个青年怎样度过他的业余时间，就能预言出这个青年的前程怎样。
20世纪初，在数学界有这样一道难题，那就是2的76次方减去1的结果是不是人们所猜想的质数。很多科学家都在努力地攻克这一数学难关，但结果并不如愿。1903年，在纽约的数学学会上，一位叫做科尔的科学家通过令人信服的运算论证，成功地证明了这道难题。
人们在惊诧和赞许之余，向科尔问道：“您论证这个课题一共花了多少时间？”科尔回答：“3年内的全部星期天。”
同样，加拿大医学教育家奥斯勒也是利用业余时间作出成就的典范。奥斯勒对人类最大的贡献，就是成功地研究了第三种血细胞。他为了从繁忙的工作中挤出时间 读书，规定自己在睡觉之前必须读15分钟的书。不管忙碌到多晚，都坚持这一习惯不改变。这个习惯他整整坚持了半个世纪，共读了1000多本书，取得了令人 瞩目的成绩。

我荒废的今日，正是昨天殒身之人祈求的明日
闻名于世的约翰霍普金斯学院的创始人、牛津大学医学院的讲座教授、被英国国王册封为爵士的威廉。奥斯勒在年轻时，也曾为自己的前途感到迷茫。一次，他在读书时看到了一句话，给了他很大的启发。这句话是“最重要的就是不要去看远方模糊的事，而是做手边清楚的事。”
对此，哈佛提醒学生说“我荒废的今日，正是昨天殒身之人祈求的明日”。明天再美好，也不如抓住眼下的今天多做点实事。
获得哈佛大学荣誉学位的发明家、科学家本杰明。富兰克林有一次接到一个年轻人的求教电话，并与他约好了见面的时间和地点。当年轻人如约而至时，本杰明的房门大敞着，而眼前的房子里却乱七八糟、一片狼藉，年轻人很是意外。
没等他开口，本杰明就招呼道：“你看我这房间，太不整洁了，请你在门外等候一分钟，我收拾一下，你再进来吧。”然后本杰明就轻轻地关上了房门。
不到一分钟的时间，本杰明就又打开了房门，热情地把年轻人让进客厅。这时，年轻人的眼前展现出另一番景象―――房间内的一切已变得井然有序，而且有两杯倒好的红酒，在淡淡的香气里漾着微波。
年轻人在诧异中，还没有把满腹的有关人生和事业的疑难问题向本杰明讲出来，本杰明就非常客气地说道：“干杯！你可以走了。”
手持酒杯的年轻人一下子愣住了，带着一丝尴尬和遗憾说：“我还没向您请教呢……”
“这些……难道还不够吗？”本杰明一边微笑一边扫视着自己的房间说，“你进来又有一分钟了。”
“一分钟……”年轻人若有所思地说，“我懂了，您让我明白用一分钟的时间可以做许多事情，可以改变许多事情的深刻道理。”
珍惜眼前的每一分每一秒，也就珍惜了所拥有的今天。哈佛的这句话实际上揭示了一种人生哲学，那就是人生要以珍惜的态度把握时间，从今天开始，从现在做起。

觉得为时已晚的时候，恰恰是最早的时候
安曼曾经是纽约港务局的工程师，工作多年后按规定退休。开始的时候，他很是失落。但他很快就高兴起来，因为他有了一个伟大的想法。他想创办一家自己的工程公司，要把办公楼开到全球各个角落。
安曼开始一步一个脚印地实施着自己的计划，设计的建筑遍布世界各地。在退休后的三十多年里，他实践着自己在工作中没有机会尝试的大胆和新奇的设计，不停 地创造着一个又一个令世人瞩目的经典：埃塞俄比亚首都亚的斯亚贝巴机场，华盛顿杜勒斯机场，伊朗高速公路系统，宾夕法尼亚州匹兹堡市中心建筑群……这些作 品被当作大学建筑系和工程系教科书上常用的范例，也是安曼伟大梦想的见证。86岁的时候，他完成最后一个作品―――当时世界上最长的悬体公路桥―――纽约 韦拉扎诺海峡桥。
生活中，很多事情都是这样，如果你愿意开始，认清目标，打定主意去做一件事，永远不会嫌晚。

今天不走，明天要跑
在哈佛，教授们会时常提醒学生们要做好时间管理，并列举如下事例：
当今世界上最大的化学公司―――杜邦公司的总裁格劳福特。格林瓦特，每天挤出一小时来研究蜂鸟，并用专门的设备给蜂鸟拍照。权威人士把他写的关于蜂鸟的书称为自然历史丛书中的杰出作品。
休格。布莱克在进入美国议会前，并未受过高等教育。他从百忙中每天挤出一小时到国会图书馆去博览群书，包括政治、历史、哲学、诗歌等方面的书，数年如一日，就是在议会工作最忙的日子里也从未间断过。后来他成了美国最高法院的法官。
一位名叫尼古拉的希腊籍电梯维修工对现代科学很感兴趣，他每天下班后到晚饭前，总要花一小时时间来攻读核物理学方面的书籍。随着知识的积累，一个念头跃 入他的脑海。1948年，他提出了建立一种新型粒子加速器的计划。这种加速器比当时其他类型的加速器造价便宜而且更强有力。他把计划递交给美国原子能委员 会做试验，又再经改进，这台加速器为美国节省了7000万美元。尼古拉得到了1万美元的奖励，还被聘请到加州大学放射实验室工作。
在人生的道路上，你停步不前，但有人却在拼命赶路。也许当你站立的时候，他还在你的后面向前追赶，但当你再一回望时，已看不到他的身影了，因为，他已经跑到你的前面了，现在需要你来追赶他了。所以，你不能停步，你要不断向前，不断超越。
狗一样地学，绅士一样地玩
我们说要珍惜时间，努力为实现理想而打拼，但有一点要注意，那就是不要一味地拼命，也要有适度的休息和放松。对此，哈佛有个很贴切的说法，叫做“狗一样地学，绅士一样地玩”。话虽略显粗俗，但揭示的道理却很深刻。
在哈佛，虽然学习强度很大，学生们承受着很大的学习压力，但他们也不提倡学生把所有的时间都用来学习。他们认为，学要尽力，玩也不能忽视。哈佛的学生也 说，哈佛的课余生活要胜过正规学习。而哈佛也意识到适度的课外活动不但不会背离教育使命，而且还会给教育使命以支持。因此，他们提出要像“绅士一样地 玩”。
在哈佛，学生们除了紧张地学习，还会参加学校组织的多种艺术活动，比如音乐会、戏剧演出、舞蹈表演及各种艺术展览等，此外，哈佛每年还 会举办艺术节，以活跃学生的业余生活。这些充满着浓厚艺术氛围的活动不仅让学生接受了艺术教育和熏陶，而且提高了学生的艺术修养和审美能力。
哈佛的理念就是要求你在紧张的学习和工作后，能够暂时地完全忘记它们，像投入工作那样投入玩耍，尽情地放松。的确，在你尽心休闲的时候，所得到的体力和精力的恢复会为你下一阶段的奋斗增添无穷的动力。所以，在前进的路上，你不仅要勤奋努力，更要学会放松。

现在流的口水，将成为明天的眼泪
成功与安逸是不可兼得的，选择了其一，就必定放弃了另一结局。正像哈佛所提醒的那样：现在流的口水，将成为明天的眼泪。今天不努力，明天必定遭罪。
我的邻居查尔斯曾经在哈佛度过4年的大学时光，他现在就职于纽约的一家软件公司，做他最擅长的行政管理工作,九九读书人。不久前，他的公司被一家法国公 司兼并了。在兼并合同签订的当天，公司的新总裁宣布：“我们不会随意裁员，但如果你的法语太差，导致无法和其他员工交流，那么，不管是多高职位的人，我们 都不得不请你离开。这个周末我们将进行一次法语考试，只有考试及格的人才能继续在这里工作。”
散会后，几乎所有的人都拥向了图书馆，他们这时才意识到要赶快补习法语了。只有查尔斯像平常一样直接回家了，同事们都认为他已经准备放弃这份工作了，毕竟，哈佛的学习背景和公司管理层的工作经验会帮助他轻而易举地找到另一份不错的工作。
然而，令所有人都想不到的是，考试结果出来后，这个在大家眼中没有希望的人却考了最高分。原来，查尔斯在毕业后来到这家公司后，他在工作中发现与法国人 打交道的机会特别多，不会法语会使自己的工作受到很大的限制，所以，他很早就开始自学法语了。他利用可利用的一切时间，每天坚持学习，最终学有所获。
在哈佛，你从来看不到学生在偷懒，在消磨时间。当若干年后回想起曾经的梦想时，希望带给你的是无尽的欣慰笑容，而不是因蹉跎而流下的悔恨泪水。


投资未来的人，是忠于现实的人
作为世界知名的学府，哈佛十分强调要有长远眼光，为未来投资。要投资未来，就要定好未来的投资方向，也就是要及早地设定人生目标。没有目标，就谈不到发展，更谈不上成功。
哈佛大学曾进行过这样一项跟踪调查，对象是一群在智力、学历和环境等方面条件差不多的年轻人。调查结果发现：27%的人没有目标；60%的人目标模糊；10%的人有着清晰但比较短期的目标；其余3%的人有着清晰而长远的目标.
以后的岁月，他们行进在各自的人生旅途中。25年后，哈佛再次对这群学生进行了跟踪调查。结果是这样的：
3%的人，在25年间朝着一个方向不懈努力，几乎都成为社会各界的成功人士，其中不乏行业领袖和社会精英；10%的人，他们的短期目标不断地实现，成为 各个领域中的专业人士，大都生活在社会的中上层；60%的人，他们安稳地生活与工作，但都没有什么特别成绩，几乎都生活在社会的中下层；剩下27%的人， 他们的生活没有目标，过得很不如意，并且常常在抱怨他人，抱怨社会，当然，也抱怨自己。
其实，他们之间的差别仅仅在于：25年前，他们中的一些人就已经知道自己最想要做的是什么，而另一些人则不清楚或不很清楚。这个调查生动地说明了明确生活目标对于人生成功的重要意义。


posted @ 2010-09-01 09:19 MEYE 阅读(601) | 评论 (0) | 编辑 收藏
也谈谈如何做演讲

也谈谈如何做演讲

http://blog.zdnet.com.cn/html/99/421499-2886530.html

作为一个经常做演讲的人，我很高兴的看到CatChen在他的文章里介绍了如何做演讲。洪超大哥在MVP openday上的培训是非常好的，我没去成很可惜。

话说回来，演讲这事我一年大概搞个小100次，如果算上我的各种Cast则要更多，所以不才就在这里随便说说关于演讲的东西。

1.演讲的目的

正本清源的说，演讲这事的目的只有一个，就是让对方相信你让他相信的，赞同你提出的，反对你反对的。演讲是宣传的工具，宣传则是包装的工具，对好事我们所做的一切叫宣传，对坏事我们所做的一切叫炒作。但是本质上，两者做的是同一种事。也就是说，你演讲的目的大体只有一个，也就是宣传或者说炒作。如果你不赞同这一观点，可以参考下面的文字《什么是炒作》

2.演讲的技巧

演讲最重要的技巧就是了解你的受众，人们只希望听见自己希望听见的话，喜欢听见自己喜欢听见的话，记住自己愿意记住的话，而其它的话，则全是废话。牢记这一点有助于你进行演讲，在开始演讲之前，你非常有必要了解你的听众，他们是谁、为什么来着、想听什么？

为了不让这个事情说的像国产教科书，我简单的把这事做如下表述“你的记忆就像一幢房子，里面是精装修，家具电器一应俱全，就是没有男主人，后来天长日久就老旧了，你选择性记忆把那些你觉的好的留下了，然后对记忆修饰一新，涂上腻子雕梁画栋，没事的时候还不断拉人来参观粉饰太平，最后你也分不清那些是原来的哪些是后弄的。简单的说，你把自己给糊弄了。”

大体上，我们在成长和衰老过程中进行着不断肯定的自我记忆修复，我们不断回忆自己做的好的往事，然后通过这一肯定让自己有继续生活的勇气，少部分人因为脑部受了损伤，总是记住自己做的坏事，然后自我否定，我们一般称呼这种病为“抑郁症”，患者都有自杀倾向，要吃百忧解才能继续生活，不幸的是，越是善于客观、理智思考的人，越不能随便忘记过失和盲目自我肯定，这也就造就了的他们早夭。人类社会千百年来没什么进步，且一茬不如一茬的根本症结就在于此。

2.1 做好自我定位

我们人类社会大体是分小圈子的，一个人的穿着打扮就说明了他的小圈子，你在演讲的时候，你和你受众必须是一个小圈子，否则一切说法就无从谈起，不信的话，你可以参考那些到处游说的职业政客，每个人走进工人的时候都是蓝领子的衬衫，走向农民的时候都是灰色尼龙绸夹克，绝对不会穿衬衫和西装。跟知识分子握手的时候则必然西装笔挺，还要带着领结。要知道，这些随着外部环境变化的形象工程是演讲成功的关键，你传的衣服，行为举止让对方感觉你不是这个圈子的，则你不用开口，就已经输了。

2.2 目标导向明确

演讲要有宣传的目的，我一开头就说了，这里再强调并非是说还要在演讲中不断的强调你的目标，刚好相反，你应该尽量回避告诉你的听众你的目标，外国PPT开头最喜欢告诉受众，我这个PPT要讲的内容是什么，然后1.2.3一列举，坦白讲，这种演讲的影响力其实很有限，因为听众会在一开头就知道，哦，原来你要讲这些啊，而且会根据内容选择性收听或者不听，因为他们想，反正我有PPT可看，还听你废话干什么。外国这么搞当然是有原因的，因为外国人是实在，来听演讲一定就是来听演讲，一定一心一意的，因为他们是自愿来的，他们对这个演讲感兴趣，但是多数情况下，来听你演讲的同胞们很多情况下完全是因为“无聊，被迫，不来听就要去干活”等等纯粹的消极因素来听演讲。所以对他们来说，PPT前面的123可以跟讲的东西完全不搭调，123是给他们一个来的理由，而他们听到的东西则决定了他们的反馈。

除了不要照本宣科以外，我还得说，演讲的诀窍之一就是把你的目的弄成简单的口号，人们对母语中有韵脚的语序有特殊的好感，大脑会选择记住他们，并且简短的东西便于口口相传，比如“不要迷恋哥，哥只是传说。”十个字，体现了很高的境界，再比如“哥抽的不是烟，燃烧的是寂寞。”11个字，体现了品位，最后比如“做人勿装B，装B被雷劈”10个字，提前了对以上所有说法的否定，如果你想让你的演讲也能深入人心，那么一定要把主题弄在10个字里，并且让他们押韵，比如…

3.演讲常见悖论

演讲需要做大量准备，反复对这镜子练习，注意观察自己的口型和神态。

凡提供这一说法的都是上过MBA课，或者被外国人忽悠了，大体上国外进口的演讲入门书籍里都这么说，这种说法很适合受众固定，内容统一的演讲，也就是说，如果你长年累月就说着一套话，那么再最开始，你应该可以通过这样准备而获得比较好的提高。但是，实际上，多说情况下，这种准备对你的帮助有限，对演讲的内容最好的准备是，在演讲之前对稿子熟练，然后扩充各种相关内容，仔细分析各种相关书籍和文章，尽量在演讲的时候说听众没想到或者没听说过的。这比口型神态什么的管用的多。

演讲需要口齿清楚，逻辑流畅，这样才能打动人。

有兴趣的人可以参加一下安利的讲座，或者跟保险推销员以及任何直销销售人员聊天，如果您有机会现场听学校辅导员老师讲课，则您更会理解我说的内容。这里就不多谈了。

演讲只是交流的手段，演讲的目的是为了交流，激荡出智力的火花。

这跟两个已经势同水火的平级领导在年会上频频碰杯，并高呼“我们是一个Team”，或者一对早就貌合神离却总在媒体前如胶似漆，还说“我们一直很恩爱”的演员伉俪一样。这种说法源于虚伪，其实更像那些想骗你钱的打电话给你推销东西的人说的一样，“我们都是为你好。”

以上是我关于演讲能想起来的大部分细节，最后还有一句老话，卖油的大爷说的“无他，手熟尔。”勤学苦练总是一个亘古不变的好方法。

下面说说题外话，面试的紧张。

任何人面试都紧张，因为要被质问，谁都不喜欢被质问，另外就是心里很想得到这个工作很怕失去这个机会，其实站在人生这个长度看问题，面试连小插曲都算不上，顶多算打一个喷嚏，既不新鲜也不有趣。任何机会如果被标上“一旦错过，永不可能”，则应该坦然让这机会走开，因为谁也不能妄论别人的生死乃至前程，世界充满未知和不确定，一份工作的得失其实微不足道，人，无论伟大或者渺小，最后都是一个终极目标，所以在这过程中尽力耍宝就好，压根用不着为了别人的评价烦恼。

posted @ 2010-08-26 19:25 MEYE 阅读(412) | 评论 (0) | 编辑 收藏
人生如戏，谈如何面对困难

人生如戏，谈如何面对困难

转自：http://blog.zdnet.com.cn/html/99/421499-type-index.html

看见好多人都说困难，家里困难，工作困难，等等逐日此类不一而足，我也随便说两句，我得看法，怎么解决外部环境问题，战天斗地这些我不想说了，我就想说说自己怎么调整心态吧。

其实调整心态挺简单的，就四个字，人生如戏。

人生如戏何解呢，也很简单，就是把你现在所发生的事都当一处话剧，你，你爸爸，你妈妈，你同事，你朋友，你领导，你下属，你老婆，你情人，其实都是演员，大伙兴冲冲的你方唱罢我登场，其实都是演戏，没人跟你来真的，也没有真的。你也就演这几十年，演好演坏无所谓，反正最后都是眼一闭腿一蹬，所以得想开。

当然这话说着容易做着难。首先是得知道自己演的什么角色，您在外面威风八面，回家都得演孝子贤孙，中国人讲究这个。所以记得跟你爸爸妈妈说话的时候要当孝子贤孙，所谓孝是孝敬，尊敬的程度多一点。不是孝顺，没有顺从的必要。你一完全行为能力责任人，你干什么都可以自己负责，压根不用你爸爸妈妈操心。为了避免老有人说看不懂，我再说透亮点。你爸你妈说什么，就答应什么，回头一扭脸，你演别的角色了，就完全不用管答应过他们什么了，因为那是俩角色，不能混着来，你爸你妈苦口婆心跟你说，也是他们的责任，他们作为老演员演了几十年，眼看到最后一班岗了，非得站的敬业一点才好。敬着他们，就是说什么都答应，不顺着他们，就是只捡自己觉得好的做。

角色一时一变，语言、行动也得跟着变。上班的时候你是个积极的程序员，跟你女朋友在一起的时候你就是好男朋友、好老公，这俩角色不交叉，台词也不能混着来，不信你跟你同事聊韩剧，跟女朋友聊.NET，你肯定得倒霉。好多人犯拧巴，非得一天到晚一个腔调，这就是所谓没事找抽型，活该别人不给你好脸色。

跟女朋友打完电话，你又摇身一变成积极青年了，大半夜不睡觉，你得学习新技术，这时候问你女朋友叫什么，你都不用搭理他，因为你这会不演这个角色，这个角色的台词你就不需要记得。

大部分的角色其实都挺好找的，人家一叫你，你一答应就全找到了。人家叫你儿子，你就知道你演儿子呢，人家叫你孙子，你就知道你演孙子呢，人家叫你老公，你就知道你演老公呢，人家叫你SB，你就知道，你演SB呢。前三种都知道怎么演，就最后一种好多人拿不住，人家一叫他这个他就不知道怎么办了，你想想看，一个SB没思考能力，能怎么办？这事稍微一过脑子就能明白，低等动物受到攻击怎么办，脊椎反射都知道，挨骂就骂回去挨打就打回去，不用担心什么礼貌一类，因为你在演一个SB。

诸如此类，社会角色也定义了，演也演了，好多人不满意，非要当角儿，要跟一帮演员里拔得头筹，觉得不这样不算混这一场演出。要我说这事没必要，大伙都是演这一阵，谁知道谁什么时候就下场了。为这点电光石火之间的事争长短，犯不上。

最后就是演着演着好多人谢幕了，有些老演员匆匆忙忙就谢幕了，有些提前还假装不舒服，让演医生的出来串串场，有些则干脆不打招呼就溜号了，这时候你也别太难过，这不是没有戏德的表现，实在是老演员太辛苦了，演了那么长时间，需要休息，你也别难过，没准哪天就在街上碰见了，虽然彼此都装着不认识，但是心里还是认识的。我小时候就这么想，所以姥姥姥爷走了以后不怎么难过，今天我劝大家都这么想，也许就少难过一点。（要依着我自己写，这句话就不加，但又怕说看不懂）

对于女朋友，人家漂亮姑娘肯定得赶场，档期实在排不开就不能陪你演着一阵你也更不用难过，人家跟谁不是演这一阵子啊，换句话说，你不是得找那个能跟你演一辈子的吗，所以别着急。别犯牛劲。

然后就是事业不顺，那就更看得开了。韩信跟漂母讨饭，秦琼卖马，赵匡胤跟街上摆象棋摊，哪个大人物不是从挫折戏演起的，换句话说，没有挫折戏这一出，哪能体现后面飞黄腾达的刺激呢，所以演这出戏是必由之路，一旦导演给您派了这出戏，您应该高兴，那是您要飞黄腾达的了，这会忍住以后就能吃香的喝辣的。

况且导演哪能真把您逼得绝路上，前面肯定给您安排了峰回路转的情节，无论如何都得静观其变，中途罢演那就没劲了。

最后就是希望大家都好，别管有钱没有，有吃的没有，总把这一切都当成一出戏，有演的有看的，就能乐在其中，其乐融融了。
posted @ 2010-08-26 19:23 MEYE 阅读(418) | 评论 (0) | 编辑 收藏
android多线程下载详解
     摘要: [转载：]   http://www.ideasandroid.com/?p=328 本文将介绍在android平台下如何实现多线程下载，大家都知道，android平台使用java做为开发语言，所以java中支持的多线程下载方式在android平台下都支持，其中主要有两种方式可以实现多线程下载。 一种方式是使用很多个线程分别下载文件的不同部分，最后把所有下载完的文件合并成一个文...  阅读全文
posted @ 2010-08-17 17:16 MEYE 阅读(2360) | 评论 (0) | 编辑 收藏
Android开发之：如何使用样式和主题

样式是用于描述一个View或是一个窗口的显示属性的集合，样式可以指定如高度，填充，字体颜色，字体大小，背景颜色等属性。样式是从布局文件中分离出来的一个XML资源文件。Android中的样式就像Web开发中的css样式表，它使用我们的样式独立于内容进行设计开发。
例如，通过使用一个样式可以让如下的布局文件

<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textColor="#00FF00"
    android:typeface="monospace"
    android:text="@string/hello" />

简化为：

<TextView
    style="@style/CodeFont"
    android:text="@string/hello" />

所有和样式有关的属性都被从布局XML文件中移动到一个叫“CodeFont”的样式定义中，然后使用一个style属性指定样式名称。你将会在以下的内容中看到如何定义一个样式。

应用于一个Activity或应用程序的样式称为主题（theme）,而不是刚才说的一个View。所有在当前Activity或应用下的视图（VIEW）都会应用相同的主题样式。例如，您可以让一个Activity使用”CodeFont”主题，那么这个Activity下的所有视图的的文本都将是绿色等宽字体。

定义样式

定义样式我们需要在 res/values/目录下新建一个XML文件，文件名自已随便命名，但必须以.xml为文件后缀。Xml的根节点必须为。
我们用style标签来定义一个样式，用标签来定义样式属性。如下所示：

<?xml version="1.0" encoding="utf-8"?>
<resources>
<style name="CodeFont" parent="@android:style/TextAppearance.Medium">
<item name="android:layout_width">fill_parent</item>
<item name="android:layout_height">wrap_content</item>
<item name="android:textColor">#00FF00</item>
<item name="android:typeface">monospace</item>
</style>
</resources>

Style标签的name属性是必须有的，节点可以定义颜色、高度或者是另一个资源的引用。所有节点的子节点在编译时都会做为应用程序的一个资源。所以我们可以通过style节点的name属性值来引用这个资源。比如在布局文件中使用@style/CodeFont来引用这个样式。parent 属性是可选的，用它来标识本样式是继承哪个样式，在父样式中的所有属性都将被应用于本样式中，同时可以覆盖父样式中的样式（和java的继承相似）。

样式的继承
这里有两种方式可以实现样式继承，如上例中所示的，我们可以在定义样式时使用parent属性来继承样式，使用这种方式，我们可以继承一个我们自己定义好的样式，也可以继承一个android平台自带的样式(后文中会介绍android平台自带的所有样式)。如下所示，我们继承一个android平台默认的文本样式，并把它的字体颜色改为我们需要的颜色。

<style name="GreenText" parent="@android:style/TextAppearance">
<item name="android:textColor">#00FF00</item>
</style>

另一种继承的方式是使用用户自定义的样式作为前缀即可。这种方式只适用于继承用户自定义样式。如下所示：

<style name="CodeFont.Red">
<item name="android:textColor">#FF0000</item>
</style>

这样，新定义的样式就会继承CodeFont样式的所有属性，然后把字体颜色变为#FF0000。我们可以这样引用新的样式： @style/CodeFont.Red
相同的方法，我们可以再继承下去，如下所示：

<style name="CodeFont.Red.Big">
<item name="android:textSize">30sp</item>
</style>

这样新的样式文子的大小就和CodeFont.Red样式不同了。

样式属性

到这里为止，你已经知道了如何定义一个样式，你还需要知道有多少种样式属性可以通过节点来定义。你可能已经对其中的一些比较熟悉了，如layout_width 、textColor等。当然，还有很多的样式属性是你可以使用的。

最好的方法查询一个视图支持哪些样式属性的方法是查询视图类的文档中XML Attributes表格，如TextView的XML attributes如链接中所示： http://www.ideasandroid.com/android/sdk/docs/reference/android/widget/TextView.html#lattrs

如需所有可用的样式属性的，请参阅R.attr： http://www.ideasandroid.com/android/sdk/docs/reference/android/R.attr.html
不是所有的视图都支持上面的样式属性，如果遇到不支持的样式属性，您定义的属性将会被忽略。

应用样式和主题

应用样式和主题的方法很简单，在布局定义文件（layout）中，使用style属性直接引用样式资源，如下所示：

<TextView
    style="@style/CodeFont"
    android:text="@string/hello" />

在AndroidManifest.xml文件中可以引用样式主题，可以为一个Activity定义一个主题，也可以为整个应用程序定义一个主题，如下所示：

<application android:theme="@style/CustomTheme">

或者：

<activity android:theme="@style/CustomDialogTheme">

Android平台的样式和主题

样式见：http://www.ideasandroid.com/android/sdk/styles.xml
主题见：http://www.ideasandroid.com/android/sdk/themes.xml
posted @ 2010-08-17 17:14 MEYE 阅读(1082) | 评论 (0) | 编辑 收藏
Android开发之ListView 适配器（Adapter）优化

ListView的Adapter的作用如下图所示：

Adapter的作用就是ListView界面与数据之间的桥梁，当列表里的每一项显示到页面时，都会调用Adapter的getView方法返回一个View。想过没有？ 在我们的列表有1000000项时会是什么样的？是不是会占用极大的系统资源？

先看看下面的代码：

public View getView(int position, View convertView, ViewGroup parent) {
View item = mInflater.inflate(R.layout.list_item_icon_text, null);
((TextView) item.findViewById(R.id.text)).setText(DATA[position]);
((ImageView) item.findViewById(R.id.icon)).setImageBitmap(
(position & 1) == 1 ? mIcon1 : mIcon2);
return item;
}

怎么样？如果超过1000000项时，后果不堪设想！您可千万别这么写！

我们再来看看下面的代码：

public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = mInflater.inflate(R.layout.item, null);
}
((TextView) convertView.findViewById(R.id.text)).setText(DATA[position]);
((ImageView) convertView.findViewById(R.id.icon)).setImageBitmap(
(position & 1) == 1 ? mIcon1 : mIcon2);
return convertView;
}

怎么样，上面的代码是不是好了很多？系统将会减少创建很多View。性能得到了很大的提升。

还有没有优化的方法呢？ 答案是肯定的：

public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = mInflater.inflate(R.layout.list_item_icon_text, null);
holder = new ViewHolder();
holder.text = (TextView) convertView.findViewById(R.id.text);
holder.icon = (ImageView) convertView.findViewById(R.id.icon);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
holder.text.setText(DATA[position]);
holder.icon.setImageBitmap((position & 1) == 1 ? mIcon1 : mIcon2);
return convertView;
}
 
static class ViewHolder {
TextView text;
ImageView icon;
}

怎么样？会不会又给您的系统带来很大的提升呢？看看下面三种方式的性能对比图您就知道了！

本文是Google I/O 2009 Romain Guy 所讲的内容，这里只做简单介绍，相信一看代码就能看懂！有问题请留言！
posted @ 2010-08-17 17:13 MEYE 阅读(2914) | 评论 (1) | 编辑 收藏
Android系统搜索对话框（浮动搜索框）的使用
     摘要: 当您需要在您的应用程序中提供搜索服务时，您第一个想到的是您的搜索框要放哪呢？通过使用Android的搜索框架，应用程序将显示一个自定义搜索对话框来处理用户的搜索请求。通过一个简单的搜索按钮或从您的应用程序中调用API，搜索对话框就会显示在屏幕的顶部，并会自动显示您的应用程序图标。如下图所示： 本文将教你如何为你的应用程序提供一个自定义搜索对话框。这样做，给您的用户提供一个标准化的搜索体验，并...  阅读全文
posted @ 2010-08-17 17:12 MEYE 阅读(1028) | 评论 (0) | 编辑 收藏
Android开发者必须深入学习的10个应用开源项目

Android开发又将带来新一轮热潮，很多开发者都投入到这个浪潮中去了，创造了许许多多相当优秀的应用。其中也有许许多多的开发者提供了应用开源项 目，贡献出他们的智慧和创造力。学习开源代码是掌握技术的一个最佳方式。下面推荐几个应用开源项目，这些项目不仅提供了优秀的创意，也可以直接掌握 Android内核的接口使用：

1.Android团队提供的示例项目

如果不是从学习Android SDK中提供的那些样例代码开始，可能没有更好的方法来掌握在Android这个框架上开发。由Android的核心开发团队提供了15个优秀的示例项 目，包含了游戏、图像处理、时间显示、开始菜单快捷方式等。 
地址：http://code.google.com/p/apps-for-android/

2.Remote Droid

RemoteDroid是一个Android应用，能够让用户使用自己的无线网络使用无线键盘、触摸屏操作手机。这个项目为开发者提供了如网络连接、触 摸屏手指运动等很好的样例。 
地址：http://code.google.com/p/remotedroid/

3.TorProxy和Shadow 
TorProxy应用实现了Android手机无线电电传通讯(TOR)，和Shadow应用一起使用，可以使用手机匿名上网。从该项目源代码中，可以 掌握socket连接、管理cookie等方法。 
地址：http://www.cl.cam.ac.uk/research/dtg/code/svn/android-tor/ 
http://www.cl.cam.ac.uk/research/dtg/android/tor/

4、 Android SMSPopup 
SMSPopup可以截获短信内容显示在一个泡泡形状的窗口中。从这个项目中可以掌握到如何使用内置的短信SMS接口。 
地址：http://code.google.com/p/android-smspopup/

5、 Standup Timer 
Standup Timer应用用于控制站立会议时间，类似秒表倒计时，可以提醒每个人的讲话时间已到，从而保证每个与会者使用时间一样。从该项目的代码中，可以学会如何 使用时间函数。另外，这个项目的代码是采用视图view、模型model严格分离的设计思路。 
地址：http://github.com/jwood/standup-timer

6、 
是.com的一个客户端应用，该应用主要分为两个模块API(com.joelapenna.foursquare)和界面前端 (com.joelapenna.foursquared)两部分。从该项目代码中，可以学会如何同步、多线程、HTTP连接等技术。 
地址：http://code.google.com/p/foursquared/

7、 Pedometer 
Pedometer应用用于记录你每天走路步数的。尽管记录不一定精准，但是从这个项目中，可以学习几个不同的技术：加速器交互、语音更新、后台运行服 务等。 
地址：http://code.google.com/p/pedometer/  

8、 OpenSudoku-android 
OpenSudoku是一个简单的九宫格数独游戏。从代码中可以学习到如何在视图中显示表格数据，以及如何和一个网站交互等技术。 
地址：http://code.google.com/p/opensudoku-android/

9、 ConnectBot 
ConnectBot是Android平台的一个客户端安全壳应用。从该项目代码中，可以学习到很多Android安全方面的内容，这些是你在开发应用 时经常需要考虑的安全问题。 
地址：http://code.google.com/p/connectbot/

10、 WordPress的Android应用 
当然在最后不能不提WordPress的Android应用了，这是WordPress官方开发团队提供的一个项目。从代码中可以学习到XMLRPC调 用（当然还有更多的优秀内容）。 
地址：http://android.svn.wordpress.org/trunk/
posted @ 2010-08-17 17:06 MEYE 阅读(538) | 评论 (0) | 编辑 收藏
Ubuntu环境安装配置Bugzilla
Ubuntu环境安装配置Bugzilla

http://www.bugzilla.org/download/#v218

http://www.bugzilla.org/download

1 Bugzilla简介
1.1 产生
Bugzilla是一个共享的免费的产品缺陷记录及跟踪工具。由Mozilla公司提供。创始人是Terry Weissman，开始时使用一种名为“TCL”的语言创建的，后用Perl语言实现，并作为Open source发布。
1.2 特点
Bugzilla能够为你建立一个完善的bug跟踪体系，包括报告bug、查询bug记录并产生报表、处理解决bug、管理员系统初始化和设置四部分。Bugzilla具有如下特点：
1．基于Web方式，安装简单、运行方便快捷、管理安全。
2．有利于缺陷的清楚传达。本系统使用数据库进行管理，提供全面详尽的报告输入项，产生标准化的bug报告。 提供大量的分析选项和强大的查询匹配能力，能根据各种条件组合进行bug统计。当缺陷在它的生命周期中变化时，开发人员、测试人员、及管理人员将及时获得 动态的变化信息，允许你获取历史记录，并在检查缺陷的状态时参考这一记录。
3．系统灵活，强大的可配置能力。Bugzilla工具可以对软件产品设定不同的模块，并针对不同的模块设定开发人员和测试人员。这样可以实现提交报告时 自动发给指定的责任人，并可设定不同的小组，权限也可划分。设定不同的用户对bug记录的操作权限不同，可有效控制进行管理。允许设定不同的严重程度和优 先级。可以在缺陷的生命期中管理缺陷。从最初的报告到最后的解决，确保了缺陷不会被忽略。同时可以使注意力集中在优先级和严重程度高的缺陷上。
4．自动发送Email,通知相关人员。根据设定的不同责任人，自动发送最新的动态信息，有效的帮助测试人员和开发人员进行沟通。


2 安装Step by Step
Bugzilla是一个基于WEB的缺陷管理系统。前台用 Perl语言实现，后台使用MySQL数据库。因为Bugzilla除了通过WEB来跟踪处理bug外，还同时通过Email来跟踪bug的处理过程。如 果不通过Email来跟踪bug的话，Email电子邮件系统并不是必要的。但是，如果要正常运行Bugzilla，必须设置一个smtp邮件发送服务 器。
安装Bugzilla需要MySQL、Perl等等配套软件。为了简化Bugzilla的安装过程，让大家少走弯路，我们把Bugzilla及其配套软件的安装包都整合到一个目录Bugzilla-2.20.1下，并以Step by Step的方式介绍安装及配置过程：
Bugzilla-2.20.1
01.mysql
02.perl
03.bugzilla
04.ReadMe
    
我刚刚入手UNIX系统学习，学着安装配置Bugzilla。被不少的问题折腾着浪费不少时间，查了不少资料，最终还是圆满成功了。在这作个总结，希望这篇博文能帮助初学者。欢迎各位朋友共同探讨学习。
emial：zongguo.zhang@gmail.com
欢迎转载，请注明出处。
bugzilla安装工具 apache2+mysql5.1+perl+bugzilla3.2.2

Step by step

安装篇

1.安装apache2   
  Ubuntu就可以直接用命令行可以安装 #sudo apt-get install apache2 系统自动安好，打开浏览器在地址栏输入http：//ip （你的ip地址或者127.0.0.1）就会在 页面上出现 “ It works”则表明apache安装成功。
  出了问题的话，进入/etc/apache2 目录下 用#vi httpd.conf打开文件添加ServerName 127.0.0.1:80即可.

2.安装mysql
  用命令#sudo apt-get install mysql-server 系统自动安装，我装的是mysql5.1.
  安装时要输入密码这是进入root的密码(建议用你ubuntu系统密码)，（mysql -uroot -p密码），然后用上述命令行来登录，登录成功显示版本信息和 mysql> ，OK！
  mysql 服务启动/停止/重启命令#service mysql start/stop/restart.

3.安装Bugzilla
  bugzilla到官网去下载（一般为tar.gz包），这个不用我说了吧！不懂google一下，然后cd到下载目录解压包#tar -xzf bugzilla.xx.xx.tar.gz ,再改名#mv bugzilla.xx.xx bugzilla ,再移动到/var/www下面#mv bugzilla /var/www  完毕～～～～ok！

4.安装perl
  先进入到bugzilla目录#cd /var/www/bugzilla，在命令行输入#./checksetup.pl命令检查一下还有哪些perl模块没有安装，因为在系统自动安转apache和mysql时就已安装一部分，

Checking perl modules...
Checking for              CGI.pm (v3.33)   ok: found v3.49 
Checking for            TimeDate (v2.21)   ok: found v2.24 
Checking for           PathTools (v0.84)   ok: found v3.31 
Checking for                 DBI (v1.41)   ok: found v1.611 
Checking for    Template-Toolkit (v2.15)   ok: found v2.22 
Checking for          Email-Send (v2.00)   ok: found v2.198 
Checking for          Email-MIME (v1.861)  ok: found v1.903 
Checking for Email-MIME-Modifier (v1.442)  ok: found v1.903 

Checking available perl DBD modules...
Checking for              DBD-Pg (v1.45)    not found 
Checking for           DBD-mysql (v4.00)   ok: found v4.012 
Checking for          DBD-Oracle (v1.19)    not found 
第一组要全装，第二组就看你装的什么数据库了，这里装的是mysql就选DBD-mysql，not found表示没有安装，用下面提的COMMANDS TO INSTALL:需要什么就复制粘贴就可安装好。

到这里Buglilla所需要的组件全安装完毕，第一篇OK！


配置篇

1.apache2配置 
  A.修改 apache的配置文件apache2.conf：进入/etc/www/apache2目录下面 vi /apache2.conf 找到ServerRoot，修改ServerRoot 为bugzilla所在的目录“/var/www”，即如下：（注释原来的添加修改）
#ServerRoot "/etc/apache2"
ServerRoot "/var/www"
  B.修改apache的配置文件apache2.conf: 设置 apache访问bugzilla的用户及用户组，本安装中将用户及用户组都设置为www-data:如下：
#User ${APACHE_RUN_USER}
#Group ${APACHE_RUN_GROUP}
User www-data
Group www-data
  C.修改apache的配置文件apache2.conf：添加bugzilla所在目录：即在apache.conf文件末添加如下

  Alias /bug/ "/var/www/bugzilla"

  <Directory "/var/www/bugzilla">

     AddHandler cgi-script .cgi

  Options +Indexes +ExecCGI +FollowSymLinks

  DirectoryIndex index.cgi

  AllowOverride None

  Order allow,deny

  Allow from all

</Directory>

  D: 修改 www-data对bugzilla的访问权限
        chown -R www-data:www-data /var/www/bugzilla     
  最后，重启apache2服务 #/etc/init.d/apache2 restart   ~~~~~OK!

2.mysql配置
  用#mysql -uroot -p密码 登录mysql 。
  首先，创建数据库bugs   mysql> create database bugs； 
  其次，创建用户bugs     mysql> use mysql;
  再次，授权 mysql> GRANT SELECT, INSERT,UPDATE, DELETE, INDEX, ALTER, CREATE, LOCK TABLES,CREATE TEMPORARY TABLES, DROP, REFERENCES ON bugs.*TO bugs@localhost IDENTIFIED BY '前面root密码'; 
  最后，mysql> FLUSH PRIVILEGES; 
       退出mysql：mysql>exit或quit
  注：mysql命令以（；）结束，不区分大小写。

3.Bugzilla配置
  先#cd /var/www/bugzilla 运行bugzilla目录下的checksetup.pl (#.checksetup.pl)自动生成loacalconfig文件（原本bugzilla目录里没有），打开文件localconfig(#vi localconfig)，配置如下：
$webservergroup = 'www-data';
$db_driver = 'mysql';
$db_host = 'localhost';
$db_name = 'bugs';
$db_user = 'bugs';
$db_pass = '密码';  注意：为了防止出错，建议所有密码都设置为ubuntu系统密码。
其它不变。

现的配置文件都设置完成，重启apache2 #/etc/init.d/apache2 restart
                     重启mysql  #service mysql restart
                     重新运行checksetuo.pl #./checksetup.pl
结果会出现如下错误：
  SESSION variable 'max_allowed_packet' is read only. Use SET GLOBAL to assign 
the value

  上面错误的原因是bugzilla3.3.2对mysql5.1及以上新版本的兼容性不好。需要修改几处源码文件Bugzilla/Config/Attachment.pm和Bugzilla/Config/Common.pm等，地址：https://bug480001.bugzilla.mozilla.org/attachment.cgi?id=364818其中(-)表示删除（+）表示添加。

bugzilla的预编译和生成相应的配置信息等,如下提示：
Precompiling templates...done.
Fixing file permissions...
Initializing "Dependency Tree Changes" email_setting ...
Marking closed bug statuses as such...
Now filling the 'status_workflow' table with valid bug status transitions...
Adding foreign key: attachments.submitter_id -> profiles.userid...
Adding foreign key: bugs_activity.who -> profiles.userid...
Adding foreign key: bugs_fulltext.bug_id -> bugs.bug_id...
·
·
·
并且会提示输入以下信息：
Enter the e-mail address of the administrator: test@uestc.edu.cn
Enter the real name of the administrator: 用户名
Enter a password for the administrator account: password
Please retype the password to verify: password
根据以上提示输入bugzilla管理员的相关信息
成功后，在浏览器输入：http://127.0.0.1/bugzilla会出现bugzilla的管理主页面

应用篇

   Bugzilla网上有很多使用文档，我就不再细述。主要想说一下bugzilla发不出去邮件的问题。
配置smtp。
登录后点击administrator进行参数设置，点击parameter进入，再点击email设置。

mail_delivery_method : smtp
mailfrom                   : 设置成我的真实邮箱     例 me@163.com 可能有的mail server会验证邮箱的真实性以及是否属于该mail server
sendmailnow          : on
smtpserver           : 设置成smtp authentication服务器 例smtp.163.com
smtp_username        : 我的邮箱    例 me@163.com
smtp_password        : 密码
注意后两个parameters(选项)是2.22.1 debian所没有的。

但是接下来我在测试发送邮件的时候总是报

“The new value for smtp_username is invalid: Error requiring
Authen::SASL: ‘Can’t locate Authen/SASL.pm in @INC (@INC contains: .
lib c:/perl/site/lib c:/perl/lib) at (eval 84) line 3. ‘.”
这个错误要求我们安装Authen::SASL 可以回到checksetup.pl处按照提示安装，但是我在这里却出现了问题。
由于之前已经将bugzilla3.2.2文件夹的访问权限设置给了www-data组，现在无法进入到bugzilla3.2.2文件夹内执行任何操作，总报permissions access

采用 sudo –s –H 并输入密码，可以以root权限进入该文件夹操作，安装好Authen::SASL后，发送邮件功能ok。
posted @ 2010-08-13 14:00 MEYE 阅读(2026) | 评论 (1) | 编辑 收藏
这些道理不懂，你注定就是穷打工的命
     摘要: 这些道理不懂，你注定就是穷打工的命 http://kb.cnblogs.com/page/57888/ 　　首先声明：如果你是“愤青”或“类愤青”，对不起，请放下此书，因为文中的观点可能会伤害你的心灵（不是对“愤青”有偏见，而是“愤青”们多数都是“纯洁”得不识人间烟火...  阅读全文
posted @ 2010-08-12 22:28 MEYE 阅读(477) | 评论 (0) | 编辑 收藏
Ubuntu 6.06/7.04 安装bugzilla
     摘要: Ubuntu 6.06/7.04 安装bugzilla 弄了好久才安装成功，记下来备忘！  1.安装mysql  sudo apt-get install mysql-server  mysql -uroot  create database bugzilla;  2.安装apache2  sudo apt-get in...  阅读全文
posted @ 2010-08-12 22:14 MEYE 阅读(680) | 评论 (1) | 编辑 收藏
在windows下配置svn服务器(
在windows下配置svn服务器(方法一，无apache
 

1.下载文件

2.安装Subversion 服务器

由于我下载的是setup.exe版本,安装程序安装后会自动设置系统变量.如果你下载的是zip版就需要手动设置系统变量.
setup.exe版直接安装就可以了.安装到D:\Program Files\Subversion

首先创建SVN储存库(repository)

svnadmin create F:\lava\svn\
【注】创建仓库的方法也可以使用TortoiseSVN，在目的文件夹上右键->Create Repository

repository创建完毕后会在目录下生成若干个文件和文件夹，dav目录是提供给Apache与mod_dav_svn使用的目录，让它们存储内部数据；db目录就是所有版本控制的数据文件；hooks目录放置hook脚本文件的目录；locks用来放置Subversion文件库锁定数据的目录，用来追踪存取文件库的客户端；format文件是一个文本文件，里面只放了一个整数，表示当前文件库配置的版本号；

3.配置SVN服务器


打开svn目录中配置文件conf\svnserve.conf，修改配置参数。
例：d:\svnhome\conf\svnserve.conf去掉以下内容之前的注释符#
[general]
anon-access = none   
auth-access = write
password-db = passwd
realm = My First Repository

说明：
anon-access = none   
－－不允许匿名访问！这个很重要，不然谁都能访问这个代码仓库了。
        auth-access = write  
－－ 允许提交修改
        password-db = passwd
－－密码文件名字 

 

【注】如果需要控制访问的用户身份，则：
# [general]
# password-db = passwd

去之每行开头的#，其中第二行是指定身份验证的文件名，即passwd文件
同样打开passwd文件，将

# [users]
# harry = harryssecret
# sally = sallyssecret

这几行的开头#字符去掉，这是设置用户，一行一个，存储格式为“用户名 = 密码”，如可插入一行：admin = admin888，即为系统添加一个用户名为admin，密码为admin888的用户

4.运行SVN服务器

运行SVN服务
在命令行执行

svnserve --daemon --root F:\lava\svn

服务启动，--daemon可简写为-d，--root可简写为-r，可以建立一个批处理文件并放在windows启动组中便于开机就运行SVN服务，或者在这个地址http://clanlib.org/~mbn/svnservice/下载那个svnservice.exe文件，拷贝到E:\svn\bin目录下，再从命令行下执行：

svnservice -install --daemon --root "E:\svn\Repository"
sc config svnservice start= auto
net start svnservice 
 
5、添加为系统服务


方法1(推荐)：
在Windows NT中（包括Windows XP, Windows 2000, Windows 2003 Server）本身包含了一个安装服务的工具，叫做"Service Control"，也就是sc.exe。
1.安装为服务：
例:我的Subversion安装在"D:\program files\Subversion"，版本库在"D:\svn_root"，而我希望对应的Subversion服务名为svnservice，安装这个svn服务的命令就可以这样写：
sc create svnservice
binpath= "D:\ Program Files\Subversion\bin\svnserve.exe --service -r D:\svn_root"
displayname= "SVNService"
depend= Tcpip
请注意，因为便于察看，上面的命令分为多行，但在实际执行时应该在一行里。另外，在以前启动svnserve时会使用"-d"选项，也就是守护进程模式，在这里不能使用，会导致服务无法启动。同样，"-i"和"-t"选项也不能使用。
另外还有两点需要小心处理。首先，如果路径中包括空格，一定要用“\”处理“"”号，例如上面的例子中如果svnserve.exe在“c:\ program files\subversion\”中，则命令应该写为“binpath= "\"c:\program files\subversion\bin\svnserve.exe\"”（“”中的内容），整个命令如下，红色部分是改变部分：
sc create svnservice
binpath= "\"D:\ Program Files\Subversion\bin\svnserve.exe\" --service -r D:\svnroot"
displayname= "SVNService"
depend= Tcpip
其次，sc对选项的格式还有要求，例如“depend= Tcpip”不能写为“depend = Tcpip”或“depend=Tcpip”，也就是“=”前不能有空各，而后面必须有空格。
2.启动服务
在命令行窗口执行完这个命令之后，服务还没有启动，你可以继续运行"net start svnservice"启动这个服务。
3.停止服务
然后使用"net stop svnservice"停止服务。
4．删除服务
如果服务安装的有问题，你可能需要删除服务。要删除前面添加的服务，只需要运行"sc delete svnservice"，"svnservice"就是我们创建服务时使用的名字。
5．配置服务是自动启动
默认情况下安装的服务不会随Windows的启动而启动，为了使svn服务能够随Windows启动而启动，需要修改一下"sc create"命令（首先要删除），增加"start= auto"选项：
sc create svnservice
binpath= "D:\ Program Files\Subversion\bin\svnserve.exe --service -r D:\svn_root"
displayname= "SVNService"
depend= Tcpip
start= auto
当然你也可以使用图形化的工具修改服务的属性，你可以在“开始->运行...”中执行"services.msc"，然后在界面中修改。
方法2：
建立一个批处理文件并放在windows启动组中便于开机就运行SVN服务。
方法3：
这个地址http://clanlib.org/~mbn/svnservice/下载那个svnservice.exe文件，拷贝到E:\svn\bin目录下，再从命令行下执行：
svnservice --install --daemon --root "E:\svn\Repository"
sc config svnservice start= auto
net start svnservice
此文件会将SVN变成windows系统的一个服务，并默认为自启动，注意：执行第三句时确保前面以命令行方式运行的SVN服务已经停止，如果没停止可在其窗口中按Ctrl+C中止运行。
 



轻松搭建一个Windows SVN服务器

 

　　前文所述SVN客户端使用的时候，用的SVN服务器通常为外部，例如Google Code的服务器，不过，做为一个程序开发人员，就算自己一个人写程序，也应该有一个SVN版本控制系统，以便对开发代码进行有效的管理。这里我就介绍一个在Windows环境下简单快速搭建SVN服务器的方法。

　　通常的SVN服务器是搭建在Linux等系统下，例如用Apache+SVN配置，Linux下的SVN性能会非常好，但配置有些繁琐，如果SVN服务器只有自己使用，那么可以直接把SVN服务器搭建在个人Windows环境下使用。

　　目前较为简单的方案是VisualSVN Server。该SVN服务器是免费的，支持Windows NT， 2000， XP and 2003等环境，安装非常简单。

　　安装的时候可以选择SVN走http协议还是https协议，http协议速度快一些，而https协议安全性好。两者均可以从浏览器直接访问SVN项目。

　　安装完成后打开，可以看到一个微软的MMS管理界面，在里面可以轻松添加设置项目。用户权限可以使用Windows的用户，也可以单独新建用户。如果原先有一个SVN数据，则可以在界面上导入原有的SVN数据。

VisualSVN Server

　　SVN客户端依旧推荐使用Windows下的TortoiseSVN，两者搭配起来，非常好用。

posted @ 2010-03-10 13:16 MEYE 阅读(1289) | 评论 (0) | 编辑 收藏
美女瑜珈
http://blog.163.com/dahebaobao@126/blog/static/50974483201002745726971/
posted @ 2010-01-30 20:08 MEYE 阅读(655) | 评论 (1) | 编辑 收藏
PCI驱动程序实现（linux）收藏

 PCI驱动程序实现（linux）收藏
 1. 关键数据结构


PCI 设备上有三种地址空间：PCI的I/O空间、PCI的存储空间和PCI的配置空间。CPU可以访问PCI设备上的所有地址空间，其中I/O空间和存储空间提供给设备驱动程序使用，而配置空间则由Linux内核中的PCI初始化代码使用。内核在启动时负责对所有PCI设备进行初始化，配置好所有的PCI设备，包括中断号以及I/O基址，并在文件/proc/pci中列出所有找到的PCI设备，以及这些设备的参数和属性。

Linux驱动程序通常使用结构（struct）来表示一种设备，而结构体中的变量则代表某一具体设备，该变量存放了与该设备相关的所有信息。好的驱动程序都应该能驱动多个同种设备，每个设备之间用次设备号进行区分，如果采用结构数据来代表所有能由该驱动程序驱动的设备，那么就可以简单地使用数组下标来表示次设备号。

在PCI驱动程序中，下面几个关键数据结构起着非常核心的作用：

pci_driver

这个数据结构在文件include/linux/pci.h里，这是Linux内核版本2.4之后为新型的PCI设备驱动程序所添加的，其中最主要的是用于识别设备的id_table结构，以及用于检测设备的函数probe( )和卸载设备的函数remove( )：

struct pci_driver {
struct list_head node;
char *name;
const struct pci_device_id *id_table;
int   (*probe)   (struct pci_dev *dev, const struct pci_device_id *id);
void (*remove) (struct pci_dev *dev);
int   (*save_state) (struct pci_dev *dev, u32 state);
int   (*suspend)(struct pci_dev *dev, u32 state);
int   (*resume) (struct pci_dev *dev);
int   (*enable_wake) (struct pci_dev *dev, u32 state, int enable);
};


pci_dev

这个数据结构也在文件include/linux/pci.h里，它详细描述了一个PCI设备几乎所有的硬件信息，包括厂商ID、设备ID、各种资源等：

struct pci_dev {
struct list_head global_list;
struct list_head bus_list;
struct pci_bus   *bus;
struct pci_bus   *subordinate;

void        *sysdata;
struct proc_dir_entry *procent;

unsigned int devfn;
unsigned short   vendor;
unsigned short   device;
unsigned short   subsystem_vendor;
unsigned short   subsystem_device;
unsigned int class;
u8    hdr_type;
u8    rom_base_reg;

struct pci_driver *driver;
void        *driver_data;
u64     dma_mask;
u32          current_state;

unsigned short vendor_compatible[DEVICE_COUNT_COMPATIBLE];
unsigned short device_compatible[DEVICE_COUNT_COMPATIBLE];

unsigned int irq;
struct resource resource[DEVICE_COUNT_RESOURCE];
struct resource dma_resource[DEVICE_COUNT_DMA];
struct resource irq_resource[DEVICE_COUNT_IRQ];

char        name[80];
char        slot_name[8];
int     active;
int     ro;
unsigned short   regs;

int (*prepare)(struct pci_dev *dev);
int (*activate)(struct pci_dev *dev);
int (*deactivate)(struct pci_dev *dev);
};


2. 基本框架

在用模块方式实现PCI设备驱动程序时，通常至少要实现以下几个部分：初始化设备模块、设备打开模块、数据读写和控制模块、中断处理模块、设备释放模块、设备卸载模块。下面给出一个典型的PCI设备驱动程序的基本框架，从中不难体会到这几个关键模块是如何组织起来的。

/* 指明该驱动程序适用于哪一些PCI设备 */
static struct pci_device_id demo_pci_tbl [] __initdata = {
{PCI_VENDOR_ID_DEMO, PCI_DEVICE_ID_DEMO,
    PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEMO},
{0,}
};

/* 对特定PCI设备进行描述的数据结构 */
struct demo_card {
unsigned int magic;

/* 使用链表保存所有同类的PCI设备 */
struct demo_card *next;

/* ... */
}

/* 中断处理模块 */
static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
/* ... */
}

/* 设备文件操作接口 */
static struct file_operations demo_fops = {
owner:    THIS_MODULE, /* demo_fops所属的设备模块 */
read:    demo_read, /* 读设备操作*/
write:    demo_write, /* 写设备操作*/
ioctl:    demo_ioctl, /* 控制设备操作*/
mmap:    demo_mmap, /* 内存重映射操作*/
open:    demo_open, /* 打开设备操作*/
release: demo_release /* 释放设备操作*/
/* ... */
};

/* 设备模块信息 */
static struct pci_driver demo_pci_driver = {
name:    demo_MODULE_NAME, /* 设备模块名称 */
id_table: demo_pci_tbl, /* 能够驱动的设备列表 */
probe:    demo_probe, /* 查找并初始化设备 */
remove:     demo_remove /* 卸载设备模块 */
/* ... */
};

static int __init demo_init_module (void)
{
/* ... */
}

static void __exit demo_cleanup_module (void)
{
pci_unregister_driver(&demo_pci_driver);
}

/* 加载驱动程序模块入口 */
module_init(demo_init_module);

/* 卸载驱动程序模块入口 */
module_exit(demo_cleanup_module);


上面这段代码给出了一个典型的PCI设备驱动程序的框架，是一种相对固定的模式。需要注意的是，同加载和卸载模块相关的函数或数据结构都要在前面加上 __init、__exit等标志符，以使同普通函数区分开来。构造出这样一个框架之后，接下去的工作就是如何完成框架内的各个功能模块了。

 

3. 初始化设备模块

在Linux系统下，想要完成对一个PCI设备的初始化，需要完成以下工作：

* 检查PCI总线是否被Linux内核支持；
* 检查设备是否插在总线插槽上，如果在的话则保存它所占用的插槽的位置等信息。
* 读出配置头中的信息提供给驱动程序使用。

当Linux内核启动并完成对所有PCI设备进行扫描、登录和分配资源等初始化操作的同时，会建立起系统中所有PCI设备的拓扑结构，此后当PCI驱动程序需要对设备进行初始化时，一般都会调用如下的代码：

static int __init demo_init_module (void)
{
/* 检查系统是否支持PCI总线 */
if (!pci_present())
       return -ENODEV;

/* 注册硬件驱动程序 */
if (!pci_register_driver(&demo_pci_driver)) {
       pci_unregister_driver(&demo_pci_driver);
            return -ENODEV;
}

return 0;
}


驱动程序首先调用函数pci_present( )检查PCI总线是否已经被Linux内核支持，如果系统支持PCI总线结构，这个函数的返回值为0，如果驱动程序在调用这个函数时得到了一个非0的返回值，那么驱动程序就必须得中止自己的任务了。在2.4以前的内核中，需要手工调用pci_find_device( )函数来查找PCI设备，但在2.4以后更好的办法是调用pci_register_driver( )函数来注册PCI设备的驱动程序，此时需要提供一个pci_driver结构，在该结构中给出的probe探测例程将负责完成对硬件的检测工作。

static int __init demo_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
{
struct demo_card *card;

/* 启动PCI设备 */
if (pci_enable_device(pci_dev))
       return -EIO;

/* 设备DMA标识 */
if (pci_set_dma_mask(pci_dev, DEMO_DMA_MASK)) {
       return -ENODEV;
}

/* 在内核空间中动态申请内存 */
if ((card = kmalloc(sizeof(struct demo_card), GFP_KERNEL)) == NULL) {
       printk(KERN_ERR "pci_demo: out of memory\n");
       return -ENOMEM;
}
memset(card, 0, sizeof(*card));

/* 读取PCI配置信息 */
card->iobase = pci_resource_start (pci_dev, 1);
card->pci_dev = pci_dev;
card->pci_id = pci_id->device;
card->irq = pci_dev->irq;
card->next = devs;
card->magic = DEMO_CARD_MAGIC;

/* 设置成总线主DMA模式 */
pci_set_master(pci_dev);

/* 申请I/O资源 */
request_region(card->iobase, 64, card_names[pci_id->driver_data]);

return 0;
}

 


4. 打开设备模块

在这个模块里主要实现申请中断、检查读写模式以及申请对设备的控制权等。在申请控制权的时候，非阻塞方式遇忙返回，否则进程主动接受调度，进入睡眠状态，等待其它进程释放对设备的控制权。

static int demo_open(struct inode *inode, struct file *file)
{
/* 申请中断，注册中断处理程序 */
request_irq(card->irq, &demo_interrupt, SA_SHIRQ,
       card_names[pci_id->driver_data], card)) {

/* 检查读写模式 */
if(file->f_mode & FMODE_READ) {
       /* ... */
}
if(file->f_mode & FMODE_WRITE) {

}

/* 申请对设备的控制权 */
down(&card->open_sem);
while(card->open_mode & file->f_mode) {
       if (file->f_flags & O_NONBLOCK) {
         /* NONBLOCK模式，返回-EBUSY */
         up(&card->open_sem);
         return -EBUSY;
       } else {
         /* 等待调度，获得控制权 */
         card->open_mode |= f_mode & (FMODE_READ | FMODE_WRITE);
         up(&card->open_sem);

         /* 设备打开计数增1 */
         MOD_INC_USE_COUNT;

       }
}
}

5. 数据读写和控制信息模块

PCI设备驱动程序可以通过demo_fops 结构中的函数demo_ioctl( )，向应用程序提供对硬件进行控制的接口。例如，通过它可以从I/O寄存器里读取一个数据，并传送到用户空间里：

static int demo_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{

switch(cmd) {
       case DEMO_RDATA:
         /* 从I/O端口读取4字节的数据 */
         val = inl(card->iobae + 0x10);
        
/* 将读取的数据传输到用户空间 */
         return 0;
}

}


事实上，在demo_fops里还可以实现诸如demo_read( )、demo_mmap( )等操作，Linux内核源码中的driver目录里提供了许多设备驱动程序的源代码，找那里可以找到类似的例子。在对资源的访问方式上，除了有I/O指令以外，还有对外设I/O内存的访问。对这些内存的操作一方面可以通过把I/O内存重新映射后作为普通内存进行操作，另一方面也可以通过总线主DMA （Bus Master DMA）的方式让设备把数据通过DMA传送到系统内存中。


6. 中断处理模块

PC的中断资源比较有限，只有0~15的中断号，因此大部分外部设备都是以共享的形式申请中断号的。当中断发生的时候，中断处理程序首先负责对中断进行识别，然后再做进一步的处理。

static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct demo_card *card = (struct demo_card *)dev_id;
u32 status;

spin_lock(&card->lock);

/* 识别中断 */
status = inl(card->iobase + GLOB_STA);
if(!(status & INT_MASK))
{
       spin_unlock(&card->lock);
       return;   /* not for us */
}

/* 告诉设备已经收到中断 */
outl(status & INT_MASK, card->iobase + GLOB_STA);
spin_unlock(&card->lock);

/* 其它进一步的处理，如更新DMA缓冲区指针等 */
}

7. 释放设备模块

释放设备模块主要负责释放对设备的控制权，释放占用的内存和中断等，所做的事情正好与打开设备模块相反：

static int demo_release(struct inode *inode, struct file *file)
{

/* 释放对设备的控制权 */
card->open_mode &= (FMODE_READ | FMODE_WRITE);

/* 唤醒其它等待获取控制权的进程 */
wake_up(&card->open_wait);
up(&card->open_sem);

/* 释放中断 */
free_irq(card->irq, card);

/* 设备打开计数增1 */
MOD_DEC_USE_COUNT;

}

8. 卸载设备模块
调用函数pci_unregister_driver( )从Linux内核中注销设备驱动程序

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/mingjie_520/archive/2009/03/27/4029695.aspx

posted @ 2009-06-20 16:02 MEYE 阅读(695) | 评论 (0) | 编辑 收藏
Linux下PCI设备驱动程序开发基本框架

 Linux下PCI设备驱动程序开发基本框架收藏
PCI是一种广泛采用的总线标准，它提供了许多优于其它总线标准（如EISA）的新特性，目前已经成为计算 机系统中应用最为广泛，并且最为通用的总线标准。Linux的内核能较好地支持PCI总线，本文以Intel 386体系结构为主，探讨了在Linux下开发PCI设备驱动程序的基本框架。

一、PCI总线系统体系结构

PCI是外围设备互连（Peripheral Component Interconnect）的简称，作为一种通用的总线接口标准，它在目前的计算机系统中得到了非常广泛的应用。PCI提供了一组完整的总线接口规范，其 目的是描述如何将计算机系统中的外围设备以一种结构化和可控化的方式连接在一起，同时它还刻画了外围设备在连接时的电气特性和行为规约，并且详细定义了计 算机系统中的各个不同部件之间应该如何正确地进行交互。

无论是在基于Intel芯片的PC机中，或是在基于Alpha芯片的工作 站上，PCI毫无疑问都是目前使用最广泛的一种总线接口标准。同旧式的ISA总线不同，PCI将计算机系统中的总线子系统与存储子系统完全地分开，CPU 通过一块称为PCI桥（PCI-Bridge）的设备来完成同总线子系统的交互，如图1所示。

 

图1 PCI子系统的体系结构

由于使用了更高的时钟频率，因此PCI总线能够获得比ISA总线更好的整体性能。PCI总线的时钟频率一般在25MHz到33MHz范围内，有些甚至能 够达到66MHz或者133MHz，而在64位系统中则最高能达到266MHz。尽管目前PCI设备大多采用32位数据总线，但PCI规范中已经给出了 64位的扩展实现，从而使PCI总线能够更好地实现平台无关性，现在PCI总线已经能够用于IA-32、Alpha、PowerPC、SPARC64和 IA-64等体系结构中。

PCI总线具有三个非常显著的优点，使得它能够完成最终取代ISA总线这一历史使命：

在计算机和外设间传输数据时具有更好的性能；

能够尽量独立于具体的平台；

可以很方便地实现即插即用。

图2是一个典型的基于PCI总线的计算机系统逻辑示意图，系统的各个部分通过PCI总线和PCI-PCI桥连接在一起。从图中不难看出，CPU和RAM 需要通过PCI桥连接到PCI总线0（即主PCI总线），而具有PCI接口的显卡则可以直接连接到主PCI总线上。PCI-PCI桥是一个特殊的PCI设 备，它负责将PCI总线0和PCI总线1（即从PCI主线）连接在一起，通常PCI总线1称为PCI-PCI桥的下游（downstream），而PCI 总线0则称为PCI-PCI桥的上游（upstream）。图中连接到从PCI总线上的是SCSI卡和以太网卡。为了兼容旧的ISA总线标准，PCI总线 还可以通过PCI-ISA桥来连接ISA总线，从而能够支持以前的ISA设备。图中ISA总线上连接着一个多功能I/O控制器，用于控制键盘、鼠标和软 驱。


图2 PCI系统示意图

在此我只对PCI总线系统体系结构作了概括性介绍，如果读者想进一步了解，David A Rusling在The Linux Kernel（http://tldp.org/LDP/tlk/dd/pci.html）中对Linux的PCI子系统有比较详细的介绍。


二、Linux驱动程序框架

Linux将所有外部设备看成是一类特殊文件，称之为“设备文件”，如果说系统调用是Linux内核和应用程序之间的接口，那么设备驱动程序则可以看成是 Linux内核与外部设备之间的接口。设备驱动程序向应用程序屏蔽了硬件在实现上的细节，使得应用程序可以像操作普通文件一样来操作外部设备。

1. 字符设备和块设备

Linux抽象了对硬件的处理，所有的硬件设备都可以像普通文件一样来看待：它们可以使用和操作文件相同的、标准的系统调用接口来完成打开、关闭、读写和 I/O控制操作，而驱动程序的主要任务也就是要实现这些系统调用函数。Linux系统中的所有硬件设备都使用一个特殊的设备文件来表示，例如，系统中的第 一个IDE硬盘使用/dev/hda表示。每个设备文件对应有两个设备号：一个是主设备号，标识该设备的种类，也标识了该设备所使用的驱动程序；另一个是 次设备号，标识使用同一设备驱动程序的不同硬件设备。设备文件的主设备号必须与设备驱动程序在登录该设备时申请的主设备号一致，否则用户进程将无法访问到 设备驱动程序。

在Linux操作系统下有两类主要的设备文件：一类是字符设备，另一类则是块设备。字符设备是以字节为单位逐个进行I/O操作的设备，在对字符设备发出读 写请求时，实际的硬件I/O紧接着就发生了，一般来说字符设备中的缓存是可有可无的，而且也不支持随机访问。块设备则是利用一块系统内存作为缓冲区，当用 户进程对设备进行读写请求时，驱动程序先查看缓冲区中的内容，如果缓冲区中的数据能满足用户的要求就返回相应的数据，否则就调用相应的请求函数来进行实际 的I/O操作。块设备主要是针对磁盘等慢速设备设计的，其目的是避免耗费过多的CPU时间来等待操作的完成。一般说来，PCI卡通常都属于字符设备。

所有已经注册（即已经加载了驱动程序）的硬件设备的主设备号可以从/proc/devices文件中得到。使用mknod命令可以创建指定类型的设备文件，同时为其分配相应的主设备号和次设备号。例如，下面的命令：

[root@gary root]# mknod  /dev/lp0  c  6  0


将建立一个主设备号为6，次设备号为0的字符设备文件/dev/lp0。当应用程序对某个设备文件进行系统调用时，Linux内核会根据该设备文件的设备 类型和主设备号调用相应的驱动程序，并从用户态进入到核心态，再由驱动程序判断该设备的次设备号，最终完成对相应硬件的操作。

2. 设备驱动程序接口

Linux中的I/O子系统向内核中的其他部分提供了一个统一的标准设备接口，这是通过include/linux/fs.h中的数据结构file_operations来完成的：

struct file_operations {        struct module *owner;        loff_t (*llseek) (struct file *, loff_t, int);        ssize_t (*read) (struct file *, char *, size_t, loff_t *);        ssize_t (*write) (struct file *, const char *, size_t, loff_t *);        int (*readdir) (struct file *, void *, filldir_t);        unsigned int (*poll) (struct file *, struct poll_table_struct *);        int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);        int (*mmap) (struct file *, struct vm_area_struct *);        int (*open) (struct inode *, struct file *);        int (*flush) (struct file *);        int (*release) (struct inode *, struct file *);        int (*fsync) (struct file *, struct dentry *, int datasync);        int (*fasync) (int, struct file *, int);        int (*lock) (struct file *, int, struct file_lock *);        ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);        ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);        unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);};


当应用程序对设备文件进行诸如open、close、read、write等操作时，Linux内核将通过file_operations结构访问驱动程 序提供的函数。例如，当应用程序对设备文件执行读操作时，内核将调用file_operations结构中的read函数。

3. 设备驱动程序模块

Linux下的设备驱动程序可以按照两种方式进行编译，一种是直接静态编译成内核的一部分，另一种则是编译成可以动态加载的模块。如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态地卸载，不利于调试，所有推荐使用模块方式。

从本质上来讲，模块也是内核的一部分，它不同于普通的应用程序，不能调用位于用户态下的C或者C++库函数，而只能调用Linux内核提供的函数，在/proc/ksyms中可以查看到内核提供的所有函数。

在以模块方式编写驱动程序时，要实现两个必不可少的函数init_module( )和cleanup_module( )，而且至少要包含和两 个头文件。在用gcc编译内核模块时，需要加上-DMODULE -D__KERNEL__ -DLINUX这几个参数，编译生成的模块（一般为.o文件）可以使用命令insmod载入Linux内核，从而成为内核的一个组成部分，此时内核会调用 模块中的函数init_module( )。当不需要该模块时，可以使用rmmod命令进行卸载，此进内核会调用模块中的函数cleanup_module( )。任何时候都可以使用命令来lsmod查看目前已经加载的模块以及正在使用该模块的用户数。

4. 设备驱动程序结构

了解设备驱动程序的基本结构（或者称为框架），对开发人员而言是非常重要的，Linux的设备驱动程序大致可以分为如下几个部分：驱动程序的注册与注销、设备的打开与释放、设备的读写操作、设备的控制操作、设备的中断和轮询处理。

驱动程序的注册与注销

向系统增加一个驱动程序意味着要赋予它一个主设备号，这可以通过在驱动程序的初始化过程中调用register_chrdev( )或者register_blkdev( )来完成。而在关闭字符设备或者块设备时，则需要通过调用unregister_chrdev( )或unregister_blkdev( )从内核中注销设备，同时释放占用的主设备号。

设备的打开与释放

打开设备是通过调用file_operations结构中的函数open( )来完成的，它是驱动程序用来为今后的操作完成初始化准备工作的。在大部分驱动程序中，open( )通常需要完成下列工作：

1.检查设备相关错误，如设备尚未准备好等。

2.如果是第一次打开，则初始化硬件设备。

3.识别次设备号，如果有必要则更新读写操作的当前位置指针f_ops。

4.分配和填写要放在file->private_data里的数据结构。

5.使用计数增1。

释放设备是通过调用file_operations结构中的函数release( )来完成的，这个设备方法有时也被称为close( )，它的作用正好与open( )相反，通常要完成下列工作：

1.使用计数减1。

2.释放在file->private_data中分配的内存。

3.如果使用计算为0，则关闭设备。

设备的读写操作

字符设备的读写操作相对比较简单，直接使用函数read( )和write( )就可以了。但如果是块设备的话，则需要调用函数block_read( )和block_write( )来进行数据读写，这两个函数将向设备请求表中增加读写请求，以便Linux内核可以对请求顺序进行优化。由于是对内存缓冲区而不是直接对设备进行操作 的，因此能很大程度上加快读写速度。如果内存缓冲区中没有所要读入的数据，或者需要执行写操作将数据写入设备，那么就要执行真正的数据传输，这是通过调用 数据结构blk_dev_struct中的函数request_fn( )来完成的。

设备的控制操作

除了读写操作外，应用程序有时还需要对设备进行控制，这可以通过设备驱动程序中的函数ioctl( )来完成。ioctl( )的用法与具体设备密切关联，因此需要根据设备的实际情况进行具体分析。

设备的中断和轮询处理

对于不支持中断的硬件设备，读写时需要轮流查询设备状态，以便决定是否继续进行数据传输。如果设备支持中断，则可以按中断方式进行操作。

三、PCI驱动程序实现

1. 关键数据结构

PCI设备上有三种地址空间：PCI的I/O空间、PCI的存储空间和PCI的配置空间。CPU可以访问PCI设备上的所有地址空间，其中I/O空间和存 储空间提供给设备驱动程序使用，而配置空间则由Linux内核中的PCI初始化代码使用。内核在启动时负责对所有PCI设备进行初始化，配置好所有的 PCI设备，包括中断号以及I/O基址，并在文件/proc/pci中列出所有找到的PCI设备，以及这些设备的参数和属性。

Linux驱动程序通常使用结构（struct）来表示一种设备，而结构体中的变量则代表某一具体设备，该变量存放了与该设备相关的所有信息。好的驱动程 序都应该能驱动多个同种设备，每个设备之间用次设备号进行区分，如果采用结构数据来代表所有能由该驱动程序驱动的设备，那么就可以简单地使用数组下标来表 示次设备号。

在PCI驱动程序中，下面几个关键数据结构起着非常核心的作用：

pci_driver

这个数据结构在文件include/linux/pci.h里，这是Linux内核版本2.4之后为新型的PCI设备驱动程序所添加的，其中最主要的是用于识别设备的id_table结构，以及用于检测设备的函数probe( )和卸载设备的函数remove( )：

struct pci_driver {    struct list_head node;    char *name;    const struct pci_device_id *id_table;    int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);    void (*remove) (struct pci_dev *dev);    int  (*save_state) (struct pci_dev *dev, u32 state);    int  (*suspend)(struct pci_dev *dev, u32 state);    int  (*resume) (struct pci_dev *dev);    int  (*enable_wake) (struct pci_dev *dev, u32 state, int enable);};


pci_dev

这个数据结构也在文件include/linux/pci.h里，它详细描述了一个PCI设备几乎所有的硬件信息，包括厂商ID、设备ID、各种资源等：

struct pci_dev {    struct list_head global_list;    struct list_head bus_list;    struct pci_bus  *bus;    struct pci_bus  *subordinate;    void        *sysdata;    struct proc_dir_entry *procent;    unsigned int    devfn;    unsigned short  vendor;    unsigned short  device;    unsigned short  subsystem_vendor;    unsigned short  subsystem_device;    unsigned int    class;    u8      hdr_type;    u8      rom_base_reg;    struct pci_driver *driver;    void        *driver_data;    u64     dma_mask;    u32             current_state;    unsigned short vendor_compatible[DEVICE_COUNT_COMPATIBLE];    unsigned short device_compatible[DEVICE_COUNT_COMPATIBLE];    unsigned int    irq;    struct resource resource[DEVICE_COUNT_RESOURCE];    struct resource dma_resource[DEVICE_COUNT_DMA];    struct resource irq_resource[DEVICE_COUNT_IRQ];    char        name[80];    char        slot_name[8];    int     active;    int     ro;    unsigned short  regs;    int (*prepare)(struct pci_dev *dev);    int (*activate)(struct pci_dev *dev);    int (*deactivate)(struct pci_dev *dev);};


2. 基本框架

在用模块方式实现PCI设备驱动程序时，通常至少要实现以下几个部分：初始化设备模块、设备打开模块、数据读写和控制模块、中断处理模块、设备释放模块、设备卸载模块。下面给出一个典型的PCI设备驱动程序的基本框架，从中不难体会到这几个关键模块是如何组织起来的。

/* 指明该驱动程序适用于哪一些PCI设备 */static struct pci_device_id demo_pci_tbl [] __initdata = {    {PCI_VENDOR_ID_DEMO, PCI_DEVICE_ID_DEMO,     PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEMO},    {0,}};/* 对特定PCI设备进行描述的数据结构 */struct demo_card {    unsigned int magic;    /* 使用链表保存所有同类的PCI设备 */    struct demo_card *next;        /* ... */}/* 中断处理模块 */static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs){    /* ... */}/* 设备文件操作接口 */static struct file_operations demo_fops = {    owner:      THIS_MODULE,   /* demo_fops所属的设备模块 */    read:       demo_read,    /* 读设备操作*/    write:      demo_write,    /* 写设备操作*/    ioctl:      demo_ioctl,    /* 控制设备操作*/    mmap:       demo_mmap,    /* 内存重映射操作*/    open:       demo_open,    /* 打开设备操作*/    release:    demo_release    /* 释放设备操作*/    /* ... */};/* 设备模块信息 */static struct pci_driver demo_pci_driver = {    name:       demo_MODULE_NAME,    /* 设备模块名称 */    id_table:   demo_pci_tbl,    /* 能够驱动的设备列表 */    probe:      demo_probe,    /* 查找并初始化设备 */    remove:     demo_remove    /* 卸载设备模块 */    /* ... */};static int __init demo_init_module (void){    /* ... */}static void __exit demo_cleanup_module (void){    pci_unregister_driver(&demo_pci_driver);}/* 加载驱动程序模块入口 */module_init(demo_init_module);/* 卸载驱动程序模块入口 */module_exit(demo_cleanup_module);


上面这段代码给出了一个典型的PCI设备驱动程序的框架，是一种相对固定的模式。需要注意的是，同加载和卸载模块相关的函数或数据结构都要在前面加上 __init、__exit等标志符，以使同普通函数区分开来。构造出这样一个框架之后，接下去的工作就是如何完成框架内的各个功能模块了。

3. 初始化设备模块

在Linux系统下，想要完成对一个PCI设备的初始化，需要完成以下工作：

检查PCI总线是否被Linux内核支持；

检查设备是否插在总线插槽上，如果在的话则保存它所占用的插槽的位置等信息。

读出配置头中的信息提供给驱动程序使用。

当Linux内核启动并完成对所有PCI设备进行扫描、登录和分配资源等初始化操作的同时，会建立起系统中所有PCI设备的拓扑结构，此后当PCI驱动程序需要对设备进行初始化时，一般都会调用如下的代码：

static int __init demo_init_module (void){    /* 检查系统是否支持PCI总线 */    if (!pci_present())        return -ENODEV;    /* 注册硬件驱动程序 */    if (!pci_register_driver(&demo_pci_driver)) {        pci_unregister_driver(&demo_pci_driver);                return -ENODEV;    }    /* ... */       return 0;}


驱动程序首先调用函数pci_present( )检查PCI总线是否已经被Linux内核支持，如果系统支持PCI总线结构，这个函数的返回值为0，如果驱动程序在调用这个函数时得到了一个非0的返回 值，那么驱动程序就必须得中止自己的任务了。在2.4以前的内核中，需要手工调用pci_find_device( )函数来查找PCI设备，但在2.4以后更好的办法是调用pci_register_driver( )函数来注册PCI设备的驱动程序，此时需要提供一个pci_driver结构，在该结构中给出的probe探测例程将负责完成对硬件的检测工作。

 static int __init demo_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id){    struct demo_card *card;    /* 启动PCI设备 */    if (pci_enable_device(pci_dev))        return -EIO;    /* 设备DMA标识 */    if (pci_set_dma_mask(pci_dev, DEMO_DMA_MASK)) {        return -ENODEV;    }    /* 在内核空间中动态申请内存 */    if ((card = kmalloc(sizeof(struct demo_card), GFP_KERNEL)) == NULL) {        printk(KERN_ERR "pci_demo: out of memory\n");        return -ENOMEM;    }    memset(card, 0, sizeof(*card));    /* 读取PCI配置信息 */    card->iobase = pci_resource_start (pci_dev, 1);    card->pci_dev = pci_dev;    card->pci_id = pci_id->device;    card->irq = pci_dev->irq;    card->next = devs;    card->magic = DEMO_CARD_MAGIC;    /* 设置成总线主DMA模式 */        pci_set_master(pci_dev);    /* 申请I/O资源 */    request_region(card->iobase, 64, card_names[pci_id->driver_data]);    return 0;}


4. 打开设备模块

在这个模块里主要实现申请中断、检查读写模式以及申请对设备的控制权等。在申请控制权的时候，非阻塞方式遇忙返回，否则进程主动接受调度，进入睡眠状态，等待其它进程释放对设备的控制权。

static int demo_open(struct inode *inode, struct file *file){    /* 申请中断，注册中断处理程序 */    request_irq(card->irq, &demo_interrupt, SA_SHIRQ,        card_names[pci_id->driver_data], card)) {    /* 检查读写模式 */    if(file->f_mode & FMODE_READ) {        /* ... */    }    if(file->f_mode & FMODE_WRITE) {       /* ... */    }        /* 申请对设备的控制权 */    down(&card->open_sem);    while(card->open_mode & file->f_mode) {        if (file->f_flags & O_NONBLOCK) {            /* NONBLOCK模式，返回-EBUSY */            up(&card->open_sem);            return -EBUSY;        } else {            /* 等待调度，获得控制权 */            card->open_mode |= f_mode & (FMODE_READ | FMODE_WRITE);            up(&card->open_sem);            /* 设备打开计数增1 */            MOD_INC_USE_COUNT;            /* ... */        }    }}


5. 数据读写和控制信息模块

PCI设备驱动程序可以通过demo_fops 结构中的函数demo_ioctl( )，向应用程序提供对硬件进行控制的接口。例如，通过它可以从I/O寄存器里读取一个数据，并传送到用户空间里：

static int demo_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){    /* ... */        switch(cmd) {        case DEMO_RDATA:            /* 从I/O端口读取4字节的数据 */            val = inl(card->iobae + 0x10);            /* 将读取的数据传输到用户空间 */            return 0;    }        /* ... */}


事实上，在demo_fops里还可以实现诸如demo_read( )、demo_mmap( )等操作，Linux内核源码中的driver目录里提供了许多设备驱动程序的源代码，找那里可以找到类似的例子。在对资源的访问方式上，除了有I/O指 令以外，还有对外设I/O内存的访问。对这些内存的操作一方面可以通过把I/O内存重新映射后作为普通内存进行操作，另一方面也可以通过总线主DMA （Bus Master DMA）的方式让设备把数据通过DMA传送到系统内存中。

6. 中断处理模块

PC的中断资源比较有限，只有0~15的中断号，因此大部分外部设备都是以共享的形式申请中断号的。当中断发生的时候，中断处理程序首先负责对中断进行识别，然后再做进一步的处理。

static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs){    struct demo_card *card = (struct demo_card *)dev_id;    u32 status;    spin_lock(&card->lock);    /* 识别中断 */    status = inl(card->iobase + GLOB_STA);    if(!(status & INT_MASK))     {        spin_unlock(&card->lock);        return;  /* not for us */    }    /* 告诉设备已经收到中断 */    outl(status & INT_MASK, card->iobase + GLOB_STA);    spin_unlock(&card->lock);        /* 其它进一步的处理，如更新DMA缓冲区指针等 */}


7. 释放设备模块

释放设备模块主要负责释放对设备的控制权，释放占用的内存和中断等，所做的事情正好与打开设备模块相反：

static int demo_release(struct inode *inode, struct file *file){    /* ... */        /* 释放对设备的控制权 */    card->open_mode &= (FMODE_READ | FMODE_WRITE);        /* 唤醒其它等待获取控制权的进程 */    wake_up(&card->open_wait);    up(&card->open_sem);        /* 释放中断 */    free_irq(card->irq, card);        /* 设备打开计数增1 */    MOD_DEC_USE_COUNT;        /* ... */  }


8. 卸载设备模块

卸载设备模块与初始化设备模块是相对应的，实现起来相对比较简单，主要是调用函数pci_unregister_driver( )从Linux内核中注销设备驱动程序：

static void __exit demo_cleanup_module (void){    pci_unregister_driver(&demo_pci_driver);}


四、小结

PCI总线不仅是目前应用广泛的计算机总线标准，而且是一种兼容性最强、功能最全的计算机总线。而Linux作为一种新的操作系统，其发展前景是无法估量 的，同时也为PCI总线与各种新型设备互连成为可能。由于Linux源码开放，因此给连接到PCI总线上的任何设备编写驱动程序变得相对容易。本文介绍如 何编译Linux下的PCI驱动程序，针对的内核版本是2.4。

参考资料： David A Rusling在 The Linux Kernel中对Linux的PCI子系统进行了比较详细的介绍。

Linux PCI-HOWTO是了解Linux下PCI设备的最好读物。

毛德操，胡希明，Linux内核源代码情景分析，杭州：浙江大学出版社，2001

Alessandro Rubini,，Linux Device Drivers（2nd Edition） USA：O’Reilly，2001

Tomshanley，DonAderson，PCI系统结构（第四版），北京：电子工业出版社，2000


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/mingjie_520/archive/2009/03/27/4029919.aspx

posted @ 2009-06-20 16:02 MEYE 阅读(608) | 评论 (0) | 编辑 收藏
换内核

换内核

由于开发环境需要，更换了一个比较新的内核，更换过程参考了附文，但文章稍显繁琐，我给大致总结一下，具体过程见原文。
1、找到自己需要的内核，可以在此寻找：http://www.kernel.org/pub/linux/kernel/v2.6（当然不一定能找到最新的，我用到的2.6.30当时未能找到）。
2、下载内核升级工具：
（1）安装module-init-tools工具
# tar jvxf module-init-tools-3.2.tar.bz2  (解压module-init-tools) 
# cd module-init-tools-3.2  (由/usr/src目录进入module-init-tools目录下)
#./configure --prefix=/ 
# make moveold
# make all install
#./generate-modprobe.conf /etc/modprobe.conf （该步能否运行未知，多次运行均未果）
（2）安装另外三个升级工具
# rpm -ivh --nodeps mkinitrd-4.1.18-2.i386.rpm  (注意，这里一定要加入--nodeps参数，下同)
# rpm -ivh --nodeps lvm2-2.00.25-1.01.i386.rpm
# rpm -ivh --nodeps device-mapper-1.00.19-2.i386.rpm
4、配置编译内核
解压内核源码包到linux-2.6.x
# cd linux-2.6.x  
# make mrproper  (该命令可确保源代码目录下没有不正确的.o文件)
# make menuconfig (配置内核各选项，配置详情参考原文）
 
# make dep  (建立编译时所需的从属文件。注意：如果内核从未编译过，此步可跳过)
# make clean  (清除内核编译的目标文件。注意：如果内核从未编译过，此步可跳过)
# make bzImage  (注意大小写。这一步才是真正编译内核)
 # make modules  (编译可加载模块) （此步骤约半到1小时,需耐心等待）
# make modules_install  (安装可加载模块)
  安装成功后，系统会在/lib/modules目录下生成一个2.6.18子目录，里面存放着新内核的所有可加载模块。
# make install  (安装新内核)
5、启动新内核
此时我的系统中/root目录下已经有了新内核及启动项，启动配置文件（我的貌似是/root/grub/menu.lst)也已自动更改好，直接重启并在启动页面选择新内核OK。
若启动项未自动更改再次参考原文。
附原文：
序  言
由于开发环境需要在linux-2.6内核上进行，于是准备对我的虚拟机上的Linux系统升级。没想到这一弄就花了两天时间(反复装系统，辛苦啊~~)，总算把Linux系统从2.4.20-8内核成功升级到了2.6.18内核。
网上虽然有很多介绍Linux内核升级的文章，不过要么过时，下载链接失效；要么表达不清，不知所云；更可气的是很多文章在转载过程中命令行都有错误。刚开始我就是在这些“攻略”的指点下来升级的，以致于浪费了很多时间。
现在，费尽周折，升级成功，心情很爽，趁性也来写个“升级攻略”吧！于是特意又在虚拟机上重新安装一个Linux系统，再来一次完美的升级，边升级边记录这些步骤，写成一篇Linux内核升级记实录(可不是回忆录啊！)，和大家一起分享~~！
一、准备工作
首先说明，下面带#号的行都是要输入的命令行，且本文提到的所有命令行都在终端里输入。
启动Linux系统，并用根用户登录，进入终端模式下。
1、查看Linux内核版本
# uname -a
如果屏幕显示的是2.6.x，说明你的已经是2.6的内核，也用不着看下文了，该干什么干什么去吧！~~~如果显示的是2.4.x，那恭喜你，闯关通过，赶快进行下一步。
3、下载内核升级工具
(1)下载module-init-tools-3.2.tar.bz2
http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/module-init-tools-3.2.tar.bz2 
(2)下载mkinitrd-4.1.18-2.i386.rpm
http://ayo.freshrpms.net/fedora/linux/3/i386/RPMS.core/mkinitrd-4.1.18-2.i386.rpm 
(3)下载lvm2-2.00.25-1.01.i386.rpm
http://ayo.freshrpms.net/fedora/linux/3/i386/RPMS.core/lvm2-2.00.25-1.01.i386.rpm
(4)下载device-mapper-1.00.19-2.i386.rpm
http://ayo.freshrpms.net/fedora/linux/3/i386/RPMS.core/device-mapper-1.00.19-2.i386.rpm
(2.6.18内核和这4个升级工具我都有备份，如果以上下载地址失效，请到http://www.piaoyang.org/guestbook 留下你的邮箱，我给你发过去)
二、配置工作
好啦，2.6内核和4个升级工具都下载完了(少一个也不行，如果没有下载齐全，请不要尝试下面的步骤，升级是不会成功的)，下面回到Linux系统中开始配置工作吧。
4、将下载好的内核源码包和4个升级工具都拷贝到/usr/src文件夹下。怎么拷贝就不用我教了吧~~~~不会拷贝的去撞墙吧！~~呵呵！
5、拷贝完毕，开始解压新内核，具体操作请依次执行以下命令：
# cd /usr/src  (进入到/usr/src目录下，如果已经在/usr/src目录下，可不执行该命令)
# rm –rf linux  (删除linux文件夹。值得一提的是，如果内核先前从未编译过，则没有这个文件夹，此命令行可略过)
# tar jvxf linux-2.6.18.tar.bz2  (解压新内核)
# ln -s linux-2.6.18 linux  (重新生成linux文件夹)
6、安装module-init-tools工具
在/usr/src目录下，依次执行下列命令：
# tar jvxf module-init-tools-3.2.tar.bz2  (解压module-init-tools) 
# cd module-init-tools-3.2  (由/usr/src目录进入module-init-tools目录下)
#./configure --prefix=/ 
# make moveold
# make all install
#./generate-modprobe.conf /etc/modprobe.conf
7、安装另外三个升级工具
回到/usr/src目录下，依次执行下列3个命令来安装另外三个升级工具：
# rpm -ivh --nodeps mkinitrd-4.1.18-2.i386.rpm  (注意，这里一定要加入--nodeps参数，下同)
# rpm -ivh --nodeps lvm2-2.00.25-1.01.i386.rpm
# rpm -ivh --nodeps device-mapper-1.00.19-2.i386.rpm
如果不更新以上几个升级包，在后面编译内核时会提示以下错误：
      mkinitrd failed
      make[1]: *** [install] Error 1
      make: *** [install] Error 2
8、配置内核选项。有点繁琐，~~希望一次成功哦~~。
# cd linux-2.6.18  (进入到/usr/src/linux-2.6.18目录下)
# make mrproper  (该命令可确保源代码目录下没有不正确的.o文件)
# make menuconfig (配置内核各选项)
此时会出现一个图形界面，列出了所有的内核配置选项，有的选项下还有子选项，你可以用方向键来选择，用Y键来确定。经过我多次试验，大多数选项默认就行，以下几个选项必须选择(请认真核对下面每一个选项，否则编译很有可能前功尽弃)：
(1)Loadable Module support选项中，选上“Module unloading”和“Automatic kernel module loading”这两项；
(2)Device Drivers--->Block Devices中选上“Loopback device support”；
     Device Drivers--->Multi-device support(RAID and LVM)处要选上“device mapper  support”；
     Device Drivers--->Graphics support，一定要选上“ Support for  buffer devices”；
     Device Drivers  --->USB support  --->选上“USB Mass Storage support”(如果是在实环境中，想要更多USB支持，就全选吧。我的是在虚拟机中，用不着了)
     Device Drivers  --->;Network device support  --->Ethernet (10 or 100Mbit)  ---><*>  AMD PCnet32 PCI support 
(3)File system--->(以下9个选项是关于ext2和ext3文件系统配置，全部选上)
           Second extended fs support
           Ext2 extended attributes
           Ext2 POSIX Access Control Lists
           Ext2 Security Labels
           Ext3 journalling file system support
           Ext3 extended attributes
           Ext3 POSIX Access Control Lists
           Ext3 Security Labels
           JBB (ext3) debugging support
     File system--->DOS/FAT/NT Filesystems  --->选上“NTFS file system support”；
注意：
       ext2和ext3文件系统配置很重要，也是必需的，如果对Ext3、Ext2文件的支持直接编译进内核，在你reboot时机器就会当掉，出现如下错误信息：
          kernel panic : no init found ,try passing init = option to kernel.....
或者是：
          VFS:Cannot open root device "hdxy" or unknow-block(0,0)
          Please append a correct "root=" boot option
          kernel panic:VFS:Unable to mount root fs on unknown-block(0,0) 
或者是：
          mount: error 19 mounting ext3
          pivotroot: pivot_root(/sysroot,/sysroot/initrd) failed: 2
          umount /initrd/proc fail: 2
          Freeing unused kernel memory: 244k freed
          Kernel panic – not syncing: No init found. Try passing init = option to kernel
(我的机器就是在重启之后出现第三种错误，进不去系统，郁闷死，只好重装了~~~如果依照本文做完所有步骤，当你重启Linux系统后，若不幸进不去2.6.18内核，你会发现你的出错信息就是上面三种了~~~哈！)
(4)如果你在vmware下编译内核，硬盘用的是scsi的，以下三个选项必选：
     Device Drivers ---><*>SCSI device support  (此项不选的话，下面两项就选择不上)
     Device Drivers ---><*>SCSI device support ---><*>SCSI disk support
     Device Drivers---><8>SCSI device support--->SCSI low-level drivers---><*>; BusLogic SCSI support
三、编译工作
OK，繁杂的配置工作完成了，至此，编译前的准备工作都做好了！
9、开始编译啦……
在/usr/src/linux-2.6.18目录下，执行以下命令即可编译。编译需要一段时间，给自己倒杯茶耐心等候吧！
# make dep  (建立编译时所需的从属文件。注意：如果内核从未编译过，此步可跳过)
# make clean  (清除内核编译的目标文件。注意：如果内核从未编译过，此步可跳过)
# make bzImage  (注意大小写。这一步才是真正编译内核)
     内核编译成功后，会在/usr/src/linux/arch/i386/boot目录中生成一个新内核的映像文件bzImage。如果用 make  zImage编译，内核很大的话，系统会提示你使用make   bzImage命令来编译，所以我直接用make bzImage来编译。
# make modules  (编译可加载模块)
# make modules_install  (安装可加载模块)
  安装成功后，系统会在/lib/modules目录下生成一个2.6.18子目录，里面存放着新内核的所有可加载模块。
# make install  (安装新内核)
注意：
        make install的时候可能会出现如下错误信息：
        No module BusLogic found for kernel 2.4.12
        mkinitrd failed
此问题一般只出现在SCSI硬盘＋VMWARE+REDHAT架构中，因为BusLogic被编译进了内核而不是一个module的形式(2.4内核的Buslogic模块即使静态编译进内核也不行)。解决方式是直接将BusLogic.o文件复制过去：
# cp /usr/src/linux-2.6.18/drivers/scsi/BusLogic.o  /lib/modules/2.6.18/kernel/drivers/scsi
不过别忘记，复制过后再执行一下make install。这一步若卡住了，下面的都无法进行，如果看本文档还是没有解决问题，就来我的网上留言本求助吧，进http://www.piaoyang.org ，点“留言本”即可，我会及时看到你的求助信息的。
四、启动新内核
10、将新内核和System.map文件拷贝到/boot目录下，依次执行以下命令：     
# cp  /usr/src/linux-2.6.18/arch/i386/boot/bzImage   /boot/vmlinuz-2.6.18     
# cp  /usr/src/linux-2.6.18/System.map   /boot/System.map-2.6.18     
# cd  /boot  (进入boot目录)
# rm –rf  System.map  (删除原来的连接)     
# ln –s System.map-2.6.18  System.map   (重新建立连接)     
11、修改Grub启动管理器
如果没有错误的话, 下面开始修改grub配置文件(不要告诉我你用的lilo)
在/boot目录下，执行以下命令：
# new-kernel-pkg --mkinitrd --depmod --install 2.6.18 (这时候你的/boot下会生成一个initrd-2.4.18.img，并且你的grub.conf文件也作了相应更改)
# df  (查看根目录在那个分区，下一步要用到。注意，这里根分区不时boot的那个50M的分区，而一般是你最大的那个分区，也就是“/”，千万不要搞错哦。我的为 /dev/hda2)
# vi /grub/grub.conf  
进入grub.conf文件，找到如下信息：
default=1
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Red Hat Linux (2.6.18)
        root (hd0,0)
        kernel /vmlinuz-2.6.18 ro root= LABEL=/
        initrd /initrd-2.6.18.img
做两处修改：
(1) 将default=1改为default=0(不改的话也可以，只不过重启之后会默认进入2.4内核)
(2) 将kernel行的“LABEL=/”换成根目录所在的分区(上一步查看的就是)
此步很重要，修改错误将可能导致进不去系统，我把我修改后的grub.conf文件列出来，不明之处，可以对照修改：
default=0
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Red Hat Linux (2.6.18)
        root (hd0,0)
        kernel /vmlinuz-2.6.18 ro root=/dev/hda2
        initrd /initrd-2.6.18.img
title Red Hat Linux (2.4.20-8)
        root (hd0,0)
        kernel /vmlinuz-2.4.20-8 ro root=LABEL=/
        initrd /initrd-2.4.20-8.img
12，OK，大功告成！赶快重启，看看升级后的2.6内核吧~~~~
后记：
Linux内核 升级和编译，老掉牙的话题了，网上相关的文章不计其数。然后，这么多的文章，却没有一篇让我顺利的升级成功。经过两天的体验，我深切的感受到，对于像我这样的新手来说，第一次升级和编译Linux内核，真是一项艰巨的任务。好在没有失去耐心，经过多篇文章的比对和自己的琢磨，一次次的修正，终于正确升级、编译成功。总结这两天的感受，那就是“痛，并快乐着”！如果你照着这些步骤一路下来的话，仍然没有成功；那么我可以告诉你两点：一是，不要怀疑我的步骤有问题，因为不光是我，我的同事照我的这篇文档也一次成功；二是，你可以到我的留言本http://www.piaoyang.org/guestbook 给我留言，我会尽力解答你的问题。以此拙作，希望能给大家带去些微的帮助。
posted @ 2009-06-11 21:32 MEYE 阅读(445) | 评论 (0) | 编辑 收藏
linux设备模型深探(1
     摘要: linux设备模型深探(1)　2009-06-05 15:37 分类：LinuxDriver 字号： 大大  中中  小小 转自：http://blog.chinaunix.net/u1/51562/showart_1077877.html ------------------------------------------ 本文系本站原创,...  阅读全文
posted @ 2009-06-11 21:31 MEYE 阅读(910) | 评论 (0) | 编辑 收藏
linux设备模型深探(2

linux设备模型深探(2)　2009-06-05 15:40

分类：LinuxDriver
字号： 大  中  小
这段代码中比较繁锁的就是bus_type对应目录下的属性文件建立,为了直观的说明,将属性文件的建立统一放到一起分析
从上面的代码中可以看,创建属性文件对应的属性分别为:
bus_attr_uevent bus_attr_drivers_probe, bus_attr_drivers_autoprobe
分别定义如下:
static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
         show_drivers_autoprobe, store_drivers_autoprobe);
BUS_ATTR定义如下:
#define BUS_ATTR(_name, _mode, _show, _store)  \
struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
#define __ATTR(_name,_mode,_show,_store) { \
     .attr = {.name = __stringify(_name), .mode = _mode },   \
     .show    = _show,                    \
     .store   = _store,                   \
}
由此可见.上面这三个属性对应的名称为别为uevent, drivers_probe, drivers_autoprobe.也就是说,会在bus_types目录下生成三个文件,分别为uevent,probe,autoprobe.
根据之前的分析,我们知道在sysfs文件系统中,对普通属性文件的读写都会回溯到kobject->ktype->sysfs_ops中.在这里,注意到有:
     priv->subsys.kobj.kset = bus_kset;
     priv->subsys.kobj.ktype = &bus_ktype;
显然,读写操作就回溯到了bus_ktype中.定义如下:
static struct kobj_type bus_ktype = {
     .sysfs_ops    = &bus_sysfs_ops,
};
static struct sysfs_ops bus_sysfs_ops = {
     .show    = bus_attr_show,
     .store   = bus_attr_store,
};
Show和store函数对应的代码为:
static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
                   char *buf)
{
     struct bus_attribute *bus_attr = to_bus_attr(attr);
     struct bus_type_private *bus_priv = to_bus(kobj);
     ssize_t ret = 0;
 
     if (bus_attr->show)
         ret = bus_attr->show(bus_priv->bus, buf);
     return ret;
}
 
static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
                    const char *buf, size_t count)
{
     struct bus_attribute *bus_attr = to_bus_attr(attr);
     struct bus_type_private *bus_priv = to_bus(kobj);
     ssize_t ret = 0;
 
     if (bus_attr->store)
         ret = bus_attr->store(bus_priv->bus, buf, count);
     return ret;
}
从代码可以看出.读写操作又会回溯到bus_attribute中的show和store中.在自定义结构里嵌入struct attribute,.然后再操作回溯到自定义结构中,这是一种比较高明的架构设计手法.
闲言少叙.我们对应看一下上面三个文件对应的最终操作:
Uevent对应的读写操作为:NULL, bus_uevent_store.对于这个文件没有读操作,只有写操作.用cat 命令去查看这个文件的时候,可能会返回”设备不存在”的错误.bus_uevent_store()代码如下:
static ssize_t bus_uevent_store(struct bus_type *bus,
                   const char *buf, size_t count)
{
     enum kobject_action action;
 
     if (kobject_action_type(buf, count, &action) == 0)
         kobject_uevent(&bus->p->subsys.kobj, action);
     return count;
}
从这里可以看到,可以在用户空间控制事件的发生,如echo add > event就会产生一个add的事件,
Probe文件对应的读写操作为:NULL store_drivers_probe.
store_drivers_probe()这个函数的代码涉及到struct device.等分析完struct device可以自行回过来看下这个函数的实现.实际上,这个函数是将用户输和的设备名称对应的设备与驱动匹配一次.
 
Autoprobe文件对应的读写操作为show_drivers_autoprobe, store_drivers_autoprobe.对应读的代码为:
static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
{
     return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
}
它将总线对应的drivers_autoprobe的值输出到用户空间,这个值为1时,自动将驱动与设备进行匹配.否则,反之.
写操作的代码如下:
static ssize_t store_drivers_autoprobe(struct bus_type *bus,
                          const char *buf, size_t count)
{
     if (buf[0] == '0')
         bus->p->drivers_autoprobe = 0;
     else
         bus->p->drivers_autoprobe = 1;
     return count;
}
写操作就会改变bus->p->drivers_autoprobe的值.
就这样,通过sysfs就可以控制总线是否要进行自动匹配了.
从这里也可以看出.内核开发者的思维是何等的灵活.
我们从sysfs中找个例子来印证一下：
Cd  / sys/bus/usb
用ls命令查看：
devices  drivers  drivers_autoprobe  drivers_probe  uevent
与上面分析的相吻合
 
设备的注册接口为: device_register().
int device_register(struct device *dev)
{
     device_initialize(dev);
     return device_add(dev);
}
Device_initialize()中有几个很重要的操作,如下:
void device_initialize(struct device *dev)
{
     dev->kobj.kset = devices_kset;
     kobject_init(&dev->kobj, &device_ktype);
     klist_init(&dev->klist_children, klist_children_get,
            klist_children_put);
     INIT_LIST_HEAD(&dev->dma_pools);
     INIT_LIST_HEAD(&dev->node);
     init_MUTEX(&dev->sem);
     spin_lock_init(&dev->devres_lock);
     INIT_LIST_HEAD(&dev->devres_head);
     device_init_wakeup(dev, 0);
     set_dev_node(dev, -1);
}
在这里,它为device的内嵌kobject指定了ktype和kset.device_kset的值如下:
devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
即对应sysfs中的/sys/devices
device_ktype 中对属性的读写操作同bus中的类似,被回溯到了struct device_attribute中的show 和store.
接着往下看device_add()的实现.这个函数比较长,分段分析如下:
int device_add(struct device *dev)
{
     struct device *parent = NULL;
     struct class_interface *class_intf;
     int error;
 
     dev = get_device(dev);
     if (!dev || !strlen(dev->bus_id)) {
         error = -EINVAL;
         goto Done;
     }
 
     pr_debug("device: '%s': %s\n", dev->bus_id, __FUNCTION__);
 
     parent = get_device(dev->parent);
     setup_parent(dev, parent);
 
     /* first, register with generic layer. */
     error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev->bus_id);
     if (error)
         goto Error;
     如果注册device的时候,没有指定父结点,在kobject_add将会在/sys/device/下建立相同名称的目录
     /* notify platform of device entry */
     if (platform_notify)
         platform_notify(dev);
 
     /* notify clients of device entry (new way) */
     if (dev->bus)
         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                            BUS_NOTIFY_ADD_DEVICE, dev);
 
忽略notify部份,这部份不会影响本函数的流程
 
     error = device_create_file(dev, &uevent_attr);
     if (error)
         goto attrError;
 
     if (MAJOR(dev->devt)) {
         error = device_create_file(dev, &devt_attr);
         if (error)
              goto ueventattrError;
     }
建立属性为uevent_attr的属性文件,如果device中指定了设备号,则建立属性为devt_attr的属性文件
 
     error = device_add_class_symlinks(dev);
     if (error)
         goto SymlinkError;
     error = device_add_attrs(dev);
     if (error)
         goto AttrsError;
     error = dpm_sysfs_add(dev);
     if (error)
         goto PMError;
     device_pm_add(dev);
在这里,不打算讨论class的部份,dpm pm是选择编译部份,不讨论. device_add_attrs中涉及到了group的部分,暂不讨论
     error = bus_add_device(dev);
     if (error)
         goto BusError;
     kobject_uevent(&dev->kobj, KOBJ_ADD);
     bus_attach_device(dev);
     if (parent)
         klist_add_tail(&dev->knode_parent, &parent->klist_children);
 
     if (dev->class) {
         down(&dev->class->sem);
         /* tie the class to the device */
         list_add_tail(&dev->node, &dev->class->devices);
 
         /* notify any interfaces that the device is here */
         list_for_each_entry(class_intf, &dev->class->interfaces, node)
              if (class_intf->add_dev)
                   class_intf->add_dev(dev, class_intf);
         up(&dev->class->sem);
     }
bus_add_device()会在对应总线代表目录的device目录下创建几个到device的链接.然后产生一个add事件,再调用bus_attach_device()去匹配已经注册到总线的驱动程序.全部做完之后,将设备挂到父结点的子链表.
 Done:
     put_device(dev);
     return error;
 BusError:
     device_pm_remove(dev);
 PMError:
     if (dev->bus)
         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                            BUS_NOTIFY_DEL_DEVICE, dev);
     device_remove_attrs(dev);
 AttrsError:
     device_remove_class_symlinks(dev);
 SymlinkError:
     if (MAJOR(dev->devt))
         device_remove_file(dev, &devt_attr);
 ueventattrError:
     device_remove_file(dev, &uevent_attr);
 attrError:
     kobject_uevent(&dev->kobj, KOBJ_REMOVE);
     kobject_del(&dev->kobj);
 Error:
     cleanup_device_parent(dev);
     if (parent)
         put_device(parent);
     goto Done;
}
出错处理部份.
 
bus_attach_device()是一个很重要的函数。它将设备自动与挂在总线上面的驱动进行匹配。代码如下：
void bus_attach_device(struct device *dev)
{
     struct bus_type *bus = dev->bus;
     int ret = 0;
 
     if (bus) {
         dev->is_registered = 1;
         if (bus->p->drivers_autoprobe)
              ret = device_attach(dev);
         WARN_ON(ret < 0);
         if (ret >= 0)
              klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
         else
              dev->is_registered = 0;
     }
}
从上面的代码我们可以看出。只有在bus->p->drivers_autoprobe为1的情况下，才会去自己匹配。这也就是bus目录下的drivers_probe 文件的作用.然后，将设备挂到总线的设备链表。
Device_attach()代码如下：
int device_attach(struct device *dev)
{
     int ret = 0;
 
     down(&dev->sem);
     if (dev->driver) {
         ret = device_bind_driver(dev);
         if (ret == 0)
              ret = 1;
         else {
              dev->driver = NULL;
              ret = 0;
         }
     } else {
         ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
     }
     up(&dev->sem);
     return ret;
}
对于设备自己已经指定驱动的情况，只需要将其直接和驱动绑定即可。如果没有指定驱动。就匹配总线之上的驱动。这是在bus_for_each_drv(dev->bus, NULL, dev, __device_attach);完成的。代码如下：
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
              void *data, int (*fn)(struct device_driver *, void *))
{
     struct klist_iter i;
     struct device_driver *drv;
     int error = 0;
 
     if (!bus)
         return -EINVAL;
 
     klist_iter_init_node(&bus->p->klist_drivers, &i,
                   start ? &start->p->knode_bus : NULL);
     while ((drv = next_driver(&i)) && !error)
         error = fn(drv, data);
     klist_iter_exit(&i);
     return error;
}
很明显，这个函数就是遍历总线之上的驱动。每遍历一个驱动就调用一次回调函数进行判断。如果回调函数返回不为0。就说明匹配已经成功了。不需要再匹配剩余的。退出。在这里调用的回调函数是__device_attach().在这里。完全了设备与驱动匹配的最核心的动作。代码如下：
static int __device_attach(struct device_driver *drv, void *data)
{
     struct device *dev = data;
     return driver_probe_device(drv, dev);
}
转到driver_probe_device():
int driver_probe_device(struct device_driver *drv, struct device *dev)
{
     int ret = 0;
 
     if (!device_is_registered(dev))
         return -ENODEV;
     if (drv->bus->match && !drv->bus->match(dev, drv))
         goto done;
 
     pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
          drv->bus->name, __FUNCTION__, dev->bus_id, drv->name);
 
     ret = really_probe(dev, drv);
 
done:
     return ret;
}
如果设备没有注册到总线之上。即dev->is_registered不为1. 就直接返回。
然后，再调用总线的match()函数进行匹配。如果match()函数返回0.说明匹配失败。那退出此函数。如果match函数返回1.说明初步的检查已经通过了。可以进入really_probe()再进行细致的检查。如果匹配成功，这个函数会返回1.此函数比较长而且比较重要，分段列出代码：
static int really_probe(struct device *dev, struct device_driver *drv)
{
     int ret = 0;
 
     atomic_inc(&probe_count);
     pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
          drv->bus->name, __FUNCTION__, drv->name, dev->bus_id);
     WARN_ON(!list_empty(&dev->devres_head));
 
     dev->driver = drv;
     if (driver_sysfs_add(dev)) {
         printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
              __FUNCTION__, dev->bus_id);
         goto probe_failed;
     }
先假设驱动和设备是匹配的。为设备结构设置驱动成员。使其指向匹配的驱动。然后再调用driver_sysfs_add()建立几个符号链接。这几个链接分别为：
1：在驱动目录下建立一个到设备的同名链接
2：在设备目录下建立一个名为driver。到驱动的链接
 
     if (dev->bus->probe) {
         ret = dev->bus->probe(dev);
         if (ret)
              goto probe_failed;
     } else if (drv->probe) {
         ret = drv->probe(dev);
         if (ret)
              goto probe_failed;
     }
然后，再调用总线的probe函数。如果总线的此函数不存在。就会调用驱动的probe函数。如果匹配成功，返回0.如果不成功，就会跳转到probe_failed
 
     driver_bound(dev);
     ret = 1;
     pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
          drv->bus->name, __FUNCTION__, dev->bus_id, drv->name);
     goto done;
到这里。设备和驱动已经匹配成功，调用driver_bound()将其关联起来。在这个函数里：
会将设备加至驱动的设备链表。这在我们之前分析bus,device driver中分析到的。相关的代码如下示：
     klist_add_tail(&dev->knode_driver, &dev->driver->p->klist_devices);
至此，这个匹配过程已经圆满结束了。返回1
 
probe_failed:
     devres_release_all(dev);
     driver_sysfs_remove(dev);
     dev->driver = NULL;
 
     if (ret != -ENODEV && ret != -ENXIO) {
         /* driver matched but the probe failed */
         printk(KERN_WARNING
                "%s: probe of %s failed with error %d\n",
                drv->name, dev->bus_id, ret);
     }
     /*
      * Ignore errors returned by ->probe so that the next driver can try
      * its luck.
      */
     ret = 0;
这里是匹配不成功的处理，在这里，删除之前建立的几个链接文件，然后将设备的driver域置空。
done:
     atomic_dec(&probe_count);
     wake_up(&probe_waitqueue);
     return ret;
}
 
从上面的分析可以看到，对应创建的属性文件分别为：uevent_attr devt_attr。它们的定义如下：
static struct device_attribute uevent_attr =
     __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
static struct device_attribute devt_attr =
     __ATTR(dev, S_IRUGO, show_dev, NULL);
uevent_attr对应的读写函数分别为：show_uevent store_uevent。先分析读操作。它的代码如下：
static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
                 char *buf)
{
     struct kobject *top_kobj;
     struct kset *kset;
     struct kobj_uevent_env *env = NULL;
     int i;
     size_t count = 0;
     int retval;
 
     /* search the kset, the device belongs to */
     top_kobj = &dev->kobj;
     while (!top_kobj->kset && top_kobj->parent)
         top_kobj = top_kobj->parent;
     if (!top_kobj->kset)
         goto out;
 
     kset = top_kobj->kset;
     if (!kset->uevent_ops || !kset->uevent_ops->uevent)
         goto out;
 
     /* respect filter */
     if (kset->uevent_ops && kset->uevent_ops->filter)
         if (!kset->uevent_ops->filter(kset, &dev->kobj))
              goto out;
 
     env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
     if (!env)
         return -ENOMEM;
 
     /* let the kset specific function add its keys */
     retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
     if (retval)
         goto out;
 
     /* copy keys to file */
     for (i = 0; i < env->envp_idx; i++)
         count += sprintf(&buf[count], "%s\n", env->envp[i]);
out:
     kfree(env);
     return count;
}
从代码可以看出。这里会显示出由设备对应的kset.也就是由devices_kset所产生的环境变量。例如，在shell中输入如下指令：
Cat /sys/devices/LNXSYSTM:00/ uevent
输出结果如下：
PHYSDEVBUS=acpi
MODALIAS=acpi:LNXSYSTM:
这就是由devices_kset所添加的环境变量
 
写操作对应的代码如下：
static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
                  const char *buf, size_t count)
{
     enum kobject_action action;
 
     if (kobject_action_type(buf, count, &action) == 0) {
         kobject_uevent(&dev->kobj, action);
         goto out;
     }
 
     dev_err(dev, "uevent: unsupported action-string; this will "
              "be ignored in a future kernel version\n");
     kobject_uevent(&dev->kobj, KOBJ_ADD);
out:
     return count;
}
从上面的代码可以看出。这个文件的作用是输入一个字符字串。如果字符不合法，就会默认产生一个add事件。
 
devt_attr对应的读写函数为show_dev NULL.写函数为空，也就是说这个属性文件不允许写。只允许读。读操作的代码如下示：
static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
              char *buf)
{
     return print_dev_t(buf, dev->devt);
}
也就是说，会将设备号显示出来.
 
分析完了bus.device.再接着分析driver.这里我们要分析的最后一个元素了。耐着性子往下看，快要完了^_^
 
驱动注册的接口为：driver_register().代码如下：
int driver_register(struct device_driver *drv)
{
     int ret;
 
     if ((drv->bus->probe && drv->probe) ||
         (drv->bus->remove && drv->remove) ||
         (drv->bus->shutdown && drv->shutdown))
         printk(KERN_WARNING "Driver '%s' needs updating - please use "
              "bus_type methods\n", drv->name);
     ret = bus_add_driver(drv);
     if (ret)
         return ret;
     ret = driver_add_groups(drv, drv->groups);
     if (ret)
         bus_remove_driver(drv);
     return ret;
}
如果设备与总线定义了相同的成员的函数。内核是优先使用bus中定义的.这一点我们在分析device注册的时候已经分析过。所以。这里打印出警告信息，用来提醒代码编写者。在这里，忽略有关group的东西。剩余的便只剩下bus_add_driver().代码如下：
int bus_add_driver(struct device_driver *drv)
{
     struct bus_type *bus;
     struct driver_private *priv;
     int error = 0;
 
     bus = bus_get(drv->bus);
     if (!bus)
         return -EINVAL;
 
     pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
 
     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
     if (!priv) {
         error = -ENOMEM;
         goto out_put_bus;
     }
     klist_init(&priv->klist_devices, NULL, NULL);
     priv->driver = drv;
     drv->p = priv;
     priv->kobj.kset = bus->p->drivers_kset;
     error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
                        "%s", drv->name);
初始化驱动的driver_private域。使其内嵌的kobject的kset指bus中的drivers_kset.这样，这个内嵌的kobject所生成的目录就会存在于bus对应目录的driver目录之下。这里还要注意的是,为内嵌kobject指定的ktype是driver_ktype.属性文件的读写操作都回回溯到struct driver_attribute中。这在之后再分析.
 
     if (error)
         goto out_unregister;
 
     if (drv->bus->p->drivers_autoprobe) {
         error = driver_attach(drv);
         if (error)
              goto out_unregister;
     }
     klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
b
     module_add_driver(drv->owner, drv);
如果总线允许自动进行匹配。就会调用driver_attach()进行这个自己匹配过程。这个函数跟我们在上面分析的device自动匹配过程是一样的。请自行分析.最后，将驱动挂到bus对应的驱动链表
 
     error = driver_create_file(drv, &driver_attr_uevent);
     if (error) {
         printk(KERN_ERR "%s: uevent attr (%s) failed\n",
              __FUNCTION__, drv->name);
     }
生成一个属性为driver_attr_uevent的属性文件
 
     error = driver_add_attrs(bus, drv);
     if (error) {
         /* How the hell do we get out of this pickle? Give up */
         printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
              __FUNCTION__, drv->name);
     }
为bus中的driver属性生成属性文件
 
     error = add_bind_files(drv);
     if (error) {
         /* Ditto */
         printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
              __FUNCTION__, drv->name);
     }
生成属性为driver_attr_unbind和driver_attr_bind的属性文件
 
     kobject_uevent(&priv->kobj, KOBJ_ADD);
生成一个add事件
     return error;
out_unregister:
     kobject_put(&priv->kobj);
out_put_bus:
     bus_put(bus);
     return error;
}
总的来说，这个函数比较简单。其中涉及到的子函数大部份都在之前分析过。我们接下来分析一下。它所创建的几个属性文件的含义。
如上所述。在这里会创建三个属性文件，对应属性分别为：driver_attr_uevent，driver_attr_unbind，driver_attr_bind。这几个属性的定义如下：
static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store);
static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
DRIVER_ATTR宏的定义如下：
#define DRIVER_ATTR(_name, _mode, _show, _store)   \
struct driver_attribute driver_attr_##_name =      \
     __ATTR(_name, _mode, _show, _store)
 
对于driver_attr_uevent.它的读写函数分别为：NULL。driver_uevent_store。也就是说这个文件只允许写，不允许读操作。写操作的代码如下示：
static ssize_t driver_uevent_store(struct device_driver *drv,
                      const char *buf, size_t count)
{
     enum kobject_action action;
 
     if (kobject_action_type(buf, count, &action) == 0)
         kobject_uevent(&drv->p->kobj, action);
     return count;
}
很明显，这是一个手动产生事件的过程。用户可间可以写事件到这个文件来产生事件。
对于driver_unbind.它的读写函数分别为：NULL driver_unbind。这个文件也是不允许读的。写操作代码如下：
static ssize_t driver_unbind(struct device_driver *drv,
                   const char *buf, size_t count)
{
     struct bus_type *bus = bus_get(drv->bus);
     struct device *dev;
     int err = -ENODEV;
 
     dev = bus_find_device_by_name(bus, NULL, buf);
     if (dev && dev->driver == drv) {
         if (dev->parent)   /* Needed for USB */
              down(&dev->parent->sem);
         device_release_driver(dev);
         if (dev->parent)
              up(&dev->parent->sem);
         err = count;
     }
     put_device(dev);
     bus_put(bus);
     return err;
}
从上面的代码可以看出。写入文件的是一个设备名称。这个函数对应操作是将这个设备与驱动的绑定分离开来。
 
driver_attr_bind属性对应的读写函数分别为NULL。driver_attr_bind 即也是不允许写的。从字面意思和上面分析的driver_attr_unbind操作代码来看，这个属性对应的写函数应该是将写入的设备文件与此驱动绑定起来。我们来看下代码。以证实我们的猜测。代码如下：
static ssize_t driver_bind(struct device_driver *drv,
                 const char *buf, size_t count)
{
     struct bus_type *bus = bus_get(drv->bus);
     struct device *dev;
     int err = -ENODEV;
 
     dev = bus_find_device_by_name(bus, NULL, buf);
     if (dev && dev->driver == NULL) {
         if (dev->parent)   /* Needed for USB */
              down(&dev->parent->sem);
         down(&dev->sem);
         err = driver_probe_device(drv, dev);
         up(&dev->sem);
         if (dev->parent)
              up(&dev->parent->sem);
 
         if (err > 0) {
              /* success */
              err = count;
         } else if (err == 0) {
              /* driver didn't accept device */
              err = -ENODEV;
         }
     }
     put_device(dev);
     bus_put(bus);
     return err;
}
果然，和我们猜测的是一样的。
 
五：小结
在这一节里，分析了设备模型中的最底层的元素和他们之间的关系。也分析了它们建立的几个属性文件的含义。到这里，我们已经可以自己写驱动架构代码了.^_^
posted @ 2009-06-11 21:31 MEYE 阅读(613) | 评论 (0) | 编辑 收藏
linux下的GPIO驱动

linux下的GPIO驱动　2009-06-05 08:29

分类：技术
字号： 大  中  小

编写驱动程序，首先要了解是什么类型的设备。linux下的设备分为三类，分别为：字符设备，块设备和网络设备。字符设备类型是根据是否以字符流为数据的交换方式，大部分设备都是字符设备，如键盘，串口等，块设备则是以块为单位进行管理的设备，如，磁盘。网络设备就是网卡等。

其次要了解应用程序和驱动程序的区别，两者的主要区别分为以下三点：

1入口函数的任务不相同，应用程序完成一个任务，驱动只完成初始化工作，比如中断

      申请，寄存器设置，定时器设置。

2运行时的cpu模式不相同，驱动具有很高的权限，应用程序是在用户态下运行，而驱

  动程序是在内核态下执行。

3 驱动程序不能调用C库函数，内核为驱动程序提供一些函数。如printk(KERN_NOTICE fmt, ##arg)，第一个参数为打印级别，有如下的打印级别：

KERN_EMERG 用于紧急事件,一般是系统崩溃前的提示信息

KERN_ALERT 用于需要立即采取动作的场合

KERN_CRIT 临界状态,通常设计验证的硬件或软件操作失败

KERN_ERR 用于报告错误状态.设备驱动程序通常会用它报告来自硬件的问题

KERN_WARNING 就可能出现的问题提出警告.这些问题通常不会对系统造成严重破坏

KERN_NOTICE 有必要提示的正常情况.许多安全相关的情况用这个级别汇报

KERN_INFO 提示性信息.有很多驱动程序在启动时用这个级别打印相关信息

KERN_DEBUG 用于调试的信息

u_long copy_from_user(void *to, const void *from, u_long len)，由用户态拷贝到内核态；

u_long copy_to_user(void * to, const void *from, u_long len)，由内核态拷贝到用户态。

鉴于以上区别，驱动程序需要完成以下三点基本功能：

1：要对设备进行初始化和释放功能模块，就如上面的寄存器设置，中断的申请，向内核注 

   册驱动程序（register_chrdev（）），卸载驱动程序（unregister_chrdev（））。

2：能进行数据传输，在read()，write()函数里具体实现，数据传输工作。

3：能进行控制操作，给用户提供的ioctl（）函数里可实现一些用户的选择性设置功能。

确定一个设备的执行函数集（结构体）

static struct file_operations myGPIO_fops = {

owner: THIS_MODULE,

write: myGPIO_write,

read: myGPIO_read,

ioctl: myGPIO_ioctl,

open: myGPIO_open,

release: myGPIO_release,

};

接下来是初始化工作，需要写在一个init（）函数中，这个函数是独立的也是自动执行的，在这之中主要是对一些寄存器进行初始化操作。同样需要完成卸载驱动模块。

myGPIO_Major = register_chrdev(0, DRIVER_NAME, &myDriver_fops);

上面的程序完成设备号的注册，第一个参数为主设备号，一般为0，由系统来分配。

第二个参数为设备名，这需要在/dev/（/dev目录下设备名由命令 <mknod  设备名 C 主设备号  从设备号>来生成）目录下出现的设备名相符合。相反的在卸载中就取消注册

unregister_chrdev(myGPIO_Major, DRIVER_NAME);

最后将这两个模块加入到内核中，由程序段的最后两行完成。

static int __init myGPIO_init(void)

{

PRINTK("GPIO init\n");

myGPIO_Major = register_chrdev(0, DRIVER_NAME, &myGPIO_fops);

if(myGPIO_Major < 0)

{

PRINTK("register char device fail!\n");

return myGPIO_Major;

}

PRINTK("register myGPIO OK! Major = %d\n", myGPIO_Major);

#ifdef CONFIG_DEVFS_FS

devfs_myDriver_dir = devfs_mk_dir(NULL, "GPIO", NULL);

devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myGPIO_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myGPIO_fops, NULL);

PRINTK("add dev file to devfs OK!\n");

#endif

return 0;

}

static void __exit myGPIO_exit(void)

{

/* Module exit code */

PRINTK("GPIO exit\n");

/* Driver unregister */

if(myGPIO_Major > 0)

{

#ifdef CONFIG_DEVFS_FS

devfs_unregister(devfs_myDriver_raw);

devfs_unregister(devfs_myDriver_dir);

#endif

unregister_chrdev(myGPIO_Major, DRIVER_NAME);

}

return;

}

MODULE_AUTHOR("LiuFan");

MODULE_LICENSE("Dual BSD/GPL");

module_init(myGPIO_init);

module_exit(myGPIO_exit);

设备执行函数功能的实现将在下面完成。如结构体的函数，但并不是全都需要实现。open()函数中是执行一些设备工作前的初始化工作。rlease()则是将设备的相关寄存器恢复到原来的值。read()函数是将设备中的数据拷贝到内核，write（）函数是将内核数据拷贝到对应的设备中。MOD_INC_USE_COUNT和MOD_DEC_USE_COUNT两个宏是提供给系统对硬件资源进行控制访问的。在open（）和rlease()两个函数中最基本的操作应是实现以上两个宏的操作。

static unsigned char myGPIO_Buffer[1024*1024];

/* Driver Operation Functions */

static int myGPIO_open(struct inode *inode, struct file *filp)

{

// int Minor = MINOR(inode->i_rdev);

// filp->private_data = 0;

MOD_INC_USE_COUNT;

PRINTK("myDriver open called!\n");

return 0;

}

static int myGPIO_release(struct inode *inode, struct file *filp)

{

// int Minor = MINOR(inode->i_rdev);

MOD_DEC_USE_COUNT;

PRINTK("myDriver release called!\n");

return 0;

}

static ssize_t myGPIO_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)

{

char dat;

size_t read_size = count;

PRINTK("GPIO read called!\n");

PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);

/* if(*f_pos >= sizeof(myGPIO_Buffer))

{

PRINTK("[GPIO read]Buffer Overlap\n");

*f_pos = sizeof(myGPIO_Buffer);

return 0;

}

if((count + *f_pos) > sizeof(myGPIO_Buffer))

{

PRINTK("count + f_pos > sizeof buffer\n");

read_size = sizeof(myGPIO_Buffer) - *f_pos;

}*/

dat= GPFDAT;

copy_to_user(buf,&dat,1);

// *f_pos += read_size;

return read_size;

}

static ssize_t myGPIO_write(struct file *filp,const char *buf, size_t count, loff_t *f_pos)

{

char dat;

size_t fill_size = count;

PRINTK("myDriver write called!\n");

PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);

if(*f_pos >= sizeof(myGPIO_Buffer))

{

PRINTK("[myDriver write]Buffer Overlap\n");

*f_pos = sizeof(myGPIO_Buffer);

return 0;

}

if((count + *f_pos) > sizeof(myGPIO_Buffer))

{

PRINTK("count + f_pos > sizeof buffer\n");

fill_size = sizeof(myGPIO_Buffer) - *f_pos;

}

copy_from_user(&dat,buf,fill_size);

GPFDAT = dat;

// *f_pos += fill_size;

return fill_size;

}

控制ioctl() 函数则是提供给应用层的接口函数，功能并不是固定的，由开发者定义，一般都是对硬件的一些除过上述功能的其他操作。

static int myGPIO_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)

{

int i;

unsigned int mask=0x01;

GPFUP = 0x00;

PRINTK("myGPIO ioctl called(%d)!\n", cmd);

    switch(cmd)

{

case MOD_IN:

for(i=0;i<8;i++)

{

if((mask & arg)!=0x0)

{

GPFCON &=~(3<<i*2); 

}

mask =mask << 1;

}

break;

case MOD_OUT:

 PRINTK("IOCTRL 0 called(0x%lx)!\n", arg);

 for(i=0;i<8;i++)

 {

 if((mask & arg)!=0x00)

 {

        GPFCON &= ~(3 <<( i*2));

GPFCON |=(0x01<<(i*2));

 }

mask=mask<<1;

 }

 break;

case MOD_EXIT_INT:

PRINTK("IOCTRL 1 called(0x%lx)!\n", arg);

GPFDAT = 0xFFFFFF00;

break;

default:

break;

}

return 0;

}

posted @ 2009-06-11 21:30 MEYE 阅读(2610) | 评论 (0) | 编辑 收藏
2009-05-25 | 嵌入式Linux下USB驱动程序的设计

2009-05-25 | 嵌入式Linux下USB驱动程序的设计

 
标签： Linux  嵌入式  USB  驱动 

一、引言

    USB(Universal Serial Bus)即通用串行总线，是一种全新的双向同步传输的支持热插拔的数据传输总线，其目的是为了提供一种兼容不同速度的、可扩充的并且使用方便的外围设备接口，同时也是为了解决计算机接口的太多的弊端而设计的。一个USB系统主要有三部分组成：USB互连、USB主机、USB设备三部分组成的，其结构如图1 所示。在编写USB设备驱动程序设计时，可以分为三部分编写：主机端设备驱动程序、主机控制器驱动程序设计和设备端驱动程序三部分，在本文中重点介绍主机端驱动程序的设计。

    二、USB设备驱动程序的设计

    USB设备驱动程序的设计包括主机端设备驱动程序设计、主机控制器驱动程序设计和设备端驱动程序设计三部分组成。主机端设备驱动程序就是通常说的设备驱动程序，它是主机环境中为用户应用程序提供一个访问USB外设的接口。Linux为这部分驱动程序提供编程接口，驱动程序设计者只要按照需求编写驱动程序框架，通过调用操作系统提供的API接口函数可以完成对USB外设的特定访问。

    主机控制驱动主要是对USB主机控制器的驱动，在大多数PC环境下，主机控制器都是由操作系统提供。嵌入式设备一般都没有USB主机控制器，只是工作在 Slave模式下。如果要使USB具有主机功能，那么设备中需要选用一个带主机控制器的USB接口控制芯片，同时自己还要有实现该主机控制器的驱动程序。目前Linux内核中只提供USB主机控制器的开放主机控制器和通用主机控制器接口两种规格，而这两种规格主要用在PC架构中。USB主机端驱动程序与主机控制器的结构如图2所示。其中USB核是Linux的一个子模块，集中定义了一组USB相关的数据结构、宏以及API函数。

    USB设备驱动程序是常说的设备固件程序的一部分，提供设备信息与主机的通信接口。设备端USB驱动程序设计由以下几部分处理程序组成。初始化例程：完成描述符指针、端点、配置改变等操作。数据传输例程：完成控制传输、批量传输、中断传输及同步传输等传输方式下的数据收发工作。标准设备处理请求：处理标准设备请求。厂商请求处理：处理生产商指定请求。其他操作：处理主机发出的端口复位、配置改变等操作。

   1.USB设备驱动程序框架

    USB驱动程序首先要向Linux内核注册自己，并告诉系统它所支持的设备类型以及它所支持的操作。这些信息通过一个usb_driver结构来传递。usb_driver结构如下：

    static struct usb_driver skel_driver = {

    name: "skeleton"；/*驱动程序的名称*/

    probe: skel_probe； /*设备列举时被调用*/

    disconnect: skel_disconnect； /*设备被卸载时被调用*/

    fops: &skel_fops； /*指向一个file_operation结构，内核通过它来访问驱动程序的文件操作函数，与用户程序的read、write等操作进行交互*/

    minor USB_SKEL_MINOR_BASE； /*指向设备的次设备号，用于系统识别主设备号相同的设备（即一个驱动程序可以同时支持多个USB设备*/

    id_table: skel_table； /*保存设备的厂商ID和产品ID，作为该设备的唯一标识，驱动程序向系统注册后，当下次插入时，系统根据这个标识查找正确的驱动程序，实现设备的即插即用*/

    };

    static struct file_operation skel_fops={

    {

    owner:THIS_MODULE,

    read:skel_read,

    write:skel_write,

    ioctl:skel_ioctl,

    open:skel_open,

    release:skel_release,

    };

    （1）注册和注销

    USB驱动程序注册，就是把在初始化函数中填好的use_driver结构作为参数传递给
   
    use_register()函数即可，函数的调用方法为：

    result=usb_register(&skel_driver);

    当要从系统卸载驱动程序时，也是将use_driver结构作为参数传递给usb_deregister 函数处理。 函数的调用格式为：

    static void __exit usb_skel_exit(void)

    { /* deregister this driver with the USB subsystem */

    usb_deregister(&skel_driver);

    }

    module_exit(usb_skel_exit);

    当USB设备插入时，为了使linux-hotplug（Linux中PCI、USB等设备热插拔支持）系统自动装载驱动程序，需要创建一个MODULE_DEVICE_TABLE。核心代码如下（这个模块仅支持某一特定设备）：

    /* table of devices that work with this driver */

    static struct usb_device_id skel_table [] = {

    { USB_DEVICE(USB_SKEL_VENDOR_ID,

    USB_SKEL_PRODUCT_ID) },

    { } /* Terminating entry */

    };

    MODULE_DEVICE_TABLE (usb, skel_table);

    USB_DEVICE宏利用厂商ID和产品ID提供了一个设备的唯一标识。当系统插入一个ID匹配的USB设备到USB总线时，驱动会在USB core中注册，驱动程序中probe 函数也就会被调用。usb_device 结构指针、接口号和接口ID都会被传递到函数中。

    （2）probe()函数

    probe()函数的编写格式为：static void * skel_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id)；驱动程序需要确认插入的设备是否可以被接受，如果不接受，或者在初始化的过程中发生任何错误，probe()函数返回一个NULL值。否则返回一个含有设备驱动程序状态的指针，通过这个指针，就可以访问所有结构中的回调函数。

    在驱动程序里，最后一点是要注册devfs（设备文件系统）。首先创建一个缓冲用来保存那些被发送给USB设备的数据和那些从设备上接受的数据，并为设备传输创建一个USB请求块（URB）以向设备写入数据，同时USB urb 被初始化，然后在devfs子系统中注册设备，允许devfs用户访问USB的设备。注册过程如下：

    /* initialize the devfs node for this device and register it */

    sprintf(name, "skel%d", skel->minor);

    skel->devfs = devfs_register (usb_devfs_handle, name, DEVFS_FL_DEFAULT, USB_MAJOR, USB_SKEL_MINOR_BASE + skel->minor, S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, &skel_fops, NULL);

    如果devfs_register函数失败， devfs子系统会将此情况报告给用户。如果设备从USB总线拔掉，设备指针会调用disconnect 函数。驱动程序就需要清除那些被分配了的所有私有数据、关闭urbs，并且从devfs上注销调自己。调用函数的格式为：

    /* remove our devfs node */

    devfs_unregister(skel->devfs);

    现在，skeleton驱动就已经和设备绑定上了，任何用户态程序要操作此设备都可以通过file_operations结构所定义的函数进行了。

    （3）open()、write()和read()函数

    首先，要打开此设备。在open()函数中MODULE_INC_USE_COUNT 宏是一个关键，它起到一个计数的作用，有一个用户态程序打开一个设备，计数器就加1。例如，以模块方式加入一个驱动，若计数器不为零，就说明仍然有用户程序在使用此驱动，这时候，就不能通过rmmod命令卸载驱动模块了。

    /* increment our usage count for the module */

    MOD_INC_USE_COUNT;

    ++skel->open_count;

    /* save our object in the file's private structure */

    file->private_data = skel;

    当open完设备后，read()、write()函数就可以收、发数据了。

    read()函数首先从open()函数中保存的fi。

    Write()函数和read()函数是完成驱动对读写等操作的响应。在skel_write中，一个FILL_BULK_URB函数，就完成了urb 系统callbak和的skel_write_bulk_callback之间的联系。注意skel_write_bulkcallback是中断方式，所以要注意时间不能太久，本程序中它就只是报告一些urb的状态等。 read 函数与write 函数稍有不同在于：程序并没有用urb 将数据从设备传送到驱动程序，而是用usb_bulk_msg 函数代替，这个函数能够不需要创建urbs 和操作urb函数的情况下，来发送数据给设备，或者从设备来接收数据。调用usb_bulk_msg函数并传到一个存储空间，用来缓冲和放置驱动收到的数据，若没有收到数据表示失败并返回一个错误信息。

    usb_bulk_msg函数：当对usb设备进行一次读或者写时，usb_bulk_msg 函数是非常有用的; 然而, 当需要连续地对设备进行读/写时，应建立一个自己的urbs，同时将urbs 提交给USB子系统。

    skel_disconnect函数：当释放设备文件句柄时，这个函数会被调用。
    MOD_DEC_USE_COUNT宏也会被调用到（和MOD_INC_USE_COUNT刚好对应，它减少一个计数器），首先确认当前是否有其他的程序正在访问这个设备，如果是最后一个用户在使用，可以关闭任何正在发生的写，操作如下：

    /* decrement our usage count for the device */

    --skel->open_count;

    if (skel->open_count <= 0) {

    /* shutdown any bulk writes that might be

    going on */

    usb_unlink_urb (skel->write_urb);

    skel->open_count = 0;

    }

    /* decrement our usage count for the module */

    MOD_DEC_USE_COUNT;

    USB设备可以在任何时间点从系统中取走，即使程序目前正在访问它。USB驱动程序必须要能够很好地处理解决此问题，它需要能够切断任何当前的读写，同时通知用户空间程序：USB设备已经被取走。

   2.设计实例

    下面通过介绍键盘飞梭驱动程序的实例来让读者更好的理解USB驱动程序的工作原理，实现代码如下：

    /*需要的头文件*/

    #include <linux/kernel.h>

    #include <linux/slab.h>            

    #include <linux/module.h>

    #include <linux/input.h>

    #include <linux/init.h>

    #include <linux/usb.h>

    #include <linux/kbd_ll.h>

    /* 驱动程序版本信息*/

    #define DRIVER_VERSION ""

    #define DRIVER_AUTHOR " TGE HOTKEY "

    #define DRIVER_DESC "USB HID Tge hotkey driver"

    #define USB_HOTKEY_VENDOR_ID 0x07e4

    #define USB_HOTKEY_PRODUCT_ID 0x9473

    /*厂商和产品ID信息就是/proc/bus/usb/devices中看到的值，通过cat/proc/bus/usb/devices得到当前系统探测到的USB总线上的设备信息。它包括Vendor、ProdID、Product等*/

    MODULE_AUTHOR( DRIVER_AUTHOR );

    MODULE_DESCRIPTION( DRIVER_DESC );

    /*此结构来自内核中drivers/usb/usbkbd.c*/

    struct usb_kbd {

    struct input_dev dev;

    struct usb_device *usbdev;

    unsigned char new[8];

    unsigned char old[8];

    struct urb irq, led;

    struct usb_ctrlrequest dr;

    unsigned char leds, newleds;

    char name[128];

    int open;

    };

    static void usb_kbd_irq(struct urb *urb) /*urb为USB请求块*/

    {

    struct usb_kbd *kbd = urb->context;

    int *new;

    new = (int *) kbd->new;

    if(kbd->new[0] == (char)0x01)

    {

    if(((kbd->new[1]>>4)&0x0f)!=0x7)

    {

    handle_scancode(0xe0,1);

    handle_scancode(0x4b,1);

    handle_scancode(0xe0,0);

    handle_scancode(0x4b,0);

    }

    else

    { handle_scancode(0xe0,1);

    handle_scancode(0x4d,1);

    handle_scancode(0xe0,0);

    handle_scancode(0x4d,0);

    }

    }

    printk("new=%x %x %x %x %x %x %x %x"， kbd->new[0],kbd->new[1],kbd->new[2],kbd->new[3],

    kbd->new[4],kbd->new[5],kbd->new[6],kbd->new[7]);

    }

    static void *usb_kbd_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id)

    {

    struct usb_interface *iface;

    struct usb_interface_descriptor *interface;

    struct usb_endpoint_descriptor *endpoint;

    struct usb_kbd *kbd;

    int pipe, maxp;

    iface = &dev->actconfig->interface[ifnum];

    interface = &iface->altsetting[iface->act_altsetting];

    if ((dev->descriptor.idVendor != USB_HOTKEY_VENDOR_ID) || (dev->descriptor.idProduct != USB_HOTKEY_PRODUCT_ID) || (ifnum != 1))

    {

    return NULL;

    }

    if (dev->actconfig->bNumInterfaces != 2)

    {

    return NULL;

    }

    if (interface->bNumEndpoints != 1) return NULL;

    endpoint = interface->endpoint + 0;

    pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);

    maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));

    usb_set_protocol(dev, interface->bInterfaceNumber, 0);

    usb_set_idle(dev, interface->bInterfaceNumber, 0, 0);

    printk(KERN_INFO "GUO: Vid = %.4x, Pid = %.4x, Device = %.2x, ifnum = %.2x, bufCount = %.8x\\n", dev->descriptor.idVendor,dev->descriptor.idProduct,dev->descriptor.bcdDevice, ifnum, maxp);

    if (!(kbd = kmalloc(sizeof(struct usb_kbd), GFP_KERNEL))) return NULL;

    memset(kbd, 0, sizeof(struct usb_kbd));

    kbd->usbdev = dev;

    FILL_INT_URB(&kbd->irq, dev, pipe, kbd->new, maxp > 8 ? 8 : maxp, usb_kbd_irq,kbd, endpoint->bInterval); kbd->irq.dev = kbd->usbdev;

    if (dev->descriptor.iManufacturer) usb_string(dev, dev->descriptor.iManufacturer, kbd->name, 63);

    if (usb_submit_urb(&kbd->irq)) {

    kfree(kbd); return NULL; }

    printk(KERN_INFO "input%d: %s on usb%d:%d.%d\\n", kbd->dev.number, kbd->name, dev->bus->busnum, dev->devnum, ifnum);

    return kbd; }

    static void usb_kbd_disconnect(struct usb_device *dev, void *ptr)

    {

    struct usb_kbd *kbd = ptr;

    usb_unlink_urb(&kbd->irq);

    kfree(kbd);

    }

    static struct usb_device_id usb_kbd_id_table [] = {

    { USB_DEVICE(USB_HOTKEY_VENDOR_ID, USB_HOTKEY_PRODUCT_ID) },

    { } /* Terminating entry */

    };

    MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);

    static struct usb_driver usb_kbd_driver = {

    name: "Hotkey",

    probe: usb_kbd_probe,

    disconnect: usb_kbd_disconnect,

    id_table: usb_kbd_id_table,

    NULL,

    };

    static int __init usb_kbd_init(void)

    {

    usb_register(&usb_kbd_driver);

    info(DRIVER_VERSION ":" DRIVER_DESC);

    return 0;

    }

    static void __exit usb_kbd_exit(void)

    {

    usb_deregister(&usb_kbd_driver);

    }

    module_init(usb_kbd_init);

    module_exit(usb_kbd_exit);

    三、结语

    USB规范是一门比较新的技术，接口使用方便，但是驱动程序的设计较复杂。上面介绍了USB设备驱动程序的设计，主要分析了主机端驱动程序的设计，并且给出了一个编写USB驱动程序的实例。

    参考文献

    1．刘峥嵘.嵌入式Linux应用开发详界解.机械工业出版社，2004

    2．周立功.ARM嵌入式Linux系统构件与驱动开发范例.北京航天航空大学出版社，2006

    3．刘淼.嵌入式系统接口设计与Linux驱动程序开发.北京航天航空大学出版社，2006

posted @ 2009-06-11 21:29 MEYE 阅读(560) | 评论 (0) | 编辑 收藏
仅列出标题
共10页: 上一页 1 2 3 4 5 6 7 8 9 下一页 Last 
Copyright ©2024 MEYE Powered By博客园 模板提供：沪江博客