readl 与 writel

本文介绍了在内核编程中如何使用writel()函数向内存映射的I/O空间写入32位数据,以及如何通过readl()函数从该空间读取32位数据。详细解释了这两个函数的用法及参数含义。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

writel() 往内存映射的 I/O 空间上写数据,wirtel()   I/O 上写入 32 位数据 (4字节)。
 原型:


引用
#include <asm/io.h> 

void writel (unsigned char data , unsigned short addr )


readl() 从内存映射的 I/O 空间读取数据,readl 从 I/O 读取 32 位数据 ( 4 字节 )。
原型:
#include <asm/io.h> 

unsigned char readl (unsigned int addr )

注:变量    addr  是 I/O 地址。

返回值 : 从 I/O 空间读取的数值。
static int ufshcd_wait_for_register(struct ufs_hba *hba, u32 reg, u32 mask, u32 val, unsigned long timeout_ms) { int err = 0; unsigned long start = get_timer(0); /* ignore bits that we don't intend to wait on */ val = val & mask; while ((ufshcd_readl(hba, reg) & mask) != val) { if (get_timer(start) > timeout_ms) { if ((ufshcd_readl(hba, reg) & mask) != val) err = -ETIMEDOUT; break; } } return err; } /** * ufshcd_init_pwr_info - setting the POR (power on reset) * values in hba power info */ static void ufshcd_init_pwr_info(struct ufs_hba *hba) { hba->pwr_info.gear_rx = UFS_PWM_G1; hba->pwr_info.gear_tx = UFS_PWM_G1; hba->pwr_info.lane_rx = 1; hba->pwr_info.lane_tx = 1; hba->pwr_info.pwr_rx = SLOWAUTO_MODE; hba->pwr_info.pwr_tx = SLOWAUTO_MODE; hba->pwr_info.hs_rate = 0; } /** * ufshcd_print_pwr_info - print power params as saved in hba * power info */ static void ufshcd_print_pwr_info(struct ufs_hba *hba) { static const char * const names[] = { "INVALID MODE", "FAST MODE", "SLOW_MODE", "INVALID MODE", "FASTAUTO_MODE", "SLOWAUTO_MODE", "INVALID MODE", }; dev_err(hba->dev, "[RX, TX]: gear=[%d, %d], lane[%d, %d], pwr[%s, %s], rate = %d\n", hba->pwr_info.gear_rx, hba->pwr_info.gear_tx, hba->pwr_info.lane_rx, hba->pwr_info.lane_tx, names[hba->pwr_info.pwr_rx], names[hba->pwr_info.pwr_tx], hba->pwr_info.hs_rate); } static void ufshcd_device_reset(struct ufs_hba *hba) { ufshcd_vops_device_reset(hba); } /** * ufshcd_ready_for_uic_cmd - Check if controller is ready * to accept UIC commands */ static inline bool ufshcd_ready_for_uic_cmd(struct ufs_hba *hba) { if (ufshcd_readl(hba, REG_CONTROLLER_STATUS) & UIC_COMMAND_READY) return true; else return false; } /** * ufshcd_get_uic_cmd_result - Get the UIC command result */ static inline int ufshcd_get_uic_cmd_result(struct ufs_hba *hba) { return ufshcd_readl(hba, REG_UIC_COMMAND_ARG_2) & MASK_UIC_COMMAND_RESULT; } /** * ufshcd_get_dme_attr_val - Get the value of attribute returned by UIC command */ static inline u32 ufshcd_get_dme_attr_val(struct ufs_hba *hba) { return ufshcd_readl(hba, REG_UIC_COMMAND_ARG_3); } /** * ufshcd_is_device_present - Check if any device connected to * the host controller */ static inline bool ufshcd_is_device_present(struct ufs_hba *hba) { return (ufshcd_readl(hba, REG_CONTROLLER_STATUS) & DEVICE_PRESENT) ? true : false; } /** * ufshcd_send_uic_cmd - UFS Interconnect layer command API * */ static int ufshcd_send_uic_cmd(struct ufs_hba *hba, struct uic_command *uic_cmd) { unsigned long start = 0; u32 intr_status; u32 enabled_intr_status; if (!ufshcd_ready_for_uic_cmd(hba)) { dev_err(hba->dev, "Controller not ready to accept UIC commands\n"); return -EIO; } debug("sending uic command:%d\n", uic_cmd->command); /* Write Args */ ufshcd_writel(hba, uic_cmd->argument1, REG_UIC_COMMAND_ARG_1); ufshcd_writel(hba, uic_cmd->argument2, REG_UIC_COMMAND_ARG_2); ufshcd_writel(hba, uic_cmd->argument3, REG_UIC_COMMAND_ARG_3); /* Write UIC Cmd */ ufshcd_writel(hba, uic_cmd->command & COMMAND_OPCODE_MASK, REG_UIC_COMMAND); start = get_timer(0); do { intr_status = ufshcd_readl(hba, REG_INTERRUPT_STATUS); enabled_intr_status = intr_status & hba->intr_mask; ufshcd_writel(hba, intr_status, REG_INTERRUPT_STATUS); if (get_timer(start) > UFS_UIC_CMD_TIMEOUT) { dev_err(hba->dev, "Timedout waiting for UIC response\n"); return -ETIMEDOUT; } if (enabled_intr_status & UFSHCD_ERROR_MASK) { dev_err(hba->dev, "Error in status:%08x\n", enabled_intr_status); return -1; } } while (!(enabled_intr_status & UFSHCD_UIC_MASK)); uic_cmd->argument2 = ufshcd_get_uic_cmd_result(hba); uic_cmd->argument3 = ufshcd_get_dme_attr_val(hba); debug("Sent successfully\n"); return 0; } /** * ufshcd_dme_set_attr - UIC command for DME_SET, DME_PEER_SET * */ int ufshcd_dme_set_attr(struct ufs_hba *hba, u32 attr_sel, u8 attr_set, u32 mib_val, u8 peer) { struct uic_command uic_cmd = {0}; static const char *const action[] = { "dme-set", "dme-peer-set" }; const char *set = action[!!peer]; int ret; int retries = UFS_UIC_COMMAND_RETRIES; uic_cmd.command = peer ? UIC_CMD_DME_PEER_SET : UIC_CMD_DME_SET; uic_cmd.argument1 = attr_sel; uic_cmd.argument2 = UIC_ARG_ATTR_TYPE(attr_set); uic_cmd.argument3 = mib_val; do { /* for peer attributes we retry upon failure */ ret = ufshcd_send_uic_cmd(hba, &uic_cmd); if (ret) dev_dbg(hba->dev, "%s: attr-id 0x%x val 0x%x error code %d\n", set, UIC_GET_ATTR_ID(attr_sel), mib_val, ret); } while (ret && peer && --retries); if (ret) dev_err(hba->dev, "%s: attr-id 0x%x val 0x%x failed %d retries\n", set, UIC_GET_ATTR_ID(attr_sel), mib_val, UFS_UIC_COMMAND_RETRIES - retries); return ret; } /** * ufshcd_dme_get_attr - UIC command for DME_GET, DME_PEER_GET * */ int ufshcd_dme_get_attr(struct ufs_hba *hba, u32 attr_sel, u32 *mib_val, u8 peer) { struct uic_command uic_cmd = {0}; static const char *const action[] = { "dme-get", "dme-peer-get" }; const char *get = action[!!peer]; int ret; int retries = UFS_UIC_COMMAND_RETRIES; uic_cmd.command = peer ? UIC_CMD_DME_PEER_GET : UIC_CMD_DME_GET; uic_cmd.argument1 = attr_sel; do { /* for peer attributes we retry upon failure */ ret = ufshcd_send_uic_cmd(hba, &uic_cmd); if (ret) dev_dbg(hba->dev, "%s: attr-id 0x%x error code %d\n", get, UIC_GET_ATTR_ID(attr_sel), ret); } while (ret && peer && --retries); if (ret) dev_err(hba->dev, "%s: attr-id 0x%x failed %d retries\n", get, UIC_GET_ATTR_ID(attr_sel), UFS_UIC_COMMAND_RETRIES - retries); if (mib_val && !ret) *mib_val = uic_cmd.argument3; return ret; } static int ufshcd_disable_tx_lcc(struct ufs_hba *hba, bool peer) { u32 tx_lanes, i, err = 0; if (!peer) ufshcd_dme_get(hba, UIC_ARG_MIB(PA_CONNECTEDTXDATALANES), &tx_lanes); else ufshcd_dme_peer_get(hba, UIC_ARG_MIB(PA_CONNECTEDTXDATALANES), &tx_lanes); for (i = 0; i < tx_lanes; i++) { unsigned int val = UIC_ARG_MIB_SEL(TX_LCC_ENABLE, UIC_ARG_MPHY_TX_GEN_SEL_INDEX(i)); if (!peer) err = ufshcd_dme_set(hba, val, 0); else err = ufshcd_dme_peer_set(hba, val, 0); if (err) { dev_err(hba->dev, "%s: TX LCC Disable failed, peer = %d, lane = %d, err = %d\n", __func__, peer, i, err); break; } } return err; } static inline int ufshcd_disable_device_tx_lcc(struct ufs_hba *hba) { return ufshcd_disable_tx_lcc(hba, true); } /** * ufshcd_dme_link_startup - Notify Unipro to perform link startup * */ static int ufshcd_dme_link_startup(struct ufs_hba *hba) { struct uic_command uic_cmd = {0}; int ret; uic_cmd.command = UIC_CMD_DME_LINK_STARTUP; ret = ufshcd_send_uic_cmd(hba, &uic_cmd); if (ret) dev_dbg(hba->dev, "dme-link-startup: error code %d\n", ret); return ret; } /** * ufshcd_disable_intr_aggr - Disables interrupt aggregation. * */ static inline void ufshcd_disable_intr_aggr(struct ufs_hba *hba) { ufshcd_writel(hba, 0, REG_UTP_TRANSFER_REQ_INT_AGG_CONTROL); } /** * ufshcd_get_lists_status - Check UCRDY, UTRLRDY and UTMRLRDY */ static inline int ufshcd_get_lists_status(u32 reg) { return !((reg & UFSHCD_STATUS_READY) == UFSHCD_STATUS_READY); } /** * ufshcd_enable_run_stop_reg - Enable run-stop registers, * When run-stop registers are set to 1, it indicates the * host controller that it can process the requests */ static void ufshcd_enable_run_stop_reg(struct ufs_hba *hba) { ufshcd_writel(hba, UTP_TASK_REQ_LIST_RUN_STOP_BIT, REG_UTP_TASK_REQ_LIST_RUN_STOP); ufshcd_writel(hba, UTP_TRANSFER_REQ_LIST_RUN_STOP_BIT, REG_UTP_TRANSFER_REQ_LIST_RUN_STOP); } /** * ufshcd_enable_intr - enable interrupts */ static void ufshcd_enable_intr(struct ufs_hba *hba, u32 intrs) { u32 set = ufshcd_readl(hba, REG_INTERRUPT_ENABLE); u32 rw; if (hba->version == UFSHCI_VERSION_10) { rw = set & INTERRUPT_MASK_RW_VER_10; set = rw | ((set ^ intrs) & intrs); } else { set |= intrs; } ufshcd_writel(hba, set, REG_INTERRUPT_ENABLE); hba->intr_mask = set; } /** * ufshcd_make_hba_operational - Make UFS controller operational * * To bring UFS host controller to operational state, * 1. Enable required interrupts * 2. Configure interrupt aggregation * 3. Program UTRL and UTMRL base address * 4. Configure run-stop-registers * */ static int ufshcd_make_hba_operational(struct ufs_hba *hba) { int err = 0; u32 reg; /* Enable required interrupts */ ufshcd_enable_intr(hba, UFSHCD_ENABLE_INTRS); /* Disable interrupt aggregation */ ufshcd_disable_intr_aggr(hba); /* Configure UTRL and UTMRL base address registers */ ufshcd_writel(hba, lower_32_bits((dma_addr_t)hba->utrdl), REG_UTP_TRANSFER_REQ_LIST_BASE_L); ufshcd_writel(hba, upper_32_bits((dma_addr_t)hba->utrdl), REG_UTP_TRANSFER_REQ_LIST_BASE_H); ufshcd_writel(hba, lower_32_bits((dma_addr_t)hba->utmrdl), REG_UTP_TASK_REQ_LIST_BASE_L); ufshcd_writel(hba, upper_32_bits((dma_addr_t)hba->utmrdl), REG_UTP_TASK_REQ_LIST_BASE_H); /* * Make sure base address and interrupt setup are updated before * enabling the run/stop registers below. */ wmb(); /* * UCRDY, UTMRLDY and UTRLRDY bits must be 1 */ reg = ufshcd_readl(hba, REG_CONTROLLER_STATUS); if (!(ufshcd_get_lists_status(reg))) { ufshcd_enable_run_stop_reg(hba); } else { dev_err(hba->dev, "Host controller not ready to process requests\n"); err = -EIO; goto out; } out: return err; } /** * ufshcd_link_startup - Initialize unipro link startup */ static int ufshcd_link_startup(struct ufs_hba *hba) { int ret; int retries = DME_LINKSTARTUP_RETRIES; do { ufshcd_ops_link_startup_notify(hba, PRE_CHANGE); ret = ufshcd_dme_link_startup(hba); /* check if device is detected by inter-connect layer */ if (!ret && !ufshcd_is_device_present(hba)) { dev_err(hba->dev, "%s: Device not present\n", __func__); ret = -ENXIO; goto out; } /* * DME link lost indication is only received when link is up, * but we can't be sure if the link is up until link startup * succeeds. So reset the local Uni-Pro and try again. */ if (ret && ufshcd_hba_enable(hba)) goto out; } while (ret && retries--); if (ret) /* failed to get the link up... retire */ goto out; /* Mark that link is up in PWM-G1, 1-lane, SLOW-AUTO mode */ ufshcd_init_pwr_info(hba); if (hba->quirks & UFSHCD_QUIRK_BROKEN_LCC) { ret = ufshcd_disable_device_tx_lcc(hba); if (ret) goto out; } /* Include any host controller configuration via UIC commands */ ret = ufshcd_ops_link_startup_notify(hba, POST_CHANGE); if (ret) goto out; /* Clear UECPA once due to LINERESET has happened during LINK_STARTUP */ ufshcd_readl(hba, REG_UIC_ERROR_CODE_PHY_ADAPTER_LAYER); ret = ufshcd_make_hba_operational(hba); out: if (ret) dev_err(hba->dev, "link startup failed %d\n", ret); return ret; }
05-28
// SPDX-License-Identifier: GPL-2.0-only // // Copyright (c) 2024 GoldenRiver Inc. // Copyright (c) 2024 MediaTek Inc. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/debugfs.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/idr.h> #include <linux/of.h> #include <linux/of_address.h> #include <linux/of_platform.h> #include <linux/platform_device.h> #include <linux/kthread.h> #include <linux/slab.h> #include <linux/module.h> #include <linux/uaccess.h> #include <linux/mutex.h> #include <linux/delay.h> #include <linux/completion.h> #include <linux/spinlock.h> #include <linux/arm-smccc.h> #include <linux/nebula/hvcall.h> #include "rpmsg_virtio.h" #include "nebula_rproc_remote.h" enum { RPROC_REG_SET_READY = 0x0, RPROC_REG_CLEAR_READY = 0x4, RPROC_REG_SHM_BASE_LOW = 0x8, RPROC_REG_SHM_BASE_HIGH = 0xc, RPROC_REG_STATE = 0x10, RPROC_REG_KICK = 0x14, RPROC_REG_PEER_VMID = 0x18, RPROC_REG_PEER_ONLINE = 0x1c, }; enum { STATE_NOT_READY, STATE_READY, }; enum { IDLE, CREATING_VDEV, VDEV_CREATED, DESTROYING_VDEV, }; char *state_string[] = { __stringify(IDLE), __stringify(CREATING_VDEV), __stringify(VDEV_CREATED), __stringify(DESTROYING_VDEV), }; #define MAX_VIRTIO_DEVICES 20 #define ALL_HOSTS -2 struct rproc_resource_table { u32 ver; u32 num; u32 reserved[2]; u32 offset[MAX_VIRTIO_DEVICES]; } __packed; static void signal_irq(uint16_t irq) { struct arm_smccc_res res; unsigned long r7 = SMC_HYP_SECURE_ID << 16; arm_smccc_smc(SMC_FC_NBL_VHM_REQ, 0, irq, 0, 0, 0, 0, r7, &res); } struct irq_info { int local_virq; int remote_hwirq; struct virtio_vring_info *vring_info; }; struct virtio_device_info { struct virtio_device *dev; struct nebula_rproc_vdev_ops *ops; void *user_priv; }; struct rproc_remote_priv { void *__iomem reg_base; void *shm_base; size_t shm_size; phys_addr_t host_shm_phys; struct metal_io_region shm_io; struct device *dev; int num_queues; struct irq_info *irq_info; bool notify_with_phys_irq; struct mutex rsc_table_mutex; struct virtio_device_info vdevs[MAX_VIRTIO_DEVICES]; void *rsc_table; size_t rsc_table_offset; size_t num_vdevs; struct task_struct *thread; struct completion compl; bool need_release; int state; bool ready; spinlock_t state_lock; struct dentry *dbgfs; bool auto_restart; struct list_head node; bool force_offline; }; static void set_state(struct rproc_remote_priv *priv, int state) { unsigned long flags; int prev_state; spin_lock_irqsave(&priv->state_lock, flags); prev_state = priv->state; priv->state = state; spin_unlock_irqrestore(&priv->state_lock, flags); dev_info(priv->dev, "%s -> %s\n", state_string[prev_state], state_string[state]); } static int get_host(struct rproc_remote_priv *priv) { if (!priv) return -EINVAL; return readl_relaxed(priv->reg_base + RPROC_REG_PEER_VMID); } static int get_state(struct rproc_remote_priv *priv) { unsigned long flags; int state; spin_lock_irqsave(&priv->state_lock, flags); state = priv->state; spin_unlock_irqrestore(&priv->state_lock, flags); return state; } LIST_HEAD(rproc_devices); DEFINE_MUTEX(rproc_devices_lock); int nebula_rproc_register_device_for_host( const void *rsc, size_t rsc_size, struct nebula_rproc_vdev_ops *vdev_ops, int vmid, void *user_priv) { struct rproc_remote_priv *priv; struct rproc_resource_table *rsc_table; int vdev_idx, host_vmid; if (!vdev_ops) return -EINVAL; mutex_lock(&rproc_devices_lock); if (list_empty(&rproc_devices)) { mutex_unlock(&rproc_devices_lock); return -ENODEV; } list_for_each_entry(priv, &rproc_devices, node) { mutex_lock(&priv->rsc_table_mutex); host_vmid = get_host(priv); if(vmid != ALL_HOSTS && host_vmid != vmid){ mutex_unlock(&priv->rsc_table_mutex); continue; } vdev_idx = priv->num_vdevs; if (vdev_idx < 0 || vdev_idx >= MAX_VIRTIO_DEVICES) { mutex_unlock(&priv->rsc_table_mutex); mutex_unlock(&rproc_devices_lock); return -EINVAL; } pr_debug("register vdev%d, rsc_offset %lx, rsc_size %lx\n", vdev_idx, priv->rsc_table_offset, rsc_size); rsc_table = priv->rsc_table; rsc_table->offset[vdev_idx] = priv->rsc_table_offset; priv->vdevs[vdev_idx].ops = vdev_ops; priv->vdevs[vdev_idx].user_priv = user_priv; BUG_ON(priv->rsc_table_offset + rsc_size >= PAGE_SIZE); memcpy(priv->rsc_table + priv->rsc_table_offset, rsc, rsc_size); priv->num_vdevs++; priv->rsc_table_offset += rsc_size; rsc_table->num = priv->num_vdevs; mutex_unlock(&priv->rsc_table_mutex); } mutex_unlock(&rproc_devices_lock); return 0; } EXPORT_SYMBOL(nebula_rproc_register_device_for_host); int nebula_rproc_register_device(const void *rsc, size_t rsc_size, struct nebula_rproc_vdev_ops *vdev_ops, void *user_priv) { int ret; ret = nebula_rproc_register_device_for_host(rsc, rsc_size, vdev_ops, ALL_HOSTS, user_priv); if (ret) { pr_err("failed to register devices for host(%d)\n", ret); return ret; } return 0; } EXPORT_SYMBOL(nebula_rproc_register_device); static inline bool is_shm_paddr(struct rproc_remote_priv *priv, phys_addr_t phys) { return phys > priv->host_shm_phys; } static inline bool is_shm_vaddr(struct rproc_remote_priv *priv, void *vaddr) { u64 start = (u64)priv->shm_base; u64 end = (u64)(priv->shm_base + priv->shm_size); u64 target = (u64)vaddr; return (target > start) && (target < end); } static void *rproc_paddr_to_vaddr(struct virtqueue *vq, phys_addr_t phys) { struct remoteproc_virtio *rpvdev = container_of(vq->vq_dev, struct remoteproc_virtio, vdev); struct rproc_remote_priv *priv = rpvdev->priv; void *virt; if (is_shm_paddr(priv, phys)) { u32 off = phys - priv->host_shm_phys; virt = priv->shm_base + off; } else { virt = phys_to_virt(phys); } pr_debug("paddr_to_vaddr: phys: %llx, virt: %px\n", phys, virt); return virt; } static phys_addr_t rproc_vaddr_to_paddr(struct virtqueue *vq, void *vaddr) { struct remoteproc_virtio *rpvdev = container_of(vq->vq_dev, struct remoteproc_virtio, vdev); struct rproc_remote_priv *priv = rpvdev->priv; phys_addr_t phys; if (is_shm_vaddr(priv, vaddr)) { u32 off = (vaddr - priv->shm_base); phys = priv->host_shm_phys + off; } else { phys = virt_to_phys(vaddr); } pr_debug("vaddr_to_paddr: phys: %llx, virt: %px\n", phys, vaddr); return phys; } static int rproc_vdev_notify(void *data, uint32_t notifyid) { struct rproc_remote_priv *priv = data; if (priv->notify_with_phys_irq) { struct irq_info *info = &priv->irq_info[notifyid]; signal_irq(info->remote_hwirq); } else { writel_relaxed(notifyid, priv->reg_base + RPROC_REG_KICK); } return 0; } static irqreturn_t rproc_notify_irq_handler(int irq, void *data) { struct irq_info *info = data; BUG_ON(info->vring_info == NULL || info->vring_info->vq == NULL); virtqueue_notification(info->vring_info->vq); return IRQ_HANDLED; } static void dump_rsc_table(struct device *dev, void *table) { struct rproc_resource_table *rsc_table = table; int i; dev_dbg(dev, "dump_rsc_table\n"); dev_dbg(dev, "ver=%d\n", rsc_table->ver); dev_dbg(dev, "num=%d\n", rsc_table->num); for (i = 0; i < rsc_table->num; i++) { struct fw_rsc_vdev *vdev_desc; u32 offset = rsc_table->offset[i]; vdev_desc = table + offset; dev_dbg(dev, "vdev%d, offset=%x\n", i, rsc_table->offset[i]); dev_dbg(dev, "vdev%d, type=%x", i, vdev_desc->type); dev_dbg(dev, "vdev%d, num_vrings=%d", i, vdev_desc->num_of_vrings); } } static void rproc_vdev_destroy_single(struct rproc_remote_priv *priv, int vdev_idx) { struct virtio_device_info *vdev = &priv->vdevs[vdev_idx]; struct remoteproc_virtio *rpvdev; struct rproc_resource_table *rsc_table = priv->rsc_table; struct fw_rsc_vdev *rsc = priv->rsc_table + rsc_table->offset[vdev_idx]; int i; // reset virtio device rsc->status = 0; if (!vdev->dev) return; rpvdev = container_of(vdev->dev, struct remoteproc_virtio, vdev); for (i = 0; i < vdev->dev->vrings_num; i++) { struct irq_info *irq_info; int notifyid = vdev->dev->vrings_info[i].notifyid; irq_info = &priv->irq_info[notifyid]; if (irq_info->vring_info) { irq_set_affinity_hint(irq_info->local_virq, NULL); devm_free_irq(priv->dev, irq_info->local_virq, irq_info); irq_info->vring_info = NULL; } } BUG_ON(vdev->ops->on_destroy == NULL); vdev->ops->on_destroy(vdev->dev); dev_err(priv->dev, "destroy vdev%d\n", vdev_idx); rproc_virtio_remove_vdev(vdev->dev); vdev->dev = NULL; } static bool vdev_wait_remote_ready(struct virtio_device *vdev) { uint8_t status; struct remoteproc_virtio *rpvdev; struct rproc_remote_priv *priv; int ret, retry = 0; rpvdev = container_of(vdev, struct remoteproc_virtio, vdev); priv = rpvdev->priv; while (1) { if (priv->need_release) { pr_info("virtio-%d is not alive!!!!! just quit\n", vdev->id.device); return false; } ret = virtio_get_status(vdev, &status); if (ret) { pr_info("virtio-%d: can't get status\n", vdev->id.device); return false; } if (status & VIRTIO_CONFIG_STATUS_DRIVER_OK) return true; msleep(100); retry++; if (retry == 50) { pr_info("virtio-%d still waiting for remote ready\n", vdev->id.device); retry = 0; } } } static int create_rproc_vdev(struct rproc_remote_priv *priv) { int ret, host_vmid; unsigned int num_vrings, i, vdev_idx; struct fw_rsc_vdev *vdev_rsc; struct virtio_device *vdev; struct rproc_resource_table *rsc_table = priv->rsc_table; struct nebula_rproc_vdev_ops *vdev_ops; cpumask_t mask; // bind rproc irq to vcpu4 cpumask_clear(&mask); cpumask_set_cpu(4, &mask); priv->need_release = false; dump_rsc_table(priv->dev, priv->rsc_table); for (vdev_idx = 0; vdev_idx < rsc_table->num; vdev_idx++) { dev_dbg(priv->dev, "rproc vdev%d start init\n", vdev_idx); vdev_ops = priv->vdevs[vdev_idx].ops; vdev_rsc = priv->rsc_table + rsc_table->offset[vdev_idx]; BUG_ON(vdev_rsc->type != RSC_VDEV); vdev = rproc_virtio_create_vdev(VIRTIO_DEV_DEVICE, vdev_idx, (void *)vdev_rsc, /*rsc_io=*/NULL, priv, rproc_vdev_notify, vdev_ops->on_reset); if (!vdev) { dev_info(priv->dev, "failed to create virtio vdev"); ret = -ENOMEM; goto err_free_vdev; } ret = vdev_wait_remote_ready(vdev); if (!ret) { ret = -ENODEV; rproc_virtio_remove_vdev(vdev); goto err_free_vdev; } /* The dfeatures has been updated after remote driver is ready, * we should apply it to local vdev->features */ vdev->features = vdev_rsc->dfeatures; /* set the notification id for vrings */ num_vrings = vdev_rsc->num_of_vrings; for (i = 0; i < num_vrings; i++) { const struct fw_rsc_vdev_vring *vring_rsc; phys_addr_t da; unsigned int num_descs, align; struct metal_io_region *io = NULL; void *va; size_t size; uint32_t off; struct irq_info *irq_info; int notifyid; vring_rsc = &vdev_rsc->vring[i]; notifyid = vring_rsc->notifyid; da = vring_rsc->da; dev_dbg(priv->dev, "vdev%d vring%d da=%llx\n", vdev_idx, notifyid, da); num_descs = vring_rsc->num; align = vring_rsc->align; size = vring_size(num_descs, align); off = da - (priv->host_shm_phys & 0xffffffff); va = priv->shm_base + off; ret = rproc_virtio_init_vring(vdev, i, notifyid, va, io, num_descs, align); if (ret) { dev_err(priv->dev, "vdev%d: failed to init vring, ret=%d\n", vdev_idx, ret); rproc_virtio_remove_vdev(vdev); goto err_free_vdev; } BUG_ON(notifyid >= priv->num_queues); irq_info = &priv->irq_info[notifyid]; irq_info->vring_info = &vdev->vrings_info[i]; } dev_info(priv->dev, "creating vdev%d (id:%d)\n", vdev_idx, vdev->id.device); host_vmid = get_host(priv); BUG_ON(vdev_ops->on_create == NULL); ret = vdev_ops->on_create(vdev, &priv->shm_io, host_vmid, priv->vdevs[vdev_idx].user_priv); if (ret) { dev_info(priv->dev, "failed to create rproc vdev%d, ret=%d\n", vdev_idx, ret); rproc_virtio_remove_vdev(vdev); continue; } dev_info(priv->dev, "created vdev%d (id:%d)\n", vdev_idx, vdev->id.device); priv->vdevs[vdev_idx].dev = vdev; // bind rproc irq to vcpu4 cpumask_clear(&mask); cpumask_set_cpu(4, &mask); /* The virtqueue should be created in vdev's on_create() callback, and * we should request irq only after virtqueue is created. */ for (i = 0; i < num_vrings; i++) { int notifyid = vdev_rsc->vring[i].notifyid; struct irq_info *irq_info = &priv->irq_info[notifyid]; ret = devm_request_threaded_irq(priv->dev, irq_info->local_virq, NULL, rproc_notify_irq_handler, IRQF_ONESHOT, dev_name(priv->dev), irq_info); if (ret) { dev_err(priv->dev, "vdev%d: failed to request irq, ret=%d\n", vdev_idx, ret); irq_info->vring_info = NULL; goto err_free_vdev; } irq_set_affinity_hint(irq_info->local_virq, &mask); } dev_dbg(priv->dev, "rproc vdev%d init done\n", vdev_idx); } return 0; err_free_vdev: for (i = 0; i <= vdev_idx; i++) { rproc_vdev_destroy_single(priv, i); } return ret; } static void rproc_vdev_destroy(struct rproc_remote_priv *priv) { int i, j; dev_info(priv->dev, "rproc vdev destroy start\n"); for (i = 0; i < priv->num_vdevs; i++) { struct virtio_device_info *vdev = &priv->vdevs[i]; struct remoteproc_virtio *rpvdev; struct rproc_resource_table *rsc_table = priv->rsc_table; struct fw_rsc_vdev *rsc = priv->rsc_table + rsc_table->offset[i]; // reset virtio device rsc->status = 0; dev_info(priv->dev, "destroying vdev%d\n", i); if (!vdev->dev) { dev_info(priv->dev, "vdev%d is not created, skipped\n", i); continue; } rpvdev = container_of(vdev->dev, struct remoteproc_virtio, vdev); for (j = 0; j < vdev->dev->vrings_num; j++) { struct irq_info *irq_info; int notifyid = vdev->dev->vrings_info[j].notifyid; irq_info = &priv->irq_info[notifyid]; if (irq_info->vring_info) { irq_set_affinity_hint(irq_info->local_virq, NULL); devm_free_irq(priv->dev, irq_info->local_virq, irq_info); irq_info->vring_info = NULL; } } BUG_ON(vdev->ops->on_destroy == NULL); vdev->ops->on_destroy(vdev->dev); dev_err(priv->dev, "destroyed vdev%d start\n", i); rproc_virtio_remove_vdev(vdev->dev); dev_err(priv->dev, "destroyed vdev%d end\n", i); vdev->dev = NULL; } dev_info(priv->dev, "rproc vdev destroy done\n"); } static irqreturn_t rproc_ctrl_irq_handler(int irq, void *data) { struct rproc_remote_priv *priv = (struct rproc_remote_priv *)data; u32 peer_online = readl_relaxed(priv->reg_base + RPROC_REG_PEER_ONLINE); if (!peer_online) priv->need_release = true; complete(&priv->compl); return IRQ_HANDLED; } static void get_host_shm_base_addr(struct rproc_remote_priv *priv) { priv->host_shm_phys = readl_relaxed(priv->reg_base + RPROC_REG_SHM_BASE_LOW); priv->host_shm_phys |= (u64)readl_relaxed(priv->reg_base + RPROC_REG_SHM_BASE_HIGH) << 32; } static int handle_idle(struct rproc_remote_priv *priv) { u32 peer_online = readl_relaxed(priv->reg_base + RPROC_REG_PEER_ONLINE); if (peer_online && priv->ready) { get_host_shm_base_addr(priv); writel_relaxed(0, priv->reg_base + RPROC_REG_SET_READY); complete(&priv->compl); return CREATING_VDEV; } return IDLE; } static int handle_creating_vdev(struct rproc_remote_priv *priv) { int ret = create_rproc_vdev(priv); if (ret == 0) { return VDEV_CREATED; } else { return IDLE; } } static int handle_vdev_created(struct rproc_remote_priv *priv) { u32 peer_online = readl_relaxed(priv->reg_base + RPROC_REG_PEER_ONLINE); if (priv->force_offline) peer_online = false; if (!peer_online || !priv->ready) { writel_relaxed(0, priv->reg_base + RPROC_REG_CLEAR_READY); complete(&priv->compl); return DESTROYING_VDEV; } return VDEV_CREATED; } static int handle_destroying_vdev(struct rproc_remote_priv *priv) { rproc_vdev_destroy(priv); return IDLE; } static int create_vdev(void *args) { struct rproc_remote_priv *priv = (struct rproc_remote_priv *)args; int state, next_state; while (!kthread_should_stop()) { wait_for_completion_interruptible(&priv->compl); state = get_state(priv); switch (state) { case IDLE: next_state = handle_idle(priv); break; case CREATING_VDEV: next_state = handle_creating_vdev(priv); break; case VDEV_CREATED: next_state = handle_vdev_created(priv); break; case DESTROYING_VDEV: pr_err("create_vdev DESTROYING_VDEV \n"); next_state = handle_destroying_vdev(priv); break; default: BUG(); } set_state(priv, next_state); } return 0; } static ssize_t ready_show(struct device *dev, struct device_attribute *attr, char *buf) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); return sprintf(buf, "%u\n", priv->ready); } static ssize_t ready_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); bool ready; int ret; ret = strtobool(buf, &ready); if (ret < 0) return ret; priv->ready = ready; complete(&priv->compl); return ret == 0 ? size : ret; } static DEVICE_ATTR_RW(ready); static ssize_t state_show(struct device *dev, struct device_attribute *attr, char *buf) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); return sprintf(buf, "%s\n", state_string[get_state(priv)]); } static DEVICE_ATTR_RO(state); static ssize_t peer_vmid_show(struct device *dev, struct device_attribute *attr, char *buf) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); return sprintf(buf, "%d\n", readl_relaxed(priv->reg_base + RPROC_REG_PEER_VMID)); } static DEVICE_ATTR_RO(peer_vmid); static ssize_t peer_online_show(struct device *dev, struct device_attribute *attr, char *buf) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); return sprintf(buf, "%d\n", readl_relaxed(priv->reg_base + RPROC_REG_PEER_ONLINE)); } static DEVICE_ATTR_RO(peer_online); static ssize_t resource_table_show(struct device *dev, struct device_attribute *attr, char *buf) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); int len, i, j; struct rproc_resource_table *rsc_table = priv->shm_base; len = snprintf(buf, PAGE_SIZE, "ver=0x%x, num=%u\n", rsc_table->ver, rsc_table->num); if ((len >= PAGE_SIZE) || (len < 0)) return -ENOSPC; for (i = 0; i < rsc_table->num; i++) { struct fw_rsc_vdev *vdev = (void *)rsc_table + rsc_table->offset[i]; len += snprintf( buf + len, PAGE_SIZE - len, " id=0x%x, features=0x%x, status=0x%x, num_vrings=%d\n", vdev->id, vdev->gfeatures, vdev->status, vdev->num_of_vrings); if (len >= PAGE_SIZE) return -ENOSPC; for (j = 0; j < vdev->num_of_vrings; j++) { struct fw_rsc_vdev_vring *vring = &vdev->vring[j]; len += snprintf(buf + len, PAGE_SIZE - len, " vring%d, notifyid=%d, num=%d\n", j, vring->notifyid, vring->num); if (len >= PAGE_SIZE) return -ENOSPC; } } return len; } static DEVICE_ATTR_RO(resource_table); static ssize_t force_offline_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct rproc_remote_priv *priv = dev_get_drvdata(dev); int ret = 0; bool force_offline; ret = strtobool(buf, &force_offline); if (ret < 0) return ret; priv->force_offline = force_offline; complete(&priv->compl); return ret == 0 ? size : ret; } static DEVICE_ATTR_WO(force_offline); static struct attribute *rproc_dev_attrs[] = { &dev_attr_ready.attr, &dev_attr_state.attr, &dev_attr_peer_vmid.attr, &dev_attr_peer_online.attr, &dev_attr_resource_table.attr, &dev_attr_force_offline.attr, NULL, }; static struct attribute_group rproc_dev_group = { .attrs = rproc_dev_attrs, }; static int rproc_remote_probe(struct platform_device *pdev) { struct resource *mem; struct device *dev = &pdev->dev; struct rproc_remote_priv *priv; int ret; void *__iomem reg_base; void *shm_base; size_t shm_size; int i, irq_count, remote_irq_count, virq; struct rproc_resource_table *rsc_table; cpumask_t mask; priv = kzalloc(sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { ret = -EINVAL; goto err_free_priv; } reg_base = devm_ioremap_resource(dev, mem); if (IS_ERR(reg_base)) { ret = PTR_ERR(reg_base); goto err_free_priv; } mem = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (!mem) { ret = -EINVAL; goto err_unmap_reg; } shm_size = resource_size(mem); shm_base = devm_memremap(dev, mem->start, shm_size, MEMREMAP_WB); if (!shm_base) { ret = -EINVAL; goto err_unmap_reg; } dev_info(dev, "shared memory @ %px, size %lx\n", shm_base, shm_size); priv->reg_base = reg_base; priv->shm_base = shm_base; priv->shm_size = shm_size; priv->rsc_table = priv->shm_base; priv->dev = &pdev->dev; priv->shm_io.paddr_to_vaddr = rproc_paddr_to_vaddr; priv->shm_io.vaddr_to_paddr = rproc_vaddr_to_paddr; mutex_init(&priv->rsc_table_mutex); platform_set_drvdata(pdev, priv); irq_count = platform_irq_count(pdev); ret = of_property_read_u32(dev->of_node, "remote_irq_count", &remote_irq_count); BUG_ON(ret != 0); if (remote_irq_count) { dev_info(dev, "notify using physical interrupt\n"); priv->notify_with_phys_irq = true; BUG_ON(remote_irq_count != irq_count - 1); } // bind rproc irq to vcpu4 cpumask_clear(&mask); cpumask_set_cpu(4, &mask); init_completion(&priv->compl); virq = platform_get_irq(pdev, 0); ret = devm_request_threaded_irq(&pdev->dev, virq, NULL, rproc_ctrl_irq_handler, IRQF_ONESHOT, dev_name(&pdev->dev), priv); BUG_ON(ret < 0); irq_set_affinity_hint(virq, &mask); priv->num_queues = irq_count - 1; priv->irq_info = kzalloc(irq_count * sizeof(struct irq_info), GFP_KERNEL); if (!priv->irq_info) goto err_unmap_reg; for (i = 0; i < priv->num_queues; i++) { struct irq_info *irq_info = &priv->irq_info[i]; virq = platform_get_irq(pdev, i + 1); BUG_ON(virq < 0); irq_info->local_virq = virq; if (priv->notify_with_phys_irq) { int hwirq; ret = of_property_read_u32_index( dev->of_node, "remote_irqs", i, &hwirq); BUG_ON(ret < 0); irq_info->remote_hwirq = hwirq; } } rsc_table = priv->shm_base; rsc_table->ver = 1; priv->rsc_table_offset = sizeof(struct rproc_resource_table); INIT_LIST_HEAD(&priv->node); priv->state = IDLE; spin_lock_init(&priv->state_lock); ret = sysfs_create_group(&dev->kobj, &rproc_dev_group); WARN_ON(ret != 0); priv->thread = kthread_run(create_vdev, priv, "rproc_vdev_create"); if (IS_ERR(priv->thread)) { dev_err(priv->dev, "ERROR: failed to start rproc_vdev_create\n"); ret = PTR_ERR(priv->thread); goto err_unmap_reg; } mutex_lock(&rproc_devices_lock); list_add(&priv->node, &rproc_devices); mutex_unlock(&rproc_devices_lock); return 0; err_unmap_reg: devm_iounmap(dev, reg_base); err_free_priv: kfree(priv); return ret; } static const struct of_device_id rproc_remote_of_match[] = { { .compatible = "grt,rproc-remote", }, {}, }; static struct platform_driver nebula_rproc_remote = { .probe = rproc_remote_probe, .driver = { .name = "nebula-rproc-remote", .owner = THIS_MODULE, .of_match_table = rproc_remote_of_match, }, }; static int __init nebula_rproc_remote_init(void) { return platform_driver_register(&nebula_rproc_remote); } module_init(nebula_rproc_remote_init); MODULE_LICENSE("Dual BSD/GPL");
最新发布
08-03
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值