1 #include <linux/kernel.h> 2 #include <linux/fs.h> 3 #include <linux/semaphore.h> 4 #include <linux/slab.h> 5 #include <linux/uaccess.h> 6 #include <asm/rtas.h> 7 8 #include "cxl.h" 9 #include "hcalls.h" 10 11 #define DOWNLOAD_IMAGE 1 12 #define VALIDATE_IMAGE 2 13 14 struct ai_header { 15 u16 version; 16 u8 reserved0[6]; 17 u16 vendor; 18 u16 device; 19 u16 subsystem_vendor; 20 u16 subsystem; 21 u64 image_offset; 22 u64 image_length; 23 u8 reserved1[96]; 24 }; 25 26 static struct semaphore sem; 27 static unsigned long *buffer[CXL_AI_MAX_ENTRIES]; 28 static struct sg_list *le; 29 static u64 continue_token; 30 static unsigned int transfer; 31 32 struct update_props_workarea { 33 __be32 phandle; 34 __be32 state; 35 __be64 reserved; 36 __be32 nprops; 37 } __packed; 38 39 struct update_nodes_workarea { 40 __be32 state; 41 __be64 unit_address; 42 __be32 reserved; 43 } __packed; 44 45 #define DEVICE_SCOPE 3 46 #define NODE_ACTION_MASK 0xff000000 47 #define NODE_COUNT_MASK 0x00ffffff 48 #define OPCODE_DELETE 0x01000000 49 #define OPCODE_UPDATE 0x02000000 50 #define OPCODE_ADD 0x03000000 51 52 static int rcall(int token, char *buf, s32 scope) 53 { 54 int rc; 55 56 spin_lock(&rtas_data_buf_lock); 57 58 memcpy(rtas_data_buf, buf, RTAS_DATA_BUF_SIZE); 59 rc = rtas_call(token, 2, 1, NULL, rtas_data_buf, scope); 60 memcpy(buf, rtas_data_buf, RTAS_DATA_BUF_SIZE); 61 62 spin_unlock(&rtas_data_buf_lock); 63 return rc; 64 } 65 66 static int update_property(struct device_node *dn, const char *name, 67 u32 vd, char *value) 68 { 69 struct property *new_prop; 70 u32 *val; 71 int rc; 72 73 new_prop = kzalloc(sizeof(*new_prop), GFP_KERNEL); 74 if (!new_prop) 75 return -ENOMEM; 76 77 new_prop->name = kstrdup(name, GFP_KERNEL); 78 if (!new_prop->name) { 79 kfree(new_prop); 80 return -ENOMEM; 81 } 82 83 new_prop->length = vd; 84 new_prop->value = kzalloc(new_prop->length, GFP_KERNEL); 85 if (!new_prop->value) { 86 kfree(new_prop->name); 87 kfree(new_prop); 88 return -ENOMEM; 89 } 90 memcpy(new_prop->value, value, vd); 91 92 val = (u32 *)new_prop->value; 93 rc = cxl_update_properties(dn, new_prop); 94 pr_devel("%s: update property (%s, length: %i, value: %#x)\n", 95 dn->name, name, vd, be32_to_cpu(*val)); 96 97 if (rc) { 98 kfree(new_prop->name); 99 kfree(new_prop->value); 100 kfree(new_prop); 101 } 102 return rc; 103 } 104 105 static int update_node(__be32 phandle, s32 scope) 106 { 107 struct update_props_workarea *upwa; 108 struct device_node *dn; 109 int i, rc, ret; 110 char *prop_data; 111 char *buf; 112 int token; 113 u32 nprops; 114 u32 vd; 115 116 token = rtas_token("ibm,update-properties"); 117 if (token == RTAS_UNKNOWN_SERVICE) 118 return -EINVAL; 119 120 buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL); 121 if (!buf) 122 return -ENOMEM; 123 124 dn = of_find_node_by_phandle(be32_to_cpu(phandle)); 125 if (!dn) { 126 kfree(buf); 127 return -ENOENT; 128 } 129 130 upwa = (struct update_props_workarea *)&buf[0]; 131 upwa->phandle = phandle; 132 do { 133 rc = rcall(token, buf, scope); 134 if (rc < 0) 135 break; 136 137 prop_data = buf + sizeof(*upwa); 138 nprops = be32_to_cpu(upwa->nprops); 139 140 if (*prop_data == 0) { 141 prop_data++; 142 vd = be32_to_cpu(*(__be32 *)prop_data); 143 prop_data += vd + sizeof(vd); 144 nprops--; 145 } 146 147 for (i = 0; i < nprops; i++) { 148 char *prop_name; 149 150 prop_name = prop_data; 151 prop_data += strlen(prop_name) + 1; 152 vd = be32_to_cpu(*(__be32 *)prop_data); 153 prop_data += sizeof(vd); 154 155 if ((vd != 0x00000000) && (vd != 0x80000000)) { 156 ret = update_property(dn, prop_name, vd, 157 prop_data); 158 if (ret) 159 pr_err("cxl: Could not update property %s - %i\n", 160 prop_name, ret); 161 162 prop_data += vd; 163 } 164 } 165 } while (rc == 1); 166 167 of_node_put(dn); 168 kfree(buf); 169 return rc; 170 } 171 172 static int update_devicetree(struct cxl *adapter, s32 scope) 173 { 174 struct update_nodes_workarea *unwa; 175 u32 action, node_count; 176 int token, rc, i; 177 __be32 *data, drc_index, phandle; 178 char *buf; 179 180 token = rtas_token("ibm,update-nodes"); 181 if (token == RTAS_UNKNOWN_SERVICE) 182 return -EINVAL; 183 184 buf = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL); 185 if (!buf) 186 return -ENOMEM; 187 188 unwa = (struct update_nodes_workarea *)&buf[0]; 189 unwa->unit_address = cpu_to_be64(adapter->guest->handle); 190 do { 191 rc = rcall(token, buf, scope); 192 if (rc && rc != 1) 193 break; 194 195 data = (__be32 *)buf + 4; 196 while (be32_to_cpu(*data) & NODE_ACTION_MASK) { 197 action = be32_to_cpu(*data) & NODE_ACTION_MASK; 198 node_count = be32_to_cpu(*data) & NODE_COUNT_MASK; 199 pr_devel("device reconfiguration - action: %#x, nodes: %#x\n", 200 action, node_count); 201 data++; 202 203 for (i = 0; i < node_count; i++) { 204 phandle = *data++; 205 206 switch (action) { 207 case OPCODE_DELETE: 208 /* nothing to do */ 209 break; 210 case OPCODE_UPDATE: 211 update_node(phandle, scope); 212 break; 213 case OPCODE_ADD: 214 /* nothing to do, just move pointer */ 215 drc_index = *data++; 216 break; 217 } 218 } 219 } 220 } while (rc == 1); 221 222 kfree(buf); 223 return 0; 224 } 225 226 static int handle_image(struct cxl *adapter, int operation, 227 long (*fct)(u64, u64, u64, u64 *), 228 struct cxl_adapter_image *ai) 229 { 230 size_t mod, s_copy, len_chunk = 0; 231 struct ai_header *header = NULL; 232 unsigned int entries = 0, i; 233 void *dest, *from; 234 int rc = 0, need_header; 235 236 /* base adapter image header */ 237 need_header = (ai->flags & CXL_AI_NEED_HEADER); 238 if (need_header) { 239 header = kzalloc(sizeof(struct ai_header), GFP_KERNEL); 240 if (!header) 241 return -ENOMEM; 242 header->version = cpu_to_be16(1); 243 header->vendor = cpu_to_be16(adapter->guest->vendor); 244 header->device = cpu_to_be16(adapter->guest->device); 245 header->subsystem_vendor = cpu_to_be16(adapter->guest->subsystem_vendor); 246 header->subsystem = cpu_to_be16(adapter->guest->subsystem); 247 header->image_offset = cpu_to_be64(CXL_AI_HEADER_SIZE); 248 header->image_length = cpu_to_be64(ai->len_image); 249 } 250 251 /* number of entries in the list */ 252 len_chunk = ai->len_data; 253 if (need_header) 254 len_chunk += CXL_AI_HEADER_SIZE; 255 256 entries = len_chunk / CXL_AI_BUFFER_SIZE; 257 mod = len_chunk % CXL_AI_BUFFER_SIZE; 258 if (mod) 259 entries++; 260 261 if (entries > CXL_AI_MAX_ENTRIES) { 262 rc = -EINVAL; 263 goto err; 264 } 265 266 /* < -- MAX_CHUNK_SIZE = 4096 * 256 = 1048576 bytes --> 267 * chunk 0 ---------------------------------------------------- 268 * | header | data | 269 * ---------------------------------------------------- 270 * chunk 1 ---------------------------------------------------- 271 * | data | 272 * ---------------------------------------------------- 273 * .... 274 * chunk n ---------------------------------------------------- 275 * | data | 276 * ---------------------------------------------------- 277 */ 278 from = (void *) ai->data; 279 for (i = 0; i < entries; i++) { 280 dest = buffer[i]; 281 s_copy = CXL_AI_BUFFER_SIZE; 282 283 if ((need_header) && (i == 0)) { 284 /* add adapter image header */ 285 memcpy(buffer[i], header, sizeof(struct ai_header)); 286 s_copy = CXL_AI_BUFFER_SIZE - CXL_AI_HEADER_SIZE; 287 dest += CXL_AI_HEADER_SIZE; /* image offset */ 288 } 289 if ((i == (entries - 1)) && mod) 290 s_copy = mod; 291 292 /* copy data */ 293 if (copy_from_user(dest, from, s_copy)) 294 goto err; 295 296 /* fill in the list */ 297 le[i].phys_addr = cpu_to_be64(virt_to_phys(buffer[i])); 298 le[i].len = cpu_to_be64(CXL_AI_BUFFER_SIZE); 299 if ((i == (entries - 1)) && mod) 300 le[i].len = cpu_to_be64(mod); 301 from += s_copy; 302 } 303 pr_devel("%s (op: %i, need header: %i, entries: %i, token: %#llx)\n", 304 __func__, operation, need_header, entries, continue_token); 305 306 /* 307 * download/validate the adapter image to the coherent 308 * platform facility 309 */ 310 rc = fct(adapter->guest->handle, virt_to_phys(le), entries, 311 &continue_token); 312 if (rc == 0) /* success of download/validation operation */ 313 continue_token = 0; 314 315 err: 316 kfree(header); 317 318 return rc; 319 } 320 321 static int transfer_image(struct cxl *adapter, int operation, 322 struct cxl_adapter_image *ai) 323 { 324 int rc = 0; 325 int afu; 326 327 switch (operation) { 328 case DOWNLOAD_IMAGE: 329 rc = handle_image(adapter, operation, 330 &cxl_h_download_adapter_image, ai); 331 if (rc < 0) { 332 pr_devel("resetting adapter\n"); 333 cxl_h_reset_adapter(adapter->guest->handle); 334 } 335 return rc; 336 337 case VALIDATE_IMAGE: 338 rc = handle_image(adapter, operation, 339 &cxl_h_validate_adapter_image, ai); 340 if (rc < 0) { 341 pr_devel("resetting adapter\n"); 342 cxl_h_reset_adapter(adapter->guest->handle); 343 return rc; 344 } 345 if (rc == 0) { 346 pr_devel("remove current afu\n"); 347 for (afu = 0; afu < adapter->slices; afu++) 348 cxl_guest_remove_afu(adapter->afu[afu]); 349 350 pr_devel("resetting adapter\n"); 351 cxl_h_reset_adapter(adapter->guest->handle); 352 353 /* The entire image has now been 354 * downloaded and the validation has 355 * been successfully performed. 356 * After that, the partition should call 357 * ibm,update-nodes and 358 * ibm,update-properties to receive the 359 * current configuration 360 */ 361 rc = update_devicetree(adapter, DEVICE_SCOPE); 362 transfer = 1; 363 } 364 return rc; 365 } 366 367 return -EINVAL; 368 } 369 370 static long ioctl_transfer_image(struct cxl *adapter, int operation, 371 struct cxl_adapter_image __user *uai) 372 { 373 struct cxl_adapter_image ai; 374 375 pr_devel("%s\n", __func__); 376 377 if (copy_from_user(&ai, uai, sizeof(struct cxl_adapter_image))) 378 return -EFAULT; 379 380 /* 381 * Make sure reserved fields and bits are set to 0 382 */ 383 if (ai.reserved1 || ai.reserved2 || ai.reserved3 || ai.reserved4 || 384 (ai.flags & ~CXL_AI_ALL)) 385 return -EINVAL; 386 387 return transfer_image(adapter, operation, &ai); 388 } 389 390 static int device_open(struct inode *inode, struct file *file) 391 { 392 int adapter_num = CXL_DEVT_ADAPTER(inode->i_rdev); 393 struct cxl *adapter; 394 int rc = 0, i; 395 396 pr_devel("in %s\n", __func__); 397 398 BUG_ON(sizeof(struct ai_header) != CXL_AI_HEADER_SIZE); 399 400 /* Allows one process to open the device by using a semaphore */ 401 if (down_interruptible(&sem) != 0) 402 return -EPERM; 403 404 if (!(adapter = get_cxl_adapter(adapter_num))) { 405 rc = -ENODEV; 406 goto err_unlock; 407 } 408 409 file->private_data = adapter; 410 continue_token = 0; 411 transfer = 0; 412 413 for (i = 0; i < CXL_AI_MAX_ENTRIES; i++) 414 buffer[i] = NULL; 415 416 /* aligned buffer containing list entries which describes up to 417 * 1 megabyte of data (256 entries of 4096 bytes each) 418 * Logical real address of buffer 0 - Buffer 0 length in bytes 419 * Logical real address of buffer 1 - Buffer 1 length in bytes 420 * Logical real address of buffer 2 - Buffer 2 length in bytes 421 * .... 422 * .... 423 * Logical real address of buffer N - Buffer N length in bytes 424 */ 425 le = (struct sg_list *)get_zeroed_page(GFP_KERNEL); 426 if (!le) { 427 rc = -ENOMEM; 428 goto err; 429 } 430 431 for (i = 0; i < CXL_AI_MAX_ENTRIES; i++) { 432 buffer[i] = (unsigned long *)get_zeroed_page(GFP_KERNEL); 433 if (!buffer[i]) { 434 rc = -ENOMEM; 435 goto err1; 436 } 437 } 438 439 return 0; 440 441 err1: 442 for (i = 0; i < CXL_AI_MAX_ENTRIES; i++) { 443 if (buffer[i]) 444 free_page((unsigned long) buffer[i]); 445 } 446 447 if (le) 448 free_page((unsigned long) le); 449 err: 450 put_device(&adapter->dev); 451 err_unlock: 452 up(&sem); 453 454 return rc; 455 } 456 457 static long device_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 458 { 459 struct cxl *adapter = file->private_data; 460 461 pr_devel("in %s\n", __func__); 462 463 if (cmd == CXL_IOCTL_DOWNLOAD_IMAGE) 464 return ioctl_transfer_image(adapter, 465 DOWNLOAD_IMAGE, 466 (struct cxl_adapter_image __user *)arg); 467 else if (cmd == CXL_IOCTL_VALIDATE_IMAGE) 468 return ioctl_transfer_image(adapter, 469 VALIDATE_IMAGE, 470 (struct cxl_adapter_image __user *)arg); 471 else 472 return -EINVAL; 473 } 474 475 static long device_compat_ioctl(struct file *file, unsigned int cmd, 476 unsigned long arg) 477 { 478 return device_ioctl(file, cmd, arg); 479 } 480 481 static int device_close(struct inode *inode, struct file *file) 482 { 483 struct cxl *adapter = file->private_data; 484 int i; 485 486 pr_devel("in %s\n", __func__); 487 488 for (i = 0; i < CXL_AI_MAX_ENTRIES; i++) { 489 if (buffer[i]) 490 free_page((unsigned long) buffer[i]); 491 } 492 493 if (le) 494 free_page((unsigned long) le); 495 496 up(&sem); 497 put_device(&adapter->dev); 498 continue_token = 0; 499 500 /* reload the module */ 501 if (transfer) 502 cxl_guest_reload_module(adapter); 503 else { 504 pr_devel("resetting adapter\n"); 505 cxl_h_reset_adapter(adapter->guest->handle); 506 } 507 508 transfer = 0; 509 return 0; 510 } 511 512 static const struct file_operations fops = { 513 .owner = THIS_MODULE, 514 .open = device_open, 515 .unlocked_ioctl = device_ioctl, 516 .compat_ioctl = device_compat_ioctl, 517 .release = device_close, 518 }; 519 520 void cxl_guest_remove_chardev(struct cxl *adapter) 521 { 522 cdev_del(&adapter->guest->cdev); 523 } 524 525 int cxl_guest_add_chardev(struct cxl *adapter) 526 { 527 dev_t devt; 528 int rc; 529 530 devt = MKDEV(MAJOR(cxl_get_dev()), CXL_CARD_MINOR(adapter)); 531 cdev_init(&adapter->guest->cdev, &fops); 532 if ((rc = cdev_add(&adapter->guest->cdev, devt, 1))) { 533 dev_err(&adapter->dev, 534 "Unable to add chardev on adapter (card%i): %i\n", 535 adapter->adapter_num, rc); 536 goto err; 537 } 538 adapter->dev.devt = devt; 539 sema_init(&sem, 1); 540 err: 541 return rc; 542 } 543