Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1e8da956 JG |
2 | /* |
3 | * Copyright IBM Corp. 2012 | |
4 | * | |
5 | * Author(s): | |
6 | * Jan Glauber <jang@linux.vnet.ibm.com> | |
7 | */ | |
8 | ||
896cb7e6 GS |
9 | #define KMSG_COMPONENT "zpci" |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
1e8da956 JG |
11 | |
12 | #include <linux/kernel.h> | |
13 | #include <linux/stat.h> | |
14 | #include <linux/pci.h> | |
15 | ||
576c75e3 NS |
16 | #include "../../../drivers/pci/pci.h" |
17 | ||
368704a6 SO |
18 | #include <asm/sclp.h> |
19 | ||
b346953d SO |
20 | #define zpci_attr(name, fmt, member) \ |
21 | static ssize_t name##_show(struct device *dev, \ | |
22 | struct device_attribute *attr, char *buf) \ | |
23 | { \ | |
198a5278 | 24 | struct zpci_dev *zdev = to_zpci(to_pci_dev(dev)); \ |
b346953d SO |
25 | \ |
26 | return sprintf(buf, fmt, zdev->member); \ | |
27 | } \ | |
28 | static DEVICE_ATTR_RO(name) | |
29 | ||
30 | zpci_attr(function_id, "0x%08x\n", fid); | |
31 | zpci_attr(function_handle, "0x%08x\n", fh); | |
32 | zpci_attr(pchid, "0x%04x\n", pchid); | |
33 | zpci_attr(pfgid, "0x%02x\n", pfgid); | |
ac4995b9 SO |
34 | zpci_attr(vfn, "0x%04x\n", vfn); |
35 | zpci_attr(pft, "0x%02x\n", pft); | |
e6ab7490 | 36 | zpci_attr(port, "%d\n", port); |
ac4995b9 SO |
37 | zpci_attr(uid, "0x%x\n", uid); |
38 | zpci_attr(segment0, "0x%02x\n", pfip[0]); | |
39 | zpci_attr(segment1, "0x%02x\n", pfip[1]); | |
40 | zpci_attr(segment2, "0x%02x\n", pfip[2]); | |
41 | zpci_attr(segment3, "0x%02x\n", pfip[3]); | |
b346953d | 42 | |
8e4708b3 SO |
43 | static ssize_t mio_enabled_show(struct device *dev, |
44 | struct device_attribute *attr, char *buf) | |
45 | { | |
46 | struct zpci_dev *zdev = to_zpci(to_pci_dev(dev)); | |
47 | ||
48 | return sprintf(buf, zpci_use_mio(zdev) ? "1\n" : "0\n"); | |
49 | } | |
50 | static DEVICE_ATTR_RO(mio_enabled); | |
51 | ||
b346953d | 52 | static ssize_t recover_store(struct device *dev, struct device_attribute *attr, |
0b60f9ea | 53 | const char *buf, size_t count) |
0ff70ec8 | 54 | { |
576c75e3 | 55 | struct kernfs_node *kn; |
0ff70ec8 | 56 | struct pci_dev *pdev = to_pci_dev(dev); |
198a5278 | 57 | struct zpci_dev *zdev = to_zpci(pdev); |
576c75e3 NS |
58 | int ret = 0; |
59 | ||
60 | /* Can't use device_remove_self() here as that would lead us to lock | |
61 | * the pci_rescan_remove_lock while holding the device' kernfs lock. | |
62 | * This would create a possible deadlock with disable_slot() which is | |
63 | * not directly protected by the device' kernfs lock but takes it | |
64 | * during the device removal which happens under | |
65 | * pci_rescan_remove_lock. | |
66 | * | |
67 | * This is analogous to sdev_store_delete() in | |
68 | * drivers/scsi/scsi_sysfs.c | |
69 | */ | |
70 | kn = sysfs_break_active_protection(&dev->kobj, &attr->attr); | |
71 | WARN_ON_ONCE(!kn); | |
72 | /* device_remove_file() serializes concurrent calls ignoring all but | |
73 | * the first | |
74 | */ | |
75 | device_remove_file(dev, attr); | |
76 | ||
77 | /* A concurrent call to recover_store() may slip between | |
78 | * sysfs_break_active_protection() and the sysfs file removal. | |
79 | * Once it unblocks from pci_lock_rescan_remove() the original pdev | |
80 | * will already be removed. | |
81 | */ | |
2a01bd1b | 82 | pci_lock_rescan_remove(); |
576c75e3 NS |
83 | if (pci_dev_is_added(pdev)) { |
84 | pci_stop_and_remove_bus_device(pdev); | |
1f3f7681 NS |
85 | if (zdev->dma_table) { |
86 | ret = zpci_dma_exit_device(zdev); | |
87 | if (ret) | |
88 | goto out; | |
89 | } | |
90 | ||
91 | if (zdev_enabled(zdev)) { | |
92 | ret = zpci_disable_device(zdev); | |
1c8174fd NS |
93 | /* |
94 | * Due to a z/VM vs LPAR inconsistency in the error | |
95 | * state the FH may indicate an enabled device but | |
96 | * disable says the device is already disabled don't | |
97 | * treat it as an error here. | |
98 | */ | |
99 | if (ret == -EINVAL) | |
100 | ret = 0; | |
1f3f7681 NS |
101 | if (ret) |
102 | goto out; | |
103 | } | |
576c75e3 NS |
104 | |
105 | ret = zpci_enable_device(zdev); | |
106 | if (ret) | |
107 | goto out; | |
1f3f7681 NS |
108 | ret = zpci_dma_init_device(zdev); |
109 | if (ret) { | |
110 | zpci_disable_device(zdev); | |
111 | goto out; | |
112 | } | |
05bc1be6 | 113 | pci_rescan_bus(zdev->zbus->bus); |
576c75e3 NS |
114 | } |
115 | out: | |
2a01bd1b | 116 | pci_unlock_rescan_remove(); |
576c75e3 NS |
117 | if (kn) |
118 | sysfs_unbreak_active_protection(kn); | |
119 | return ret ? ret : count; | |
0ff70ec8 | 120 | } |
b346953d | 121 | static DEVICE_ATTR_WO(recover); |
0ff70ec8 | 122 | |
ac4995b9 SO |
123 | static ssize_t util_string_read(struct file *filp, struct kobject *kobj, |
124 | struct bin_attribute *attr, char *buf, | |
125 | loff_t off, size_t count) | |
126 | { | |
127 | struct device *dev = kobj_to_dev(kobj); | |
128 | struct pci_dev *pdev = to_pci_dev(dev); | |
198a5278 | 129 | struct zpci_dev *zdev = to_zpci(pdev); |
ac4995b9 SO |
130 | |
131 | return memory_read_from_buffer(buf, count, &off, zdev->util_str, | |
132 | sizeof(zdev->util_str)); | |
133 | } | |
134 | static BIN_ATTR_RO(util_string, CLP_UTIL_STR_LEN); | |
368704a6 SO |
135 | |
136 | static ssize_t report_error_write(struct file *filp, struct kobject *kobj, | |
137 | struct bin_attribute *attr, char *buf, | |
138 | loff_t off, size_t count) | |
139 | { | |
140 | struct zpci_report_error_header *report = (void *) buf; | |
141 | struct device *dev = kobj_to_dev(kobj); | |
142 | struct pci_dev *pdev = to_pci_dev(dev); | |
143 | struct zpci_dev *zdev = to_zpci(pdev); | |
144 | int ret; | |
145 | ||
146 | if (off || (count < sizeof(*report))) | |
147 | return -EINVAL; | |
148 | ||
149 | ret = sclp_pci_report(report, zdev->fh, zdev->fid); | |
150 | ||
151 | return ret ? ret : count; | |
152 | } | |
153 | static BIN_ATTR(report_error, S_IWUSR, NULL, report_error_write, PAGE_SIZE); | |
154 | ||
408f2c9c NS |
155 | static ssize_t uid_is_unique_show(struct device *dev, |
156 | struct device_attribute *attr, char *buf) | |
157 | { | |
158 | return sysfs_emit(buf, "%d\n", zpci_unique_uid ? 1 : 0); | |
159 | } | |
160 | static DEVICE_ATTR_RO(uid_is_unique); | |
161 | ||
81bbf039 NS |
162 | #ifndef CONFIG_DMI |
163 | /* analogous to smbios index */ | |
164 | static ssize_t index_show(struct device *dev, | |
165 | struct device_attribute *attr, char *buf) | |
166 | { | |
167 | struct zpci_dev *zdev = to_zpci(to_pci_dev(dev)); | |
168 | u32 index = ~0; | |
169 | ||
170 | if (zpci_unique_uid) | |
171 | index = zdev->uid; | |
172 | ||
173 | return sysfs_emit(buf, "%u\n", index); | |
174 | } | |
175 | static DEVICE_ATTR_RO(index); | |
176 | ||
177 | static umode_t zpci_index_is_visible(struct kobject *kobj, | |
178 | struct attribute *attr, int n) | |
179 | { | |
180 | return zpci_unique_uid ? attr->mode : 0; | |
181 | } | |
182 | ||
183 | static struct attribute *zpci_ident_attrs[] = { | |
184 | &dev_attr_index.attr, | |
185 | NULL, | |
186 | }; | |
187 | ||
188 | static struct attribute_group zpci_ident_attr_group = { | |
189 | .attrs = zpci_ident_attrs, | |
190 | .is_visible = zpci_index_is_visible, | |
191 | }; | |
192 | #endif | |
193 | ||
ac4995b9 SO |
194 | static struct bin_attribute *zpci_bin_attrs[] = { |
195 | &bin_attr_util_string, | |
368704a6 | 196 | &bin_attr_report_error, |
ac4995b9 SO |
197 | NULL, |
198 | }; | |
199 | ||
93065d04 SO |
200 | static struct attribute *zpci_dev_attrs[] = { |
201 | &dev_attr_function_id.attr, | |
202 | &dev_attr_function_handle.attr, | |
203 | &dev_attr_pchid.attr, | |
204 | &dev_attr_pfgid.attr, | |
ac4995b9 | 205 | &dev_attr_pft.attr, |
e6ab7490 | 206 | &dev_attr_port.attr, |
ac4995b9 SO |
207 | &dev_attr_vfn.attr, |
208 | &dev_attr_uid.attr, | |
93065d04 | 209 | &dev_attr_recover.attr, |
8e4708b3 | 210 | &dev_attr_mio_enabled.attr, |
408f2c9c | 211 | &dev_attr_uid_is_unique.attr, |
93065d04 SO |
212 | NULL, |
213 | }; | |
408f2c9c | 214 | |
93065d04 SO |
215 | static struct attribute_group zpci_attr_group = { |
216 | .attrs = zpci_dev_attrs, | |
ac4995b9 SO |
217 | .bin_attrs = zpci_bin_attrs, |
218 | }; | |
219 | ||
220 | static struct attribute *pfip_attrs[] = { | |
221 | &dev_attr_segment0.attr, | |
222 | &dev_attr_segment1.attr, | |
223 | &dev_attr_segment2.attr, | |
224 | &dev_attr_segment3.attr, | |
225 | NULL, | |
226 | }; | |
227 | static struct attribute_group pfip_attr_group = { | |
228 | .name = "pfip", | |
229 | .attrs = pfip_attrs, | |
93065d04 | 230 | }; |
ac4995b9 | 231 | |
93065d04 SO |
232 | const struct attribute_group *zpci_attr_groups[] = { |
233 | &zpci_attr_group, | |
ac4995b9 | 234 | &pfip_attr_group, |
81bbf039 NS |
235 | #ifndef CONFIG_DMI |
236 | &zpci_ident_attr_group, | |
237 | #endif | |
1e8da956 JG |
238 | NULL, |
239 | }; |