drivers/s390/crypto/zcrypt_cex2c.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Copyright IBM Corp. 2001, 2018
   4  *  Author(s): Robert Burroughs
   5  *             Eric Rossman (edrossma@us.ibm.com)
   6  *
   7  *  Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
   8  *  Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
   9  *                                Ralph Wuerthner <rwuerthn@de.ibm.com>
  10  *  MSGTYPE restruct:             Holger Dengler <hd@linux.vnet.ibm.com>
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/err.h>
  16 #include <linux/delay.h>
  17 #include <linux/slab.h>
  18 #include <linux/atomic.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/mod_devicetable.h>
  21
  22 #include "ap_bus.h"
  23 #include "zcrypt_api.h"
  24 #include "zcrypt_error.h"
  25 #include "zcrypt_msgtype6.h"
  26 #include "zcrypt_cex2c.h"
  27 #include "zcrypt_cca_key.h"
  28
  29 #define CEX2C_MIN_MOD_SIZE       16     /*  128 bits    */
  30 #define CEX2C_MAX_MOD_SIZE      256     /* 2048 bits    */
  31 #define CEX3C_MIN_MOD_SIZE       16     /*  128 bits    */
  32 #define CEX3C_MAX_MOD_SIZE      512     /* 4096 bits    */
  33 #define CEX2C_MAX_XCRB_MESSAGE_SIZE (12*1024)
  34 #define CEX2C_CLEANUP_TIME      (15*HZ)
  35
  36 MODULE_AUTHOR("IBM Corporation");
  37 MODULE_DESCRIPTION("CEX2C/CEX3C Cryptographic Coprocessor device driver, " \
  38                    "Copyright IBM Corp. 2001, 2018");
  39 MODULE_LICENSE("GPL");
  40
  41 static struct ap_device_id zcrypt_cex2c_card_ids[] = {
  42         { .dev_type = AP_DEVICE_TYPE_CEX2C,
  43           .match_flags = AP_DEVICE_ID_MATCH_CARD_TYPE },
  44         { .dev_type = AP_DEVICE_TYPE_CEX3C,
  45           .match_flags = AP_DEVICE_ID_MATCH_CARD_TYPE },
  46         { /* end of list */ },
  47 };
  48
  49 MODULE_DEVICE_TABLE(ap, zcrypt_cex2c_card_ids);
  50
  51 static struct ap_device_id zcrypt_cex2c_queue_ids[] = {
  52         { .dev_type = AP_DEVICE_TYPE_CEX2C,
  53           .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE },
  54         { .dev_type = AP_DEVICE_TYPE_CEX3C,
  55           .match_flags = AP_DEVICE_ID_MATCH_QUEUE_TYPE },
  56         { /* end of list */ },
  57 };
  58
  59 MODULE_DEVICE_TABLE(ap, zcrypt_cex2c_queue_ids);
  60
  61 /**
  62  * Large random number detection function. Its sends a message to a CEX2C/CEX3C
  63  * card to find out if large random numbers are supported.
  64  * @ap_dev: pointer to the AP device.
  65  *
  66  * Returns 1 if large random numbers are supported, 0 if not and < 0 on error.
  67  */
  68 static int zcrypt_cex2c_rng_supported(struct ap_queue *aq)
  69 {
  70         struct ap_message ap_msg;
  71         unsigned long long psmid;
  72         unsigned int domain;
  73         struct {
  74                 struct type86_hdr hdr;
  75                 struct type86_fmt2_ext fmt2;
  76                 struct CPRBX cprbx;
  77         } __packed *reply;
  78         struct {
  79                 struct type6_hdr hdr;
  80                 struct CPRBX cprbx;
  81                 char function_code[2];
  82                 short int rule_length;
  83                 char rule[8];
  84                 short int verb_length;
  85                 short int key_length;
  86         } __packed *msg;
  87         int rc, i;
  88
  89         ap_init_message(&ap_msg);
  90         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
  91         if (!ap_msg.message)
  92                 return -ENOMEM;
  93
  94         rng_type6CPRB_msgX(&ap_msg, 4, &domain);
  95
  96         msg = ap_msg.message;
  97         msg->cprbx.domain = AP_QID_QUEUE(aq->qid);
  98
  99         rc = ap_send(aq->qid, 0x0102030405060708ULL, ap_msg.message,
 100                      ap_msg.length);
 101         if (rc)
 102                 goto out_free;
 103
 104         /* Wait for the test message to complete. */
 105         for (i = 0; i < 2 * HZ; i++) {
 106                 msleep(1000 / HZ);
 107                 rc = ap_recv(aq->qid, &psmid, ap_msg.message, 4096);
 108                 if (rc == 0 && psmid == 0x0102030405060708ULL)
 109                         break;
 110         }
 111
 112         if (i >= 2 * HZ) {
 113                 /* Got no answer. */
 114                 rc = -ENODEV;
 115                 goto out_free;
 116         }
 117
 118         reply = ap_msg.message;
 119         if (reply->cprbx.ccp_rtcode == 0 && reply->cprbx.ccp_rscode == 0)
 120                 rc = 1;
 121         else
 122                 rc = 0;
 123 out_free:
 124         free_page((unsigned long) ap_msg.message);
 125         return rc;
 126 }
 127
 128 /**
 129  * Probe function for CEX2C/CEX3C card devices. It always accepts the
 130  * AP device since the bus_match already checked the hardware type.
 131  * @ap_dev: pointer to the AP card device.
 132  */
 133 static int zcrypt_cex2c_card_probe(struct ap_device *ap_dev)
 134 {
 135         /*
 136          * Normalized speed ratings per crypto adapter
 137          * MEX_1k, MEX_2k, MEX_4k, CRT_1k, CRT_2k, CRT_4k, RNG, SECKEY
 138          */
 139         static const int CEX2C_SPEED_IDX[] = {
 140                 1000, 1400, 2400, 1100, 1500, 2600, 100, 12};
 141         static const int CEX3C_SPEED_IDX[] = {
 142                 500,  700, 1400,  550,  800, 1500,  80, 10};
 143
 144         struct ap_card *ac = to_ap_card(&ap_dev->device);
 145         struct zcrypt_card *zc;
 146         int rc = 0;
 147
 148         zc = zcrypt_card_alloc();
 149         if (!zc)
 150                 return -ENOMEM;
 151         zc->card = ac;
 152         ac->private = zc;
 153         switch (ac->ap_dev.device_type) {
 154         case AP_DEVICE_TYPE_CEX2C:
 155                 zc->user_space_type = ZCRYPT_CEX2C;
 156                 zc->type_string = "CEX2C";
 157                 memcpy(zc->speed_rating, CEX2C_SPEED_IDX,
 158                        sizeof(CEX2C_SPEED_IDX));
 159                 zc->min_mod_size = CEX2C_MIN_MOD_SIZE;
 160                 zc->max_mod_size = CEX2C_MAX_MOD_SIZE;
 161                 zc->max_exp_bit_length = CEX2C_MAX_MOD_SIZE;
 162                 break;
 163         case AP_DEVICE_TYPE_CEX3C:
 164                 zc->user_space_type = ZCRYPT_CEX3C;
 165                 zc->type_string = "CEX3C";
 166                 memcpy(zc->speed_rating, CEX3C_SPEED_IDX,
 167                        sizeof(CEX3C_SPEED_IDX));
 168                 zc->min_mod_size = CEX3C_MIN_MOD_SIZE;
 169                 zc->max_mod_size = CEX3C_MAX_MOD_SIZE;
 170                 zc->max_exp_bit_length = CEX3C_MAX_MOD_SIZE;
 171                 break;
 172         default:
 173                 zcrypt_card_free(zc);
 174                 return -ENODEV;
 175         }
 176         zc->online = 1;
 177
 178         rc = zcrypt_card_register(zc);
 179         if (rc) {
 180                 ac->private = NULL;
 181                 zcrypt_card_free(zc);
 182         }
 183
 184         return rc;
 185 }
 186
 187 /**
 188  * This is called to remove the CEX2C/CEX3C card driver information
 189  * if an AP card device is removed.
 190  */
 191 static void zcrypt_cex2c_card_remove(struct ap_device *ap_dev)
 192 {
 193         struct zcrypt_card *zc = to_ap_card(&ap_dev->device)->private;
 194
 195         if (zc)
 196                 zcrypt_card_unregister(zc);
 197 }
 198
 199 static struct ap_driver zcrypt_cex2c_card_driver = {
 200         .probe = zcrypt_cex2c_card_probe,
 201         .remove = zcrypt_cex2c_card_remove,
 202         .ids = zcrypt_cex2c_card_ids,
 203         .flags = AP_DRIVER_FLAG_DEFAULT,
 204 };
 205
 206 /**
 207  * Probe function for CEX2C/CEX3C queue devices. It always accepts the
 208  * AP device since the bus_match already checked the hardware type.
 209  * @ap_dev: pointer to the AP card device.
 210  */
 211 static int zcrypt_cex2c_queue_probe(struct ap_device *ap_dev)
 212 {
 213         struct ap_queue *aq = to_ap_queue(&ap_dev->device);
 214         struct zcrypt_queue *zq;
 215         int rc;
 216
 217         zq = zcrypt_queue_alloc(CEX2C_MAX_XCRB_MESSAGE_SIZE);
 218         if (!zq)
 219                 return -ENOMEM;
 220         zq->queue = aq;
 221         zq->online = 1;
 222         atomic_set(&zq->load, 0);
 223         rc = zcrypt_cex2c_rng_supported(aq);
 224         if (rc < 0) {
 225                 zcrypt_queue_free(zq);
 226                 return rc;
 227         }
 228         if (rc)
 229                 zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 230                                          MSGTYPE06_VARIANT_DEFAULT);
 231         else
 232                 zq->ops = zcrypt_msgtype(MSGTYPE06_NAME,
 233                                          MSGTYPE06_VARIANT_NORNG);
 234         ap_queue_init_reply(aq, &zq->reply);
 235         aq->request_timeout = CEX2C_CLEANUP_TIME;
 236         aq->private = zq;
 237         rc = zcrypt_queue_register(zq);
 238         if (rc) {
 239                 aq->private = NULL;
 240                 zcrypt_queue_free(zq);
 241         }
 242         return rc;
 243 }
 244
 245 /**
 246  * This is called to remove the CEX2C/CEX3C queue driver information
 247  * if an AP queue device is removed.
 248  */
 249 static void zcrypt_cex2c_queue_remove(struct ap_device *ap_dev)
 250 {
 251         struct ap_queue *aq = to_ap_queue(&ap_dev->device);
 252         struct zcrypt_queue *zq = aq->private;
 253
 254         ap_queue_remove(aq);
 255         if (zq)
 256                 zcrypt_queue_unregister(zq);
 257 }
 258
 259 static struct ap_driver zcrypt_cex2c_queue_driver = {
 260         .probe = zcrypt_cex2c_queue_probe,
 261         .remove = zcrypt_cex2c_queue_remove,
 262         .suspend = ap_queue_suspend,
 263         .resume = ap_queue_resume,
 264         .ids = zcrypt_cex2c_queue_ids,
 265         .flags = AP_DRIVER_FLAG_DEFAULT,
 266 };
 267
 268 int __init zcrypt_cex2c_init(void)
 269 {
 270         int rc;
 271
 272         rc = ap_driver_register(&zcrypt_cex2c_card_driver,
 273                                 THIS_MODULE, "cex2card");
 274         if (rc)
 275                 return rc;
 276
 277         rc = ap_driver_register(&zcrypt_cex2c_queue_driver,
 278                                 THIS_MODULE, "cex2cqueue");
 279         if (rc)
 280                 ap_driver_unregister(&zcrypt_cex2c_card_driver);
 281
 282         return rc;
 283 }
 284
 285 void zcrypt_cex2c_exit(void)
 286 {
 287         ap_driver_unregister(&zcrypt_cex2c_queue_driver);
 288         ap_driver_unregister(&zcrypt_cex2c_card_driver);
 289 }
 290
 291 module_init(zcrypt_cex2c_init);
 292 module_exit(zcrypt_cex2c_exit);