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/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> 22 #include <asm/clp.h> 23 #include <uapi/asm/clp.h> 24 25 bool zpci_unique_uid; 26 27 static inline void zpci_err_clp(unsigned int rsp, int rc) 28 { 29 struct { 30 unsigned int rsp; 31 int rc; 32 } __packed data = {rsp, rc}; 33 34 zpci_err_hex(&data, sizeof(data)); 35 } 36 37 /* 38 * Call Logical Processor with c=1, lps=0 and command 1 39 * to get the bit mask of installed logical processors 40 */ 41 static inline int clp_get_ilp(unsigned long *ilp) 42 { 43 unsigned long mask; 44 int cc = 3; 45 46 asm volatile ( 47 " .insn rrf,0xb9a00000,%[mask],%[cmd],8,0\n" 48 "0: ipm %[cc]\n" 49 " srl %[cc],28\n" 50 "1:\n" 51 EX_TABLE(0b, 1b) 52 : [cc] "+d" (cc), [mask] "=d" (mask) : [cmd] "a" (1) 53 : "cc"); 54 *ilp = mask; 55 return cc; 56 } 57 58 /* 59 * Call Logical Processor with c=0, the give constant lps and an lpcb request. 60 */ 61 static inline int clp_req(void *data, unsigned int lps) 62 { 63 struct { u8 _[CLP_BLK_SIZE]; } *req = data; 64 u64 ignored; 65 int cc = 3; 66 67 asm volatile ( 68 " .insn rrf,0xb9a00000,%[ign],%[req],0,%[lps]\n" 69 "0: ipm %[cc]\n" 70 " srl %[cc],28\n" 71 "1:\n" 72 EX_TABLE(0b, 1b) 73 : [cc] "+d" (cc), [ign] "=d" (ignored), "+m" (*req) 74 : [req] "a" (req), [lps] "i" (lps) 75 : "cc"); 76 return cc; 77 } 78 79 static void *clp_alloc_block(gfp_t gfp_mask) 80 { 81 return (void *) __get_free_pages(gfp_mask, get_order(CLP_BLK_SIZE)); 82 } 83 84 static void clp_free_block(void *ptr) 85 { 86 free_pages((unsigned long) ptr, get_order(CLP_BLK_SIZE)); 87 } 88 89 static void clp_store_query_pci_fngrp(struct zpci_dev *zdev, 90 struct clp_rsp_query_pci_grp *response) 91 { 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; 97 98 switch (response->version) { 99 case 1: 100 zdev->max_bus_speed = PCIE_SPEED_5_0GT; 101 break; 102 default: 103 zdev->max_bus_speed = PCI_SPEED_UNKNOWN; 104 break; 105 } 106 } 107 108 static int clp_query_pci_fngrp(struct zpci_dev *zdev, u8 pfgid) 109 { 110 struct clp_req_rsp_query_pci_grp *rrb; 111 int rc; 112 113 rrb = clp_alloc_block(GFP_KERNEL); 114 if (!rrb) 115 return -ENOMEM; 116 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; 122 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); 126 else { 127 zpci_err("Q PCI FGRP:\n"); 128 zpci_err_clp(rrb->response.hdr.rsp, rc); 129 rc = -EIO; 130 } 131 clp_free_block(rrb); 132 return rc; 133 } 134 135 static int clp_store_query_pci_fn(struct zpci_dev *zdev, 136 struct clp_rsp_query_pci *response) 137 { 138 int i; 139 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]; 143 } 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; 152 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)); 157 } 158 159 return 0; 160 } 161 162 static int clp_query_pci_fn(struct zpci_dev *zdev, u32 fh) 163 { 164 struct clp_req_rsp_query_pci *rrb; 165 int rc; 166 167 rrb = clp_alloc_block(GFP_KERNEL); 168 if (!rrb) 169 return -ENOMEM; 170 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; 176 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); 180 if (rc) 181 goto out; 182 rc = clp_query_pci_fngrp(zdev, rrb->response.pfgid); 183 } else { 184 zpci_err("Q PCI FN:\n"); 185 zpci_err_clp(rrb->response.hdr.rsp, rc); 186 rc = -EIO; 187 } 188 out: 189 clp_free_block(rrb); 190 return rc; 191 } 192 193 int clp_add_pci_device(u32 fid, u32 fh, int configured) 194 { 195 struct zpci_dev *zdev; 196 int rc = -ENOMEM; 197 198 zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid, fh, configured); 199 zdev = kzalloc(sizeof(*zdev), GFP_KERNEL); 200 if (!zdev) 201 goto error; 202 203 zdev->fh = fh; 204 zdev->fid = fid; 205 206 /* Query function properties and update zdev */ 207 rc = clp_query_pci_fn(zdev, fh); 208 if (rc) 209 goto error; 210 211 if (configured) 212 zdev->state = ZPCI_FN_STATE_CONFIGURED; 213 else 214 zdev->state = ZPCI_FN_STATE_STANDBY; 215 216 rc = zpci_create_device(zdev); 217 if (rc) 218 goto error; 219 return 0; 220 221 error: 222 zpci_dbg(0, "add fid:%x, rc:%d\n", fid, rc); 223 kfree(zdev); 224 return rc; 225 } 226 227 /* 228 * Enable/Disable a given PCI function defined by its function handle. 229 */ 230 static int clp_set_pci_fn(u32 *fh, u8 nr_dma_as, u8 command) 231 { 232 struct clp_req_rsp_set_pci *rrb; 233 int rc, retries = 100; 234 235 rrb = clp_alloc_block(GFP_KERNEL); 236 if (!rrb) 237 return -ENOMEM; 238 239 do { 240 memset(rrb, 0, sizeof(*rrb)); 241 rrb->request.hdr.len = sizeof(rrb->request); 242 rrb->request.hdr.cmd = CLP_SET_PCI_FN; 243 rrb->response.hdr.len = sizeof(rrb->response); 244 rrb->request.fh = *fh; 245 rrb->request.oc = command; 246 rrb->request.ndas = nr_dma_as; 247 248 rc = clp_req(rrb, CLP_LPS_PCI); 249 if (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY) { 250 retries--; 251 if (retries < 0) 252 break; 253 msleep(20); 254 } 255 } while (rrb->response.hdr.rsp == CLP_RC_SETPCIFN_BUSY); 256 257 if (!rc && rrb->response.hdr.rsp == CLP_RC_OK) 258 *fh = rrb->response.fh; 259 else { 260 zpci_err("Set PCI FN:\n"); 261 zpci_err_clp(rrb->response.hdr.rsp, rc); 262 rc = -EIO; 263 } 264 clp_free_block(rrb); 265 return rc; 266 } 267 268 int clp_enable_fh(struct zpci_dev *zdev, u8 nr_dma_as) 269 { 270 u32 fh = zdev->fh; 271 int rc; 272 273 rc = clp_set_pci_fn(&fh, nr_dma_as, CLP_SET_ENABLE_PCI_FN); 274 if (!rc) 275 /* Success -> store enabled handle in zdev */ 276 zdev->fh = fh; 277 278 zpci_dbg(3, "ena fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc); 279 return rc; 280 } 281 282 int clp_disable_fh(struct zpci_dev *zdev) 283 { 284 u32 fh = zdev->fh; 285 int rc; 286 287 if (!zdev_enabled(zdev)) 288 return 0; 289 290 rc = clp_set_pci_fn(&fh, 0, CLP_SET_DISABLE_PCI_FN); 291 if (!rc) 292 /* Success -> store disabled handle in zdev */ 293 zdev->fh = fh; 294 295 zpci_dbg(3, "dis fid:%x, fh:%x, rc:%d\n", zdev->fid, zdev->fh, rc); 296 return rc; 297 } 298 299 static int clp_list_pci(struct clp_req_rsp_list_pci *rrb, void *data, 300 void (*cb)(struct clp_fh_list_entry *, void *)) 301 { 302 u64 resume_token = 0; 303 int entries, i, rc; 304 305 do { 306 memset(rrb, 0, sizeof(*rrb)); 307 rrb->request.hdr.len = sizeof(rrb->request); 308 rrb->request.hdr.cmd = CLP_LIST_PCI; 309 /* store as many entries as possible */ 310 rrb->response.hdr.len = CLP_BLK_SIZE - LIST_PCI_HDR_LEN; 311 rrb->request.resume_token = resume_token; 312 313 /* Get PCI function handle list */ 314 rc = clp_req(rrb, CLP_LPS_PCI); 315 if (rc || rrb->response.hdr.rsp != CLP_RC_OK) { 316 zpci_err("List PCI FN:\n"); 317 zpci_err_clp(rrb->response.hdr.rsp, rc); 318 rc = -EIO; 319 goto out; 320 } 321 322 zpci_unique_uid = rrb->response.uid_checking; 323 WARN_ON_ONCE(rrb->response.entry_size != 324 sizeof(struct clp_fh_list_entry)); 325 326 entries = (rrb->response.hdr.len - LIST_PCI_HDR_LEN) / 327 rrb->response.entry_size; 328 329 resume_token = rrb->response.resume_token; 330 for (i = 0; i < entries; i++) 331 cb(&rrb->response.fh_list[i], data); 332 } while (resume_token); 333 out: 334 return rc; 335 } 336 337 static void __clp_add(struct clp_fh_list_entry *entry, void *data) 338 { 339 struct zpci_dev *zdev; 340 341 if (!entry->vendor_id) 342 return; 343 344 zdev = get_zdev_by_fid(entry->fid); 345 if (!zdev) 346 clp_add_pci_device(entry->fid, entry->fh, entry->config_state); 347 } 348 349 static void __clp_update(struct clp_fh_list_entry *entry, void *data) 350 { 351 struct zpci_dev *zdev; 352 353 if (!entry->vendor_id) 354 return; 355 356 zdev = get_zdev_by_fid(entry->fid); 357 if (!zdev) 358 return; 359 360 zdev->fh = entry->fh; 361 } 362 363 int clp_scan_pci_devices(void) 364 { 365 struct clp_req_rsp_list_pci *rrb; 366 int rc; 367 368 rrb = clp_alloc_block(GFP_KERNEL); 369 if (!rrb) 370 return -ENOMEM; 371 372 rc = clp_list_pci(rrb, NULL, __clp_add); 373 374 clp_free_block(rrb); 375 return rc; 376 } 377 378 int clp_rescan_pci_devices(void) 379 { 380 struct clp_req_rsp_list_pci *rrb; 381 int rc; 382 383 zpci_remove_reserved_devices(); 384 385 rrb = clp_alloc_block(GFP_KERNEL); 386 if (!rrb) 387 return -ENOMEM; 388 389 rc = clp_list_pci(rrb, NULL, __clp_add); 390 391 clp_free_block(rrb); 392 return rc; 393 } 394 395 int clp_rescan_pci_devices_simple(void) 396 { 397 struct clp_req_rsp_list_pci *rrb; 398 int rc; 399 400 rrb = clp_alloc_block(GFP_NOWAIT); 401 if (!rrb) 402 return -ENOMEM; 403 404 rc = clp_list_pci(rrb, NULL, __clp_update); 405 406 clp_free_block(rrb); 407 return rc; 408 } 409 410 struct clp_state_data { 411 u32 fid; 412 enum zpci_state state; 413 }; 414 415 static void __clp_get_state(struct clp_fh_list_entry *entry, void *data) 416 { 417 struct clp_state_data *sd = data; 418 419 if (entry->fid != sd->fid) 420 return; 421 422 sd->state = entry->config_state; 423 } 424 425 int clp_get_state(u32 fid, enum zpci_state *state) 426 { 427 struct clp_req_rsp_list_pci *rrb; 428 struct clp_state_data sd = {fid, ZPCI_FN_STATE_RESERVED}; 429 int rc; 430 431 rrb = clp_alloc_block(GFP_KERNEL); 432 if (!rrb) 433 return -ENOMEM; 434 435 rc = clp_list_pci(rrb, &sd, __clp_get_state); 436 if (!rc) 437 *state = sd.state; 438 439 clp_free_block(rrb); 440 return rc; 441 } 442 443 static int clp_base_slpc(struct clp_req *req, struct clp_req_rsp_slpc *lpcb) 444 { 445 unsigned long limit = PAGE_SIZE - sizeof(lpcb->request); 446 447 if (lpcb->request.hdr.len != sizeof(lpcb->request) || 448 lpcb->response.hdr.len > limit) 449 return -EINVAL; 450 return clp_req(lpcb, CLP_LPS_BASE) ? -EOPNOTSUPP : 0; 451 } 452 453 static int clp_base_command(struct clp_req *req, struct clp_req_hdr *lpcb) 454 { 455 switch (lpcb->cmd) { 456 case 0x0001: /* store logical-processor characteristics */ 457 return clp_base_slpc(req, (void *) lpcb); 458 default: 459 return -EINVAL; 460 } 461 } 462 463 static int clp_pci_slpc(struct clp_req *req, struct clp_req_rsp_slpc *lpcb) 464 { 465 unsigned long limit = PAGE_SIZE - sizeof(lpcb->request); 466 467 if (lpcb->request.hdr.len != sizeof(lpcb->request) || 468 lpcb->response.hdr.len > limit) 469 return -EINVAL; 470 return clp_req(lpcb, CLP_LPS_PCI) ? -EOPNOTSUPP : 0; 471 } 472 473 static int clp_pci_list(struct clp_req *req, struct clp_req_rsp_list_pci *lpcb) 474 { 475 unsigned long limit = PAGE_SIZE - sizeof(lpcb->request); 476 477 if (lpcb->request.hdr.len != sizeof(lpcb->request) || 478 lpcb->response.hdr.len > limit) 479 return -EINVAL; 480 if (lpcb->request.reserved2 != 0) 481 return -EINVAL; 482 return clp_req(lpcb, CLP_LPS_PCI) ? -EOPNOTSUPP : 0; 483 } 484 485 static int clp_pci_query(struct clp_req *req, 486 struct clp_req_rsp_query_pci *lpcb) 487 { 488 unsigned long limit = PAGE_SIZE - sizeof(lpcb->request); 489 490 if (lpcb->request.hdr.len != sizeof(lpcb->request) || 491 lpcb->response.hdr.len > limit) 492 return -EINVAL; 493 if (lpcb->request.reserved2 != 0 || lpcb->request.reserved3 != 0) 494 return -EINVAL; 495 return clp_req(lpcb, CLP_LPS_PCI) ? -EOPNOTSUPP : 0; 496 } 497 498 static int clp_pci_query_grp(struct clp_req *req, 499 struct clp_req_rsp_query_pci_grp *lpcb) 500 { 501 unsigned long limit = PAGE_SIZE - sizeof(lpcb->request); 502 503 if (lpcb->request.hdr.len != sizeof(lpcb->request) || 504 lpcb->response.hdr.len > limit) 505 return -EINVAL; 506 if (lpcb->request.reserved2 != 0 || lpcb->request.reserved3 != 0 || 507 lpcb->request.reserved4 != 0) 508 return -EINVAL; 509 return clp_req(lpcb, CLP_LPS_PCI) ? -EOPNOTSUPP : 0; 510 } 511 512 static int clp_pci_command(struct clp_req *req, struct clp_req_hdr *lpcb) 513 { 514 switch (lpcb->cmd) { 515 case 0x0001: /* store logical-processor characteristics */ 516 return clp_pci_slpc(req, (void *) lpcb); 517 case 0x0002: /* list PCI functions */ 518 return clp_pci_list(req, (void *) lpcb); 519 case 0x0003: /* query PCI function */ 520 return clp_pci_query(req, (void *) lpcb); 521 case 0x0004: /* query PCI function group */ 522 return clp_pci_query_grp(req, (void *) lpcb); 523 default: 524 return -EINVAL; 525 } 526 } 527 528 static int clp_normal_command(struct clp_req *req) 529 { 530 struct clp_req_hdr *lpcb; 531 void __user *uptr; 532 int rc; 533 534 rc = -EINVAL; 535 if (req->lps != 0 && req->lps != 2) 536 goto out; 537 538 rc = -ENOMEM; 539 lpcb = clp_alloc_block(GFP_KERNEL); 540 if (!lpcb) 541 goto out; 542 543 rc = -EFAULT; 544 uptr = (void __force __user *)(unsigned long) req->data_p; 545 if (copy_from_user(lpcb, uptr, PAGE_SIZE) != 0) 546 goto out_free; 547 548 rc = -EINVAL; 549 if (lpcb->fmt != 0 || lpcb->reserved1 != 0 || lpcb->reserved2 != 0) 550 goto out_free; 551 552 switch (req->lps) { 553 case 0: 554 rc = clp_base_command(req, lpcb); 555 break; 556 case 2: 557 rc = clp_pci_command(req, lpcb); 558 break; 559 } 560 if (rc) 561 goto out_free; 562 563 rc = -EFAULT; 564 if (copy_to_user(uptr, lpcb, PAGE_SIZE) != 0) 565 goto out_free; 566 567 rc = 0; 568 569 out_free: 570 clp_free_block(lpcb); 571 out: 572 return rc; 573 } 574 575 static int clp_immediate_command(struct clp_req *req) 576 { 577 void __user *uptr; 578 unsigned long ilp; 579 int exists; 580 581 if (req->cmd > 1 || clp_get_ilp(&ilp) != 0) 582 return -EINVAL; 583 584 uptr = (void __force __user *)(unsigned long) req->data_p; 585 if (req->cmd == 0) { 586 /* Command code 0: test for a specific processor */ 587 exists = test_bit_inv(req->lps, &ilp); 588 return put_user(exists, (int __user *) uptr); 589 } 590 /* Command code 1: return bit mask of installed processors */ 591 return put_user(ilp, (unsigned long __user *) uptr); 592 } 593 594 static long clp_misc_ioctl(struct file *filp, unsigned int cmd, 595 unsigned long arg) 596 { 597 struct clp_req req; 598 void __user *argp; 599 600 if (cmd != CLP_SYNC) 601 return -EINVAL; 602 603 argp = is_compat_task() ? compat_ptr(arg) : (void __user *) arg; 604 if (copy_from_user(&req, argp, sizeof(req))) 605 return -EFAULT; 606 if (req.r != 0) 607 return -EINVAL; 608 return req.c ? clp_immediate_command(&req) : clp_normal_command(&req); 609 } 610 611 static int clp_misc_release(struct inode *inode, struct file *filp) 612 { 613 return 0; 614 } 615 616 static const struct file_operations clp_misc_fops = { 617 .owner = THIS_MODULE, 618 .open = nonseekable_open, 619 .release = clp_misc_release, 620 .unlocked_ioctl = clp_misc_ioctl, 621 .compat_ioctl = clp_misc_ioctl, 622 .llseek = no_llseek, 623 }; 624 625 static struct miscdevice clp_misc_device = { 626 .minor = MISC_DYNAMIC_MINOR, 627 .name = "clp", 628 .fops = &clp_misc_fops, 629 }; 630 631 static int __init clp_misc_init(void) 632 { 633 return misc_register(&clp_misc_device); 634 } 635 636 device_initcall(clp_misc_init); 637