static ssize_t store_orig_interval(struct kobject *kobj, struct attribute *attr, char *buff, size_t count) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct bat_priv *bat_priv = netdev_priv(net_dev); unsigned long orig_interval_tmp; int ret; ret = strict_strtoul(buff, 10, &orig_interval_tmp); if (ret) { bat_info(net_dev, "Invalid parameter for 'orig_interval' " "setting received: %s\n", buff); return -EINVAL; } if (orig_interval_tmp < JITTER * 2) { bat_info(net_dev, "New originator interval too small: %li " "(min: %i)\n", orig_interval_tmp, JITTER * 2); return -EINVAL; } if (atomic_read(&bat_priv->orig_interval) == orig_interval_tmp) return count; bat_info(net_dev, "Changing originator interval from: %i to: %li\n", atomic_read(&bat_priv->orig_interval), orig_interval_tmp); atomic_set(&bat_priv->orig_interval, orig_interval_tmp); return count; }
static ssize_t store_log_level(struct kobject *kobj, struct attribute *attr, char *buff, size_t count) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct bat_priv *bat_priv = netdev_priv(net_dev); unsigned long log_level_tmp; int ret; ret = strict_strtoul(buff, 10, &log_level_tmp); if (ret) { bat_info(net_dev, "Invalid parameter for 'log_level' " "setting received: %s\n", buff); return -EINVAL; } if (log_level_tmp > 3) { bat_info(net_dev, "New log level too big: %li " "(max: %i)\n", log_level_tmp, 3); return -EINVAL; } if (atomic_read(&bat_priv->log_level) == log_level_tmp) return count; bat_info(net_dev, "Changing log level from: %i to: %li\n", atomic_read(&bat_priv->log_level), log_level_tmp); atomic_set(&bat_priv->log_level, (unsigned)log_level_tmp); return count; }
static blk_status_t pmem_clear_poison(struct pmem_device *pmem, phys_addr_t offset, unsigned int len) { struct device *dev = to_dev(pmem); sector_t sector; long cleared; blk_status_t rc = BLK_STS_OK; sector = (offset - pmem->data_offset) / 512; cleared = nvdimm_clear_poison(dev, pmem->phys_addr + offset, len); if (cleared < len) rc = BLK_STS_IOERR; if (cleared > 0 && cleared / 512) { hwpoison_clear(pmem, pmem->phys_addr + offset, cleared); cleared /= 512; dev_dbg(dev, "%#llx clear %ld sector%s\n", (unsigned long long) sector, cleared, cleared > 1 ? "s" : ""); badblocks_clear(&pmem->bb, sector, cleared); if (pmem->bb_state) sysfs_notify_dirent(pmem->bb_state); } arch_invalidate_pmem(pmem->virt_addr + offset, len); return rc; }
static int pmem_clear_poison(struct pmem_device *pmem, phys_addr_t offset, unsigned int len) { struct device *dev = to_dev(pmem); sector_t sector; long cleared; int rc = 0; sector = (offset - pmem->data_offset) / 512; cleared = nvdimm_clear_poison(dev, pmem->phys_addr + offset, len); if (cleared < len) rc = -EIO; if (cleared > 0 && cleared / 512) { cleared /= 512; dev_dbg(dev, "%s: %#llx clear %ld sector%s\n", __func__, (unsigned long long) sector, cleared, cleared > 1 ? "s" : ""); badblocks_clear(&pmem->bb, sector, cleared); } invalidate_pmem(pmem->virt_addr + offset, len); return rc; }
static ssize_t show_log_level(struct kobject *kobj, struct attribute *attr, char *buff) { struct device *dev = to_dev(kobj->parent); struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); int log_level = atomic_read(&bat_priv->log_level); return sprintf(buff, "%d\n", log_level); }
static ssize_t show_orig_interval(struct kobject *kobj, struct attribute *attr, char *buff) { struct device *dev = to_dev(kobj->parent); struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); return sprintf(buff, "%i\n", atomic_read(&bat_priv->orig_interval)); }
static void audmapp_write(struct audmapp_chan *auchan, u32 data, u32 reg) { struct audmapp_device *audev = to_dev(auchan); struct device *dev = audev->dev; dev_dbg(dev, "w %p : %08x\n", auchan->base + reg, data); iowrite32(data, auchan->base + reg); }
static u32 mt9m032_row_time(struct mt9m032 *sensor, unsigned int width) { unsigned int effective_width; u32 ns; effective_width = width + 716; /* empirical value */ ns = div_u64(1000000000ULL * effective_width, sensor->pix_clock); dev_dbg(to_dev(sensor), "MT9M032 line time: %u ns\n", ns); return ns; }
static ssize_t show_bond(struct kobject *kobj, struct attribute *attr, char *buff) { struct device *dev = to_dev(kobj->parent); struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); int bond_status = atomic_read(&bat_priv->bonding_enabled); return sprintf(buff, "%s\n", bond_status == 0 ? "disabled" : "enabled"); }
static ssize_t dev_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) { struct device_attribute * dev_attr = to_dev_attr(attr); struct device * dev = to_dev(kobj); ssize_t ret = -EIO; if (dev_attr->show) ret = dev_attr->show(dev, dev_attr, buf); return ret; }
static int dev_hotplug_filter(struct kset *kset, struct kobject *kobj) { struct kobj_type *ktype = get_ktype(kobj); if (ktype == &ktype_device) { struct device *dev = to_dev(kobj); if (dev->bus) return 1; } return 0; }
static ssize_t show_vis_mode(struct kobject *kobj, struct attribute *attr, char *buff) { struct device *dev = to_dev(kobj->parent); struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); int vis_mode = atomic_read(&bat_priv->vis_mode); return sprintf(buff, "%s\n", vis_mode == VIS_TYPE_CLIENT_UPDATE ? "client" : "server"); }
static ssize_t dev_attr_store(struct kobject * kobj, struct attribute * attr, const char * buf, size_t count) { struct device_attribute * dev_attr = to_dev_attr(attr); struct device * dev = to_dev(kobj); ssize_t ret = -EIO; if (dev_attr->store) ret = dev_attr->store(dev, dev_attr, buf, count); return ret; }
/** * device_release - free device structure. * @kobj: device's kobject. * * This is called once the reference count for the object * reaches 0. We forward the call to the device's release * method, which should handle actually freeing the structure. */ static void device_release(struct kobject * kobj) { struct device * dev = to_dev(kobj); if (dev->release) dev->release(dev); else { printk(KERN_ERR "Device '%s' does not have a release() function, " "it is broken and must be fixed.\n", dev->bus_id); WARN_ON(1); } }
static ssize_t show_mesh_iface(struct kobject *kobj, struct attribute *attr, char *buff) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct batman_if *batman_if = get_batman_if_by_netdev(net_dev); if (!batman_if) return 0; return sprintf(buff, "%s\n", batman_if->if_status == IF_NOT_IN_USE ? "none" : "bat0"); }
static void audmapp_start_xfer(struct shdma_chan *schan, struct shdma_desc *sdesc) { struct audmapp_chan *auchan = to_chan(schan); struct audmapp_device *audev = to_dev(auchan); struct audmapp_desc *desc = to_desc(sdesc); struct device *dev = audev->dev; u32 chcr = auchan->chcr | PDMACHCR_DE; dev_dbg(dev, "src/dst/chcr = %pad/%pad/%08x\n", &desc->src, &desc->dst, chcr); audmapp_write(auchan, desc->src, PDMASAR); audmapp_write(auchan, desc->dst, PDMADAR); audmapp_write(auchan, chcr, PDMACHCR); }
static int audmapp_get_config(struct audmapp_chan *auchan, int slave_id, u32 *chcr, dma_addr_t *dst) { struct audmapp_device *audev = to_dev(auchan); struct audmapp_pdata *pdata = audev->pdata; struct audmapp_slave_config *cfg; int i; *chcr = 0; *dst = 0; if (!pdata) { /* DT */ *chcr = ((u32)slave_id) << 16; auchan->shdma_chan.slave_id = (slave_id) >> 8; return 0; }
/* * Export the forwarding information table as a binary file * The records are struct __fdb_entry. * * Returns the number of bytes read. */ static ssize_t brforward_read(struct kobject *kobj, char *buf, loff_t off, size_t count) { struct device *dev = to_dev(kobj); struct net_bridge *br = to_bridge(dev); int n; /* must read whole records */ if (off % sizeof(struct __fdb_entry) != 0) return -EINVAL; n = br_fdb_fillbuf(br, buf, count / sizeof(struct __fdb_entry), off / sizeof(struct __fdb_entry)); if (n > 0) n *= sizeof(struct __fdb_entry); return n; }
static ssize_t store_vis_mode(struct kobject *kobj, struct attribute *attr, char *buff, size_t count) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct bat_priv *bat_priv = netdev_priv(net_dev); unsigned long val; int ret, vis_mode_tmp = -1; ret = strict_strtoul(buff, 10, &val); if (((count == 2) && (!ret) && (val == VIS_TYPE_CLIENT_UPDATE)) || (strncmp(buff, "client", 6) == 0) || (strncmp(buff, "off", 3) == 0)) vis_mode_tmp = VIS_TYPE_CLIENT_UPDATE; if (((count == 2) && (!ret) && (val == VIS_TYPE_SERVER_SYNC)) || (strncmp(buff, "server", 6) == 0)) vis_mode_tmp = VIS_TYPE_SERVER_SYNC; if (vis_mode_tmp < 0) { if (buff[count - 1] == '\n') buff[count - 1] = '\0'; bat_info(net_dev, "Invalid parameter for 'vis mode' setting received: " "%s\n", buff); return -EINVAL; } if (atomic_read(&bat_priv->vis_mode) == vis_mode_tmp) return count; bat_info(net_dev, "Changing vis mode from: %s to: %s\n", atomic_read(&bat_priv->vis_mode) == VIS_TYPE_CLIENT_UPDATE ? "client" : "server", vis_mode_tmp == VIS_TYPE_CLIENT_UPDATE ? "client" : "server"); atomic_set(&bat_priv->vis_mode, (unsigned)vis_mode_tmp); return count; }
static int dev_hotplug(struct kset *kset, struct kobject *kobj, char **envp, int num_envp, char *buffer, int buffer_size) { struct device *dev = to_dev(kobj); int i = 0; int length = 0; int retval = 0; /* add bus name of physical device */ if (dev->bus) add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &length, "PHYSDEVBUS=%s", dev->bus->name); /* add driver name of physical device */ if (dev->driver) add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &length, "PHYSDEVDRIVER=%s", dev->driver->name); /* terminate, set to next free slot, shrink available space */ envp[i] = NULL; envp = &envp[i]; num_envp -= i; buffer = &buffer[length]; buffer_size -= length; if (dev->bus && dev->bus->hotplug) { /* have the bus specific function add its stuff */ retval = dev->bus->hotplug (dev, envp, num_envp, buffer, buffer_size); if (retval) { pr_debug ("%s - hotplug() returned %d\n", __FUNCTION__, retval); } } return retval; }
static ssize_t store_mesh_iface(struct kobject *kobj, struct attribute *attr, char *buff, size_t count) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct batman_if *batman_if = get_batman_if_by_netdev(net_dev); int status_tmp = -1; if (!batman_if) return count; if (strncmp(buff, "none", 4) == 0) status_tmp = IF_NOT_IN_USE; if (strncmp(buff, "bat0", 4) == 0) status_tmp = IF_I_WANT_YOU; if (status_tmp < 0) { if (buff[count - 1] == '\n') buff[count - 1] = '\0'; pr_err("Invalid parameter for 'mesh_iface' setting received: " "%s\n", buff); return -EINVAL; } if ((batman_if->if_status == status_tmp) || ((status_tmp == IF_I_WANT_YOU) && (batman_if->if_status != IF_NOT_IN_USE))) return count; if (status_tmp == IF_I_WANT_YOU) status_tmp = hardif_enable_interface(batman_if); else hardif_disable_interface(batman_if); return (status_tmp < 0 ? status_tmp : count); }
static ssize_t store_bond(struct kobject *kobj, struct attribute *attr, char *buff, size_t count) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct bat_priv *bat_priv = netdev_priv(net_dev); int bonding_enabled_tmp = -1; if (((count == 2) && (buff[0] == '1')) || (strncmp(buff, "enable", 6) == 0)) bonding_enabled_tmp = 1; if (((count == 2) && (buff[0] == '0')) || (strncmp(buff, "disable", 7) == 0)) bonding_enabled_tmp = 0; if (bonding_enabled_tmp < 0) { if (buff[count - 1] == '\n') buff[count - 1] = '\0'; bat_err(net_dev, "Invalid parameter for 'bonding' setting received: " "%s\n", buff); return -EINVAL; } if (atomic_read(&bat_priv->bonding_enabled) == bonding_enabled_tmp) return count; bat_info(net_dev, "Changing bonding from: %s to: %s\n", atomic_read(&bat_priv->bonding_enabled) == 1 ? "enabled" : "disabled", bonding_enabled_tmp == 1 ? "enabled" : "disabled"); atomic_set(&bat_priv->bonding_enabled, (unsigned)bonding_enabled_tmp); return count; }
static ssize_t show_iface_status(struct kobject *kobj, struct attribute *attr, char *buff) { struct device *dev = to_dev(kobj->parent); struct net_device *net_dev = to_net_dev(dev); struct batman_if *batman_if = get_batman_if_by_netdev(net_dev); if (!batman_if) return 0; switch (batman_if->if_status) { case IF_TO_BE_REMOVED: return sprintf(buff, "disabling\n"); case IF_INACTIVE: return sprintf(buff, "inactive\n"); case IF_ACTIVE: return sprintf(buff, "active\n"); case IF_TO_BE_ACTIVATED: return sprintf(buff, "enabling\n"); case IF_NOT_IN_USE: default: return sprintf(buff, "not in use\n"); } }
struct device * get_device(struct device * dev) { return dev ? to_dev(kobject_get(&dev->kobj)) : NULL; }
static struct nd_region *to_region(struct pmem_device *pmem) { return to_nd_region(to_dev(pmem)->parent); }
int mcp2210_gpio_to_irq(struct gpio_chip *chip, unsigned offset) { struct mcp2210_device *dev = to_dev(chip); return irq_create_mapping(dev->irq_domain, offset); }
static const char *dev_hotplug_name(struct kset *kset, struct kobject *kobj) { struct device *dev = to_dev(kobj); return dev->bus->name; }