2 * Copyright IBM Corp. 2012
5 * Jan Glauber <jang@linux.vnet.ibm.com>
8 #define KMSG_COMPONENT "zpci"
9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11 #include <linux/compat.h>
12 #include <linux/kernel.h>
13 #include <linux/miscdevice.h>
14 #include <linux/slab.h>
15 #include <linux/err.h>
16 #include <linux/delay.h>
17 #include <linux/pci.h>
18 #include <linux/uaccess.h>
19 #include <asm/pci_debug.h>
20 #include <asm/pci_clp.h>
21 #include <asm/compat.h>
23 #include <uapi/asm/clp.h>
27 static void update_uid_checking(bool new)
29 if (zpci_unique_uid
!= new)
30 zpci_dbg(1, "uid checking:%d\n", new);
32 zpci_unique_uid
= new;
35 static inline void zpci_err_clp(unsigned int rsp
, int rc
)
40 } __packed data
= {rsp
, rc
};
42 zpci_err_hex(&data
, sizeof(data
));
46 * Call Logical Processor with c=1, lps=0 and command 1
47 * to get the bit mask of installed logical processors
49 static inline int clp_get_ilp(unsigned long *ilp
)
55 " .insn rrf,0xb9a00000,%[mask],%[cmd],8,0\n"
60 : [cc
] "+d" (cc
), [mask
] "=d" (mask
) : [cmd
] "a" (1)
67 * Call Logical Processor with c=0, the give constant lps and an lpcb request.
69 static inline int clp_req(void *data
, unsigned int lps
)
71 struct { u8 _
[CLP_BLK_SIZE
]; } *req
= data
;
76 " .insn rrf,0xb9a00000,%[ign],%[req],0,%[lps]\n"
81 : [cc
] "+d" (cc
), [ign
] "=d" (ignored
), "+m" (*req
)
82 : [req
] "a" (req
), [lps
] "i" (lps
)
87 static void *clp_alloc_block(gfp_t gfp_mask
)
89 return (void *) __get_free_pages(gfp_mask
, get_order(CLP_BLK_SIZE
));
92 static void clp_free_block(void *ptr
)
94 free_pages((unsigned long) ptr
, get_order(CLP_BLK_SIZE
));
97 static void clp_store_query_pci_fngrp(struct zpci_dev
*zdev
,
98 struct clp_rsp_query_pci_grp
*response
)
100 zdev
->tlb_refresh
= response
->refresh
;
101 zdev
->dma_mask
= response
->dasm
;
102 zdev
->msi_addr
= response
->msia
;
103 zdev
->max_msi
= response
->noi
;
104 zdev
->fmb_update
= response
->mui
;
106 switch (response
->version
) {
108 zdev
->max_bus_speed
= PCIE_SPEED_5_0GT
;
111 zdev
->max_bus_speed
= PCI_SPEED_UNKNOWN
;
116 static int clp_query_pci_fngrp(struct zpci_dev
*zdev
, u8 pfgid
)
118 struct clp_req_rsp_query_pci_grp
*rrb
;
121 rrb
= clp_alloc_block(GFP_KERNEL
);
125 memset(rrb
, 0, sizeof(*rrb
));
126 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
127 rrb
->request
.hdr
.cmd
= CLP_QUERY_PCI_FNGRP
;
128 rrb
->response
.hdr
.len
= sizeof(rrb
->response
);
129 rrb
->request
.pfgid
= pfgid
;
131 rc
= clp_req(rrb
, CLP_LPS_PCI
);
132 if (!rc
&& rrb
->response
.hdr
.rsp
== CLP_RC_OK
)
133 clp_store_query_pci_fngrp(zdev
, &rrb
->response
);
135 zpci_err("Q PCI FGRP:\n");
136 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
143 static int clp_store_query_pci_fn(struct zpci_dev
*zdev
,
144 struct clp_rsp_query_pci
*response
)
148 for (i
= 0; i
< PCI_BAR_COUNT
; i
++) {
149 zdev
->bars
[i
].val
= le32_to_cpu(response
->bar
[i
]);
150 zdev
->bars
[i
].size
= response
->bar_size
[i
];
152 zdev
->start_dma
= response
->sdma
;
153 zdev
->end_dma
= response
->edma
;
154 zdev
->pchid
= response
->pchid
;
155 zdev
->pfgid
= response
->pfgid
;
156 zdev
->pft
= response
->pft
;
157 zdev
->vfn
= response
->vfn
;
158 zdev
->uid
= response
->uid
;
159 zdev
->fmb_length
= sizeof(u32
) * response
->fmb_len
;
161 memcpy(zdev
->pfip
, response
->pfip
, sizeof(zdev
->pfip
));
162 if (response
->util_str_avail
) {
163 memcpy(zdev
->util_str
, response
->util_str
,
164 sizeof(zdev
->util_str
));
170 static int clp_query_pci_fn(struct zpci_dev
*zdev
, u32 fh
)
172 struct clp_req_rsp_query_pci
*rrb
;
175 rrb
= clp_alloc_block(GFP_KERNEL
);
179 memset(rrb
, 0, sizeof(*rrb
));
180 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
181 rrb
->request
.hdr
.cmd
= CLP_QUERY_PCI_FN
;
182 rrb
->response
.hdr
.len
= sizeof(rrb
->response
);
183 rrb
->request
.fh
= fh
;
185 rc
= clp_req(rrb
, CLP_LPS_PCI
);
186 if (!rc
&& rrb
->response
.hdr
.rsp
== CLP_RC_OK
) {
187 rc
= clp_store_query_pci_fn(zdev
, &rrb
->response
);
190 rc
= clp_query_pci_fngrp(zdev
, rrb
->response
.pfgid
);
192 zpci_err("Q PCI FN:\n");
193 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
201 int clp_add_pci_device(u32 fid
, u32 fh
, int configured
)
203 struct zpci_dev
*zdev
;
206 zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid
, fh
, configured
);
207 zdev
= kzalloc(sizeof(*zdev
), GFP_KERNEL
);
214 /* Query function properties and update zdev */
215 rc
= clp_query_pci_fn(zdev
, fh
);
220 zdev
->state
= ZPCI_FN_STATE_CONFIGURED
;
222 zdev
->state
= ZPCI_FN_STATE_STANDBY
;
224 rc
= zpci_create_device(zdev
);
230 zpci_dbg(0, "add fid:%x, rc:%d\n", fid
, rc
);
236 * Enable/Disable a given PCI function defined by its function handle.
238 static int clp_set_pci_fn(u32
*fh
, u8 nr_dma_as
, u8 command
)
240 struct clp_req_rsp_set_pci
*rrb
;
241 int rc
, retries
= 100;
243 rrb
= clp_alloc_block(GFP_KERNEL
);
248 memset(rrb
, 0, sizeof(*rrb
));
249 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
250 rrb
->request
.hdr
.cmd
= CLP_SET_PCI_FN
;
251 rrb
->response
.hdr
.len
= sizeof(rrb
->response
);
252 rrb
->request
.fh
= *fh
;
253 rrb
->request
.oc
= command
;
254 rrb
->request
.ndas
= nr_dma_as
;
256 rc
= clp_req(rrb
, CLP_LPS_PCI
);
257 if (rrb
->response
.hdr
.rsp
== CLP_RC_SETPCIFN_BUSY
) {
263 } while (rrb
->response
.hdr
.rsp
== CLP_RC_SETPCIFN_BUSY
);
265 if (!rc
&& rrb
->response
.hdr
.rsp
== CLP_RC_OK
)
266 *fh
= rrb
->response
.fh
;
268 zpci_err("Set PCI FN:\n");
269 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
276 int clp_enable_fh(struct zpci_dev
*zdev
, u8 nr_dma_as
)
281 rc
= clp_set_pci_fn(&fh
, nr_dma_as
, CLP_SET_ENABLE_PCI_FN
);
283 /* Success -> store enabled handle in zdev */
286 zpci_dbg(3, "ena fid:%x, fh:%x, rc:%d\n", zdev
->fid
, zdev
->fh
, rc
);
290 int clp_disable_fh(struct zpci_dev
*zdev
)
295 if (!zdev_enabled(zdev
))
298 rc
= clp_set_pci_fn(&fh
, 0, CLP_SET_DISABLE_PCI_FN
);
300 /* Success -> store disabled handle in zdev */
303 zpci_dbg(3, "dis fid:%x, fh:%x, rc:%d\n", zdev
->fid
, zdev
->fh
, rc
);
307 static int clp_list_pci(struct clp_req_rsp_list_pci
*rrb
, void *data
,
308 void (*cb
)(struct clp_fh_list_entry
*, void *))
310 u64 resume_token
= 0;
314 memset(rrb
, 0, sizeof(*rrb
));
315 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
316 rrb
->request
.hdr
.cmd
= CLP_LIST_PCI
;
317 /* store as many entries as possible */
318 rrb
->response
.hdr
.len
= CLP_BLK_SIZE
- LIST_PCI_HDR_LEN
;
319 rrb
->request
.resume_token
= resume_token
;
321 /* Get PCI function handle list */
322 rc
= clp_req(rrb
, CLP_LPS_PCI
);
323 if (rc
|| rrb
->response
.hdr
.rsp
!= CLP_RC_OK
) {
324 zpci_err("List PCI FN:\n");
325 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
330 update_uid_checking(rrb
->response
.uid_checking
);
331 WARN_ON_ONCE(rrb
->response
.entry_size
!=
332 sizeof(struct clp_fh_list_entry
));
334 entries
= (rrb
->response
.hdr
.len
- LIST_PCI_HDR_LEN
) /
335 rrb
->response
.entry_size
;
337 resume_token
= rrb
->response
.resume_token
;
338 for (i
= 0; i
< entries
; i
++)
339 cb(&rrb
->response
.fh_list
[i
], data
);
340 } while (resume_token
);
345 static void __clp_add(struct clp_fh_list_entry
*entry
, void *data
)
347 struct zpci_dev
*zdev
;
349 if (!entry
->vendor_id
)
352 zdev
= get_zdev_by_fid(entry
->fid
);
354 clp_add_pci_device(entry
->fid
, entry
->fh
, entry
->config_state
);
357 static void __clp_update(struct clp_fh_list_entry
*entry
, void *data
)
359 struct zpci_dev
*zdev
;
361 if (!entry
->vendor_id
)
364 zdev
= get_zdev_by_fid(entry
->fid
);
368 zdev
->fh
= entry
->fh
;
371 int clp_scan_pci_devices(void)
373 struct clp_req_rsp_list_pci
*rrb
;
376 rrb
= clp_alloc_block(GFP_KERNEL
);
380 rc
= clp_list_pci(rrb
, NULL
, __clp_add
);
386 int clp_rescan_pci_devices(void)
388 struct clp_req_rsp_list_pci
*rrb
;
391 zpci_remove_reserved_devices();
393 rrb
= clp_alloc_block(GFP_KERNEL
);
397 rc
= clp_list_pci(rrb
, NULL
, __clp_add
);
403 int clp_rescan_pci_devices_simple(void)
405 struct clp_req_rsp_list_pci
*rrb
;
408 rrb
= clp_alloc_block(GFP_NOWAIT
);
412 rc
= clp_list_pci(rrb
, NULL
, __clp_update
);
418 struct clp_state_data
{
420 enum zpci_state state
;
423 static void __clp_get_state(struct clp_fh_list_entry
*entry
, void *data
)
425 struct clp_state_data
*sd
= data
;
427 if (entry
->fid
!= sd
->fid
)
430 sd
->state
= entry
->config_state
;
433 int clp_get_state(u32 fid
, enum zpci_state
*state
)
435 struct clp_req_rsp_list_pci
*rrb
;
436 struct clp_state_data sd
= {fid
, ZPCI_FN_STATE_RESERVED
};
439 rrb
= clp_alloc_block(GFP_KERNEL
);
443 rc
= clp_list_pci(rrb
, &sd
, __clp_get_state
);
451 static int clp_base_slpc(struct clp_req
*req
, struct clp_req_rsp_slpc
*lpcb
)
453 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
455 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
456 lpcb
->response
.hdr
.len
> limit
)
458 return clp_req(lpcb
, CLP_LPS_BASE
) ? -EOPNOTSUPP
: 0;
461 static int clp_base_command(struct clp_req
*req
, struct clp_req_hdr
*lpcb
)
464 case 0x0001: /* store logical-processor characteristics */
465 return clp_base_slpc(req
, (void *) lpcb
);
471 static int clp_pci_slpc(struct clp_req
*req
, struct clp_req_rsp_slpc
*lpcb
)
473 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
475 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
476 lpcb
->response
.hdr
.len
> limit
)
478 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
481 static int clp_pci_list(struct clp_req
*req
, struct clp_req_rsp_list_pci
*lpcb
)
483 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
485 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
486 lpcb
->response
.hdr
.len
> limit
)
488 if (lpcb
->request
.reserved2
!= 0)
490 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
493 static int clp_pci_query(struct clp_req
*req
,
494 struct clp_req_rsp_query_pci
*lpcb
)
496 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
498 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
499 lpcb
->response
.hdr
.len
> limit
)
501 if (lpcb
->request
.reserved2
!= 0 || lpcb
->request
.reserved3
!= 0)
503 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
506 static int clp_pci_query_grp(struct clp_req
*req
,
507 struct clp_req_rsp_query_pci_grp
*lpcb
)
509 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
511 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
512 lpcb
->response
.hdr
.len
> limit
)
514 if (lpcb
->request
.reserved2
!= 0 || lpcb
->request
.reserved3
!= 0 ||
515 lpcb
->request
.reserved4
!= 0)
517 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
520 static int clp_pci_command(struct clp_req
*req
, struct clp_req_hdr
*lpcb
)
523 case 0x0001: /* store logical-processor characteristics */
524 return clp_pci_slpc(req
, (void *) lpcb
);
525 case 0x0002: /* list PCI functions */
526 return clp_pci_list(req
, (void *) lpcb
);
527 case 0x0003: /* query PCI function */
528 return clp_pci_query(req
, (void *) lpcb
);
529 case 0x0004: /* query PCI function group */
530 return clp_pci_query_grp(req
, (void *) lpcb
);
536 static int clp_normal_command(struct clp_req
*req
)
538 struct clp_req_hdr
*lpcb
;
543 if (req
->lps
!= 0 && req
->lps
!= 2)
547 lpcb
= clp_alloc_block(GFP_KERNEL
);
552 uptr
= (void __force __user
*)(unsigned long) req
->data_p
;
553 if (copy_from_user(lpcb
, uptr
, PAGE_SIZE
) != 0)
557 if (lpcb
->fmt
!= 0 || lpcb
->reserved1
!= 0 || lpcb
->reserved2
!= 0)
562 rc
= clp_base_command(req
, lpcb
);
565 rc
= clp_pci_command(req
, lpcb
);
572 if (copy_to_user(uptr
, lpcb
, PAGE_SIZE
) != 0)
578 clp_free_block(lpcb
);
583 static int clp_immediate_command(struct clp_req
*req
)
589 if (req
->cmd
> 1 || clp_get_ilp(&ilp
) != 0)
592 uptr
= (void __force __user
*)(unsigned long) req
->data_p
;
594 /* Command code 0: test for a specific processor */
595 exists
= test_bit_inv(req
->lps
, &ilp
);
596 return put_user(exists
, (int __user
*) uptr
);
598 /* Command code 1: return bit mask of installed processors */
599 return put_user(ilp
, (unsigned long __user
*) uptr
);
602 static long clp_misc_ioctl(struct file
*filp
, unsigned int cmd
,
611 argp
= is_compat_task() ? compat_ptr(arg
) : (void __user
*) arg
;
612 if (copy_from_user(&req
, argp
, sizeof(req
)))
616 return req
.c
? clp_immediate_command(&req
) : clp_normal_command(&req
);
619 static int clp_misc_release(struct inode
*inode
, struct file
*filp
)
624 static const struct file_operations clp_misc_fops
= {
625 .owner
= THIS_MODULE
,
626 .open
= nonseekable_open
,
627 .release
= clp_misc_release
,
628 .unlocked_ioctl
= clp_misc_ioctl
,
629 .compat_ioctl
= clp_misc_ioctl
,
633 static struct miscdevice clp_misc_device
= {
634 .minor
= MISC_DYNAMIC_MINOR
,
636 .fops
= &clp_misc_fops
,
639 static int __init
clp_misc_init(void)
641 return misc_register(&clp_misc_device
);
644 device_initcall(clp_misc_init
);