1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Intel On Demand (Software Defined Silicon) driver 4 * 5 * Copyright (c) 2022, Intel Corporation. 6 * All Rights Reserved. 7 * 8 * Author: "David E. Box" <david.e.box@linux.intel.com> 9 */ 10 11 #include <linux/auxiliary_bus.h> 12 #include <linux/bits.h> 13 #include <linux/bitfield.h> 14 #include <linux/device.h> 15 #include <linux/iopoll.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/pci.h> 19 #include <linux/slab.h> 20 #include <linux/sysfs.h> 21 #include <linux/types.h> 22 #include <linux/uaccess.h> 23 24 #include "vsec.h" 25 26 #define ACCESS_TYPE_BARID 2 27 #define ACCESS_TYPE_LOCAL 3 28 29 #define SDSI_MIN_SIZE_DWORDS 276 30 #define SDSI_SIZE_MAILBOX 1024 31 #define SDSI_SIZE_REGS 80 32 #define SDSI_SIZE_CMD sizeof(u64) 33 34 /* 35 * Write messages are currently up to the size of the mailbox 36 * while read messages are up to 4 times the size of the 37 * mailbox, sent in packets 38 */ 39 #define SDSI_SIZE_WRITE_MSG SDSI_SIZE_MAILBOX 40 #define SDSI_SIZE_READ_MSG (SDSI_SIZE_MAILBOX * 4) 41 42 #define SDSI_ENABLED_FEATURES_OFFSET 16 43 #define SDSI_FEATURE_SDSI BIT(3) 44 #define SDSI_FEATURE_METERING BIT(26) 45 46 #define SDSI_SOCKET_ID_OFFSET 64 47 #define SDSI_SOCKET_ID GENMASK(3, 0) 48 49 #define SDSI_MBOX_CMD_SUCCESS 0x40 50 #define SDSI_MBOX_CMD_TIMEOUT 0x80 51 52 #define MBOX_TIMEOUT_US 2000 53 #define MBOX_TIMEOUT_ACQUIRE_US 1000 54 #define MBOX_POLLING_PERIOD_US 100 55 #define MBOX_ACQUIRE_NUM_RETRIES 5 56 #define MBOX_ACQUIRE_RETRY_DELAY_MS 500 57 #define MBOX_MAX_PACKETS 4 58 59 #define MBOX_OWNER_NONE 0x00 60 #define MBOX_OWNER_INBAND 0x01 61 62 #define CTRL_RUN_BUSY BIT(0) 63 #define CTRL_READ_WRITE BIT(1) 64 #define CTRL_SOM BIT(2) 65 #define CTRL_EOM BIT(3) 66 #define CTRL_OWNER GENMASK(5, 4) 67 #define CTRL_COMPLETE BIT(6) 68 #define CTRL_READY BIT(7) 69 #define CTRL_STATUS GENMASK(15, 8) 70 #define CTRL_PACKET_SIZE GENMASK(31, 16) 71 #define CTRL_MSG_SIZE GENMASK(63, 48) 72 73 #define DISC_TABLE_SIZE 12 74 #define DT_ACCESS_TYPE GENMASK(3, 0) 75 #define DT_SIZE GENMASK(27, 12) 76 #define DT_TBIR GENMASK(2, 0) 77 #define DT_OFFSET(v) ((v) & GENMASK(31, 3)) 78 79 #define SDSI_GUID_V1 0x006DD191 80 #define GUID_V1_CNTRL_SIZE 8 81 #define GUID_V1_REGS_SIZE 72 82 #define SDSI_GUID_V2 0xF210D9EF 83 #define GUID_V2_CNTRL_SIZE 16 84 #define GUID_V2_REGS_SIZE 80 85 86 enum sdsi_command { 87 SDSI_CMD_PROVISION_AKC = 0x0004, 88 SDSI_CMD_PROVISION_CAP = 0x0008, 89 SDSI_CMD_READ_STATE = 0x0010, 90 SDSI_CMD_READ_METER = 0x0014, 91 }; 92 93 struct sdsi_mbox_info { 94 u64 *payload; 95 void *buffer; 96 int size; 97 }; 98 99 struct disc_table { 100 u32 access_info; 101 u32 guid; 102 u32 offset; 103 }; 104 105 struct sdsi_priv { 106 struct mutex mb_lock; /* Mailbox access lock */ 107 struct device *dev; 108 void __iomem *control_addr; 109 void __iomem *mbox_addr; 110 void __iomem *regs_addr; 111 int control_size; 112 int maibox_size; 113 int registers_size; 114 u32 guid; 115 u32 features; 116 }; 117 118 /* SDSi mailbox operations must be performed using 64bit mov instructions */ 119 static __always_inline void 120 sdsi_memcpy64_toio(u64 __iomem *to, const u64 *from, size_t count_bytes) 121 { 122 size_t count = count_bytes / sizeof(*to); 123 int i; 124 125 for (i = 0; i < count; i++) 126 writeq(from[i], &to[i]); 127 } 128 129 static __always_inline void 130 sdsi_memcpy64_fromio(u64 *to, const u64 __iomem *from, size_t count_bytes) 131 { 132 size_t count = count_bytes / sizeof(*to); 133 int i; 134 135 for (i = 0; i < count; i++) 136 to[i] = readq(&from[i]); 137 } 138 139 static inline void sdsi_complete_transaction(struct sdsi_priv *priv) 140 { 141 u64 control = FIELD_PREP(CTRL_COMPLETE, 1); 142 143 lockdep_assert_held(&priv->mb_lock); 144 writeq(control, priv->control_addr); 145 } 146 147 static int sdsi_status_to_errno(u32 status) 148 { 149 switch (status) { 150 case SDSI_MBOX_CMD_SUCCESS: 151 return 0; 152 case SDSI_MBOX_CMD_TIMEOUT: 153 return -ETIMEDOUT; 154 default: 155 return -EIO; 156 } 157 } 158 159 static int sdsi_mbox_cmd_read(struct sdsi_priv *priv, struct sdsi_mbox_info *info, 160 size_t *data_size) 161 { 162 struct device *dev = priv->dev; 163 u32 total, loop, eom, status, message_size; 164 u64 control; 165 int ret; 166 167 lockdep_assert_held(&priv->mb_lock); 168 169 /* Format and send the read command */ 170 control = FIELD_PREP(CTRL_EOM, 1) | 171 FIELD_PREP(CTRL_SOM, 1) | 172 FIELD_PREP(CTRL_RUN_BUSY, 1) | 173 FIELD_PREP(CTRL_PACKET_SIZE, info->size); 174 writeq(control, priv->control_addr); 175 176 /* For reads, data sizes that are larger than the mailbox size are read in packets. */ 177 total = 0; 178 loop = 0; 179 do { 180 void *buf = info->buffer + (SDSI_SIZE_MAILBOX * loop); 181 u32 packet_size; 182 183 /* Poll on ready bit */ 184 ret = readq_poll_timeout(priv->control_addr, control, control & CTRL_READY, 185 MBOX_POLLING_PERIOD_US, MBOX_TIMEOUT_US); 186 if (ret) 187 break; 188 189 eom = FIELD_GET(CTRL_EOM, control); 190 status = FIELD_GET(CTRL_STATUS, control); 191 packet_size = FIELD_GET(CTRL_PACKET_SIZE, control); 192 message_size = FIELD_GET(CTRL_MSG_SIZE, control); 193 194 ret = sdsi_status_to_errno(status); 195 if (ret) 196 break; 197 198 /* Only the last packet can be less than the mailbox size. */ 199 if (!eom && packet_size != SDSI_SIZE_MAILBOX) { 200 dev_err(dev, "Invalid packet size\n"); 201 ret = -EPROTO; 202 break; 203 } 204 205 if (packet_size > SDSI_SIZE_MAILBOX) { 206 dev_err(dev, "Packet size too large\n"); 207 ret = -EPROTO; 208 break; 209 } 210 211 sdsi_memcpy64_fromio(buf, priv->mbox_addr, round_up(packet_size, SDSI_SIZE_CMD)); 212 213 total += packet_size; 214 215 sdsi_complete_transaction(priv); 216 } while (!eom && ++loop < MBOX_MAX_PACKETS); 217 218 if (ret) { 219 sdsi_complete_transaction(priv); 220 return ret; 221 } 222 223 if (!eom) { 224 dev_err(dev, "Exceeded read attempts\n"); 225 return -EPROTO; 226 } 227 228 /* Message size check is only valid for multi-packet transfers */ 229 if (loop && total != message_size) 230 dev_warn(dev, "Read count %u differs from expected count %u\n", 231 total, message_size); 232 233 *data_size = total; 234 235 return 0; 236 } 237 238 static int sdsi_mbox_cmd_write(struct sdsi_priv *priv, struct sdsi_mbox_info *info) 239 { 240 u64 control; 241 u32 status; 242 int ret; 243 244 lockdep_assert_held(&priv->mb_lock); 245 246 /* Write rest of the payload */ 247 sdsi_memcpy64_toio(priv->mbox_addr + SDSI_SIZE_CMD, info->payload + 1, 248 info->size - SDSI_SIZE_CMD); 249 250 /* Format and send the write command */ 251 control = FIELD_PREP(CTRL_EOM, 1) | 252 FIELD_PREP(CTRL_SOM, 1) | 253 FIELD_PREP(CTRL_RUN_BUSY, 1) | 254 FIELD_PREP(CTRL_READ_WRITE, 1) | 255 FIELD_PREP(CTRL_PACKET_SIZE, info->size); 256 writeq(control, priv->control_addr); 257 258 /* Poll on ready bit */ 259 ret = readq_poll_timeout(priv->control_addr, control, control & CTRL_READY, 260 MBOX_POLLING_PERIOD_US, MBOX_TIMEOUT_US); 261 262 if (ret) 263 goto release_mbox; 264 265 status = FIELD_GET(CTRL_STATUS, control); 266 ret = sdsi_status_to_errno(status); 267 268 release_mbox: 269 sdsi_complete_transaction(priv); 270 271 return ret; 272 } 273 274 static int sdsi_mbox_acquire(struct sdsi_priv *priv, struct sdsi_mbox_info *info) 275 { 276 u64 control; 277 u32 owner; 278 int ret, retries = 0; 279 280 lockdep_assert_held(&priv->mb_lock); 281 282 /* Check mailbox is available */ 283 control = readq(priv->control_addr); 284 owner = FIELD_GET(CTRL_OWNER, control); 285 if (owner != MBOX_OWNER_NONE) 286 return -EBUSY; 287 288 /* 289 * If there has been no recent transaction and no one owns the mailbox, 290 * we should acquire it in under 1ms. However, if we've accessed it 291 * recently it may take up to 2.1 seconds to acquire it again. 292 */ 293 do { 294 /* Write first qword of payload */ 295 writeq(info->payload[0], priv->mbox_addr); 296 297 /* Check for ownership */ 298 ret = readq_poll_timeout(priv->control_addr, control, 299 FIELD_GET(CTRL_OWNER, control) == MBOX_OWNER_INBAND, 300 MBOX_POLLING_PERIOD_US, MBOX_TIMEOUT_ACQUIRE_US); 301 302 if (FIELD_GET(CTRL_OWNER, control) == MBOX_OWNER_NONE && 303 retries++ < MBOX_ACQUIRE_NUM_RETRIES) { 304 msleep(MBOX_ACQUIRE_RETRY_DELAY_MS); 305 continue; 306 } 307 308 /* Either we got it or someone else did. */ 309 break; 310 } while (true); 311 312 return ret; 313 } 314 315 static int sdsi_mbox_write(struct sdsi_priv *priv, struct sdsi_mbox_info *info) 316 { 317 int ret; 318 319 lockdep_assert_held(&priv->mb_lock); 320 321 ret = sdsi_mbox_acquire(priv, info); 322 if (ret) 323 return ret; 324 325 return sdsi_mbox_cmd_write(priv, info); 326 } 327 328 static int sdsi_mbox_read(struct sdsi_priv *priv, struct sdsi_mbox_info *info, size_t *data_size) 329 { 330 int ret; 331 332 lockdep_assert_held(&priv->mb_lock); 333 334 ret = sdsi_mbox_acquire(priv, info); 335 if (ret) 336 return ret; 337 338 return sdsi_mbox_cmd_read(priv, info, data_size); 339 } 340 341 static ssize_t sdsi_provision(struct sdsi_priv *priv, char *buf, size_t count, 342 enum sdsi_command command) 343 { 344 struct sdsi_mbox_info info; 345 int ret; 346 347 if (count > (SDSI_SIZE_WRITE_MSG - SDSI_SIZE_CMD)) 348 return -EOVERFLOW; 349 350 /* Qword aligned message + command qword */ 351 info.size = round_up(count, SDSI_SIZE_CMD) + SDSI_SIZE_CMD; 352 353 info.payload = kzalloc(info.size, GFP_KERNEL); 354 if (!info.payload) 355 return -ENOMEM; 356 357 /* Copy message to payload buffer */ 358 memcpy(info.payload, buf, count); 359 360 /* Command is last qword of payload buffer */ 361 info.payload[(info.size - SDSI_SIZE_CMD) / SDSI_SIZE_CMD] = command; 362 363 ret = mutex_lock_interruptible(&priv->mb_lock); 364 if (ret) 365 goto free_payload; 366 ret = sdsi_mbox_write(priv, &info); 367 mutex_unlock(&priv->mb_lock); 368 369 free_payload: 370 kfree(info.payload); 371 372 if (ret) 373 return ret; 374 375 return count; 376 } 377 378 static ssize_t provision_akc_write(struct file *filp, struct kobject *kobj, 379 struct bin_attribute *attr, char *buf, loff_t off, 380 size_t count) 381 { 382 struct device *dev = kobj_to_dev(kobj); 383 struct sdsi_priv *priv = dev_get_drvdata(dev); 384 385 if (off) 386 return -ESPIPE; 387 388 return sdsi_provision(priv, buf, count, SDSI_CMD_PROVISION_AKC); 389 } 390 static BIN_ATTR_WO(provision_akc, SDSI_SIZE_WRITE_MSG); 391 392 static ssize_t provision_cap_write(struct file *filp, struct kobject *kobj, 393 struct bin_attribute *attr, char *buf, loff_t off, 394 size_t count) 395 { 396 struct device *dev = kobj_to_dev(kobj); 397 struct sdsi_priv *priv = dev_get_drvdata(dev); 398 399 if (off) 400 return -ESPIPE; 401 402 return sdsi_provision(priv, buf, count, SDSI_CMD_PROVISION_CAP); 403 } 404 static BIN_ATTR_WO(provision_cap, SDSI_SIZE_WRITE_MSG); 405 406 static ssize_t 407 certificate_read(u64 command, struct sdsi_priv *priv, char *buf, loff_t off, 408 size_t count) 409 { 410 struct sdsi_mbox_info info; 411 size_t size; 412 int ret; 413 414 if (off) 415 return 0; 416 417 /* Buffer for return data */ 418 info.buffer = kmalloc(SDSI_SIZE_READ_MSG, GFP_KERNEL); 419 if (!info.buffer) 420 return -ENOMEM; 421 422 info.payload = &command; 423 info.size = sizeof(command); 424 425 ret = mutex_lock_interruptible(&priv->mb_lock); 426 if (ret) 427 goto free_buffer; 428 ret = sdsi_mbox_read(priv, &info, &size); 429 mutex_unlock(&priv->mb_lock); 430 if (ret < 0) 431 goto free_buffer; 432 433 if (size > count) 434 size = count; 435 436 memcpy(buf, info.buffer, size); 437 438 free_buffer: 439 kfree(info.buffer); 440 441 if (ret) 442 return ret; 443 444 return size; 445 } 446 447 static ssize_t 448 state_certificate_read(struct file *filp, struct kobject *kobj, 449 struct bin_attribute *attr, char *buf, loff_t off, 450 size_t count) 451 { 452 struct device *dev = kobj_to_dev(kobj); 453 struct sdsi_priv *priv = dev_get_drvdata(dev); 454 455 return certificate_read(SDSI_CMD_READ_STATE, priv, buf, off, count); 456 } 457 static BIN_ATTR_ADMIN_RO(state_certificate, SDSI_SIZE_READ_MSG); 458 459 static ssize_t 460 meter_certificate_read(struct file *filp, struct kobject *kobj, 461 struct bin_attribute *attr, char *buf, loff_t off, 462 size_t count) 463 { 464 struct device *dev = kobj_to_dev(kobj); 465 struct sdsi_priv *priv = dev_get_drvdata(dev); 466 467 return certificate_read(SDSI_CMD_READ_METER, priv, buf, off, count); 468 } 469 static BIN_ATTR_ADMIN_RO(meter_certificate, SDSI_SIZE_READ_MSG); 470 471 static ssize_t registers_read(struct file *filp, struct kobject *kobj, 472 struct bin_attribute *attr, char *buf, loff_t off, 473 size_t count) 474 { 475 struct device *dev = kobj_to_dev(kobj); 476 struct sdsi_priv *priv = dev_get_drvdata(dev); 477 void __iomem *addr = priv->regs_addr; 478 int size = priv->registers_size; 479 480 /* 481 * The check below is performed by the sysfs caller based on the static 482 * file size. But this may be greater than the actual size which is based 483 * on the GUID. So check here again based on actual size before reading. 484 */ 485 if (off >= size) 486 return 0; 487 488 if (off + count > size) 489 count = size - off; 490 491 memcpy_fromio(buf, addr + off, count); 492 493 return count; 494 } 495 static BIN_ATTR_ADMIN_RO(registers, SDSI_SIZE_REGS); 496 497 static struct bin_attribute *sdsi_bin_attrs[] = { 498 &bin_attr_registers, 499 &bin_attr_state_certificate, 500 &bin_attr_meter_certificate, 501 &bin_attr_provision_akc, 502 &bin_attr_provision_cap, 503 NULL 504 }; 505 506 static umode_t 507 sdsi_battr_is_visible(struct kobject *kobj, struct bin_attribute *attr, int n) 508 { 509 struct device *dev = kobj_to_dev(kobj); 510 struct sdsi_priv *priv = dev_get_drvdata(dev); 511 512 /* Registers file is always readable if the device is present */ 513 if (attr == &bin_attr_registers) 514 return attr->attr.mode; 515 516 /* All other attributes not visible if BIOS has not enabled On Demand */ 517 if (!(priv->features & SDSI_FEATURE_SDSI)) 518 return 0; 519 520 if (attr == &bin_attr_meter_certificate) 521 return (priv->features & SDSI_FEATURE_METERING) ? 522 attr->attr.mode : 0; 523 524 return attr->attr.mode; 525 } 526 527 static ssize_t guid_show(struct device *dev, struct device_attribute *attr, char *buf) 528 { 529 struct sdsi_priv *priv = dev_get_drvdata(dev); 530 531 return sysfs_emit(buf, "0x%x\n", priv->guid); 532 } 533 static DEVICE_ATTR_RO(guid); 534 535 static struct attribute *sdsi_attrs[] = { 536 &dev_attr_guid.attr, 537 NULL 538 }; 539 540 static const struct attribute_group sdsi_group = { 541 .attrs = sdsi_attrs, 542 .bin_attrs = sdsi_bin_attrs, 543 .is_bin_visible = sdsi_battr_is_visible, 544 }; 545 __ATTRIBUTE_GROUPS(sdsi); 546 547 static int sdsi_get_layout(struct sdsi_priv *priv, struct disc_table *table) 548 { 549 switch (table->guid) { 550 case SDSI_GUID_V1: 551 priv->control_size = GUID_V1_CNTRL_SIZE; 552 priv->registers_size = GUID_V1_REGS_SIZE; 553 break; 554 case SDSI_GUID_V2: 555 priv->control_size = GUID_V2_CNTRL_SIZE; 556 priv->registers_size = GUID_V2_REGS_SIZE; 557 break; 558 default: 559 dev_err(priv->dev, "Unrecognized GUID 0x%x\n", table->guid); 560 return -EINVAL; 561 } 562 return 0; 563 } 564 565 static int sdsi_map_mbox_registers(struct sdsi_priv *priv, struct pci_dev *parent, 566 struct disc_table *disc_table, struct resource *disc_res) 567 { 568 u32 access_type = FIELD_GET(DT_ACCESS_TYPE, disc_table->access_info); 569 u32 size = FIELD_GET(DT_SIZE, disc_table->access_info); 570 u32 tbir = FIELD_GET(DT_TBIR, disc_table->offset); 571 u32 offset = DT_OFFSET(disc_table->offset); 572 struct resource res = {}; 573 574 /* Starting location of SDSi MMIO region based on access type */ 575 switch (access_type) { 576 case ACCESS_TYPE_LOCAL: 577 if (tbir) { 578 dev_err(priv->dev, "Unsupported BAR index %u for access type %u\n", 579 tbir, access_type); 580 return -EINVAL; 581 } 582 583 /* 584 * For access_type LOCAL, the base address is as follows: 585 * base address = end of discovery region + base offset + 1 586 */ 587 res.start = disc_res->end + offset + 1; 588 break; 589 590 case ACCESS_TYPE_BARID: 591 res.start = pci_resource_start(parent, tbir) + offset; 592 break; 593 594 default: 595 dev_err(priv->dev, "Unrecognized access_type %u\n", access_type); 596 return -EINVAL; 597 } 598 599 res.end = res.start + size * sizeof(u32) - 1; 600 res.flags = IORESOURCE_MEM; 601 602 priv->control_addr = devm_ioremap_resource(priv->dev, &res); 603 if (IS_ERR(priv->control_addr)) 604 return PTR_ERR(priv->control_addr); 605 606 priv->mbox_addr = priv->control_addr + priv->control_size; 607 priv->regs_addr = priv->mbox_addr + SDSI_SIZE_MAILBOX; 608 609 priv->features = readq(priv->regs_addr + SDSI_ENABLED_FEATURES_OFFSET); 610 611 return 0; 612 } 613 614 static int sdsi_probe(struct auxiliary_device *auxdev, const struct auxiliary_device_id *id) 615 { 616 struct intel_vsec_device *intel_cap_dev = auxdev_to_ivdev(auxdev); 617 struct disc_table disc_table; 618 struct resource *disc_res; 619 void __iomem *disc_addr; 620 struct sdsi_priv *priv; 621 int ret; 622 623 priv = devm_kzalloc(&auxdev->dev, sizeof(*priv), GFP_KERNEL); 624 if (!priv) 625 return -ENOMEM; 626 627 priv->dev = &auxdev->dev; 628 mutex_init(&priv->mb_lock); 629 auxiliary_set_drvdata(auxdev, priv); 630 631 /* Get the SDSi discovery table */ 632 disc_res = &intel_cap_dev->resource[0]; 633 disc_addr = devm_ioremap_resource(&auxdev->dev, disc_res); 634 if (IS_ERR(disc_addr)) 635 return PTR_ERR(disc_addr); 636 637 memcpy_fromio(&disc_table, disc_addr, DISC_TABLE_SIZE); 638 639 priv->guid = disc_table.guid; 640 641 /* Get guid based layout info */ 642 ret = sdsi_get_layout(priv, &disc_table); 643 if (ret) 644 return ret; 645 646 /* Map the SDSi mailbox registers */ 647 ret = sdsi_map_mbox_registers(priv, intel_cap_dev->pcidev, &disc_table, disc_res); 648 if (ret) 649 return ret; 650 651 return 0; 652 } 653 654 static const struct auxiliary_device_id sdsi_aux_id_table[] = { 655 { .name = "intel_vsec.sdsi" }, 656 {} 657 }; 658 MODULE_DEVICE_TABLE(auxiliary, sdsi_aux_id_table); 659 660 static struct auxiliary_driver sdsi_aux_driver = { 661 .driver = { 662 .dev_groups = sdsi_groups, 663 }, 664 .id_table = sdsi_aux_id_table, 665 .probe = sdsi_probe, 666 /* No remove. All resources are handled under devm */ 667 }; 668 module_auxiliary_driver(sdsi_aux_driver); 669 670 MODULE_AUTHOR("David E. Box <david.e.box@linux.intel.com>"); 671 MODULE_DESCRIPTION("Intel On Demand (SDSi) driver"); 672 MODULE_LICENSE("GPL"); 673