static ssize_t i915_l3_read(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t offset, size_t count) { struct device *dev = kobj_to_dev(kobj); struct drm_minor *dminor = dev_to_drm_minor(dev); struct drm_device *drm_dev = dminor->dev; struct drm_i915_private *dev_priv = drm_dev->dev_private; int slice = (int)(uintptr_t)attr->private; int ret; count = round_down(count, 4); ret = l3_access_valid(drm_dev, offset); if (ret) return ret; count = min_t(size_t, GEN7_L3LOG_SIZE - offset, count); ret = i915_mutex_lock_interruptible(drm_dev); if (ret) return ret; if (dev_priv->l3_parity.remap_info[slice]) memcpy(buf, dev_priv->l3_parity.remap_info[slice] + (offset/4), count); else memset(buf, 0, count); mutex_unlock(&drm_dev->struct_mutex); return count; }
static ssize_t i915_l3_write(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t offset, size_t count) { struct device *dev = kobj_to_dev(kobj); struct drm_minor *dminor = dev_to_drm_minor(dev); struct drm_device *drm_dev = dminor->dev; struct drm_i915_private *dev_priv = drm_dev->dev_private; struct intel_context *ctx; u32 *temp = NULL; /* Just here to make handling failures easy */ int slice = (int)(uintptr_t)attr->private; int ret; if (!HAS_HW_CONTEXTS(drm_dev)) return -ENXIO; ret = l3_access_valid(drm_dev, offset); if (ret) return ret; ret = i915_mutex_lock_interruptible(drm_dev); if (ret) return ret; if (!dev_priv->l3_parity.remap_info[slice]) { temp = kzalloc(GEN7_L3LOG_SIZE, GFP_KERNEL); if (!temp) { mutex_unlock(&drm_dev->struct_mutex); return -ENOMEM; } } ret = i915_gpu_idle(drm_dev); if (ret) { kfree(temp); mutex_unlock(&drm_dev->struct_mutex); return ret; } /* TODO: Ideally we really want a GPU reset here to make sure errors * aren't propagated. Since I cannot find a stable way to reset the GPU * at this point it is left as a TODO. */ if (temp) dev_priv->l3_parity.remap_info[slice] = temp; memcpy(dev_priv->l3_parity.remap_info[slice] + (offset/4), buf, count); /* NB: We defer the remapping until we switch to the context */ list_for_each_entry(ctx, &dev_priv->context_list, link) ctx->remap_slice |= (1<<slice); mutex_unlock(&drm_dev->struct_mutex); return count; }
static ssize_t pch_phub_bin_write(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { int err; unsigned int addr_offset; int ret; ssize_t rom_size; struct pch_phub_reg *chip = dev_get_drvdata(kobj_to_dev(kobj)); ret = mutex_lock_interruptible(&pch_phub_mutex); if (ret) return -ERESTARTSYS; if (off > PCH_PHUB_OROM_SIZE) { addr_offset = 0; goto return_ok; } if (count > PCH_PHUB_OROM_SIZE) { addr_offset = 0; goto return_ok; } chip->pch_phub_extrom_base_address = pci_map_rom(chip->pdev, &rom_size); if (!chip->pch_phub_extrom_base_address) { err = -ENOMEM; goto exrom_map_err; } for (addr_offset = 0; addr_offset < count; addr_offset++) { if (PCH_PHUB_OROM_SIZE < off + addr_offset) goto return_ok; ret = pch_phub_write_serial_rom(chip, chip->pch_opt_rom_start_address + addr_offset + off, buf[addr_offset]); if (ret) { err = ret; goto return_err; } } return_ok: pci_unmap_rom(chip->pdev, chip->pch_phub_extrom_base_address); mutex_unlock(&pch_phub_mutex); return addr_offset; return_err: pci_unmap_rom(chip->pdev, chip->pch_phub_extrom_base_address); exrom_map_err: mutex_unlock(&pch_phub_mutex); return err; }
static ssize_t util_string_read(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct device *dev = kobj_to_dev(kobj); struct pci_dev *pdev = to_pci_dev(dev); struct zpci_dev *zdev = get_zdev(pdev); return memory_read_from_buffer(buf, count, &off, zdev->util_str, sizeof(zdev->util_str)); }
static umode_t csrow_dev_is_visible(struct kobject *kobj, struct attribute *attr, int idx) { struct device *dev = kobj_to_dev(kobj); struct csrow_info *csrow = container_of(dev, struct csrow_info, dev); if (idx >= csrow->nr_channels) return 0; /* Only expose populated DIMMs */ if (!csrow->channels[idx]->dimm->nr_pages) return 0; return attr->mode; }
/* * eeprom_read() - EEPROM sysfs-node read callback * @filep: Pointer to the file system node * @kobj: Pointer to the kernel object related to the sysfs-node * @attr: Attributes of the file * @buf: Buffer to write data to * @off: Offset at which data should be written to * @count: Number of bytes to write */ static ssize_t eeprom_read(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct idt_89hpesx_dev *pdev; int ret; /* Retrieve driver data */ pdev = dev_get_drvdata(kobj_to_dev(kobj)); /* Perform EEPROM read operation */ ret = idt_eeprom_read(pdev, (u16)off, (u16)count, (u8 *)buf); return (ret != 0 ? ret : count); }
static umode_t mci_attr_is_visible(struct kobject *kobj, struct attribute *attr, int idx) { struct device *dev = kobj_to_dev(kobj); struct mem_ctl_info *mci = to_mci(dev); umode_t mode = 0; if (attr != &dev_attr_sdram_scrub_rate.attr) return attr->mode; if (mci->get_sdram_scrub_rate) mode |= S_IRUGO; if (mci->set_sdram_scrub_rate) mode |= S_IWUSR; return mode; }
static umode_t armv8pmu_event_attr_is_visible(struct kobject *kobj, struct attribute *attr, int unused) { struct device *dev = kobj_to_dev(kobj); struct pmu *pmu = dev_get_drvdata(dev); struct arm_pmu *cpu_pmu = container_of(pmu, struct arm_pmu, pmu); struct perf_pmu_events_attr *pmu_attr; pmu_attr = container_of(attr, struct perf_pmu_events_attr, attr.attr); if (test_bit(pmu_attr->id, cpu_pmu->pmceid_bitmap)) return attr->mode; return 0; }
static ssize_t i915_l3_write(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t offset, size_t count) { struct device *kdev = kobj_to_dev(kobj); struct drm_i915_private *dev_priv = kdev_minor_to_i915(kdev); struct drm_device *dev = &dev_priv->drm; struct i915_gem_context *ctx; int slice = (int)(uintptr_t)attr->private; u32 **remap_info; int ret; ret = l3_access_valid(dev_priv, offset); if (ret) return ret; ret = i915_mutex_lock_interruptible(dev); if (ret) return ret; remap_info = &dev_priv->l3_parity.remap_info[slice]; if (!*remap_info) { *remap_info = kzalloc(GEN7_L3LOG_SIZE, GFP_KERNEL); if (!*remap_info) { ret = -ENOMEM; goto out; } } /* TODO: Ideally we really want a GPU reset here to make sure errors * aren't propagated. Since I cannot find a stable way to reset the GPU * at this point it is left as a TODO. */ memcpy(*remap_info + (offset/4), buf, count); /* NB: We defer the remapping until we switch to the context */ list_for_each_entry(ctx, &dev_priv->context_list, link) ctx->remap_slice |= (1<<slice); ret = count; out: mutex_unlock(&dev->struct_mutex); return ret; }
static ssize_t zorro_read_config(struct file *filp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { struct zorro_dev *z = to_zorro_dev(kobj_to_dev(kobj)); struct ConfigDev cd; /* Construct a ConfigDev */ memset(&cd, 0, sizeof(cd)); cd.cd_Rom = z->rom; cd.cd_SlotAddr = cpu_to_be16(z->slotaddr); cd.cd_SlotSize = cpu_to_be16(z->slotsize); cd.cd_BoardAddr = cpu_to_be32(zorro_resource_start(z)); cd.cd_BoardSize = cpu_to_be32(zorro_resource_len(z)); return memory_read_from_buffer(buf, count, &off, &cd, sizeof(cd)); }
static ssize_t report_error_write(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct zpci_report_error_header *report = (void *) buf; struct device *dev = kobj_to_dev(kobj); struct pci_dev *pdev = to_pci_dev(dev); struct zpci_dev *zdev = to_zpci(pdev); int ret; if (off || (count < sizeof(*report))) return -EINVAL; ret = sclp_pci_report(report, zdev->fh, zdev->fid); return ret ? ret : count; }
static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct device *dev = kobj_to_dev(kobj)->parent->parent; struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); ssize_t retval; retval = pyra_send_control(usb_dev, *(uint *)(attr->private), PYRA_CONTROL_REQUEST_PROFILE_BUTTONS); if (retval) return retval; return pyra_sysfs_read(fp, kobj, buf, off, count, PYRA_SIZE_PROFILE_BUTTONS, PYRA_COMMAND_PROFILE_BUTTONS); }
ssize_t roccat_common2_sysfs_write(struct file *fp, struct kobject *kobj, void const *buf, loff_t off, size_t count, size_t real_size, uint command) { struct device *dev = kobj_to_dev(kobj)->parent->parent; struct roccat_common2_device *roccat_dev = hid_get_drvdata(dev_get_drvdata(dev)); struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); int retval; if (off != 0 || count != real_size) return -EINVAL; mutex_lock(&roccat_dev->lock); retval = roccat_common2_send_with_status(usb_dev, command, buf, real_size); mutex_unlock(&roccat_dev->lock); return retval ? retval : real_size; }
static umode_t csrow_dev_is_visible(struct kobject *kobj, struct attribute *attr, int idx) { struct device *dev = kobj_to_dev(kobj); struct csrow_info *csrow = container_of(dev, struct csrow_info, dev); if (idx >= csrow->nr_channels) return 0; if (idx >= ARRAY_SIZE(dynamic_csrow_ce_count_attr) - 1) { WARN_ONCE(1, "idx: %d\n", idx); return 0; } /* Only expose populated DIMMs */ if (!csrow->channels[idx]->dimm->nr_pages) return 0; return attr->mode; }
/* * 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 file *filp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count) { struct device *dev = kobj_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 pyra_sysfs_write_settings(struct file *fp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct device *dev = kobj_to_dev(kobj)->parent->parent; struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); int retval = 0; struct pyra_roccat_report roccat_report; struct pyra_settings const *settings; if (off != 0 || count != PYRA_SIZE_SETTINGS) return -EINVAL; settings = (struct pyra_settings const *)buf; if (settings->startup_profile >= ARRAY_SIZE(pyra->profile_settings)) return -EINVAL; mutex_lock(&pyra->pyra_lock); retval = pyra_set_settings(usb_dev, settings); if (retval) { mutex_unlock(&pyra->pyra_lock); return retval; } profile_activated(pyra, settings->startup_profile); roccat_report.type = PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2; roccat_report.value = settings->startup_profile + 1; roccat_report.key = 0; roccat_report_event(pyra->chrdev_minor, (uint8_t const *)&roccat_report); mutex_unlock(&pyra->pyra_lock); return PYRA_SIZE_SETTINGS; }
static ssize_t pyra_sysfs_read(struct file *fp, struct kobject *kobj, char *buf, loff_t off, size_t count, size_t real_size, uint command) { struct device *dev = kobj_to_dev(kobj)->parent->parent; struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); int retval; if (off >= real_size) return 0; if (off != 0 || count != real_size) return -EINVAL; mutex_lock(&pyra->pyra_lock); retval = roccat_common2_receive(usb_dev, command, buf, real_size); mutex_unlock(&pyra->pyra_lock); if (retval) return retval; return real_size; }
static ssize_t pch_phub_bin_read(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { unsigned int rom_signature; unsigned char rom_length; unsigned int tmp; unsigned int addr_offset; unsigned int orom_size; int ret; int err; ssize_t rom_size; struct pch_phub_reg *chip = dev_get_drvdata(kobj_to_dev(kobj)); ret = mutex_lock_interruptible(&pch_phub_mutex); if (ret) { err = -ERESTARTSYS; goto return_err_nomutex; } /* Get Rom signature */ chip->pch_phub_extrom_base_address = pci_map_rom(chip->pdev, &rom_size); if (!chip->pch_phub_extrom_base_address) { err = -ENODATA; goto exrom_map_err; } pch_phub_read_serial_rom(chip, chip->pch_opt_rom_start_address, (unsigned char *)&rom_signature); rom_signature &= 0xff; pch_phub_read_serial_rom(chip, chip->pch_opt_rom_start_address + 1, (unsigned char *)&tmp); rom_signature |= (tmp & 0xff) << 8; if (rom_signature == 0xAA55) { pch_phub_read_serial_rom(chip, chip->pch_opt_rom_start_address + 2, &rom_length); orom_size = rom_length * 512; if (orom_size < off) { addr_offset = 0; goto return_ok; } if (orom_size < count) { addr_offset = 0; goto return_ok; } for (addr_offset = 0; addr_offset < count; addr_offset++) { pch_phub_read_serial_rom(chip, chip->pch_opt_rom_start_address + addr_offset + off, &buf[addr_offset]); } } else { err = -ENODATA; goto return_err; } return_ok: pci_unmap_rom(chip->pdev, chip->pch_phub_extrom_base_address); mutex_unlock(&pch_phub_mutex); return addr_offset; return_err: pci_unmap_rom(chip->pdev, chip->pch_phub_extrom_base_address); exrom_map_err: mutex_unlock(&pch_phub_mutex); return_err_nomutex: return err; }