root/drivers/ide/ide-sysfs.c

DEFINITIONS

1. ide_media_string
2. media_show
3. drivename_show
4. modalias_show
5. model_show
6. firmware_show
7. serial_show
8. store_delete_devices
9. store_scan
10. ide_sysfs_register_port

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/ide.h>
   4 
   5 char *ide_media_string(ide_drive_t *drive)
   6 {
   7         switch (drive->media) {
   8         case ide_disk:
   9                 return "disk";
  10         case ide_cdrom:
  11                 return "cdrom";
  12         case ide_tape:
  13                 return "tape";
  14         case ide_floppy:
  15                 return "floppy";
  16         case ide_optical:
  17                 return "optical";
  18         default:
  19                 return "UNKNOWN";
  20         }
  21 }
  22 
  23 static ssize_t media_show(struct device *dev, struct device_attribute *attr,
  24                           char *buf)
  25 {
  26         ide_drive_t *drive = to_ide_device(dev);
  27         return sprintf(buf, "%s\n", ide_media_string(drive));
  28 }
  29 static DEVICE_ATTR_RO(media);
  30 
  31 static ssize_t drivename_show(struct device *dev, struct device_attribute *attr,
  32                               char *buf)
  33 {
  34         ide_drive_t *drive = to_ide_device(dev);
  35         return sprintf(buf, "%s\n", drive->name);
  36 }
  37 static DEVICE_ATTR_RO(drivename);
  38 
  39 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
  40                              char *buf)
  41 {
  42         ide_drive_t *drive = to_ide_device(dev);
  43         return sprintf(buf, "ide:m-%s\n", ide_media_string(drive));
  44 }
  45 static DEVICE_ATTR_RO(modalias);
  46 
  47 static ssize_t model_show(struct device *dev, struct device_attribute *attr,
  48                           char *buf)
  49 {
  50         ide_drive_t *drive = to_ide_device(dev);
  51         return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]);
  52 }
  53 static DEVICE_ATTR_RO(model);
  54 
  55 static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
  56                              char *buf)
  57 {
  58         ide_drive_t *drive = to_ide_device(dev);
  59         return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]);
  60 }
  61 static DEVICE_ATTR_RO(firmware);
  62 
  63 static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
  64                            char *buf)
  65 {
  66         ide_drive_t *drive = to_ide_device(dev);
  67         return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]);
  68 }
  69 static DEVICE_ATTR(serial, 0400, serial_show, NULL);
  70 
  71 static DEVICE_ATTR(unload_heads, 0644, ide_park_show, ide_park_store);
  72 
  73 static struct attribute *ide_attrs[] = {
  74         &dev_attr_media.attr,
  75         &dev_attr_drivename.attr,
  76         &dev_attr_modalias.attr,
  77         &dev_attr_model.attr,
  78         &dev_attr_firmware.attr,
  79         &dev_attr_serial.attr,
  80         &dev_attr_unload_heads.attr,
  81         NULL,
  82 };
  83 
  84 static const struct attribute_group ide_attr_group = {
  85         .attrs = ide_attrs,
  86 };
  87 
  88 const struct attribute_group *ide_dev_groups[] = {
  89         &ide_attr_group,
  90         NULL,
  91 };
  92 
  93 static ssize_t store_delete_devices(struct device *portdev,
  94                                     struct device_attribute *attr,
  95                                     const char *buf, size_t n)
  96 {
  97         ide_hwif_t *hwif = dev_get_drvdata(portdev);
  98 
  99         if (strncmp(buf, "1", n))
 100                 return -EINVAL;
 101 
 102         ide_port_unregister_devices(hwif);
 103 
 104         return n;
 105 };
 106 
 107 static DEVICE_ATTR(delete_devices, S_IWUSR, NULL, store_delete_devices);
 108 
 109 static ssize_t store_scan(struct device *portdev,
 110                           struct device_attribute *attr,
 111                           const char *buf, size_t n)
 112 {
 113         ide_hwif_t *hwif = dev_get_drvdata(portdev);
 114 
 115         if (strncmp(buf, "1", n))
 116                 return -EINVAL;
 117 
 118         ide_port_unregister_devices(hwif);
 119         ide_port_scan(hwif);
 120 
 121         return n;
 122 };
 123 
 124 static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
 125 
 126 static struct device_attribute *ide_port_attrs[] = {
 127         &dev_attr_delete_devices,
 128         &dev_attr_scan,
 129         NULL
 130 };
 131 
 132 int ide_sysfs_register_port(ide_hwif_t *hwif)
 133 {
 134         int i, uninitialized_var(rc);
 135 
 136         for (i = 0; ide_port_attrs[i]; i++) {
 137                 rc = device_create_file(hwif->portdev, ide_port_attrs[i]);
 138                 if (rc)
 139                         break;
 140         }
 141 
 142         return rc;
 143 }