1 /*
2 * Copyright IBM Corp. 2012
3 *
4 * Author(s):
5 * Jan Glauber <jang@linux.vnet.ibm.com>
6 */
7
8 #define KMSG_COMPONENT "zpci"
9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
10
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/err.h>
14 #include <linux/delay.h>
15 #include <linux/pci.h>
16 #include <asm/pci_debug.h>
17 #include <asm/pci_clp.h>
18
zpci_err_clp(unsigned int rsp,int rc)19 static inline void zpci_err_clp(unsigned int rsp, int rc)
20 {
21 struct {
22 unsigned int rsp;
23 int rc;
24 } __packed data = {rsp, rc};
25
26 zpci_err_hex(&data, sizeof(data));
27 }
28
29 /*
30 * Call Logical Processor
31 * Retry logic is handled by the caller.
32 */
clp_instr(void * data)33 static inline u8 clp_instr(void *data)
34 {
35 struct { u8 _[CLP_BLK_SIZE]; } *req = data;
36 u64 ignored;
37 u8 cc;
38
39 asm volatile (
40 " .insn rrf,0xb9a00000,%[ign],%[req],0x0,0x2\n"
41 " ipm %[cc]\n"
42 " srl %[cc],28\n"
43 : [cc] "=d" (cc), [ign] "=d" (ignored), "+m" (*req)
44 : [req] "a" (req)
45 : "cc");
46 return cc;
47 }
48
clp_alloc_block(gfp_t gfp_mask)49 static void *clp_alloc_block(gfp_t gfp_mask)
50 {
51 return (void *) __get_free_pages(gfp_mask, get_order(CLP_BLK_SIZE));
52 }
53
clp_free_block(void * ptr)54 static void clp_free_block(void *ptr)
55 {
56 free_pages((unsigned long) ptr, get_order(CLP_BLK_SIZE));
57 }
58
clp_store_query_pci_fngrp(struct zpci_dev * zdev,struct clp_rsp_query_pci_grp * response)59 static void clp_store_query_pci_fngrp(struct zpci_dev *zdev,
60 struct clp_rsp_query_pci_grp *response)
61 {
62 zdev->tlb_refresh = response->refresh;
63 zdev->dma_mask = response->dasm;
64 zdev->msi_addr = response->msia;
65 zdev->fmb_update = response->mui;
66
67 switch (response->version) {
68 case 1:
69 zdev->max_bus_speed = PCIE_SPEED_5_0GT;
70 break;
71 default:
72 zdev->max_bus_speed = PCI_SPEED_UNKNOWN;
73 break;
74 }
75 }
76
clp_query_pci_fngrp(struct zpci_dev * zdev,u8 pfgid)77 static int clp_query_pci_fngrp(struct zpci_dev *zdev, u8 pfgid)
78 {
79 struct clp_req_rsp_query_pci_grp *rrb;
80 int rc;
81
82 rrb = clp_alloc_block(GFP_KERNEL);
83 if (!rrb)
84 return -ENOMEM;
85
86 memset(rrb, 0, sizeof(*rrb));
87 rrb->request.hdr.len = sizeof(rrb->request);
88 rrb->request.hdr.cmd = CLP_QUERY_PCI_FNGRP;
89 rrb->response.hdr.len = sizeof(rrb->response);
90 rrb->request.pfgid = pfgid;
91
92 rc = clp_instr(rrb);
93 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK)
94 clp_store_query_pci_fngrp(zdev, &rrb->response);
95 else {
96 zpci_err("Q PCI FGRP:\n");
97 zpci_err_clp(rrb->response.hdr.rsp, rc);
98 rc = -EIO;
99 }
100 clp_free_block(rrb);
101 return rc;
102 }
103
clp_store_query_pci_fn(struct zpci_dev * zdev,struct clp_rsp_query_pci * response)104 static int clp_store_query_pci_fn(struct zpci_dev *zdev,
105 struct clp_rsp_query_pci *response)
106 {
107 int i;
108
109 for (i = 0; i < PCI_BAR_COUNT; i++) {
110 zdev->bars[i].val = le32_to_cpu(response->bar[i]);
111 zdev->bars[i].size = response->bar_size[i];
112 }
113 zdev->start_dma = response->sdma;
114 zdev->end_dma = response->edma;
115 zdev->pchid = response->pchid;
116 zdev->pfgid = response->pfgid;
117 zdev->pft = response->pft;
118 zdev->vfn = response->vfn;
119 zdev->uid = response->uid;
120
121 memcpy(zdev->pfip, response->pfip, sizeof(zdev->pfip));
122 if (response->util_str_avail) {
123 memcpy(zdev->util_str, response->util_str,
124 sizeof(zdev->util_str));
125 }
126
127 return 0;
128 }
129
clp_query_pci_fn(struct zpci_dev * zdev,u32 fh)130 static int clp_query_pci_fn(struct zpci_dev *zdev, u32 fh)
131 {
132 struct clp_req_rsp_query_pci *rrb;
133 int rc;
134
135 rrb = clp_alloc_block(GFP_KERNEL);
136 if (!rrb)
137 return -ENOMEM;
138
139 memset(rrb, 0, sizeof(*rrb));
140 rrb->request.hdr.len = sizeof(rrb->request);
141 rrb->request.hdr.cmd = CLP_QUERY_PCI_FN;
142 rrb->response.hdr.len = sizeof(rrb->response);
143 rrb->request.fh = fh;
144
145 rc = clp_instr(rrb);
146 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK) {
147 rc = clp_store_query_pci_fn(zdev, &rrb->response);
148 if (rc)
149 goto out;
150 if (rrb->response.pfgid)
151 rc = clp_query_pci_fngrp(zdev, rrb->response.pfgid);
152 } else {
153 zpci_err("Q PCI FN:\n");
154 zpci_err_clp(rrb->response.hdr.rsp, rc);
155 rc = -EIO;
156 }
157 out:
158 clp_free_block(rrb);
159 return rc;
160 }
161
clp_add_pci_device(u32 fid,u32 fh,int configured)162 int clp_add_pci_device(u32 fid, u32 fh, int configured)
163 {
164 struct zpci_dev *zdev;
165 int rc;
166
167 zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid, fh, configured);
168 zdev = kzalloc(sizeof(*zdev), GFP_KERNEL);
169 if (!zdev)
170 return -ENOMEM;
171
172 zdev->fh = fh;
173 zdev->fid = fid;
174
175 /* Query function properties and update zdev */
176 rc = clp_query_pci_fn(zdev, fh);
177 if (rc)
178 goto error;
179
180 if (configured)
181 zdev->state = ZPCI_FN_STATE_CONFIGURED;
182 else
183 zdev->state = ZPCI_FN_STATE_STANDBY;
184
185 rc = zpci_create_device(zdev);
186 if (rc)
187 goto error;
188 return 0;
189
190 error:
191 kfree(zdev);
192 return rc;
193 }
194
195 /*
196 * Enable/Disable a given PCI function defined by its function handle.
197 */
clp_set_pci_fn(u32 * fh,u8 nr_dma_as,u8 command)198 static int clp_set_pci_fn(u32 *fh, u8 nr_dma_as, u8 command)
199 {
200 struct clp_req_rsp_set_pci *rrb;
201 int rc, retries = 100;
202
203 rrb = clp_alloc_block(GFP_KERNEL);
204 if (!rrb)
205 return -ENOMEM;
206
207 do {
208 memset(rrb, 0, sizeof(*rrb));
209 rrb->request.hdr.len = sizeof(rrb->request);
210 rrb->request.hdr.cmd = CLP_SET_PCI_FN;
211 rrb->response.hdr.len = sizeof(rrb->response);
212 rrb->request.fh = *fh;
213 rrb->request.oc = command;
214 rrb->request.ndas = nr_dma_as;
215
216 rc = clp_instr(rrb);
217 if (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY) {
218 retries--;
219 if (retries < 0)
220 break;
221 msleep(20);
222 }
223 } while (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY);
224
225 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK)
226 *fh = rrb->response.fh;
227 else {
228 zpci_err("Set PCI FN:\n");
229 zpci_err_clp(rrb->response.hdr.rsp, rc);
230 rc = -EIO;
231 }
232 clp_free_block(rrb);
233 return rc;
234 }
235
clp_enable_fh(struct zpci_dev * zdev,u8 nr_dma_as)236 int clp_enable_fh(struct zpci_dev *zdev, u8 nr_dma_as)
237 {
238 u32 fh = zdev->fh;
239 int rc;
240
241 rc = clp_set_pci_fn(&fh, nr_dma_as, CLP_SET_ENABLE_PCI_FN);
242 if (!rc)
243 /* Success -> store enabled handle in zdev */
244 zdev->fh = fh;
245
246 zpci_dbg(3, "ena fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc);
247 return rc;
248 }
249
clp_disable_fh(struct zpci_dev * zdev)250 int clp_disable_fh(struct zpci_dev *zdev)
251 {
252 u32 fh = zdev->fh;
253 int rc;
254
255 if (!zdev_enabled(zdev))
256 return 0;
257
258 rc = clp_set_pci_fn(&fh, 0, CLP_SET_DISABLE_PCI_FN);
259 if (!rc)
260 /* Success -> store disabled handle in zdev */
261 zdev->fh = fh;
262
263 zpci_dbg(3, "dis fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc);
264 return rc;
265 }
266
clp_list_pci(struct clp_req_rsp_list_pci * rrb,void (* cb)(struct clp_fh_list_entry * entry))267 static int clp_list_pci(struct clp_req_rsp_list_pci *rrb,
268 void (*cb)(struct clp_fh_list_entry *entry))
269 {
270 u64 resume_token = 0;
271 int entries, i, rc;
272
273 do {
274 memset(rrb, 0, sizeof(*rrb));
275 rrb->request.hdr.len = sizeof(rrb->request);
276 rrb->request.hdr.cmd = CLP_LIST_PCI;
277 /* store as many entries as possible */
278 rrb->response.hdr.len = CLP_BLK_SIZE - LIST_PCI_HDR_LEN;
279 rrb->request.resume_token = resume_token;
280
281 /* Get PCI function handle list */
282 rc = clp_instr(rrb);
283 if (rc || rrb->response.hdr.rsp != CLP_RC_OK) {
284 zpci_err("List PCI FN:\n");
285 zpci_err_clp(rrb->response.hdr.rsp, rc);
286 rc = -EIO;
287 goto out;
288 }
289
290 WARN_ON_ONCE(rrb->response.entry_size !=
291 sizeof(struct clp_fh_list_entry));
292
293 entries = (rrb->response.hdr.len - LIST_PCI_HDR_LEN) /
294 rrb->response.entry_size;
295
296 resume_token = rrb->response.resume_token;
297 for (i = 0; i < entries; i++)
298 cb(&rrb->response.fh_list[i]);
299 } while (resume_token);
300 out:
301 return rc;
302 }
303
__clp_add(struct clp_fh_list_entry * entry)304 static void __clp_add(struct clp_fh_list_entry *entry)
305 {
306 if (!entry->vendor_id)
307 return;
308
309 clp_add_pci_device(entry->fid, entry->fh, entry->config_state);
310 }
311
__clp_rescan(struct clp_fh_list_entry * entry)312 static void __clp_rescan(struct clp_fh_list_entry *entry)
313 {
314 struct zpci_dev *zdev;
315
316 if (!entry->vendor_id)
317 return;
318
319 zdev = get_zdev_by_fid(entry->fid);
320 if (!zdev) {
321 clp_add_pci_device(entry->fid, entry->fh, entry->config_state);
322 return;
323 }
324
325 if (!entry->config_state) {
326 /*
327 * The handle is already disabled, that means no iota/irq freeing via
328 * the firmware interfaces anymore. Need to free resources manually
329 * (DMA memory, debug, sysfs)...
330 */
331 zpci_stop_device(zdev);
332 }
333 }
334
__clp_update(struct clp_fh_list_entry * entry)335 static void __clp_update(struct clp_fh_list_entry *entry)
336 {
337 struct zpci_dev *zdev;
338
339 if (!entry->vendor_id)
340 return;
341
342 zdev = get_zdev_by_fid(entry->fid);
343 if (!zdev)
344 return;
345
346 zdev->fh = entry->fh;
347 }
348
clp_scan_pci_devices(void)349 int clp_scan_pci_devices(void)
350 {
351 struct clp_req_rsp_list_pci *rrb;
352 int rc;
353
354 rrb = clp_alloc_block(GFP_KERNEL);
355 if (!rrb)
356 return -ENOMEM;
357
358 rc = clp_list_pci(rrb, __clp_add);
359
360 clp_free_block(rrb);
361 return rc;
362 }
363
clp_rescan_pci_devices(void)364 int clp_rescan_pci_devices(void)
365 {
366 struct clp_req_rsp_list_pci *rrb;
367 int rc;
368
369 rrb = clp_alloc_block(GFP_KERNEL);
370 if (!rrb)
371 return -ENOMEM;
372
373 rc = clp_list_pci(rrb, __clp_rescan);
374
375 clp_free_block(rrb);
376 return rc;
377 }
378
clp_rescan_pci_devices_simple(void)379 int clp_rescan_pci_devices_simple(void)
380 {
381 struct clp_req_rsp_list_pci *rrb;
382 int rc;
383
384 rrb = clp_alloc_block(GFP_NOWAIT);
385 if (!rrb)
386 return -ENOMEM;
387
388 rc = clp_list_pci(rrb, __clp_update);
389
390 clp_free_block(rrb);
391 return rc;
392 }
393