drivers/crypto/bcm/util.c

   1 /*
   2  * Copyright 2016 Broadcom
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2, as
   6  * published by the Free Software Foundation (the "GPL").
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License version 2 (GPLv2) for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * version 2 (GPLv2) along with this source code.
  15  */
  16
  17 #include <linux/debugfs.h>
  18
  19 #include "cipher.h"
  20 #include "util.h"
  21
  22 /* offset of SPU_OFIFO_CTRL register */
  23 #define SPU_OFIFO_CTRL      0x40
  24 #define SPU_FIFO_WATERMARK  0x1FF
  25
  26 /**
  27  * spu_sg_at_offset() - Find the scatterlist entry at a given distance from the
  28  * start of a scatterlist.
  29  * @sg:         [in]  Start of a scatterlist
  30  * @skip:       [in]  Distance from the start of the scatterlist, in bytes
  31  * @sge:        [out] Scatterlist entry at skip bytes from start
  32  * @sge_offset: [out] Number of bytes from start of sge buffer to get to
  33  *                    requested distance.
  34  *
  35  * Return: 0 if entry found at requested distance
  36  *         < 0 otherwise
  37  */
  38 int spu_sg_at_offset(struct scatterlist *sg, unsigned int skip,
  39                      struct scatterlist **sge, unsigned int *sge_offset)
  40 {
  41         /* byte index from start of sg to the end of the previous entry */
  42         unsigned int index = 0;
  43         /* byte index from start of sg to the end of the current entry */
  44         unsigned int next_index;
  45
  46         next_index = sg->length;
  47         while (next_index <= skip) {
  48                 sg = sg_next(sg);
  49                 index = next_index;
  50                 if (!sg)
  51                         return -EINVAL;
  52                 next_index += sg->length;
  53         }
  54
  55         *sge_offset = skip - index;
  56         *sge = sg;
  57         return 0;
  58 }
  59
  60 /* Copy len bytes of sg data, starting at offset skip, to a dest buffer */
  61 void sg_copy_part_to_buf(struct scatterlist *src, u8 *dest,
  62                          unsigned int len, unsigned int skip)
  63 {
  64         size_t copied;
  65         unsigned int nents = sg_nents(src);
  66
  67         copied = sg_pcopy_to_buffer(src, nents, dest, len, skip);
  68         if (copied != len) {
  69                 flow_log("%s copied %u bytes of %u requested. ",
  70                          __func__, (u32)copied, len);
  71                 flow_log("sg with %u entries and skip %u\n", nents, skip);
  72         }
  73 }
  74
  75 /*
  76  * Copy data into a scatterlist starting at a specified offset in the
  77  * scatterlist. Specifically, copy len bytes of data in the buffer src
  78  * into the scatterlist dest, starting skip bytes into the scatterlist.
  79  */
  80 void sg_copy_part_from_buf(struct scatterlist *dest, u8 *src,
  81                            unsigned int len, unsigned int skip)
  82 {
  83         size_t copied;
  84         unsigned int nents = sg_nents(dest);
  85
  86         copied = sg_pcopy_from_buffer(dest, nents, src, len, skip);
  87         if (copied != len) {
  88                 flow_log("%s copied %u bytes of %u requested. ",
  89                          __func__, (u32)copied, len);
  90                 flow_log("sg with %u entries and skip %u\n", nents, skip);
  91         }
  92 }
  93
  94 /**
  95  * spu_sg_count() - Determine number of elements in scatterlist to provide a
  96  * specified number of bytes.
  97  * @sg_list:  scatterlist to examine
  98  * @skip:     index of starting point
  99  * @nbytes:   consider elements of scatterlist until reaching this number of
 100  *            bytes
 101  *
 102  * Return: the number of sg entries contributing to nbytes of data
 103  */
 104 int spu_sg_count(struct scatterlist *sg_list, unsigned int skip, int nbytes)
 105 {
 106         struct scatterlist *sg;
 107         int sg_nents = 0;
 108         unsigned int offset;
 109
 110         if (!sg_list)
 111                 return 0;
 112
 113         if (spu_sg_at_offset(sg_list, skip, &sg, &offset) < 0)
 114                 return 0;
 115
 116         while (sg && (nbytes > 0)) {
 117                 sg_nents++;
 118                 nbytes -= (sg->length - offset);
 119                 offset = 0;
 120                 sg = sg_next(sg);
 121         }
 122         return sg_nents;
 123 }
 124
 125 /**
 126  * spu_msg_sg_add() - Copy scatterlist entries from one sg to another, up to a
 127  * given length.
 128  * @to_sg:       scatterlist to copy to
 129  * @from_sg:     scatterlist to copy from
 130  * @from_skip:   number of bytes to skip in from_sg. Non-zero when previous
 131  *               request included part of the buffer in entry in from_sg.
 132  *               Assumes from_skip < from_sg->length.
 133  * @from_nents   number of entries in from_sg
 134  * @length       number of bytes to copy. may reach this limit before exhausting
 135  *               from_sg.
 136  *
 137  * Copies the entries themselves, not the data in the entries. Assumes to_sg has
 138  * enough entries. Does not limit the size of an individual buffer in to_sg.
 139  *
 140  * to_sg, from_sg, skip are all updated to end of copy
 141  *
 142  * Return: Number of bytes copied
 143  */
 144 u32 spu_msg_sg_add(struct scatterlist **to_sg,
 145                    struct scatterlist **from_sg, u32 *from_skip,
 146                    u8 from_nents, u32 length)
 147 {
 148         struct scatterlist *sg; /* an entry in from_sg */
 149         struct scatterlist *to = *to_sg;
 150         struct scatterlist *from = *from_sg;
 151         u32 skip = *from_skip;
 152         u32 offset;
 153         int i;
 154         u32 entry_len = 0;
 155         u32 frag_len = 0;       /* length of entry added to to_sg */
 156         u32 copied = 0;         /* number of bytes copied so far */
 157
 158         if (length == 0)
 159                 return 0;
 160
 161         for_each_sg(from, sg, from_nents, i) {
 162                 /* number of bytes in this from entry not yet used */
 163                 entry_len = sg->length - skip;
 164                 frag_len = min(entry_len, length - copied);
 165                 offset = sg->offset + skip;
 166                 if (frag_len)
 167                         sg_set_page(to++, sg_page(sg), frag_len, offset);
 168                 copied += frag_len;
 169                 if (copied == entry_len) {
 170                         /* used up all of from entry */
 171                         skip = 0;       /* start at beginning of next entry */
 172                 }
 173                 if (copied == length)
 174                         break;
 175         }
 176         *to_sg = to;
 177         *from_sg = sg;
 178         if (frag_len < entry_len)
 179                 *from_skip = skip + frag_len;
 180         else
 181                 *from_skip = 0;
 182
 183         return copied;
 184 }
 185
 186 void add_to_ctr(u8 *ctr_pos, unsigned int increment)
 187 {
 188         __be64 *high_be = (__be64 *)ctr_pos;
 189         __be64 *low_be = high_be + 1;
 190         u64 orig_low = __be64_to_cpu(*low_be);
 191         u64 new_low = orig_low + (u64)increment;
 192
 193         *low_be = __cpu_to_be64(new_low);
 194         if (new_low < orig_low)
 195                 /* there was a carry from the low 8 bytes */
 196                 *high_be = __cpu_to_be64(__be64_to_cpu(*high_be) + 1);
 197 }
 198
 199 struct sdesc {
 200         struct shash_desc shash;
 201         char ctx[];
 202 };
 203
 204 /* do a synchronous decrypt operation */
 205 int do_decrypt(char *alg_name,
 206                void *key_ptr, unsigned int key_len,
 207                void *iv_ptr, void *src_ptr, void *dst_ptr,
 208                unsigned int block_len)
 209 {
 210         struct scatterlist sg_in[1], sg_out[1];
 211         struct crypto_blkcipher *tfm =
 212             crypto_alloc_blkcipher(alg_name, 0, CRYPTO_ALG_ASYNC);
 213         struct blkcipher_desc desc = {.tfm = tfm, .flags = 0 };
 214         int ret = 0;
 215         void *iv;
 216         int ivsize;
 217
 218         flow_log("%s() name:%s block_len:%u\n", __func__, alg_name, block_len);
 219
 220         if (IS_ERR(tfm))
 221                 return PTR_ERR(tfm);
 222
 223         crypto_blkcipher_setkey((void *)tfm, key_ptr, key_len);
 224
 225         sg_init_table(sg_in, 1);
 226         sg_set_buf(sg_in, src_ptr, block_len);
 227
 228         sg_init_table(sg_out, 1);
 229         sg_set_buf(sg_out, dst_ptr, block_len);
 230
 231         iv = crypto_blkcipher_crt(tfm)->iv;
 232         ivsize = crypto_blkcipher_ivsize(tfm);
 233         memcpy(iv, iv_ptr, ivsize);
 234
 235         ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, block_len);
 236         crypto_free_blkcipher(tfm);
 237
 238         if (ret < 0)
 239                 pr_err("aes_decrypt failed %d\n", ret);
 240
 241         return ret;
 242 }
 243
 244 /**
 245  * do_shash() - Do a synchronous hash operation in software
 246  * @name:       The name of the hash algorithm
 247  * @result:     Buffer where digest is to be written
 248  * @data1:      First part of data to hash. May be NULL.
 249  * @data1_len:  Length of data1, in bytes
 250  * @data2:      Second part of data to hash. May be NULL.
 251  * @data2_len:  Length of data2, in bytes
 252  * @key:        Key (if keyed hash)
 253  * @key_len:    Length of key, in bytes (or 0 if non-keyed hash)
 254  *
 255  * Note that the crypto API will not select this driver's own transform because
 256  * this driver only registers asynchronous algos.
 257  *
 258  * Return: 0 if hash successfully stored in result
 259  *         < 0 otherwise
 260  */
 261 int do_shash(unsigned char *name, unsigned char *result,
 262              const u8 *data1, unsigned int data1_len,
 263              const u8 *data2, unsigned int data2_len,
 264              const u8 *key, unsigned int key_len)
 265 {
 266         int rc;
 267         unsigned int size;
 268         struct crypto_shash *hash;
 269         struct sdesc *sdesc;
 270
 271         hash = crypto_alloc_shash(name, 0, 0);
 272         if (IS_ERR(hash)) {
 273                 rc = PTR_ERR(hash);
 274                 pr_err("%s: Crypto %s allocation error %d", __func__, name, rc);
 275                 return rc;
 276         }
 277
 278         size = sizeof(struct shash_desc) + crypto_shash_descsize(hash);
 279         sdesc = kmalloc(size, GFP_KERNEL);
 280         if (!sdesc) {
 281                 rc = -ENOMEM;
 282                 pr_err("%s: Memory allocation failure", __func__);
 283                 goto do_shash_err;
 284         }
 285         sdesc->shash.tfm = hash;
 286         sdesc->shash.flags = 0x0;
 287
 288         if (key_len > 0) {
 289                 rc = crypto_shash_setkey(hash, key, key_len);
 290                 if (rc) {
 291                         pr_err("%s: Could not setkey %s shash", __func__, name);
 292                         goto do_shash_err;
 293                 }
 294         }
 295
 296         rc = crypto_shash_init(&sdesc->shash);
 297         if (rc) {
 298                 pr_err("%s: Could not init %s shash", __func__, name);
 299                 goto do_shash_err;
 300         }
 301         rc = crypto_shash_update(&sdesc->shash, data1, data1_len);
 302         if (rc) {
 303                 pr_err("%s: Could not update1", __func__);
 304                 goto do_shash_err;
 305         }
 306         if (data2 && data2_len) {
 307                 rc = crypto_shash_update(&sdesc->shash, data2, data2_len);
 308                 if (rc) {
 309                         pr_err("%s: Could not update2", __func__);
 310                         goto do_shash_err;
 311                 }
 312         }
 313         rc = crypto_shash_final(&sdesc->shash, result);
 314         if (rc)
 315                 pr_err("%s: Could not generate %s hash", __func__, name);
 316
 317 do_shash_err:
 318         crypto_free_shash(hash);
 319         kfree(sdesc);
 320
 321         return rc;
 322 }
 323
 324 /* Dump len bytes of a scatterlist starting at skip bytes into the sg */
 325 void __dump_sg(struct scatterlist *sg, unsigned int skip, unsigned int len)
 326 {
 327         u8 dbuf[16];
 328         unsigned int idx = skip;
 329         unsigned int num_out = 0;       /* number of bytes dumped so far */
 330         unsigned int count;
 331
 332         if (packet_debug_logging) {
 333                 while (num_out < len) {
 334                         count = (len - num_out > 16) ? 16 : len - num_out;
 335                         sg_copy_part_to_buf(sg, dbuf, count, idx);
 336                         num_out += count;
 337                         print_hex_dump(KERN_ALERT, "  sg: ", DUMP_PREFIX_NONE,
 338                                        4, 1, dbuf, count, false);
 339                         idx += 16;
 340                 }
 341         }
 342         if (debug_logging_sleep)
 343                 msleep(debug_logging_sleep);
 344 }
 345
 346 /* Returns the name for a given cipher alg/mode */
 347 char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
 348 {
 349         switch (alg) {
 350         case CIPHER_ALG_RC4:
 351                 return "rc4";
 352         case CIPHER_ALG_AES:
 353                 switch (mode) {
 354                 case CIPHER_MODE_CBC:
 355                         return "cbc(aes)";
 356                 case CIPHER_MODE_ECB:
 357                         return "ecb(aes)";
 358                 case CIPHER_MODE_OFB:
 359                         return "ofb(aes)";
 360                 case CIPHER_MODE_CFB:
 361                         return "cfb(aes)";
 362                 case CIPHER_MODE_CTR:
 363                         return "ctr(aes)";
 364                 case CIPHER_MODE_XTS:
 365                         return "xts(aes)";
 366                 case CIPHER_MODE_GCM:
 367                         return "gcm(aes)";
 368                 default:
 369                         return "aes";
 370                 }
 371                 break;
 372         case CIPHER_ALG_DES:
 373                 switch (mode) {
 374                 case CIPHER_MODE_CBC:
 375                         return "cbc(des)";
 376                 case CIPHER_MODE_ECB:
 377                         return "ecb(des)";
 378                 case CIPHER_MODE_CTR:
 379                         return "ctr(des)";
 380                 default:
 381                         return "des";
 382                 }
 383                 break;
 384         case CIPHER_ALG_3DES:
 385                 switch (mode) {
 386                 case CIPHER_MODE_CBC:
 387                         return "cbc(des3_ede)";
 388                 case CIPHER_MODE_ECB:
 389                         return "ecb(des3_ede)";
 390                 case CIPHER_MODE_CTR:
 391                         return "ctr(des3_ede)";
 392                 default:
 393                         return "3des";
 394                 }
 395                 break;
 396         default:
 397                 return "other";
 398         }
 399 }
 400
 401 static ssize_t spu_debugfs_read(struct file *filp, char __user *ubuf,
 402                                 size_t count, loff_t *offp)
 403 {
 404         struct device_private *ipriv;
 405         char *buf;
 406         ssize_t ret, out_offset, out_count;
 407         int i;
 408         u32 fifo_len;
 409         u32 spu_ofifo_ctrl;
 410         u32 alg;
 411         u32 mode;
 412         u32 op_cnt;
 413
 414         out_count = 2048;
 415
 416         buf = kmalloc(out_count, GFP_KERNEL);
 417         if (!buf)
 418                 return -ENOMEM;
 419
 420         ipriv = filp->private_data;
 421         out_offset = 0;
 422         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 423                                "Number of SPUs.........%u\n",
 424                                ipriv->spu.num_spu);
 425         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 426                                "Current sessions.......%u\n",
 427                                atomic_read(&ipriv->session_count));
 428         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 429                                "Session count..........%u\n",
 430                                atomic_read(&ipriv->stream_count));
 431         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 432                                "Cipher setkey..........%u\n",
 433                                atomic_read(&ipriv->setkey_cnt[SPU_OP_CIPHER]));
 434         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 435                                "Cipher Ops.............%u\n",
 436                                atomic_read(&ipriv->op_counts[SPU_OP_CIPHER]));
 437         for (alg = 0; alg < CIPHER_ALG_LAST; alg++) {
 438                 for (mode = 0; mode < CIPHER_MODE_LAST; mode++) {
 439                         op_cnt = atomic_read(&ipriv->cipher_cnt[alg][mode]);
 440                         if (op_cnt) {
 441                                 out_offset += snprintf(buf + out_offset,
 442                                                        out_count - out_offset,
 443                                "  %-13s%11u\n",
 444                                spu_alg_name(alg, mode), op_cnt);
 445                         }
 446                 }
 447         }
 448         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 449                                "Hash Ops...............%u\n",
 450                                atomic_read(&ipriv->op_counts[SPU_OP_HASH]));
 451         for (alg = 0; alg < HASH_ALG_LAST; alg++) {
 452                 op_cnt = atomic_read(&ipriv->hash_cnt[alg]);
 453                 if (op_cnt) {
 454                         out_offset += snprintf(buf + out_offset,
 455                                                out_count - out_offset,
 456                        "  %-13s%11u\n",
 457                        hash_alg_name[alg], op_cnt);
 458                 }
 459         }
 460         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 461                                "HMAC setkey............%u\n",
 462                                atomic_read(&ipriv->setkey_cnt[SPU_OP_HMAC]));
 463         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 464                                "HMAC Ops...............%u\n",
 465                                atomic_read(&ipriv->op_counts[SPU_OP_HMAC]));
 466         for (alg = 0; alg < HASH_ALG_LAST; alg++) {
 467                 op_cnt = atomic_read(&ipriv->hmac_cnt[alg]);
 468                 if (op_cnt) {
 469                         out_offset += snprintf(buf + out_offset,
 470                                                out_count - out_offset,
 471                        "  %-13s%11u\n",
 472                        hash_alg_name[alg], op_cnt);
 473                 }
 474         }
 475         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 476                                "AEAD setkey............%u\n",
 477                                atomic_read(&ipriv->setkey_cnt[SPU_OP_AEAD]));
 478
 479         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 480                                "AEAD Ops...............%u\n",
 481                                atomic_read(&ipriv->op_counts[SPU_OP_AEAD]));
 482         for (alg = 0; alg < AEAD_TYPE_LAST; alg++) {
 483                 op_cnt = atomic_read(&ipriv->aead_cnt[alg]);
 484                 if (op_cnt) {
 485                         out_offset += snprintf(buf + out_offset,
 486                                                out_count - out_offset,
 487                        "  %-13s%11u\n",
 488                        aead_alg_name[alg], op_cnt);
 489                 }
 490         }
 491         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 492                                "Bytes of req data......%llu\n",
 493                                (u64)atomic64_read(&ipriv->bytes_out));
 494         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 495                                "Bytes of resp data.....%llu\n",
 496                                (u64)atomic64_read(&ipriv->bytes_in));
 497         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 498                                "Mailbox full...........%u\n",
 499                                atomic_read(&ipriv->mb_no_spc));
 500         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 501                                "Mailbox send failures..%u\n",
 502                                atomic_read(&ipriv->mb_send_fail));
 503         out_offset += snprintf(buf + out_offset, out_count - out_offset,
 504                                "Check ICV errors.......%u\n",
 505                                atomic_read(&ipriv->bad_icv));
 506         if (ipriv->spu.spu_type == SPU_TYPE_SPUM)
 507                 for (i = 0; i < ipriv->spu.num_spu; i++) {
 508                         spu_ofifo_ctrl = ioread32(ipriv->spu.reg_vbase[i] +
 509                                                   SPU_OFIFO_CTRL);
 510                         fifo_len = spu_ofifo_ctrl & SPU_FIFO_WATERMARK;
 511                         out_offset += snprintf(buf + out_offset,
 512                                                out_count - out_offset,
 513                                        "SPU %d output FIFO high water.....%u\n",
 514                                        i, fifo_len);
 515                 }
 516
 517         if (out_offset > out_count)
 518                 out_offset = out_count;
 519
 520         ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
 521         kfree(buf);
 522         return ret;
 523 }
 524
 525 static const struct file_operations spu_debugfs_stats = {
 526         .owner = THIS_MODULE,
 527         .open = simple_open,
 528         .read = spu_debugfs_read,
 529 };
 530
 531 /*
 532  * Create the debug FS directories. If the top-level directory has not yet
 533  * been created, create it now. Create a stats file in this directory for
 534  * a SPU.
 535  */
 536 void spu_setup_debugfs(void)
 537 {
 538         if (!debugfs_initialized())
 539                 return;
 540
 541         if (!iproc_priv.debugfs_dir)
 542                 iproc_priv.debugfs_dir = debugfs_create_dir(KBUILD_MODNAME,
 543                                                             NULL);
 544
 545         if (!iproc_priv.debugfs_stats)
 546                 /* Create file with permissions S_IRUSR */
 547                 debugfs_create_file("stats", 0400, iproc_priv.debugfs_dir,
 548                                     &iproc_priv, &spu_debugfs_stats);
 549 }
 550
 551 void spu_free_debugfs(void)
 552 {
 553         debugfs_remove_recursive(iproc_priv.debugfs_dir);
 554         iproc_priv.debugfs_dir = NULL;
 555 }
 556
 557 /**
 558  * format_value_ccm() - Format a value into a buffer, using a specified number
 559  *                      of bytes (i.e. maybe writing value X into a 4 byte
 560  *                      buffer, or maybe into a 12 byte buffer), as per the
 561  *                      SPU CCM spec.
 562  *
 563  * @val:                value to write (up to max of unsigned int)
 564  * @buf:                (pointer to) buffer to write the value
 565  * @len:                number of bytes to use (0 to 255)
 566  *
 567  */
 568 void format_value_ccm(unsigned int val, u8 *buf, u8 len)
 569 {
 570         int i;
 571
 572         /* First clear full output buffer */
 573         memset(buf, 0, len);
 574
 575         /* Then, starting from right side, fill in with data */
 576         for (i = 0; i < len; i++) {
 577                 buf[len - i - 1] = (val >> (8 * i)) & 0xff;
 578                 if (i >= 3)
 579                         break;  /* Only handle up to 32 bits of 'val' */
 580         }
 581 }