drivers/misc/cxl/flash.c

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