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