Linux内核为每种设备都抽象出了框架,开发人员只需往框架中填充信息即可进行设备的注册。下面来讲解一下Linux内核的misc框架。
misc又叫杂散类设备,在早期的内核中,向ADC、WATCHDOG、PWM等设备都没有一个明确的框架,于是这些设备就都归类到了misc框架。在后来内核版本中才逐步完善各种设备框架。下面就来简单了解一下misc设备的框架,以及使用misc框架来写一个测试驱动。

    misc框架代码

static int __init misc_init(void)
{
    int err;

#ifdef CONFIG_PROC_FS
    proc_create("misc", 0, NULL, &misc_proc_fops);
#endif
    misc_class = class_create(THIS_MODULE, "misc");  // 创建类,类名叫misc
    err = PTR_ERR(misc_class);
    if (IS_ERR(misc_class))
        goto fail_remove;

    err = -EIO;
    if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))  // 注册misc字符设备,设备号是10
        goto fail_printk;
    misc_class->devnode = misc_devnode;
    return 0;

fail_printk:
    printk("unable to get major %d for misc devices\n", MISC_MAJOR);
    class_destroy(misc_class);
fail_remove:
    remove_proc_entry("misc", NULL);
    return err;
}

  

misc_init函数是初始化misc框架,首先会先创建一个叫misc的类,然后在这个类中注册一个叫misc的设备,设备号是10。


可以看到在内核中,通过命令可以查看misc设备的主设备号是10,在class中有一个叫misc的类。

 

 

int misc_register(struct miscdevice * misc)
{
    dev_t dev;
    int err = 0;

    INIT_LIST_HEAD(&misc->list);

    mutex_lock(&misc_mtx);

    if (misc->minor == MISC_DYNAMIC_MINOR) { // 判断次设备是否为255,如果是就自动分配次设备号,否则就使用开发人员传进来的次设备号
        int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS);
        if (i >= DYNAMIC_MINORS) {
            err = -EBUSY;
            goto out;
        }
        misc->minor = DYNAMIC_MINORS - i - 1;
        set_bit(i, misc_minors);
    } else {
        struct miscdevice *c;

        list_for_each_entry(c, &misc_list, list) {
            if (c->minor == misc->minor) {
                err = -EBUSY;
                goto out;
            }
        }
    }

    dev = MKDEV(MISC_MAJOR, misc->minor); // 将主设备号和次设备号进行合并得到设备号

    misc->this_device =
        device_create_with_groups(misc_class, misc->parent, dev,
                      misc, misc->groups, "%s", misc->name); // 创建设备
    if (IS_ERR(misc->this_device)) {
        int i = DYNAMIC_MINORS - misc->minor - 1;
        if (i < DYNAMIC_MINORS && i >= 0)
            clear_bit(i, misc_minors);
        err = PTR_ERR(misc->this_device);
        goto out;
    }

    /*
     * Add it to the front, so that later devices can "override"
     * earlier defaults
     */
    list_add(&misc->list, &misc_list);
 out:
    mutex_unlock(&misc_mtx);
    return err;
}

 
 

misc_register是内核提供给开发人员的注册misc设备的接口函数。该函数主要做了两件事情,首先判断次设备号是否需要自动分配,然后调用device_create_with_groups注册设备。

struct miscdevice  {
    int minor;  // 次设备号
    const char *name;  // 设备名字
    const struct file_operations *fops;  // 字符设备操作函数
    struct list_head list;               // 链表头
    struct device *parent;               // 父设备
    struct device *this_device;
    const struct attribute_group **groups;
    const char *nodename;
    umode_t mode;
};

   

struct miscdevice结构体需要开发者对里面的成员变量进行填充,填充完之后调用misc_register注册设备。

下面来写一个简单的misc设备驱动。
驱动程序

struct miscdevice led_misc;  // 定义misc结构体变量

ssize_t chrdev_read (struct file *file, char __user *usr, size_t size, loff_t *loff)
{
    printk("%s\r\n",__func__);
    return 0;
}
int chrdev_open (struct inode *inode, struct file *file)
{
    printk("%s\r\n",__func__);
    return 0;
}
int chrdev_release (struct inode *inode, struct file *file)
{
    printk("%s\r\n",__func__);
    return 0;
}
struct file_operations led_fops =
{
    .open    = chrdev_open,
    .read    = chrdev_read,
    .release = chrdev_release,
};


static int __init chrdev_init(void)
{
    int ret = 0;

    led_misc.minor = MISC_DYNAMIC_MINOR; // 自动分配次设备号
    led_misc.name = "led_misc_dev";      // 设备名
    led_misc.fops = &led_fops;           // 关联文件操作函数
    
    misc_register(&led_misc);           // 注册设备
    
    return 0;
}


static void __exit chrdev_exit(void)
{
    misc_deregister(&led_misc);
    
}

module_init(chrdev_init);
module_exit(chrdev_exit);

MODULE_DESCRIPTION("xxxxxx");
MODULE_AUTHOR("xxxxxx");
MODULE_LICENSE("GPL");

   
  


可以看到驱动程序使用misc框架注册设备非常简单,不用再关心主设备号,次设备号,不用再自己去注册类,然后再注册设备。因为misc框架已经帮我们把这些东西全部都搭建好了,我们需要做的就是填充struct miscdevice结构体,然后调用misc_register函数就可以完成注册。
 




1、什么是misc设备?

misc是英文的简称,中文名一般叫做杂项设备/杂散设备。

我们知道大部分的设备都有一个明确的分类class,有一些设备进行分类时不太好分,我们不知道一些设备到底应该分到哪一类设备中去,所以最后将这些不知道分到哪类中的设备给分到misc设备中,也就是分到了杂散类中。像蜂鸣器还有ADC设备都被分到了misc设备杂散类设备中。杂散类设备对应的是一个类的概念。随意进到系统中的/sys/class目录中就会看到一个misc目录,这个misc就是杂散类设备,进入到misc目录中,我们可以看到很多设备被丢入到了杂散类设备中。

348130566a987f10b3ecb96cacecf2e3.png

其实led也可以丢到misc杂散类设备中的,像buzzer也可以放到别的设备类中,所以这种东西并不是一定的,有些人就是不按照常规做事,见到时也不要奇怪。

杂散类设备是典型的字符设备,所以归到misc杂散类设备中的全部都是字符类设备。在后面我们也会看到misc杂散类设备本身就是被作为字符设备来来注册到内核中的,主设备号是10,是固定的表示misc设备,次设备号才是来区分具体杂散类设备的。比如九鼎的蜂鸣器驱动的主设备号是10,次设备号是61,adc驱动的主设备号是10,次设备号是131.就像我们以前实现led的驱动一样,我们将板子上的四个led都归到了leds类中了,每个led的主设备号都是一样,次设备号是不一样的,主设备号一样表示同一类,次设备号不一样表示这类设备中的不同个体,来进行区分led1,led2,led3,led4。杂散类设备的主设备号就是10.

想要自动创建设备文件节点,就需要用udev或者mdev,想要udev或者mdev自动创建设备文件节点给一些设备驱动,那么就要将这些设备驱动给归到一个class设备驱动类中。内核之所以发明misc杂散类设备就是为将一些不知道该怎么归类的设备给放到misc中,将来创建设备节点的时候,可以使用udev或者mdev的机制来进行创建,不需要自己手动的去mknode创建设备文件节点,以及在驱动代码中进行创建类等。我们只需要创建设备类就行。

misc有一套驱动框架,内核实现了一部分(misc.c,在/drvier/char/misc/misc.c),驱动实现了一部分(x210-buzzer.c,这部分就是调用misc驱动框架中内核实现的那部分中的misc_register函数来进行创建设备,Misc_register函数中间接的调用了device_create函数创建设备)。内核实现的一部分中就创建出了misc类,我们驱动开发者只需要调用内核实现的接口misc_register函数,从而间接的调用device_create函数创建设备。我们只需要创建设备,misc类已经不用我恩去创建了。misc类已经由misc驱动框架提供了。

misc设备其实就是一种字符设备。很多典型的字符设备都可以归到misc设备中。




Linux驱动框架之misc类设备驱动框架

1、何为misc设备

(1)misc中文名就是杂项设备杂散设备,因为现在的硬件设备多种多样,有好些设备不好对他们进行一个单独的分类,所以就将这些设备全部归属于

杂散设备,也就是misc设备,例如像adc、buzzer等这些设备一般都归属于misc中。

(2)需要注意的是,虽然这些设备归属于杂散设备中,但是其实你也可以不把设备放在这个类中,这都是驱动工程师按照自己的想法做的,你想把他们写在

misc类设备中也可以,自己单独建立一个类也是可以的,只不过是否标准化而已,因为人家既然建立了这个类,那你就把这个设备放在这个类下,不是很好吗?

你还自己单独搞一个类,虽然这也没错,只不过是说你不按套路出牌。

(3)所有的misc类设备都是字符设备,也就是misc类设备其实是字符设备中分出来的一个小类。

(4)misc类设备在应用层的操作接口:/dev/xxxx,  设备类对应在 /sys/class/misc 

(5)misc类设备有自己的一套驱动框架,所以我们写一个misc设备的驱动直接利用的是内核中提供的驱动框架来实现的。misc驱动框架是对内核提供的原始的字符设备

注册接口的一个类层次的封装,很多典型的字符设备都可以归于misc设备,都可以利用misc提供的驱动框架来编写驱动代码,通过misc驱动框架来进行管理。

2、misc驱动框架源码分析

在内核中,misc驱动框架的源码实现在:  driver/char/misc.c    相应的头文件在:include/linux/miscdevice.h

但是如果我们自己添加的misc类设备,那么驱动源文件最好放在 driver/misc 这个目录下,这个目录是官方推荐的目录

misc驱动框架和之前的led的驱动框架都是实现为一个模块的形式,在内核配置的时候可以进行动态的编译或者是不编译进内核当中。这样做的一个好处就是能够对内核

进行一个最大化的裁剪,将不需要的模块统统拿掉,能够使得内核在满足要求的情况下实现最小化。

(1)一个重要的结构体 struct miscdevice

 
 struct miscdevice  {
     int minor;                                        //    次设备号
     const char *name;                           //    名字 
     const struct file_operations *fops; //     file_operations 结构体指针
     struct list_head list;                        //     作为一个链表节点挂接到misc设备维护的一个链表头上去    misc_list
     struct device *parent;                    //     次设备的父设备
     struct device *this_device;            //      本设备的device 结构体指针
     const char *nodename;              
     mode_t mode;
 };

(2)misc_init函数分析

misc_init函数是misc驱动框架模块注册时的一个初始化函数,只有执行了初始化,我们才能够利用misc提供的框架来进行编写misc设备驱动程序和管理misc类设备。

misc_init函数是misc驱动框架的入口函数。

 
 static int __init misc_init(void)
 {
     int err;
 
 #ifdef CONFIG_PROC_FS      /* CONFIG_PROC_FS用来控制我们的系统中是否需要proc虚拟文件系统 */
     proc_create("misc", 0, NULL, &misc_proc_fops);   /*在proc文件系统下创建一个名为 misc 的文件*/ 
 #endif
     misc_class = class_create(THIS_MODULE, "misc");  /*在sys文件系统下创建 misc 设备类*/ 
     err = PTR_ERR(misc_class);
     if (IS_ERR(misc_class))
         goto fail_remove;
 
     err = -EIO;
     if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))  /*注册misc 字符设备  主设备号10   misc_fops*/
         goto fail_printk;
     misc_class->devnode = misc_devnode;
     return 0;
 
 fail_printk:
     printk("unable to get major %d for misc devices
", MISC_MAJOR);
     class_destroy(misc_class);
 fail_remove:
     remove_proc_entry("misc", NULL);
     return err;
 }

proc文件系统在2.4版本中用的比较流行,现在主要用的就是sys文件系统,因为sys文件系统比proc文件系统做的更好,功能更加齐全,目录层次设计的很好

所以现在proc文件系统成为了一个可以选择添加或者删除的一个选项了,可以通过在内核配置的时候进行相应的配置。

(2)misc_register函数与misc_deregister函数

misc_register函数是misc驱动框架提供给驱动工程师编写misc类设备时的注册函数,一个重要的接口,misc_deregister就是相对应的卸载函数

 
 int misc_register(struct miscdevice * misc)
 {
     struct miscdevice *c;               //  定义一个 miscdevice  结构体指针
     dev_t dev;                               //   设备号
     int err = 0;
 
     INIT_LIST_HEAD(&misc->list);      //  初始化链表
 
     mutex_lock(&misc_mtx);               //  上锁
     list_for_each_entry(c, &misc_list, list) {    //  遍历  misc_list 链表  查找是否存在次设备号与当前注册的设备的次设备号相同的
         if (c->minor == misc->minor) {
             mutex_unlock(&misc_mtx);
             return -EBUSY;     //    如果存在直接退出
         }
     }
 
     if (misc->minor == MISC_DYNAMIC_MINOR) {  //   misc->minor ==  255 表示 自动分配次设备号 
         int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS);   //  在我们的misc类设备的驱动框架中使用了一种位来表示次设备号是否被占用的情况
         if (i >= DYNAMIC_MINORS) {                           //  使用8个字节的一个变量来表示,这个数据的每一位表示一个次设备号,
             mutex_unlock(&misc_mtx);                       //   第一位代表次设备号0   第二位代表次设备号1  .......         如果这个位被置1表示已经被分配出去了,置0表示没有被分配出去
             return -EBUSY;                                         //  所以这段代码就是在找一个最小的没有被使用被置1的位,
         }                                                                        //   由此可知misc类设备最多只有64个
         misc->minor = DYNAMIC_MINORS - i - 1;    //  我们这里的意思就是我们是从小到大去寻找,那么分配就是从大到小,例如: i=0 ,minor=63   i =1,minor=62
         set_bit(i, misc_minors);                                    //  然后将该位置1
     }
 
     dev = MKDEV(MISC_MAJOR, misc->minor);      //  使用主次设备号合成设备号
 
     misc->this_device = device_create(misc_class, misc->parent, dev,        //   创建设备   /sys/devices/virtual/misc/xxx   
                       misc, "%s", misc->name);
     if (IS_ERR(misc->this_device)) {
         int i = DYNAMIC_MINORS - misc->minor - 1;
         if (i < DYNAMIC_MINORS && i >= 0)
             clear_bit(i, misc_minors);
         err = PTR_ERR(misc->this_device);
         goto out;
     }
 
     /*
      * Add it to the front, so that later devices can "override"
      * earlier defaults
      */
     list_add(&misc->list, &misc_list);     //  将 misc->list 作为节点挂接到 misc_list   链表上去
  out:
     mutex_unlock(&misc_mtx);
     return err;
 }

(2.1)misc_list是misc驱动框架中提供的用来挂载所有的已经注册的misc设备的一个链表,当我们 cat  /proc/misc 时查看系统中注册的所有misc类设备就是通过遍历

这个链表来实现的。与字符设备的用数组管理的方式一定要区分开来,misc设备的主设备号在这个数组中也占有一个位置,不要将他们之间的关系脱离了。

(2.2)对代码中宏的解析

       #define LIST_HEAD_INIT(name) { &(name), &(name) }
       #define LIST_HEAD(name)
       struct list_head name = LIST_HEAD_INIT(name)

原式子:static LIST_HEAD(misc_list);
展开后:static struct list_head misc_list = { &(misc_list), &(misc_list) }      // 其实就是定义了一个链表,next指针和prev指针都指向本身

3、一些需要注意的细节部分

(1)misc_init函数中调用的注册字符设备的函数 register_chrdev 

register_chrdev(MISC_MAJOR,"misc",&misc_fops),从这里可以看出来 misc_fops 就是传入的一个file_operations结构体,之前说过了这个结构体在注册

字符设备时的一个重要性,这里就不再重复了,misc_fops 如下:

    static const struct file_operations misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open,                       
    };

从上面可以看出来结构体中只实现了open函数,而没有实现其他的函数,因为具体的驱动实现的open、read、write函数在他们的file_operations结构体中,并不在这里实现,

我们需要通过这里的open函数去找到具体的要打开的硬件设备,然后找到他下面的file_operations结构体,调用结构体中实现的open函数,并且将要打开的设备的file_operations结构体替换当前要操作的这个结构体,之后我们就可以通过这个结构体来调用设备的其他操作函数,例如read、write....等函数。

为什么会有这样的一种操作模式呢?  其原因就是字符设备的管理的问题,调用register_chrdev函数一次就是注册了一个设备组,而这一个设备组共用了一个file_operations,所以打开这个

设备组中的任何一个设备节点最开始是对应到这个共用的file_operations,所以我们需要通过这个file_operations中的函数找到我们需要正真打开的设备的对应函数。

先来看看misc_open函数:

 
 static int misc_open(struct inode * inode, struct file * file)
 {
     int minor = iminor(inode);                  //   由传进了的inode结构体找到设备的次设备号     inode结构体之前说了它里面有一个元素记录的就是设备号,由上层传下来的,之前已经讲过
     struct miscdevice *c;                  //  定义一个miscdevice指针
     int err = -ENODEV;
     const struct file_operations *old_fops, *new_fops = NULL;       //  定义两个file_operations指针
 
     mutex_lock(&misc_mtx);       //  互斥锁上锁
 
     list_for_each_entry(c, &misc_list, list) {   //  遍历我们的misc_list链表找到次设备号与当前需要打开的设备的次设备号相同的
         if (c->minor == minor) {                           
             new_fops = fops_get(c->fops);     //  然后    获取这个设备的fops结构体  放入new_fops
             break;
         }
     }
 
     if (!new_fops) { //  这里是错误校验
         mutex_unlock(&misc_mtx);
         request_module("char-major-%d-%d", MISC_MAJOR, minor);
         mutex_lock(&misc_mtx);
 
         list_for_each_entry(c, &misc_list, list) {
             if (c->minor == minor) {
                 new_fops = fops_get(c->fops);
                 break;
             }
         }
         if (!new_fops)
             goto fail;
     }
 
     err = 0;
     old_fops = file->f_op;          //  将file中的fops先放在 old_fops ,  这是用来以免后面出错的时候能够恢复的一种手段
     file->f_op = new_fops;       //  将我们的获取到的fops放入 file->fops中,也就是替换   那么之后操作file时,对应的就是我们上面获取到的具体的设备的fops
     if (file->f_op->open) { //  如果我们的open函数存在
         file->private_data = c;      //  将miscdevice变量指针c作为 file的私有数据
         err=file->f_op->open(inode,file);      //  打开次设备的open函数
         if (err) {
             fops_put(file->f_op);
             file->f_op = fops_get(old_fops);
         }
     }
     fops_put(old_fops);
 fail:
     mutex_unlock(&misc_mtx);
     return err;



我的第一个 Linux 驱动—— misc 驱动

1. 为什么选择 misc 驱动

我认为,misc驱动是最简单的字符设备驱动,内核封装了很多的接口,我们只需调用就可以了。

这里,我基于前面文章的 reserved memory 模拟一个字符设备,然后实现一个基本的 misc 驱动框架,后面再向其中添加功能。

2. misc 驱动框架介绍

misc——miscellaneous,译为杂项。众所周知,Linux 中的驱动是分层设计的,每个设备都有自己的归属类型,比如键盘为输入设备,属于 input 子系统。但是会存在一些设备无法简单被划分到某一类中,此时可以基于 misc 驱动框架实现该设备的驱动。misc 驱动为不知类型的设备提供一个框架,方便对应设备驱动的开发。

3. misc 驱动框架特点

  1. misc 驱动为字符设备驱动;

  2. 主设备号为 10;

  3. 简单易用。无需主动调用 register_chrdev_region()、cdev_add() 等函数,只需调用 misc_register() 即可完成次设备号的分配和设备文件的创建工作;

  4. 使用 platform 总线实现 misc 驱动和设备的绑定。

4. 驱动文件中包含的内容

编写 Linux 驱动时,我认为应该实现如下基本内容:

  1. int __init xxx_init(void)
    ,用于向内核中的总线注册驱动,同时添加驱动模块到内核;

  2. void __exit xxx_exit(void)
    , 用于从内核中删除驱动;

  3. struct file_operations fops
    ,定义设备支持的操作;

  4. 定义驱动,比如struct platform_driver
    ,其中包括了设备发现后调用的 probe() 函数、与设备树中的节点进行匹配时使用的 compatible。

5. 编写 reserved-memory misc 驱动

5.1 说明

我用这篇文章中的预留内存,将预留内存模拟为一个字符设备,然后向该设备中写入和读取数据。需要实现的内容如下:

  1. 设备树:

    a. 预留内存;

    b. 自定义 compatible;

    c. 设备树中创建设备节点,节点使用自定义 compatible;

  2. 驱动文件:

    a. 实现 int __init xxx_init()
    和 void __exit xxx_exit()
    ;

    b. 定义 struct miscdevice
    ,给其中的 name、minor、fops 赋值;

    c.定义 struct platform_driver
    ,给其中的 probe、driver.of_match_table 赋值;

5.2 设备树

在设备树中实现预留内存,并使用自定义 compatible("sdc,reserved-mem")定义设备节点。

/ {
    reserved-memory {
        #address-cells = <2>;
        #size-cells = <2>;
        ranges;

        res1: buffer@0x2000000 {
            no-map;
            reg = <0x0 0x2000000 0x0 0x2000000>;
        };    
        res2: buffer@0x6000000 {
            no-map;
            reg = <0x0 0x6000000 0x0 0x2000000>;
        };
    };

    self-res-mem {
        compatible = "sdc,reserved-mem";
        reg = <0x0 0x2000000 0x0 0x2000000>;
    };
}

5.3 驱动源码

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#include <linux/mod_devicetable.h>

static int reserved_mem_open(struct inode *inode, struct file *file)
{
    pr_info("reserved memory open is called\n");

    return 0;
}

static int reserved_mem_close(struct inode *inode, struct file *file)
{
    pr_info("reserved memory close is called\n");

    return 0;
}

static const struct file_operations reserved_mem_ops = {
    .owner = THIS_MODULE,
    .open = reserved_mem_open,
    .release = reserved_mem_close,
};

static struct miscdevice reserved_mem_misc_device = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "reserved-mem",
    .fops = &reserved_mem_ops,
};

static int reserved_mem_probe(struct platform_device *pdev)
{
    int ret = 0;

    pr_info("reserved mem probe is called\n");

    ret = misc_register(&reserved_mem_misc_device);
    if (0 != ret)
    {
        pr_err("could not register the misc device:reserved memory\n");
        return ret;
    }

    pr_info("reserved mem:minor num:%d\n", reserved_mem_misc_device.minor);

    return 0;
}

static int reserved_mem_remove(struct platform_device *pdev)
{
    pr_info("reserved memory remove is called\n");

    misc_deregister(&reserved_mem_misc_device);

    return 0;
}

static const struct of_device_id res_mem_ids[] = {
    {.compatible = "sdc,reserved-mem"},
    {},
};
MODULE_DEVICE_TABLE(of, res_mem_ids);

static struct platform_driver reserved_mem_driver = {
    .probe = reserved_mem_probe,
    .remove = reserved_mem_remove,
    .driver = {
        .name = "reserved-mem",
        .of_match_table = res_mem_ids,
        .owner = THIS_MODULE,
    },
};

module_platform_driver(reserved_mem_driver);

MODULE_AUTHOR("sdc");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("self reserved memory driver");

5.4 驱动源码说明

  1. module_platform_driver(reserved_mem_driver) 实现了 int __init xxx_init()
    和 void __exit xxx_exit()
    函数;

  2. struct platform_driver reserved_mem_driver 定义了与设备节点匹配的 compatible,以及发现设备节点时调用的 probe 函数——reserved_mem_probe()
    ;

  3. struct miscdevice reserved_mem_misc_device 定义了此设备号、驱动名称,最重要的是定义了设备支持的操作—— struct file_operations reserved_mem_ops
    ;

5.5 系统启动

加载驱动:

设备文件:

 

6. 总结

misc设备驱动属于字符设备驱动,但是其实现方式要比单纯的字符设备驱动简单很多。如果需要实现某些字符设备的驱动,可以考虑基于 misc 驱动框架实现

 

 

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐