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 inline void zpci_err_clp(unsigned int rsp
, int rc
)
32 } __packed data
= {rsp
, rc
};
34 zpci_err_hex(&data
, sizeof(data
));
38 * Call Logical Processor with c=1, lps=0 and command 1
39 * to get the bit mask of installed logical processors
41 static inline int clp_get_ilp(unsigned long *ilp
)
47 " .insn rrf,0xb9a00000,%[mask],%[cmd],8,0\n"
52 : [cc
] "+d" (cc
), [mask
] "=d" (mask
) : [cmd
] "a" (1)
59 * Call Logical Processor with c=0, the give constant lps and an lpcb request.
61 static inline int clp_req(void *data
, unsigned int lps
)
63 struct { u8 _
[CLP_BLK_SIZE
]; } *req
= data
;
68 " .insn rrf,0xb9a00000,%[ign],%[req],0,%[lps]\n"
73 : [cc
] "+d" (cc
), [ign
] "=d" (ignored
), "+m" (*req
)
74 : [req
] "a" (req
), [lps
] "i" (lps
)
79 static void *clp_alloc_block(gfp_t gfp_mask
)
81 return (void *) __get_free_pages(gfp_mask
, get_order(CLP_BLK_SIZE
));
84 static void clp_free_block(void *ptr
)
86 free_pages((unsigned long) ptr
, get_order(CLP_BLK_SIZE
));
89 static void clp_store_query_pci_fngrp(struct zpci_dev
*zdev
,
90 struct clp_rsp_query_pci_grp
*response
)
92 zdev
->tlb_refresh
= response
->refresh
;
93 zdev
->dma_mask
= response
->dasm
;
94 zdev
->msi_addr
= response
->msia
;
95 zdev
->max_msi
= response
->noi
;
96 zdev
->fmb_update
= response
->mui
;
98 switch (response
->version
) {
100 zdev
->max_bus_speed
= PCIE_SPEED_5_0GT
;
103 zdev
->max_bus_speed
= PCI_SPEED_UNKNOWN
;
108 static int clp_query_pci_fngrp(struct zpci_dev
*zdev
, u8 pfgid
)
110 struct clp_req_rsp_query_pci_grp
*rrb
;
113 rrb
= clp_alloc_block(GFP_KERNEL
);
117 memset(rrb
, 0, sizeof(*rrb
));
118 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
119 rrb
->request
.hdr
.cmd
= CLP_QUERY_PCI_FNGRP
;
120 rrb
->response
.hdr
.len
= sizeof(rrb
->response
);
121 rrb
->request
.pfgid
= pfgid
;
123 rc
= clp_req(rrb
, CLP_LPS_PCI
);
124 if (!rc
&& rrb
->response
.hdr
.rsp
== CLP_RC_OK
)
125 clp_store_query_pci_fngrp(zdev
, &rrb
->response
);
127 zpci_err("Q PCI FGRP:\n");
128 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
135 static int clp_store_query_pci_fn(struct zpci_dev
*zdev
,
136 struct clp_rsp_query_pci
*response
)
140 for (i
= 0; i
< PCI_BAR_COUNT
; i
++) {
141 zdev
->bars
[i
].val
= le32_to_cpu(response
->bar
[i
]);
142 zdev
->bars
[i
].size
= response
->bar_size
[i
];
144 zdev
->start_dma
= response
->sdma
;
145 zdev
->end_dma
= response
->edma
;
146 zdev
->pchid
= response
->pchid
;
147 zdev
->pfgid
= response
->pfgid
;
148 zdev
->pft
= response
->pft
;
149 zdev
->vfn
= response
->vfn
;
150 zdev
->uid
= response
->uid
;
151 zdev
->fmb_length
= sizeof(u32
) * response
->fmb_len
;
153 memcpy(zdev
->pfip
, response
->pfip
, sizeof(zdev
->pfip
));
154 if (response
->util_str_avail
) {
155 memcpy(zdev
->util_str
, response
->util_str
,
156 sizeof(zdev
->util_str
));
162 static int clp_query_pci_fn(struct zpci_dev
*zdev
, u32 fh
)
164 struct clp_req_rsp_query_pci
*rrb
;
167 rrb
= clp_alloc_block(GFP_KERNEL
);
171 memset(rrb
, 0, sizeof(*rrb
));
172 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
173 rrb
->request
.hdr
.cmd
= CLP_QUERY_PCI_FN
;
174 rrb
->response
.hdr
.len
= sizeof(rrb
->response
);
175 rrb
->request
.fh
= fh
;
177 rc
= clp_req(rrb
, CLP_LPS_PCI
);
178 if (!rc
&& rrb
->response
.hdr
.rsp
== CLP_RC_OK
) {
179 rc
= clp_store_query_pci_fn(zdev
, &rrb
->response
);
182 rc
= clp_query_pci_fngrp(zdev
, rrb
->response
.pfgid
);
184 zpci_err("Q PCI FN:\n");
185 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
193 int clp_add_pci_device(u32 fid
, u32 fh
, int configured
)
195 struct zpci_dev
*zdev
;
198 zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid
, fh
, configured
);
199 zdev
= kzalloc(sizeof(*zdev
), GFP_KERNEL
);
206 /* Query function properties and update zdev */
207 rc
= clp_query_pci_fn(zdev
, fh
);
212 zdev
->state
= ZPCI_FN_STATE_CONFIGURED
;
214 zdev
->state
= ZPCI_FN_STATE_STANDBY
;
216 rc
= zpci_create_device(zdev
);
227 * Enable/Disable a given PCI function defined by its function handle.
229 static int clp_set_pci_fn(u32
*fh
, u8 nr_dma_as
, u8 command
)
231 struct clp_req_rsp_set_pci
*rrb
;
232 int rc
, retries
= 100;
234 rrb
= clp_alloc_block(GFP_KERNEL
);
239 memset(rrb
, 0, sizeof(*rrb
));
240 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
241 rrb
->request
.hdr
.cmd
= CLP_SET_PCI_FN
;
242 rrb
->response
.hdr
.len
= sizeof(rrb
->response
);
243 rrb
->request
.fh
= *fh
;
244 rrb
->request
.oc
= command
;
245 rrb
->request
.ndas
= nr_dma_as
;
247 rc
= clp_req(rrb
, CLP_LPS_PCI
);
248 if (rrb
->response
.hdr
.rsp
== CLP_RC_SETPCIFN_BUSY
) {
254 } while (rrb
->response
.hdr
.rsp
== CLP_RC_SETPCIFN_BUSY
);
256 if (!rc
&& rrb
->response
.hdr
.rsp
== CLP_RC_OK
)
257 *fh
= rrb
->response
.fh
;
259 zpci_err("Set PCI FN:\n");
260 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
267 int clp_enable_fh(struct zpci_dev
*zdev
, u8 nr_dma_as
)
272 rc
= clp_set_pci_fn(&fh
, nr_dma_as
, CLP_SET_ENABLE_PCI_FN
);
274 /* Success -> store enabled handle in zdev */
277 zpci_dbg(3, "ena fid:%x, fh:%x, rc:%d\n", zdev
->fid
, zdev
->fh
, rc
);
281 int clp_disable_fh(struct zpci_dev
*zdev
)
286 if (!zdev_enabled(zdev
))
289 rc
= clp_set_pci_fn(&fh
, 0, CLP_SET_DISABLE_PCI_FN
);
291 /* Success -> store disabled handle in zdev */
294 zpci_dbg(3, "dis fid:%x, fh:%x, rc:%d\n", zdev
->fid
, zdev
->fh
, rc
);
298 static int clp_list_pci(struct clp_req_rsp_list_pci
*rrb
,
299 void (*cb
)(struct clp_fh_list_entry
*entry
))
301 u64 resume_token
= 0;
305 memset(rrb
, 0, sizeof(*rrb
));
306 rrb
->request
.hdr
.len
= sizeof(rrb
->request
);
307 rrb
->request
.hdr
.cmd
= CLP_LIST_PCI
;
308 /* store as many entries as possible */
309 rrb
->response
.hdr
.len
= CLP_BLK_SIZE
- LIST_PCI_HDR_LEN
;
310 rrb
->request
.resume_token
= resume_token
;
312 /* Get PCI function handle list */
313 rc
= clp_req(rrb
, CLP_LPS_PCI
);
314 if (rc
|| rrb
->response
.hdr
.rsp
!= CLP_RC_OK
) {
315 zpci_err("List PCI FN:\n");
316 zpci_err_clp(rrb
->response
.hdr
.rsp
, rc
);
321 zpci_unique_uid
= rrb
->response
.uid_checking
;
322 WARN_ON_ONCE(rrb
->response
.entry_size
!=
323 sizeof(struct clp_fh_list_entry
));
325 entries
= (rrb
->response
.hdr
.len
- LIST_PCI_HDR_LEN
) /
326 rrb
->response
.entry_size
;
328 resume_token
= rrb
->response
.resume_token
;
329 for (i
= 0; i
< entries
; i
++)
330 cb(&rrb
->response
.fh_list
[i
]);
331 } while (resume_token
);
336 static void __clp_add(struct clp_fh_list_entry
*entry
)
338 if (!entry
->vendor_id
)
341 clp_add_pci_device(entry
->fid
, entry
->fh
, entry
->config_state
);
344 static void __clp_rescan(struct clp_fh_list_entry
*entry
)
346 struct zpci_dev
*zdev
;
348 if (!entry
->vendor_id
)
351 zdev
= get_zdev_by_fid(entry
->fid
);
353 clp_add_pci_device(entry
->fid
, entry
->fh
, entry
->config_state
);
357 if (!entry
->config_state
) {
359 * The handle is already disabled, that means no iota/irq freeing via
360 * the firmware interfaces anymore. Need to free resources manually
361 * (DMA memory, debug, sysfs)...
363 zpci_stop_device(zdev
);
367 static void __clp_update(struct clp_fh_list_entry
*entry
)
369 struct zpci_dev
*zdev
;
371 if (!entry
->vendor_id
)
374 zdev
= get_zdev_by_fid(entry
->fid
);
378 zdev
->fh
= entry
->fh
;
381 int clp_scan_pci_devices(void)
383 struct clp_req_rsp_list_pci
*rrb
;
386 rrb
= clp_alloc_block(GFP_KERNEL
);
390 rc
= clp_list_pci(rrb
, __clp_add
);
396 int clp_rescan_pci_devices(void)
398 struct clp_req_rsp_list_pci
*rrb
;
401 rrb
= clp_alloc_block(GFP_KERNEL
);
405 rc
= clp_list_pci(rrb
, __clp_rescan
);
411 int clp_rescan_pci_devices_simple(void)
413 struct clp_req_rsp_list_pci
*rrb
;
416 rrb
= clp_alloc_block(GFP_NOWAIT
);
420 rc
= clp_list_pci(rrb
, __clp_update
);
426 static int clp_base_slpc(struct clp_req
*req
, struct clp_req_rsp_slpc
*lpcb
)
428 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
430 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
431 lpcb
->response
.hdr
.len
> limit
)
433 return clp_req(lpcb
, CLP_LPS_BASE
) ? -EOPNOTSUPP
: 0;
436 static int clp_base_command(struct clp_req
*req
, struct clp_req_hdr
*lpcb
)
439 case 0x0001: /* store logical-processor characteristics */
440 return clp_base_slpc(req
, (void *) lpcb
);
446 static int clp_pci_slpc(struct clp_req
*req
, struct clp_req_rsp_slpc
*lpcb
)
448 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
450 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
451 lpcb
->response
.hdr
.len
> limit
)
453 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
456 static int clp_pci_list(struct clp_req
*req
, struct clp_req_rsp_list_pci
*lpcb
)
458 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
460 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
461 lpcb
->response
.hdr
.len
> limit
)
463 if (lpcb
->request
.reserved2
!= 0)
465 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
468 static int clp_pci_query(struct clp_req
*req
,
469 struct clp_req_rsp_query_pci
*lpcb
)
471 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
473 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
474 lpcb
->response
.hdr
.len
> limit
)
476 if (lpcb
->request
.reserved2
!= 0 || lpcb
->request
.reserved3
!= 0)
478 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
481 static int clp_pci_query_grp(struct clp_req
*req
,
482 struct clp_req_rsp_query_pci_grp
*lpcb
)
484 unsigned long limit
= PAGE_SIZE
- sizeof(lpcb
->request
);
486 if (lpcb
->request
.hdr
.len
!= sizeof(lpcb
->request
) ||
487 lpcb
->response
.hdr
.len
> limit
)
489 if (lpcb
->request
.reserved2
!= 0 || lpcb
->request
.reserved3
!= 0 ||
490 lpcb
->request
.reserved4
!= 0)
492 return clp_req(lpcb
, CLP_LPS_PCI
) ? -EOPNOTSUPP
: 0;
495 static int clp_pci_command(struct clp_req
*req
, struct clp_req_hdr
*lpcb
)
498 case 0x0001: /* store logical-processor characteristics */
499 return clp_pci_slpc(req
, (void *) lpcb
);
500 case 0x0002: /* list PCI functions */
501 return clp_pci_list(req
, (void *) lpcb
);
502 case 0x0003: /* query PCI function */
503 return clp_pci_query(req
, (void *) lpcb
);
504 case 0x0004: /* query PCI function group */
505 return clp_pci_query_grp(req
, (void *) lpcb
);
511 static int clp_normal_command(struct clp_req
*req
)
513 struct clp_req_hdr
*lpcb
;
518 if (req
->lps
!= 0 && req
->lps
!= 2)
522 lpcb
= clp_alloc_block(GFP_KERNEL
);
527 uptr
= (void __force __user
*)(unsigned long) req
->data_p
;
528 if (copy_from_user(lpcb
, uptr
, PAGE_SIZE
) != 0)
532 if (lpcb
->fmt
!= 0 || lpcb
->reserved1
!= 0 || lpcb
->reserved2
!= 0)
537 rc
= clp_base_command(req
, lpcb
);
540 rc
= clp_pci_command(req
, lpcb
);
547 if (copy_to_user(uptr
, lpcb
, PAGE_SIZE
) != 0)
553 clp_free_block(lpcb
);
558 static int clp_immediate_command(struct clp_req
*req
)
564 if (req
->cmd
> 1 || clp_get_ilp(&ilp
) != 0)
567 uptr
= (void __force __user
*)(unsigned long) req
->data_p
;
569 /* Command code 0: test for a specific processor */
570 exists
= test_bit_inv(req
->lps
, &ilp
);
571 return put_user(exists
, (int __user
*) uptr
);
573 /* Command code 1: return bit mask of installed processors */
574 return put_user(ilp
, (unsigned long __user
*) uptr
);
577 static long clp_misc_ioctl(struct file
*filp
, unsigned int cmd
,
586 argp
= is_compat_task() ? compat_ptr(arg
) : (void __user
*) arg
;
587 if (copy_from_user(&req
, argp
, sizeof(req
)))
591 return req
.c
? clp_immediate_command(&req
) : clp_normal_command(&req
);
594 static int clp_misc_release(struct inode
*inode
, struct file
*filp
)
599 static const struct file_operations clp_misc_fops
= {
600 .owner
= THIS_MODULE
,
601 .open
= nonseekable_open
,
602 .release
= clp_misc_release
,
603 .unlocked_ioctl
= clp_misc_ioctl
,
604 .compat_ioctl
= clp_misc_ioctl
,
608 static struct miscdevice clp_misc_device
= {
609 .minor
= MISC_DYNAMIC_MINOR
,
611 .fops
= &clp_misc_fops
,
614 static int __init
clp_misc_init(void)
616 return misc_register(&clp_misc_device
);
619 device_initcall(clp_misc_init
);