x86驅動編譯

⑴ 為什麼x86和arm的架構不同，但是都能裝linux呢，他們的編譯時如何實現的。

rm架構和x86架構區別：

一、性能：

X86結構的電腦無論如何都比ARM結構的系統在性能方面要快得多、強得多。X86的CPU隨便就是1G以上、雙核、四核大行其道，通常使用45nm（甚至更高級）製程的工藝進行生產；

而ARM方面：CPU通常是幾百兆，最近才出現1G左右的CPU，製程通常使用不到65nm製程的工藝，可以說在性能和生產工藝方面ARM根本不是X86結構系統的對手。

但ARM的優勢不在於性能強大而在於效率，ARM採用RISC流水線指令集，在完成綜合性工作方面根本就處於劣勢，而在一些任務相對固定的應用場合其優勢就能發揮得淋漓盡致。

二、擴展能力：

X86結構的電腦採用「橋」的方式與擴展設備（如：硬碟、內存等）進行連接，而且x86結構的電腦出現了近30年，其配套擴展的設備種類多、價格也比較便宜，所以x86結構的電腦能很容易進行性能擴展，如增加內存、硬碟等。

ARM結構的電腦是通過專用的數據介面使CPU與數據存儲設備進行連接，所以ARM的存儲、內存等性能擴展難以進行（一般在產品設計時已經定好其內存及數據存儲的容量），所以採用ARM結構的系統，一般不考慮擴展。基本奉行「夠用就好」的原則。

三實現編譯：

因為linux是系統，他支持現在大多數的結構體系。而要使他移植到相應的不同的硬體平台上時，需要對內核源碼進行相對應的交叉編譯處理，然後才能進行燒寫運行，因為都有驅動只要那個系統有對應平台的驅動就可以。

(1)x86驅動編譯擴展閱讀：

Linux常用命令

1、pwd命令該命令的英文解釋為print working directory(列印工作目錄)。

2、輸入pwd命令，Linux會輸出當前目錄。

3、cd命令cd命令用來改變所在目錄。

4、cd / 轉到根目錄中

5、cd ~ 轉到/home/user用戶目錄下

6、cd /usr 轉到根目錄下的usr目錄中-------------絕對路徑

7、cd test 轉到當前目錄下的test子目錄中-------相對路徑

8、cat命令可以用來合並文件，也可以用來在屏幕上顯示整個文件的內容。

9、cat snow.txt 該命令顯示文件snow.txt的內容，ctrl+D退出cat。

⑵ 如何編譯載入linux驅動和內核模塊

linux下編譯運行驅動
嵌入式linux下設備驅動的運行和linux x86 pc下運行設備驅動是類似的，由於手頭沒有嵌入式linux設備，先在vmware上的linux上學習驅動開發。
按照如下方法就可以成功編譯出hello world模塊驅動。
1、首先確定本機linux版本
怎麼查看Linux的內核kernel版本?
'uname'是Linux/unix系統中用來查看系統信息的命令，適用於所有Linux發行版。配合使用'uname'參數可以查看當前伺服器內核運行的各個狀態。
#uname -a
Linux whh 3.5.0-19-generic #30-Ubuntu SMPTue Nov 13 17:49:53 UTC 2012 i686 i686 i686 GNU/Linux

只列印內核版本，以及主要和次要版本：
#uname -r
3.5.0-19-generic

要列印系統的體系架構類型，即的機器是32位還是64位，使用：
#uname -p
i686

/proc/version 文件也包含系統內核信息:
# cat /proc/version
Linux version 3.5.0-19-generic(buildd@aatxe) (gcc version 4.7.2 (Ubuntu/Linaro 4.7.2-2ubuntu1) ) #30-UbuntuSMP Tue Nov 13 17:49:53 UTC 2012

發現自己的機器linux版本是：3.5.0-19-generic
2、下載機器內核對應linux源碼

⑶ 怎麼用Visual Studio編譯內核驅動

在Win8以前開發內核驅動，准備編譯環境是個較繁瑣的事情。程序員需要手動下載WDK並安裝（注1），開發環境就在安裝好的WDK中。WDK是Windows Driver Kit縮寫，即Windows驅動開發包。它提供的開發環境簡陋得很，它不是一個便於開發的IDE環境，而僅僅是一些散裝的編譯工具包。

安裝好WDK後，WDK的編譯環境鏈接就顯示在開始菜單中了，要小心不能將它們刪掉，否則會麻煩，因為手動生成鏈接是麻煩事，後文會講。
編譯環境是分類的。首先根據目標系統分類，也就是要編譯生成運行在什麼OS上的目標文件。微軟大部分的產品都保持了向後兼容的習慣，這條規律也適用於此處：使用Win7子系統環境編譯出來的驅動文件，一般都能運行在Vista和XP系統上，反之就不會成立（注2）。
其次根據硬體平台分類，現在Windows系統能夠運行的平台有四個：X86，X64，IA64和ARM。其中ARM是Win8才開始的故事，這里還輪不到它出場，這樣就只有前面三個硬體平台（注3）。
最後又要根據編譯版本來分，即Checked（也可認做Debug）和Free（也可認作Release）這兩種。這樣來看，每個OS組別下面，就一定有6個編譯環境鏈接。
在這本書裡面，如果用舊版本WDK編譯驅動，就默認使用Win7目標系統的編譯環境，生成Checked版本，目標平台是X86或X64。所以就只會選兩種：X86 Checked Build Environment和X64 Checked Build Environment.
編譯環境打開來其實就是個控制台。它當然不同於直接從cmd.exe運行起來的控制台環境，區別在哪裡呢？我們已經知道，上圖的這些黑色的編譯環境圖標，其實都是快捷方式。不妨就看看它的快捷方式的Target內容，或許就知道端倪了。以X64 Checked Build Environment這個環境為例，打開來看到如下內容：
C:\Windows\System32\cmd.exe /k C:\WinDDK\7600.16385.1\bin\setenv.bat C:\WinDDK\7600.16385.1\ chk x64 WIN7
這一行內容仔細一看就很簡單了。原來所謂的編譯環境，就是一個運行cmd.exe的控制台進程，只不過它執行了用於初始化的/k參數。在Cmd.exe命令的幫助中，/k參數是這樣描述的：Carries out the command specified by string but remains（執行一個命令，執行完之後不退出程序）。也就是說，啟動控制台進程並執行命令，執行完後，控制台程序留給用戶繼續使用。
那麼/k之後的所有內容，都是一條初始化的命令：
C:\WinDDK\7600.16385.1\bin\setenv.bat C:\WinDDK\7600.16385.1\ chk x64 WIN7
它卻又可拆成幾個部分來分析。第一個setenv.bat是初始化編譯環境的批文件。後面的是它的參數：第一個參數，是WDK的路徑，通過它可以找到編譯器程序；第二個參數是指明要編譯生成checked版本目標文件；第三個指明硬體平台是x64；第三個指明目標系統是Win7。
位於WDK中的Setenv.bat文件是負責編譯環境配置的總廚，你把什麼參數遞給它，它就給你配出什麼類型的編譯環境來（菜也）。
怎麼在這個控制台裡面編譯驅動呢？我們統一用使用以下步驟：

通過CD命令，定位到含有source文件的那個驅動目錄；
輸入build或bld（build –cz的簡寫）命令進行編譯；
如果編譯成功，將生成驅動文件，否則會有錯誤或警告信息顯示出來；也可通過查看目錄文件夾下面的相關log文件查看詳細的錯誤或警告信息。

走到這里，編譯的事情算弄明白了。可能還會有朋友問我，我用什麼東西寫代碼呢？不好意思，關於這個問題，此時還沒有康莊大道供大家駟馬高車，不過千萬條小路卻是現成的。您可以用notepad記事本或者任何文本編輯器來編輯代碼，如果不嫌麻煩，用Visual Studio寫代碼也可以，只不過僅作代碼編輯而已。

⑷ vs2015驅動開發編譯錯誤

樓主 你解決了嗎 我也遇到這樣的問題 好煩人 以前都沒有遇到過

⑸ android 移植到x86 怎麼移植驅動 有沒有詳細的教程 要有實例的 感謝

基本上來說，你直接下個android-x86版本的源代碼，編譯成ISO鏡像就可以了，別人都已經做好了的。或者你乾脆下個android-liveCD，直接可以在電腦上跑的

⑹ 如何編譯一個linux下的驅動模塊

linux下編譯運行驅動
嵌入式linux下設備驅動的運行和linux x86 pc下運行設備驅動是類似的，由於手頭沒有嵌入式linux設備，先在vmware上的linux上學習驅動開發。
按照如下方法就可以成功編譯出hello world模塊驅動。
1、首先確定本機linux版本
怎麼查看Linux的內核kernel版本?
'uname'是Linux/unix系統中用來查看系統信息的命令，適用於所有Linux發行版。配合使用'uname'參數可以查看當前伺服器內核運行的各個狀態。
#uname -a
Linux whh 3.5.0-19-generic #30-Ubuntu SMPTue Nov 13 17:49:53 UTC 2012 i686 i686 i686 GNU/Linux

只列印內核版本，以及主要和次要版本：
#uname -r
3.5.0-19-generic

要列印系統的體系架構類型，即的機器是32位還是64位，使用：
#uname -p
i686

/proc/version 文件也包含系統內核信息:
# cat /proc/version
Linux version 3.5.0-19-generic(buildd@aatxe) (gcc version 4.7.2 (Ubuntu/Linaro 4.7.2-2ubuntu1) ) #30-UbuntuSMP Tue Nov 13 17:49:53 UTC 2012

發現自己的機器linux版本是：3.5.0-19-generic
2、下載機器內核對應linux源碼
到下面網站可以下載各個版本linux源碼https://www.kernel.org/
如我的機器3.5.0版本源碼下載地址為：https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.5.tar.bz2
下載完後，找一個路徑解壓，如我解壓到/linux-3.5/
然後很重要的一步是：執行命令uname -r，可以看到Ubuntu的版本信息是3.5.0-19-generic
。進入linux源碼目錄，編輯Makefile，將EXTRAVERSION = 修改為EXTRAVERSION= -19-generic。
這些都是要配置源碼的版本號與系統版本號，如果源碼版本號和系統版本號不一致，在載入模塊的時候會出現如下錯誤：insmod: error inserting 'hello.ko': -1 Invalid mole format。
原因很明確：編譯時用的hello.ko的kenerl 不是我的pc的kenerl版本。

執行命令cp /boot/config-3.5.0-19-generic ./config，覆蓋原有配置文件。
進入linux源碼目錄，執行make menuconfig配置內核，執行make編譯內核。

3、寫一個最簡單的linux驅動代碼hello.c

/*======================================================================
Asimple kernel mole: "hello world"
======================================================================*/
#include <linux/init.h>
#include <linux/mole.h>
MODULE_LICENSE("zeroboundaryBSD/GPL");
static int hello_init(void)
{
printk(KERN_INFO"Hello World enter\n");
return0;
}

static void hello_exit(void)
{
printk(KERN_INFO"Hello World exit\n ");
}

mole_init(hello_init);
mole_exit(hello_exit);

MODULE_AUTHOR("zeroboundary");
MODULE_DESCRIPTION("A simple HelloWorld Mole");
MODULE_ALIAS("a simplestmole");

4、寫一個Makefile對源碼進行編譯
KERN_DIR = /linux-3.5
all:
make-C $(KERN_DIR) M=`pwd` moles
clean:
make-C $(KERN_DIR) M=`pwd` clean

obj-m += hello.o

5、模塊載入卸載測試
insmod hello.ko
rmmod hello.ko

然後dmesg|tail就可以看見結果了

最後，再次編譯驅動程序hello.c得到hello.ko。執行insmod ./hello.ko，即可正確insert模塊。

使用insmod hello.ko 將該Mole加入內核中。在這里需要注意的是要用 su 命令切換到root用戶，否則會顯示如下的錯誤：insmod: error inserting 'hello.ko': -1 Operation not permitted

內核模塊版本信息的命令為modinfo hello.ko
通過lsmod命令可以查看驅動是否成功載入到內核中
通過insmod命令載入剛編譯成功的time.ko模塊後，似乎系統沒有反應，也沒看到列印信息。而事實上，內核模塊的列印信息一般不會列印在終端上。驅動的列印都在內核日誌中，我們可以使用dmesg命令查看內核日誌信息。dmesg|tail

可能還會遇到這種問題insmod: error inserting 'hello.ko': -1 Invalid mole format
用dmesg|tail查看內核日誌詳細錯誤
disagrees about version of symbolmole_layout，詳細看這里。
http://www.ibm.com/developerworks/cn/linux/l-cn-kernelmoles/index.html
在X86上我的辦法是：
make -C/usr/src/linux-headers-3.5.0-19-generic SUBDIRS=$PWD moles

⑺ 怎麼編譯linux x86

首先你需要設置一下emulator工具的目錄之類的，這個不細說了，
要在.bashrc中新增環境變數，如下
ANDROID_PRODUCT_OUT=~/android/out/target/proct/generic
ANDROID_PRODUCT_OUT_BIN=~/android/out/host/linux-x86/bin
這里是設置你的輸出文件的位置和bin工具目錄，不用多解釋吧？
然後在命令行輸入：
export PATH=${PATH}:${ANDROID_PRODUCT_OUT_BIN}:${ANDROID_PRODUCT_OUT};
上面是導入了相關的配置，然後使之生效。
source ~/.bashrc
接著切換到輸出的system文件夾
cd ~/android/out/target/proct/generic
然後來創建模擬器
emulator -system system.img -data userdata.img -ramdisk ramdisk.img
如果你運氣夠好的話，也許現在已經在運行了，不過我運氣明顯不夠好。
提示一：
emulator: ERROR: You did not specify a virtual device name, and the system
directory could not be found.
If you are an Android SDK user, please use 『@<name>』 or 『-avd <name>』
to start a given virtual device (see -help-avd for details).
Otherwise, follow the instructions in -help-disk-images to start the emulator

既然人家提示了，那就按照步驟走吧，輸入命令：
emulator -help-avd
接著提示如下：
use 『-avd <name>』 to start the emulator program with a given Android
Virtual Device (a.k.a. AVD), where <name> must correspond to the name
of one of the existing AVDs available on your host machine.
See -help-virtual-device to learn how to create/list/manage AVDs.
As a special convenience, using 『@<name>』 is equivalent to using
『-avd <name>』.
跟著提示繼續走，輸入命令：
emulator -help-virtual-device
又是提示了：
An Android Virtual Device (AVD) models a single virtual
device running the Android platform that has, at least, its own
kernel, system image and data partition.
Only one emulator process can run a given AVD at a time, but
you can create several AVDs and run them concurrently.
You can invoke a given AVD at startup using either 『-avd <name>』
or 『@<name>』, both forms being equivalent. For example, to launch
the AVD named 『foo』, type:
emulator @foo
The 『android』 helper tool can be used to manage virtual devices.
For example:
android create avd -n <name> -t 1 # creates a new virtual device.
android list avd # list all virtual devices available.
Try 『android –help』 for more commands.
Each AVD really corresponds to a content directory which stores
persistent and writable disk images as well as configuration files.
Each AVD must be created against an existing SDK platform or add-on.
For more information on this topic, see -help-sdk-images.

⑻ （pc安裝）安卓x86，如何安裝無線網卡驅動linux版

最佳答案 tar.gz（bz或bz2等） 一、安裝 1、打開一個SHELL，即終端 2、用cd 命令進入源代碼壓縮包所在的目錄 3、根據壓縮包類型解壓縮文件(*代表壓縮包名稱) tar -zxvf ****.tar.gztar -jxvf ****.tar.bz(或bz2) 4、用CD命令進入解壓縮後的目錄 5、輸入編譯文件命令：./configure（有的壓縮包已經 編譯過，這一步可以省去） 6、然後是命令：make 7、再是安裝文件命令：make install 8、安裝完畢

⑼ 最近研究了一下Android x86想了解一下，能不能把nvidia的linux驅動編譯進Android x86

理論可以，實際上很困難。android只是用了linux的底層內核，與當前的LINUX發行版相比差了太多，需要很復雜的編譯知識，要藉助很多API，LZ沒有到一定境界的話還是算了。NVIDIA將來在TRGEA的影響下會出驅動的。

⑽ x86架構下linux驅動編程 看什麼書

編寫好驅動,通過掛載的方法將驅動程序掛載到內核裡面,大致步驟如下:
一: 1>建立以.c為後綴的c語言程序文件(裡麵包含了設備名及設備號等)
2>建立Makefile文件(作用是通過make來產生設備文件*.ko文件,裡面可以建立自己的平台所需的設備文件如:arm等).make產生相應的設備文件
二: 要在/dev下建立相應的設備結點(設備名),用insomd *.ko命令將相應的驅動設備文件掛載到內核中.
三:編寫測試文件(.c文件)用來測試內核是否已近成功掛載到內核.(編寫好相應的測試文件後,用gcc –o Filename Filename.c(測試文件名)來產生相應的可執行文件).
四:如果設備驅動掛載成功,當執行測試文件(./Filename)時會產生相應的結果.

五:可能用到的相關命令:
1.lsmod:列出內核已經載入模塊的專題.
輸出:
Mole(模塊名)size(大小)used by (被..使用)
2.demop:分析可載入模塊的依賴性,生成moles.dep文件和映射文件
3.uname –r 顯示內核版本(在編寫Makefile時使用到)
4.modprobe : linux內核添加和刪除模塊(相關參數請查看man幫助文檔)
5.modinfo:顯示內核模塊的信息.
6.insmod: 向linux內核中載入一個模塊,用法:insmod[filename] [mole options…]
7.rmmod: 刪除內核中的模塊, 用法: rmmod [-f,w,s,v][molename]
8.dmesg: 顯示內核緩沖區,內核的各種信息,內核啟動時的信息會寫入到/var/log/下.

六.例子1:
第一步：增加頭文件和宏定義
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/mole>
#include <linux/kernel>

第二步：添加與字元設備定義及注冊有關的數據成員
//定義設備名稱
#define DEVICE_NAME "test" //設備名
#define BUF_SIZE 1024
static char tmpbuf[BUF_SIZE];

//定義主次設備號
static unsigned int TestMajor=0; //主
static unsigned int TestMinor=0; //次

static struct cdev *test_cdev;
static dev_t dev;

第三步：增加open/release函數

static int test_chardev_open(struct inode *inode,struct file *file)
{
printk("open major=%d, minor=%d\n", imajor(inode),
iminor(inode));
return 0;
}

static int test_chardev_release(struct inode *inode,struct file *file)
{
printk("close major=%d,minor=%d\n",imajor(inode),
iminor(inode));
return 0;
}

第四步：增加read函數
static ssize_t test_chardev_read(struct file *file,char __user *buf,
size_t const count,loff_t *offset)
{
if(count < BUF_SIZE)
{
if(_to_user(buf,tmpbuf,count))
{
printk(" to user fail \n");
return -EFAULT;
}
}else{
printk("read size must be less than %d\n", BUF_SIZE);
return -EINVAL;
}
*offset += count;
return count;
}

第五步：增加write函數
static ssize_t test_chardev_write(struct file *file, const char __user*buf,size_t const count,loff_t *offset)
{
if(count < BUF_SIZE)
{
if(_from_user(tmpbuf,buf,count))
{
printk(" from user fail \n");
return -EFAULT;
}
}else{

printk("size must be less than %d\n", BUF_SIZE);
return -EINVAL;
}
*offset += count;
return count;
}

第六步：添加增加file_operations成員

static struct file_operations chardev_fops={
.owner = THIS_MODULE,
.read = test_chardev_read,
.write = test_chardev_write,
.open = test_chardev_open,
.release = test_chardev_release,
};

第七步：在模塊的入口添加設備的設備號獲取及設備注冊
static int __init chrdev_init(void)
{
int result;

if(TestMajor)
{
dev=MKDEV(TestMajor,TestMinor);//創建設備編號
result=register_chrdev_region(dev,1,DEVICE_NAME);
} else {
result=alloc_chrdev_region(&dev,TestMinor,1,DEVICE_NAME);
TestMajor=MAJOR(dev);
}
if(result<0)
{
printk(KERN_WARNING"LED: cannot get major %d \n",TestMajor);
return result;
}

test_cdev=cdev_alloc();
cdev_init(test_cdev,&chardev_fops);
//test_cdev->ops=&chardev_fops;
test_cdev->owner=THIS_MODULE;
result=cdev_add(test_cdev,dev,1);
if(result)
printk("<1>Error %d while register led device!\n",result);

return 0;
}

第八步：在模塊的出口函數增加設備設備號釋放及設備注銷函數

unregister_chrdev_region(MKDEV(TestMajor,TestMinor),1);
cdev_del(test_cdev);

第九步：編譯並載入該模塊

第十步：根據設備號的設置，在文件系統中建立對應的設備節點
#mknod /dev/test c XXX XX

例子2:
驅動文件:
#include <linux/init.h>
#include <linux/mole.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/uaccess.h>

#define DEVICENAME "ccccc"

unsigned int major=221;
unsigned int minor=0;
struct cdev *abc;
dev_t dev;
static char bufrh[1024]="read success!";

static int aaaaa_open(struct inode *inodep, struct file *filep)
{
printk("read success!\n");
return 0;
}

int aaaaa_release(struct inode *inodep, struct file *filep)
{
return 0;
}
static ssize_t aaaaa_read (struct file *filep, char __user *buf, size_tcount, loff_t *offset)
{
if(_to_user(buf, bufrh, 1))
{
printk("_to_user fail!\n");
}
return 0;
}

ssize_t aaaaa_write (struct file *filep, const char __user *buf,size_t count, loff_t *offse)
{
printk("write!\n");
return 0;
}

static const struct file_operations fops = {
.owner = THIS_MODULE,
.open = aaaaa_open,
.release = aaaaa_release,
.read = aaaaa_read,
.write = aaaaa_write,

};

static int __init aaaaa_init(void)
{
int a;
dev=MKDEV(major, minor);
a=register_chrdev_region(dev, 1, DEVICENAME);

abc=cdev_alloc();
abc->owner=THIS_MODULE;
cdev_init(abc, &fops);

cdev_add(abc, dev, 1);

return 0;
}

static void __exit aaaaa_cleanup(void)
{
cdev_del(abc);
unregister_chrdev_region(dev, 1);
}

mole_init(aaaaa_init);
mole_exit(aaaaa_cleanup);
MODULE_LICENSE("GPL ");

Makefile文件:

obj-m += firstqd.o(相應設備文件名)

KERDIR = /usr/src/linux-headers-2.6.32-24-generic
#KERDIR=/home/linux2.6/linux #arm騫沖彴
PWD=$(shell pwd)

moles:
$(MAKE) -C $(KERDIR) M=$(PWD)moles

pc:
gcc -o fristqd firstqd.c
arm:
arm-linux-gcc -o fristqd firstqd.c

clean:
rm -rf *.o *~core *.depend *.cmd *.ko *.mod.c *.tmp_versions

測試文件(test.c):

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>

char buf[1024];
char bufw[1024]="write success";
int main()
{
int fd,m,n;
fd=open("/dev/aaa",O_RDWR);
if (fd)
{
m=read(fd,buf,100);
printf("read kernel:%s\n",buf);

n=write(fd,bufw,10);
}
//printf("ni hao");
return 0;

}