Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...
[linux/fpc-iii.git] / arch / s390 / pci / pci_clp.c
blobc747394029eec181dbe521775296c701e9054a62
1 /*
2 * Copyright IBM Corp. 2012
4 * Author(s):
5 * Jan Glauber <jang@linux.vnet.ibm.com>
6 */
8 #define COMPONENT "zPCI"
9 #define pr_fmt(fmt) COMPONENT ": " fmt
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>
19 static inline void zpci_err_clp(unsigned int rsp, int rc)
21 struct {
22 unsigned int rsp;
23 int rc;
24 } __packed data = {rsp, rc};
26 zpci_err_hex(&data, sizeof(data));
30 * Call Logical Processor
31 * Retry logic is handled by the caller.
33 static inline u8 clp_instr(void *data)
35 struct { u8 _[CLP_BLK_SIZE]; } *req = data;
36 u64 ignored;
37 u8 cc;
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;
49 static void *clp_alloc_block(gfp_t gfp_mask)
51 return (void *) __get_free_pages(gfp_mask, get_order(CLP_BLK_SIZE));
54 static void clp_free_block(void *ptr)
56 free_pages((unsigned long) ptr, get_order(CLP_BLK_SIZE));
59 static void clp_store_query_pci_fngrp(struct zpci_dev *zdev,
60 struct clp_rsp_query_pci_grp *response)
62 zdev->tlb_refresh = response->refresh;
63 zdev->dma_mask = response->dasm;
64 zdev->msi_addr = response->msia;
65 zdev->fmb_update = response->mui;
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;
77 static int clp_query_pci_fngrp(struct zpci_dev *zdev, u8 pfgid)
79 struct clp_req_rsp_query_pci_grp *rrb;
80 int rc;
82 rrb = clp_alloc_block(GFP_KERNEL);
83 if (!rrb)
84 return -ENOMEM;
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;
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;
100 clp_free_block(rrb);
101 return rc;
104 static int clp_store_query_pci_fn(struct zpci_dev *zdev,
105 struct clp_rsp_query_pci *response)
107 int i;
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];
113 zdev->start_dma = response->sdma;
114 zdev->end_dma = response->edma;
115 zdev->pchid = response->pchid;
116 zdev->pfgid = response->pfgid;
117 return 0;
120 static int clp_query_pci_fn(struct zpci_dev *zdev, u32 fh)
122 struct clp_req_rsp_query_pci *rrb;
123 int rc;
125 rrb = clp_alloc_block(GFP_KERNEL);
126 if (!rrb)
127 return -ENOMEM;
129 memset(rrb, 0, sizeof(*rrb));
130 rrb->request.hdr.len = sizeof(rrb->request);
131 rrb->request.hdr.cmd = CLP_QUERY_PCI_FN;
132 rrb->response.hdr.len = sizeof(rrb->response);
133 rrb->request.fh = fh;
135 rc = clp_instr(rrb);
136 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK) {
137 rc = clp_store_query_pci_fn(zdev, &rrb->response);
138 if (rc)
139 goto out;
140 if (rrb->response.pfgid)
141 rc = clp_query_pci_fngrp(zdev, rrb->response.pfgid);
142 } else {
143 zpci_err("Q PCI FN:\n");
144 zpci_err_clp(rrb->response.hdr.rsp, rc);
145 rc = -EIO;
147 out:
148 clp_free_block(rrb);
149 return rc;
152 int clp_add_pci_device(u32 fid, u32 fh, int configured)
154 struct zpci_dev *zdev;
155 int rc;
157 zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid, fh, configured);
158 zdev = kzalloc(sizeof(*zdev), GFP_KERNEL);
159 if (!zdev)
160 return -ENOMEM;
162 zdev->fh = fh;
163 zdev->fid = fid;
165 /* Query function properties and update zdev */
166 rc = clp_query_pci_fn(zdev, fh);
167 if (rc)
168 goto error;
170 if (configured)
171 zdev->state = ZPCI_FN_STATE_CONFIGURED;
172 else
173 zdev->state = ZPCI_FN_STATE_STANDBY;
175 rc = zpci_create_device(zdev);
176 if (rc)
177 goto error;
178 return 0;
180 error:
181 kfree(zdev);
182 return rc;
186 * Enable/Disable a given PCI function defined by its function handle.
188 static int clp_set_pci_fn(u32 *fh, u8 nr_dma_as, u8 command)
190 struct clp_req_rsp_set_pci *rrb;
191 int rc, retries = 100;
193 rrb = clp_alloc_block(GFP_KERNEL);
194 if (!rrb)
195 return -ENOMEM;
197 do {
198 memset(rrb, 0, sizeof(*rrb));
199 rrb->request.hdr.len = sizeof(rrb->request);
200 rrb->request.hdr.cmd = CLP_SET_PCI_FN;
201 rrb->response.hdr.len = sizeof(rrb->response);
202 rrb->request.fh = *fh;
203 rrb->request.oc = command;
204 rrb->request.ndas = nr_dma_as;
206 rc = clp_instr(rrb);
207 if (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY) {
208 retries--;
209 if (retries < 0)
210 break;
211 msleep(20);
213 } while (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY);
215 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK)
216 *fh = rrb->response.fh;
217 else {
218 zpci_err("Set PCI FN:\n");
219 zpci_err_clp(rrb->response.hdr.rsp, rc);
220 rc = -EIO;
222 clp_free_block(rrb);
223 return rc;
226 int clp_enable_fh(struct zpci_dev *zdev, u8 nr_dma_as)
228 u32 fh = zdev->fh;
229 int rc;
231 rc = clp_set_pci_fn(&fh, nr_dma_as, CLP_SET_ENABLE_PCI_FN);
232 if (!rc)
233 /* Success -> store enabled handle in zdev */
234 zdev->fh = fh;
236 zpci_dbg(3, "ena fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc);
237 return rc;
240 int clp_disable_fh(struct zpci_dev *zdev)
242 u32 fh = zdev->fh;
243 int rc;
245 if (!zdev_enabled(zdev))
246 return 0;
248 rc = clp_set_pci_fn(&fh, 0, CLP_SET_DISABLE_PCI_FN);
249 if (!rc)
250 /* Success -> store disabled handle in zdev */
251 zdev->fh = fh;
253 zpci_dbg(3, "dis fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc);
254 return rc;
257 static int clp_list_pci(struct clp_req_rsp_list_pci *rrb,
258 void (*cb)(struct clp_fh_list_entry *entry))
260 u64 resume_token = 0;
261 int entries, i, rc;
263 do {
264 memset(rrb, 0, sizeof(*rrb));
265 rrb->request.hdr.len = sizeof(rrb->request);
266 rrb->request.hdr.cmd = CLP_LIST_PCI;
267 /* store as many entries as possible */
268 rrb->response.hdr.len = CLP_BLK_SIZE - LIST_PCI_HDR_LEN;
269 rrb->request.resume_token = resume_token;
271 /* Get PCI function handle list */
272 rc = clp_instr(rrb);
273 if (rc || rrb->response.hdr.rsp != CLP_RC_OK) {
274 zpci_err("List PCI FN:\n");
275 zpci_err_clp(rrb->response.hdr.rsp, rc);
276 rc = -EIO;
277 goto out;
280 WARN_ON_ONCE(rrb->response.entry_size !=
281 sizeof(struct clp_fh_list_entry));
283 entries = (rrb->response.hdr.len - LIST_PCI_HDR_LEN) /
284 rrb->response.entry_size;
286 resume_token = rrb->response.resume_token;
287 for (i = 0; i < entries; i++)
288 cb(&rrb->response.fh_list[i]);
289 } while (resume_token);
290 out:
291 return rc;
294 static void __clp_add(struct clp_fh_list_entry *entry)
296 if (!entry->vendor_id)
297 return;
299 clp_add_pci_device(entry->fid, entry->fh, entry->config_state);
302 static void __clp_rescan(struct clp_fh_list_entry *entry)
304 struct zpci_dev *zdev;
306 if (!entry->vendor_id)
307 return;
309 zdev = get_zdev_by_fid(entry->fid);
310 if (!zdev) {
311 clp_add_pci_device(entry->fid, entry->fh, entry->config_state);
312 return;
315 if (!entry->config_state) {
317 * The handle is already disabled, that means no iota/irq freeing via
318 * the firmware interfaces anymore. Need to free resources manually
319 * (DMA memory, debug, sysfs)...
321 zpci_stop_device(zdev);
325 static void __clp_update(struct clp_fh_list_entry *entry)
327 struct zpci_dev *zdev;
329 if (!entry->vendor_id)
330 return;
332 zdev = get_zdev_by_fid(entry->fid);
333 if (!zdev)
334 return;
336 zdev->fh = entry->fh;
339 int clp_scan_pci_devices(void)
341 struct clp_req_rsp_list_pci *rrb;
342 int rc;
344 rrb = clp_alloc_block(GFP_KERNEL);
345 if (!rrb)
346 return -ENOMEM;
348 rc = clp_list_pci(rrb, __clp_add);
350 clp_free_block(rrb);
351 return rc;
354 int clp_rescan_pci_devices(void)
356 struct clp_req_rsp_list_pci *rrb;
357 int rc;
359 rrb = clp_alloc_block(GFP_KERNEL);
360 if (!rrb)
361 return -ENOMEM;
363 rc = clp_list_pci(rrb, __clp_rescan);
365 clp_free_block(rrb);
366 return rc;
369 int clp_rescan_pci_devices_simple(void)
371 struct clp_req_rsp_list_pci *rrb;
372 int rc;
374 rrb = clp_alloc_block(GFP_NOWAIT);
375 if (!rrb)
376 return -ENOMEM;
378 rc = clp_list_pci(rrb, __clp_update);
380 clp_free_block(rrb);
381 return rc;