• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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