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