车辆TBOX科普第39次 CAN、SPI/I2C与4G模组

一、CAN总线驱动开发

1.1 CAN总线技术概述

CAN（Controller Area Network）总线是一种专门为工业控制和汽车电子设计的串行通信协议，由德国Bosch公司在1986年首次提出。其主要特点包括：

高可靠性：具备错误检测、错误通知和错误恢复机制
实时性强：采用非破坏性仲裁机制，保证高优先级消息的实时传输
多主结构：支持多个节点同时竞争总线使用权
传输距离长：在最远10km的距离内仍能保持5kbps的通信速率

在嵌入式Linux系统中，CAN总线驱动主要分为控制器驱动和设备驱动两个层次。控制器驱动负责与硬件CAN控制器交互，而设备驱动则提供网络接口，使应用程序能够通过socket API访问CAN总线。

1.2 Linux CAN子系统架构

Linux内核提供了完整的CAN子系统，其架构主要包括以下几个组件：

CAN核心层（can-core）：提供核心数据结构和API
CAN协议族（PF_CAN）：实现CAN的网络协议支持
CAN设备驱动：具体CAN控制器的驱动程序
CAN字符设备：提供字符设备接口（可选）

CAN子系统在内核中的位置如下图所示（文字描述）：

复制代码

应用程序 → Socket API → PF_CAN协议族 → CAN核心层 → CAN设备驱动 → 硬件CAN控制器

1.3 CAN控制器驱动开发

开发CAN控制器驱动需要实现struct net_device和相关操作函数。以下是一个基本的CAN控制器驱动框架：

c 复制代码

#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/can/dev.h>
#include <linux/can/platform.h>

/* CAN控制器硬件寄存器操作 */
static void can_hw_set_bittiming(struct net_device *dev)
{
    struct can_priv *priv = netdev_priv(dev);
    struct can_bittiming *bt = &priv->bittiming;
    
    /* 设置CAN总线时序参数 */
    // 硬件特定的寄存器配置
    // ...
}

static int can_hw_open(struct net_device *dev)
{
    struct can_priv *priv = netdev_priv(dev);
    int err;
    
    /* 初始化硬件 */
    // 硬件初始化代码
    // ...
    
    /* 设置中断处理 */
    err = request_irq(dev->irq, can_hw_interrupt, IRQF_SHARED,
                     dev->name, dev);
    if (err) {
        netdev_err(dev, "无法申请中断 %d\n", dev->irq);
        return err;
    }
    
    /* 启动硬件 */
    // 启动CAN控制器
    // ...
    
    netif_start_queue(dev);
    return 0;
}

static int can_hw_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
    struct can_frame *cf = (struct can_frame *)skb->data;
    
    /* 检查CAN帧有效性 */
    if (can_dropped_invalid_skb(dev, skb))
        return NETDEV_TX_OK;
    
    /* 将CAN帧发送到硬件 */
    // 硬件特定的发送代码
    // ...
    
    return NETDEV_TX_OK;
}

/* 中断处理函数 */
static irqreturn_t can_hw_interrupt(int irq, void *dev_id)
{
    struct net_device *dev = dev_id;
    struct can_priv *priv = netdev_priv(dev);
    
    /* 处理接收中断 */
    if (/* 接收中断标志 */) {
        struct sk_buff *skb;
        struct can_frame *cf;
        
        /* 分配sk_buff */
        skb = alloc_can_skb(dev, &cf);
        if (!skb) {
            priv->stats.rx_dropped++;
            return IRQ_HANDLED;
        }
        
        /* 从硬件读取CAN帧数据 */
        // 硬件特定的读取代码
        // ...
        
        /* 更新统计信息并传递到上层 */
        priv->stats.rx_packets++;
        priv->stats.rx_bytes += cf->can_dlc;
        netif_rx(skb);
    }
    
    /* 处理其他类型的中断 */
    // ...
    
    return IRQ_HANDLED;
}

/* 网络设备操作结构 */
static const struct net_device_ops can_hw_netdev_ops = {
    .ndo_open = can_hw_open,
    .ndo_stop = can_hw_close,
    .ndo_start_xmit = can_hw_start_xmit,
    // 其他操作...
};

/* 初始化函数 */
static int can_hw_probe(struct platform_device *pdev)
{
    struct net_device *dev;
    struct can_priv *priv;
    int err;
    
    /* 分配网络设备 */
    dev = alloc_candev(sizeof(struct can_priv), 1);
    if (!dev)
        return -ENOMEM;
    
    priv = netdev_priv(dev);
    
    /* 设置CAN特定参数 */
    priv->bittiming_const = &can_hw_bittiming_const;
    priv->do_set_bittiming = can_hw_set_bittiming;
    priv->do_set_mode = can_hw_set_mode;
    
    /* 设置网络设备参数 */
    dev->netdev_ops = &can_hw_netdev_ops;
    
    /* 注册网络设备 */
    err = register_candev(dev);
    if (err) {
        free_candev(dev);
        return err;
    }
    
    platform_set_drvdata(pdev, dev);
    return 0;
}

1.4 CAN设备使用与测试

在驱动开发完成后，可以使用标准的Linux工具进行测试。首先加载驱动模块：

bash 复制代码

# 加载CAN驱动模块
sudo insmod can_hw_driver.ko

# 设置CAN接口参数
sudo ip link set can0 type can bitrate 500000
sudo ip link set up can0

使用cansend和candump工具进行测试：

bash 复制代码

# 发送CAN帧
cansend can0 123#1122334455667788

# 监听CAN总线
candump can0

还可以使用SocketCAN API在应用程序中访问CAN总线：

c 复制代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <linux/can.h>
#include <linux/can/raw.h>

int main(void)
{
    int s;
    struct sockaddr_can addr;
    struct ifreq ifr;
    struct can_frame frame;
    
    /* 创建CAN套接字 */
    s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (s < 0) {
        perror("socket");
        return 1;
    }
    
    /* 指定CAN接口 */
    strcpy(ifr.ifr_name, "can0");
    ioctl(s, SIOCGIFINDEX, &ifr);
    
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    
    /* 绑定套接字 */
    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(s);
        return 1;
    }
    
    /* 准备CAN帧 */
    frame.can_id = 0x123;
    frame.can_dlc = 8;
    memcpy(frame.data, "\x11\x22\x33\x44\x55\x66\x77\x88", 8);
    
    /* 发送CAN帧 */
    if (write(s, &frame, sizeof(frame)) != sizeof(frame)) {
        perror("write");
        close(s);
        return 1;
    }
    
    close(s);
    return 0;
}

二、SPI/I2C总线驱动开发

2.1 SPI总线技术概述

SPI（Serial Peripheral Interface）是一种同步串行通信接口，由Motorola公司开发。其主要特点包括：

全双工通信：支持同时发送和接收数据
高速传输：通常可达几十Mbps
主从架构：一个主设备控制多个从设备
硬件简单：只需要4根信号线（MOSI、MISO、SCK、CS）

在Linux内核中，SPI子系统采用分层架构，包括核心层、控制器驱动和设备驱动。

2.2 SPI控制器驱动开发

SPI控制器驱动负责与硬件SPI控制器交互：

c 复制代码

#include <linux/module.h>
#include <linux/spi/spi.h>

/* SPI控制器操作函数 */
static int spi_hw_setup(struct spi_device *spi)
{
    /* 配置SPI模式、时钟等参数 */
    // 硬件特定的配置代码
    // ...
    return 0;
}

static int spi_hw_transfer(struct spi_device *spi, struct spi_message *mesg)
{
    struct spi_transfer *xfer;
    
    /* 处理SPI传输 */
    list_for_each_entry(xfer, &mesg->transfers, transfer_list) {
        /* 硬件特定的传输实现 */
        // ...
    }
    
    /* 完成传输 */
    mesg->status = 0;
    spi_finalize_current_message(mesg->spi->master);
    return 0;
}

static int spi_hw_probe(struct platform_device *pdev)
{
    struct spi_master *master;
    int ret;
    
    /* 分配SPI主控制器 */
    master = spi_alloc_master(&pdev->dev, sizeof(struct spi_hw_data));
    if (!master)
        return -ENOMEM;
    
    /* 设置SPI主控制器操作 */
    master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
    master->bits_per_word_mask = SPI_BPW_MASK(8);
    master->setup = spi_hw_setup;
    master->transfer_one_message = spi_hw_transfer;
    master->num_chipselect = 1;  /* CS线数量 */
    
    /* 注册SPI主控制器 */
    ret = devm_spi_register_master(&pdev->dev, master);
    if (ret) {
        dev_err(&pdev->dev, "无法注册SPI主控制器\n");
        spi_master_put(master);
        return ret;
    }
    
    platform_set_drvdata(pdev, master);
    return 0;
}

2.3 SPI设备驱动开发

SPI设备驱动用于控制特定的SPI外设：

c 复制代码

#include <linux/module.h>
#include <linux/spi/spi.h>

/* 设备特定的数据结构和操作 */
struct spi_sensor_data {
    struct spi_device *spi;
    struct mutex lock;
    // 其他设备特定数据...
};

static int spi_sensor_read_reg(struct spi_device *spi, u8 reg, u8 *val)
{
    int ret;
    u8 tx_buf[2] = { reg | 0x80, 0 };  /* 读命令 */
    u8 rx_buf[2];
    struct spi_transfer t = {
        .tx_buf = tx_buf,
        .rx_buf = rx_buf,
        .len = 2,
    };
    struct spi_message m;
    
    spi_message_init(&m);
    spi_message_add_tail(&t, &m);
    ret = spi_sync(spi, &m);
    if (ret < 0)
        return ret;
    
    *val = rx_buf[1];
    return 0;
}

static int spi_sensor_probe(struct spi_device *spi)
{
    struct spi_sensor_data *data;
    int ret;
    
    /* 分配设备数据 */
    data = devm_kzalloc(&spi->dev, sizeof(*data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;
    
    data->spi = spi;
    mutex_init(&data->lock);
    
    /* 初始化设备 */
    ret = spi_sensor_read_reg(spi, 0x0F, &who_am_i);
    if (ret < 0) {
        dev_err(&spi->dev, "无法读取设备ID\n");
        return ret;
    }
    
    /* 注册设备到相应子系统 */
    // 例如：输入设备、IIO设备等
    
    spi_set_drvdata(spi, data);
    dev_info(&spi->dev, "SPI传感器驱动加载成功\n");
    return 0;
}

static const struct of_device_id spi_sensor_of_match[] = {
    { .compatible = "vendor,spi-sensor" },
    { }
};
MODULE_DEVICE_TABLE(of, spi_sensor_of_match);

static struct spi_driver spi_sensor_driver = {
    .driver = {
        .name = "spi-sensor",
        .of_match_table = spi_sensor_of_match,
    },
    .probe = spi_sensor_probe,
    .remove = spi_sensor_remove,
};
module_spi_driver(spi_sensor_driver);

2.4 I2C总线驱动开发

I2C（Inter-Integrated Circuit）是一种多主从架构的串行通信总线，以其简单的两线制（SDA、SCL）而闻名。I2C驱动开发与SPI类似，但有其特定的API：

c 复制代码

#include <linux/module.h>
#include <linux/i2c.h>

/* I2C设备操作函数 */
static int i2c_sensor_read_reg(struct i2c_client *client, u8 reg, u8 *val)
{
    struct i2c_msg msg[2];
    u8 tx_buf[1] = { reg };
    u8 rx_buf[1];
    int ret;
    
    /* 写寄存器地址 */
    msg[0].addr = client->addr;
    msg[0].flags = 0;
    msg[0].len = 1;
    msg[0].buf = tx_buf;
    
    /* 读寄存器值 */
    msg[1].addr = client->addr;
    msg[1].flags = I2C_M_RD;
    msg[1].len = 1;
    msg[1].buf = rx_buf;
    
    ret = i2c_transfer(client->adapter, msg, 2);
    if (ret < 0)
        return ret;
    
    *val = rx_buf[0];
    return 0;
}

static int i2c_sensor_probe(struct i2c_client *client,
                           const struct i2c_device_id *id)
{
    struct device *dev = &client->dev;
    u8 who_am_i;
    int ret;
    
    /* 检查设备是否存在 */
    ret = i2c_sensor_read_reg(client, 0x0F, &who_am_i);
    if (ret < 0) {
        dev_err(dev, "无法读取设备ID\n");
        return ret;
    }
    
    if (who_am_i != 0xAB) {  /* 预期的设备ID */
        dev_err(dev, "设备ID不匹配: 0x%02x\n", who_am_i);
        return -ENODEV;
    }
    
    /* 初始化设备 */
    // ...
    
    dev_info(dev, "I2C传感器驱动加载成功\n");
    return 0;
}

static const struct i2c_device_id i2c_sensor_id[] = {
    { "i2c-sensor", 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, i2c_sensor_id);

static const struct of_device_id i2c_sensor_of_match[] = {
    { .compatible = "vendor,i2c-sensor" },
    { }
};
MODULE_DEVICE_TABLE(of, i2c_sensor_of_match);

static struct i2c_driver i2c_sensor_driver = {
    .driver = {
        .name = "i2c-sensor",
        .of_match_table = i2c_sensor_of_match,
    },
    .probe = i2c_sensor_probe,
    .remove = i2c_sensor_remove,
    .id_table = i2c_sensor_id,
};
module_i2c_driver(i2c_sensor_driver);

三、4G模组驱动开发

3.1 4G通信模组概述

4G通信模组为嵌入式设备提供了高速无线连接能力，主要基于LTE技术。常见的4G模组接口包括：

USB接口：大多数4G模组使用USB接口与主机连接
PCIe接口：部分高性能模组使用PCIe接口
SDIO接口：较少使用，主要用于早期的3G模组

在Linux系统中，4G模组通常被识别为USB设备或PCIe设备，并通过相应的驱动进行管理。

3.2 USB 4G模组驱动开发

USB 4G模组驱动主要基于USB串行驱动框架：

c 复制代码

#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>

/* USB设备ID表 */
static const struct usb_device_id id_table[] = {
    { USB_DEVICE(0x2c7c, 0x0125) },  /* Quectel EC25 */
    { USB_DEVICE(0x1bc7, 0x1201) },  /* Telit LE910 */
    { } /* 终止项 */
};
MODULE_DEVICE_TABLE(usb, id_table);

/* USB串口操作函数 */
static int usb_4g_open(struct tty_struct *tty, struct usb_serial_port *port)
{
    int ret;
    
    /* 初始化4G模组 */
    ret = usb_serial_generic_open(tty, port);
    if (ret)
        return ret;
    
    /* 发送AT命令初始化模组 */
    // 例如：发送AT+CFUN=1启用全功能
    // ...
    
    return 0;
}

static void usb_4g_close(struct usb_serial_port *port)
{
    /* 清理资源 */
    usb_serial_generic_close(port);
}

static int usb_4g_write(struct tty_struct *tty, struct usb_serial_port *port,
                       const unsigned char *buf, int count)
{
    /* 数据处理（如需要） */
    return usb_serial_generic_write(tty, port, buf, count);
}

/* USB串口驱动结构 */
static struct usb_serial_driver usb_4g_device = {
    .driver = {
        .owner = THIS_MODULE,
        .name = "usb_4g",
    },
    .id_table = id_table,
    .num_ports = 1,
    .open = usb_4g_open,
    .close = usb_4g_close,
    .write = usb_4g_write,
};

/* 驱动注册 */
static struct usb_serial_driver * const serial_drivers[] = {
    &usb_4g_device, NULL
};

module_usb_serial_driver(serial_drivers, id_table);

3.3 网络接口驱动开发

为了在系统中提供网络连接，需要为4G模组创建网络接口：

c 复制代码

#include <linux/netdevice.h>
#include <linux/ppp_channel.h>

/* PPP通道操作 */
static int ppp_4g_ioctl(struct ppp_channel *chan, unsigned int cmd,
                       unsigned long arg)
{
    struct usb_serial_port *port = chan->private;
    
    switch (cmd) {
    case PPPIOCGCHAN:
        /* 获取通道信息 */
        break;
    case PPPIOCGUNIT:
        /* 获取单元号 */
        break;
    default:
        return -ENOTTY;
    }
    return 0;
}

static struct ppp_channel_ops ppp_4g_ops = {
    .start_xmit = ppp_4g_xmit,
    .ioctl = ppp_4g_ioctl,
};

/* 创建PPP接口 */
static int create_ppp_interface(struct usb_serial_port *port)
{
    struct ppp_channel *ppp;
    int ret;
    
    ppp = kzalloc(sizeof(*ppp), GFP_KERNEL);
    if (!ppp)
        return -ENOMEM;
    
    ppp->private = port;
    ppp->ops = &ppp_4g_ops;
    ppp->mtu = 1500;
    
    ret = ppp_register_channel(ppp);
    if (ret) {
        kfree(ppp);
        return ret;
    }
    
    port->private_data = ppp;
    return 0;
}

3.4 AT命令管理

4G模组主要通过AT命令进行控制：

c 复制代码

#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>

/* AT命令处理 */
static int send_at_command(struct usb_serial_port *port, const char *cmd)
{
    int ret;
    int len = strlen(cmd);
    
    ret = usb_serial_generic_write(NULL, port, cmd, len);
    if (ret < 0) {
        dev_err(&port->dev, "发送AT命令失败: %d\n", ret);
        return ret;
    }
    
    return 0;
}

static void process_at_response(struct usb_serial_port *port, const char *response)
{
    /* 解析AT响应 */
    if (strstr(response, "OK")) {
        /* 命令成功 */
        dev_dbg(&port->dev, "AT命令执行成功\n");
    } else if (strstr(response, "ERROR")) {
        /* 命令失败 */
        dev_err(&port->dev, "AT命令执行失败\n");
    } else if (strstr(response, "+CREG")) {
        /* 网络注册状态 */
        // 解析网络注册信息
    }
    // 其他响应处理...
}

/* 数据接收处理 */
static void usb_4g_process_read_urb(struct urb *urb)
{
    struct usb_serial_port *port = urb->context;
    char *data = urb->transfer_buffer;
    int len = urb->actual_length;
    
    if (!len)
        return;
    
    /* 处理接收到的数据（AT响应或网络数据） */
    if (port->private_data) {
        /* 如果是PPP数据，传递到PPP层 */
        ppp_input(port->private_data, data, len);
    } else {
        /* 如果是AT响应，进行处理 */
        process_at_response(port, data);
    }
}

四、综合实战：工业物联网网关驱动集成

4.1 系统架构设计

为了更好地理解这些驱动技术的实际应用，我们设计一个工业物联网网关的案例，该网关集成了CAN总线、SPI传感器和4G通信功能：

复制代码

系统架构：
传感器层 → SPI/I2C接口 → 处理器 → CAN总线 → 工业设备
                              ↓
                        4G模组 → 云平台

4.2 设备树配置

在设备树中描述所有硬件资源：

dts 复制代码

/ {
    compatible = "vendor,industrial-gateway";
    
    /* SPI控制器 */
    spi0: spi@10000000 {
        compatible = "vendor,spi-controller";
        reg = <0x10000000 0x1000>;
        interrupts = <0 20 4>;
        #address-cells = <1>;
        #size-cells = <0>;
        
        /* 温度传感器 */
        temp_sensor@0 {
            compatible = "vendor,tmp117";
            reg = <0>;
            spi-max-frequency = <10000000>;
        };
        
        /* 湿度传感器 */
        humidity_sensor@1 {
            compatible = "vendor,sht3x";
            reg = <1>;
            spi-max-frequency = <5000000>;
        };
    };
    
    /* CAN控制器 */
    can0: can@20000000 {
        compatible = "vendor,can-controller";
        reg = <0x20000000 0x1000>;
        interrupts = <0 21 4>;
        clock-frequency = <24000000>;
    };
    
    /* USB控制器（用于4G模组） */
    usb0: usb@30000000 {
        compatible = "vendor,usb-host";
        reg = <0x30000000 0x1000>;
        interrupts = <0 22 4>;
    };
};

4.3 驱动集成与协调

实现各驱动模块间的协调工作：

c 复制代码

#include <linux/workqueue.h>
#include <linux/mutex.h>

/* 网关全局数据结构 */
struct gateway_data {
    struct can_device *can_dev;
    struct spi_device *temp_sensor;
    struct spi_device *humidity_sensor;
    struct usb_serial_port *lte_modem;
    struct workqueue_struct *workqueue;
    struct mutex data_lock;
    u8 sensor_data[64];
};

/* 数据采集工作函数 */
static void data_collection_work(struct work_struct *work)
{
    struct gateway_data *gw = container_of(work, struct gateway_data,
                                          data_work);
    u8 temp, humidity;
    
    mutex_lock(&gw->data_lock);
    
    /* 读取传感器数据 */
    spi_sensor_read_reg(gw->temp_sensor, 0x00, &temp);
    spi_sensor_read_reg(gw->humidity_sensor, 0x00, &humidity);
    
    /* 准备上传数据 */
    snprintf(gw->sensor_data, sizeof(gw->sensor_data),
             "TEMP:%d,HUM:%d", temp, humidity);
    
    mutex_unlock(&gw->data_lock);
    
    /* 触发数据上传 */
    queue_work(gw->workqueue, &gw->upload_work);
}

/* 数据上传工作函数 */
static void data_upload_work(struct work_struct *work)
{
    struct gateway_data *gw = container_of(work, struct gateway_data,
                                          upload_work);
    char at_command[128];
    
    mutex_lock(&gw->data_lock);
    
    /* 构造AT命令发送数据 */
    snprintf(at_command, sizeof(at_command),
             "AT+HTTPDATA=%d,10000\r\n%s\r\n",
             strlen(gw->sensor_data), gw->sensor_data);
    
    /* 通过4G模组发送数据 */
    send_at_command(gw->lte_modem, at_command);
    
    mutex_unlock(&gw->data_lock);
}

/* CAN数据接收处理 */
static void can_data_handler(struct can_frame *frame, void *data)
{
    struct gateway_data *gw = data;
    
    /* 处理接收到的CAN数据 */
    // 例如：控制命令、状态信息等
    
    /* 可选：通过4G上传CAN数据 */
    queue_work(gw->workqueue, &gw->upload_work);
}

4.4 系统测试与调试

开发完成后需要进行全面测试：

bash 复制代码

# 测试SPI传感器
cat /sys/bus/spi/devices/spi0.0/temperature
cat /sys/bus/spi/devices/spi0.1/humidity

# 测试CAN总线
ip link set can0 up type can bitrate 500000
candump can0 &
cansend can0 123#1122334455667788

# 测试4G连接
echo "AT+CPIN?" > /dev/ttyUSB2
echo "AT+CREG?" > /dev/ttyUSB2
echo "AT+CGATT=1" > /dev/ttyUSB2

# 测试网络连接
ping -I ppp0 8.8.8.8

五、调试技巧与最佳实践

5.1 驱动调试技巧

使用动态调试

c 复制代码

#define DEBUG
#include <linux/dynamic_debug.h>

/* 在代码中插入调试信息 */
dev_dbg(&dev->dev, "寄存器值: 0x%02x\n", reg_val);

Proc文件系统调试

c 复制代码

#include <linux/proc_fs.h>

static int can_debug_show(struct seq_file *m, void *v)
{
    struct can_priv *priv = m->private;
    
    seq_printf(m, "发送帧数: %lu\n", priv->stats.tx_frames);
    seq_printf(m, "接收帧数: %lu\n", priv->stats.rx_frames);
    seq_printf(m, "错误计数: %lu\n", priv->stats.bus_error);
    return 0;
}

Sysfs接口

c 复制代码

static ssize_t reset_store(struct device *dev,
                          struct device_attribute *attr,
                          const char *buf, size_t count)
{
    struct spi_device *spi = to_spi_device(dev);
    
    /* 执行设备复位 */
    // ...
    
    return count;
}

static DEVICE_ATTR_WO(reset);

5.2 性能优化

DMA传输

c 复制代码

static int spi_use_dma_transfer(struct spi_device *spi,
                               struct spi_transfer *xfer)
{
    /* 配置DMA传输 */
    xfer->tx_dma = dma_map_single(&spi->dev, xfer->tx_buf,
                                 xfer->len, DMA_TO_DEVICE);
    xfer->rx_dma = dma_map_single(&spi->dev, xfer->rx_buf,
                                 xfer->len, DMA_FROM_DEVICE);
    // ...
}

中断优化

c 复制代码

/* 使用线程化中断处理耗时操作 */
static irqreturn_t can_irq_thread(int irq, void *dev_id)
{
    struct net_device *dev = dev_id;
    
    /* 处理复杂的中断任务 */
    // ...
    
    return IRQ_HANDLED;
}

static irqreturn_t can_irq_handler(int irq, void *dev_id)
{
    /* 快速处理，启动线程处理复杂任务 */
    return IRQ_WAKE_THREAD;
}

结论

本文详细介绍了嵌入式Linux系统中三种重要总线驱动的开发：CAN总线、SPI/I2C总线和4G通信模组。通过深入分析每种技术的架构、驱动实现和实际应用，我们构建了从理论基础到工程实践的完整知识体系。

CAN总线驱动开发重点在于理解网络设备框架和CAN协议栈；SPI/I2C驱动开发需要掌握主控制器和外设驱动的分层架构；4G模组驱动则涉及USB/PPP等复杂网络协议栈。通过工业物联网网关的综合案例，我们展示了如何将这些技术集成到实际项目中。

嵌入式驱动开发是一个需要深厚理论基础和丰富实践经验的领域。建议开发者在掌握本文内容的基础上，进一步学习Linux内核的其他子系统，如网络协议栈、电源管理等，并积极参与开源社区，不断提升自己的技术水平。

随着5G、物联网和人工智能技术的发展，嵌入式系统的应用场景将更加广泛，对驱动开发者的要求也会越来越高。保持学习、勇于实践，才能在这个快速发展的领域中保持竞争力。

车辆TBOX科普 第39次 CAN、SPI/I2C与4G模组

一、CAN总线驱动开发

1.1 CAN总线技术概述

1.2 Linux CAN子系统架构

1.3 CAN控制器驱动开发

1.4 CAN设备使用与测试

二、SPI/I2C总线驱动开发

2.1 SPI总线技术概述

2.2 SPI控制器驱动开发

2.3 SPI设备驱动开发

2.4 I2C总线驱动开发

三、4G模组驱动开发

3.1 4G通信模组概述

3.2 USB 4G模组驱动开发

3.3 网络接口驱动开发

3.4 AT命令管理

四、综合实战：工业物联网网关驱动集成

4.1 系统架构设计

4.2 设备树配置

4.3 驱动集成与协调

4.4 系统测试与调试

五、调试技巧与最佳实践

5.1 驱动调试技巧

5.2 性能优化

结论

车辆TBOX科普第39次 CAN、SPI/I2C与4G模组