DEVICE_ATTR_RW和DEVICE_ATTR区别

时间: 2024-12-30 07:30:33 浏览: 95
### DEVICE_ATTR_RW 和 DEVICE_ATTR 的区别 Linux内核提供了多种宏来简化设备属性的创建过程。`DEVICE_ATTR` 是用于定义只读或可写属性的基础宏[^2]。 对于 `DEVICE_ATTR` 宏而言,其语法结构如下: ```c #define DEVICE_ATTR(_name, _mode, _show, _store) ``` 此宏接受四个参数:属性名称 `_name`、权限模式 `_mode` 以及两个函数指针 `_show` 和 `_store` 分别对应于读取操作和写入操作。当只需要实现单向的数据访问(即要么能读不能写,要么能写不能读),可以仅提供相应的回调函数;如果不需要某个方向的操作,则可以把该位置设为空(NULL)。 而 `DEVICE_ATTR_RW` 则是一个更高层次封装版本,在功能上更加具体化。它专门用来声明既支持读又支持写的双向属性,并自动为用户提供默认的读写接口模板。因此,使用起来更为简便快捷。其实现方式本质上还是依赖于基础版的 `DEVICE_ATTR` 来完成实际工作[^1]。 通过比较可以看出,虽然两者都基于相同的底层机制构建而成,但是面向的应用场景有所不同——前者给予开发者更大的灵活性去定制特定行为,后者则更侧重于快速搭建常规性的读写特性。 #### 示例代码展示 以下是利用上述两种不同类型的宏实例化的简单示例: ```c // 使用 DEVICE_ATTR 创建一个名为 "example_attr" 的属性, // 支持读 (read_example_show),也支持写 (write_example_store). static ssize_t read_example_show(struct device *dev, struct device_attribute *attr, char *buf); static ssize_t write_example_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count); static DEVICE_ATTR(example_attr, 0644, read_example_show, write_example_store); // 使用 DEVICE_ATTR_RW 可以达到相同的效果,但编码量减少。 static ssize_t example_rw_show(struct device *dev, struct device_attribute *attr, char *buf); static ssize_t example_rw_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count); static DEVICE_ATTR_RW(wakealarm); // 实际应用中的例子来自 rtc-sysfs.c 文件 ```
阅读全文

相关推荐

// 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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");

2025-07-01 09:04:15.454 314-1971 libc cameraserver W Unable to set property "vendor.sys.camera.callprocess" to "plat.szxingfang.com": connection failed; errno=13 (Permission denied) 2025-07-01 09:04:15.455 314-1971 CameraService cameraserver I CameraService::connect call (PID -1 "plat.szxingfang.com", camera ID 114) for HAL version default and Camera API version 1 2025-07-01 09:04:15.457 314-1971 Camera2ClientBase cameraserver I Camera 114: Opened. Client: plat.szxingfang.com (PID 1703, UID 10074) 2025-07-01 09:04:15.460 1703-1703 Thread-19 plat.szxingfang.com W type=1400 audit(0.0:245): avc: denied { write } for name="gc8034_led" dev="sysfs" ino=25164 scontext=u:r:untrusted_app_29:s0:c74,c256,c512,c768 tcontext=u:object_r:sysfs:s0 tclass=file permissive=0 app=plat.szxingfang.com 2025-07-01 09:04:15.462 1703-2340 System.err plat.szxingfang.com W java.io.FileNotFoundException: /sys/class/gc8034_class/gc8034_dev/gc8034_led: open failed: EACCES (Permission denied) 2025-07-01 09:04:15.462 1703-2340 System.err plat.szxingfang.com W at libcore.io.IoBridge.open(IoBridge.java:492) 2025-07-01 09:04:15.463 1703-2340 System.err plat.szxingfang.com W at java.io.FileOutputStream.<init>(FileOutputStream.java:236) 2025-07-01 09:04:15.463 1703-2340 System.err plat.szxingfang.com W at java.io.FileOutputStream.<init>(FileOutputStream.java:125) 2025-07-01 09:04:15.463 1703-2340 System.err plat.szxingfang.com W at android.hardware.Camera.lambda$setCameraLightMode$0(Camera.java:4590) 2025-07-01 09:04:15.463 1703-2340 System.err plat.szxingfang.com W at android.hardware.-$$Lambda$Camera$qGhgdUly9cnX7HYcg6QdXFuicLA.run(Unknown Source:2) 20

最新推荐

recommend-type

户外移动机器人的后处理,过滤 GPS、里程计和 IMU 数据以进行全球定位和环境映射。.zip

1.版本:matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点:参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象:计算机,电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
recommend-type

PKID查壳工具最新版发布,轻松识别安卓安装包加壳

根据提供的文件信息,我们可以详细解读以下知识点: ### PKiD(查壳)工具介绍 #### 标题分析 - **PKiD(查壳)**: 这是一个专门用于分析安卓安装包(APK文件)是否被加壳的应用程序。"查壳"是一种用于检测软件是否被保护层(即“壳”)包裹的技术术语。加壳是一种常见的软件保护手段,用于隐藏真实的代码逻辑,防止恶意逆向分析。 - **RAR格式文件**: 文件使用了RAR格式进行压缩,这是WinRAR软件用于文件压缩和解压缩的专有格式。 #### 描述分析 - **ApkScan-PKID查壳工具.zip**: 这指的是一款名为ApkScan的工具,它包含了PKID查壳功能。该工具被打包成ZIP格式,便于用户下载和使用。 - **安卓安装包**: 这是指Android平台的应用程序安装包,通常以APK作为文件扩展名。 - **加壳检测**: PKID查壳工具用于检测APK文件是否被加壳,加壳是一种常见的软件保护技术,用于加密和保护软件免遭逆向工程。 - **脱壳测试**: 如果检测到加壳,脱壳测试将用于尝试去除或绕过保护层,以便进行安全分析、调试或修改程序。 #### 标签分析 - **查壳**: 再次强调了工具的主要功能,即检测APK文件中的加壳情况。 - **最新版**: 表示这个文件是PKID查壳工具的最新版本。 - **PKID**: 这是工具的核心名称,代表着该软件的主要功能和用途。 #### 文件列表分析 - **PKiD(查壳).exe**: 这是一个可执行文件,说明PKID查壳工具是一个独立的应用程序,用户可以通过双击此文件直接运行程序,而无需安装。 ### 技术背景 #### 查壳工具的工作原理 查壳工具通常通过分析APK文件的头部信息、资源文件和代码段来检测加壳。它可能会检查PE文件格式的特定区域(APK基于DEX,但PE检查的概念相似),这些区域在加壳过程中可能会被特定的代码模式、字符串或签名标记。例如,某些壳会在文件头部加入特定的字符串,或者修改方法计数等信息。 #### 加壳技术 加壳技术通常用于防止软件被轻易反编译或逆向工程。它可以阻止潜在的窃取知识产权、绕过付费或防止代码分析等。加壳过程包括加密和压缩原始代码,然后在运行时解压和解密代码以供执行。 #### 脱壳技术 脱壳技术是指绕过或移除软件保护壳的过程。这通常需要对壳的工作原理有深入了解,并且需要一定的逆向工程技能。脱壳过程可能包括识别壳的签名、分析保护机制、修改代码和重定位等步骤。 #### 安全测试与逆向工程 查壳工具对于安全测试和逆向工程人员来说是非常重要的工具。它们可以帮助识别软件是否被加壳,从而决定是否需要进行脱壳操作以便深入分析软件的安全漏洞或版权问题。 #### 使用场景 - **安全测试**: 安全工程师在对移动应用程序进行安全评估时,需要确认是否有必要进行脱壳处理。 - **逆向工程**: 开发人员可能需要逆向工程某个应用,以更好地理解其工作原理或为了兼容性问题进行修改。 - **软件保护**: 对于软件开发者而言,了解常见的加壳和脱壳技术有助于更好地保护自己的应用免遭未授权的篡改和分析。 ### 结论 了解和掌握PKID查壳工具的使用对于任何需要对APK文件进行安全性分析的专业人士来说都是基础且关键的技能。该工具提供了一种快速判断软件是否加壳的方法,而且在发现壳的情况下,还可以推测出壳的来源公司,这对于后续的分析和处理提供了便利。然而,值得注意的是,进行脱壳操作往往需要对原始程序代码进行逆向工程,这在很多情况下可能涉及法律和道德问题,因此在使用此类工具时,必须确保其合法性和符合道德规范。
recommend-type

【心理学火柴人视频制作秘籍】:Coze工作流全攻略,带你从入门到精通

# 1. 心理学火柴人视频制作概述 ## 1.1 创作心理学火柴人视频的动机 心理学火柴人视频作为一种富有创意的视觉传达方式,不仅能够将复杂的心理学理论变得生动和易于理解,而且还能为观众提供轻松愉悦的学习体验。这种视频通常采用简化的角色——火柴人,通过动画的形式演绎心理学相关的内容,使得原本抽象的理论变得具体、形象。 ## 1.2 火柴人视频的普及与应用 随着互联
recommend-type

frame.onload不执行?

<think>在解决`frame.onload`不执行的问题时,我们需要考虑多种可能的原因和解决方案。下面我将详细解释这个问题,并提供相应的代码示例。##可能的原因及解决方案###1.事件绑定时机不正确如果我们在设置`src`属性之后再绑定`onload`事件,可能会错过事件的触发(因为资源可能已经加载完成)。所以,我们应该在设置`src`之前绑定`onload`事件。###2.资源加载失败如果资源加载失败,`onload`事件可能不会触发,而触发`onerror`事件。因此,我们需要同时监听`onerror`事件。###3.iframe内容为空如果我们使用`document.write`来设
recommend-type

一键关闭系统更新的工具介绍

从给定的文件信息中我们可以分析出几个相关的知识点,以下是详细说明: 【标题】“系统禁止更新工具.7z”暗示着这个压缩文件内包含的可能是一款软件工具,其主要功能是阻止或禁止操作系统的更新。这种工具可能针对的是Windows、Linux或者其他操作系统的自动更新功能。一般来说,用户可能出于稳定性考虑,希望控制更新时间,或者是因为特定的软件环境依赖于旧版本的系统兼容性,不希望系统自动更新导致兼容性问题。 【描述】“一健关闭系统更新”说明了该工具的使用方式非常简单直接。用户只需通过简单的操作,比如点击一个按钮或者执行一个命令,就能实现关闭系统自动更新的目的。这种一键式操作符合用户追求的易用性原则,使得不太精通系统操作的用户也能轻松控制更新设置。 【标签】“系统工具”表明这是一个与操作系统紧密相关的辅助工具。系统工具通常包括系统清理、性能优化、磁盘管理等多种功能,而本工具专注于管理系统更新,使其成为系统维护中的一环。 【压缩包子文件的文件名称列表】“系统禁止更新工具”是压缩包内的文件名。由于文件格式为“.7z”,这说明该工具采用了7-Zip压缩格式。7-Zip是一款开源且免费的压缩软件,支持非常高的压缩比,并且能够处理各种压缩文件格式,如ZIP、RAR等。它支持创建密码保护的压缩文件和分卷压缩,这在需要转移大量数据时特别有用。然而在这个上下文中,“系统禁止更新工具”文件名暗示了该压缩包内只包含了一个程序,即专门用于关闭系统更新的工具。 根据标题和描述,我们可以推测该工具可能的实现机制,例如: 1. 修改系统服务的配置:在Windows系统中,可以通过修改Windows Update服务的属性来禁用该服务,从而阻止系统自动下载和安装更新。 2. 修改注册表设置:通过编辑Windows注册表中的某些特定键值,可以关闭系统更新功能。这通常涉及到对HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate和HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate\AU等路径下的设置进行修改。 3. 使用第三方软件:某些第三方工具提供了一键禁用系统更新的功能,通过修改操作系统的相关文件和配置来实现更新的禁用。这包括阻止Windows Update的运行、拦截更新下载等。 该工具的使用可能带来一些后果,比如系统安全风险的增加、系统漏洞得不到及时修复以及可能违反某些软件许可协议。用户在使用这类工具时应该清楚这些潜在的影响,并自行承担相应的风险。 总结来说,该“系统禁止更新工具”可以视为一个针对特定用户需求,尤其是企业用户或个人用户中对系统稳定性有较高要求的人群,提供的一个便捷的解决方案。它通过直接修改系统设置来禁止操作系统自动更新,但用户在使用此工具时需要谨慎,因为这可能会带来系统安全和稳定性的风险。
recommend-type

罗技GHUB驱动21.03.24版自定义设置与性能优化:专家级使用技巧

# 摘要 本文综合介绍了罗技GHUB驱动的安装、自定义设置、性能优化、进阶应用以及故障排除。通过对GHUB软件界面和功能的详细介绍,阐述了硬件识别、宏命令创建以及游戏特有设置的定制。同时,文中探讨了性能调整的理论基础,并提供实践中针对网络延迟和数据传输优化的具体技巧。进一步探讨了高级个性化配置和第三方软件集成的策略,最后针对
recommend-type

RX72M单片机读取差分编码器,输入输出滤波,差分转单端后将5V电压转为3.3v输入给单片机

<think>嗯,我需要帮助用户解决关于RX72M单片机读取差分编码器的问题。用户的需求很明确:如何用RX72M单片机读取差分编码器,实现输入输出滤波,将差分信号转为单端信号,并进行5V到3.3V的电平转换。首先回顾用户之前的几个引用。引用1提到ADC的差分输入模式,这让我想到用户可能需要处理模拟信号,但差分编码器通常是数字信号。用户的主要需求集中在数字信号处理,比如正交编码器的脉冲信号。因此,可能需要参考引用1中的差分输入设置,但注意这里适用的是数字接口而非ADC。引用2关于74HC245和SN74LVC1T45DBVR芯片的内容非常有价值。这两个都是电平转换方案,尤其是SN74LVC1T4
recommend-type

鼎捷易飞ERPV9.0委外进货单批量导入解决方案

根据提供的文件信息,我们可以从标题、描述、标签以及压缩包文件列表中提取以下知识点: 1. 委外进货单批量导入程序及模版格式 标题提到的“委外进货单批量导入程序”指的是一个软件应用,其主要功能是允许用户批量地将委外进货数据导入到ERP系统中。批量导入通常是指在ERP系统中不需要逐条手动输入数据,而是通过预先定义好的模板,一次性将大量数据导入系统。这样的程序对于提高工作效率、减少重复性工作以及避免人为错误具有重要意义。 2. 鼎捷易飞ERPV9.0 描述中提到的“鼎捷易飞ERPV9.0”是一个特定版本的ERP系统,由鼎捷软件公司开发。ERP(Enterprise Resource Planning,企业资源计划)系统是一种用于整合企业内部所有资源信息,实现信息流、物流、资金流、工作流的高度集成和自动化管理的软件。ERPV9.0是该系列产品的版本号,表明该程序和文件模板是为这一特定版本的ERP系统设计。 3. .NET C#源代码 标题中的“.NET C#源代码”表示程序是使用.NET框架和C#语言开发的。.NET是微软公司开发的一个软件框架,用于构建和运行Windows应用程序。C#(读作“C Sharp”)是.NET框架下的一种编程语言,具有面向对象、类型安全和垃圾回收等特点。开发者可能提供了源代码,以便企业用户可以自行修改、调整以满足特定需求。 4. 使用方法和步骤 描述中详细说明了程序的使用方法: - 首先编辑模版格式数据,即将需要导入的数据按照特定的格式要求填写到模板中。 - 然后在程序中选择单别(可能指的是单据类型)和日期等条件。 - 点击“导入数据”按钮,程序将提示用户选择含有数据的模板文件。 - 程序会进行数据校验,以确保数据的正确性。校验规则是特定的,如果用户不需要特定的校验条件,可以在程序中直接删除这部分代码。 - 最后,数据校验无误后,程序可以生成相应的进货单据。 5. 自定义程序和模板 在标签中提到的“易飞ERP委外进货单导入程序”、“委外进货单导入程序”和“易飞ERP自定义程序”表明,所提供的程序可以根据用户的特定需求进行定制。同时,模板格式的使用,也意味着用户可以根据自己的业务需要和ERP系统的要求调整模板内容,以便更好地适应数据导入过程。 6. 压缩包子文件的文件名称列表 提供的压缩包包含两个文件: - “委外进货单批量导入格式.xls”指的是一个Excel格式的文件,这个文件应该是一个符合要求的导入模板,用户需要按照这个模板的格式来准备需要导入的数据。 - “委外入库导入(源代码).zip”是一个包含源代码的压缩文件,其中可能包含程序的完整源代码,也可能仅包含与导入功能相关的部分代码。 7. 文件列表和数据导入流程 通过文件列表可以理解整个数据导入流程: - 用户首先需要准备好数据,并将其按照“委外进货单批量导入格式.xls”模板中的要求填入相应的数据。 - 用户然后使用“委外入库导入(源代码).zip”中的程序,根据程序使用说明进行配置。 - 最后,用户通过程序界面导入整理好的Excel模板文件,程序会自动处理数据导入的过程,并进行必要的数据校验,最终生成所需的进货单据。 以上总结的知识点涵盖了该压缩包文件的内容、用途、技术细节以及操作步骤,为了解和使用该委外进货单批量导入程序提供了充分的信息。
recommend-type

罗技GHUB驱动21.03.24版更新日志详细解读:驱动改进点全掌握

# 摘要 罗技GHUB驱动自发布以来,不断更新以提升兼容性、用户界面体验、性能和功能。本文主要概述了罗技GHUB驱动的更新历程,特别聚焦于21.03.24版的改进点,包括对新硬件的支持、现有设备兼容性的增强、界面设计和交互体验的优化。此外,本文深入探讨了该版本新增与改进的功能及其具体使用方法,并提供了故障排除指南。通过与旧版驱
recommend-type

<Tag color={value} onMouseDown={onPreventMouseDown} closable={closable} onClose={onClose} style={{ marginInlineEnd: 4 }} > {label} </Tag> 我想让他的color为随机

<think>我们正在讨论如何为一个React的Tag组件设置color属性为随机颜色。根据引用[1],我们可以创建一个样式对象,但这里我们需要动态生成随机颜色。我们可以考虑在组件内部生成随机颜色的逻辑,然后将这个随机颜色应用到样式上。思路:1.在组件的函数内部(如果使用函数组件)或类组件的render方法中,生成一个随机颜色。2.将这个随机颜色作为样式属性(例如:color或backgroundColor)的值。然而,需要注意:引用[2]提到了性能优化,即如果组件不需要根据外部状态变化重新渲染,可以使用shouldComponentUpdate返回false。但这里我们每次都需要随机颜色,所