drivers/crypto/chelsio/chcr_algo.h

   1 /*
   2  * This file is part of the Chelsio T6 Crypto driver for Linux.
   3  *
   4  * Copyright (c) 2003-2016 Chelsio Communications, Inc. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  *
  34  */
  35
  36 #ifndef __CHCR_ALGO_H__
  37 #define __CHCR_ALGO_H__
  38
  39 /* Crypto key context */
  40 #define KEY_CONTEXT_CTX_LEN_S           24
  41 #define KEY_CONTEXT_CTX_LEN_M           0xff
  42 #define KEY_CONTEXT_CTX_LEN_V(x)        ((x) << KEY_CONTEXT_CTX_LEN_S)
  43 #define KEY_CONTEXT_CTX_LEN_G(x) \
  44         (((x) >> KEY_CONTEXT_CTX_LEN_S) & KEY_CONTEXT_CTX_LEN_M)
  45
  46 #define KEY_CONTEXT_DUAL_CK_S      12
  47 #define KEY_CONTEXT_DUAL_CK_M      0x1
  48 #define KEY_CONTEXT_DUAL_CK_V(x)   ((x) << KEY_CONTEXT_DUAL_CK_S)
  49 #define KEY_CONTEXT_DUAL_CK_G(x)   \
  50 (((x) >> KEY_CONTEXT_DUAL_CK_S) & KEY_CONTEXT_DUAL_CK_M)
  51 #define KEY_CONTEXT_DUAL_CK_F      KEY_CONTEXT_DUAL_CK_V(1U)
  52
  53 #define KEY_CONTEXT_SALT_PRESENT_S      10
  54 #define KEY_CONTEXT_SALT_PRESENT_M      0x1
  55 #define KEY_CONTEXT_SALT_PRESENT_V(x)   ((x) << KEY_CONTEXT_SALT_PRESENT_S)
  56 #define KEY_CONTEXT_SALT_PRESENT_G(x)   \
  57         (((x) >> KEY_CONTEXT_SALT_PRESENT_S) & \
  58          KEY_CONTEXT_SALT_PRESENT_M)
  59 #define KEY_CONTEXT_SALT_PRESENT_F      KEY_CONTEXT_SALT_PRESENT_V(1U)
  60
  61 #define KEY_CONTEXT_VALID_S     0
  62 #define KEY_CONTEXT_VALID_M     0x1
  63 #define KEY_CONTEXT_VALID_V(x)  ((x) << KEY_CONTEXT_VALID_S)
  64 #define KEY_CONTEXT_VALID_G(x)  \
  65         (((x) >> KEY_CONTEXT_VALID_S) & \
  66          KEY_CONTEXT_VALID_M)
  67 #define KEY_CONTEXT_VALID_F     KEY_CONTEXT_VALID_V(1U)
  68
  69 #define KEY_CONTEXT_CK_SIZE_S           6
  70 #define KEY_CONTEXT_CK_SIZE_M           0xf
  71 #define KEY_CONTEXT_CK_SIZE_V(x)        ((x) << KEY_CONTEXT_CK_SIZE_S)
  72 #define KEY_CONTEXT_CK_SIZE_G(x)        \
  73         (((x) >> KEY_CONTEXT_CK_SIZE_S) & KEY_CONTEXT_CK_SIZE_M)
  74
  75 #define KEY_CONTEXT_MK_SIZE_S           2
  76 #define KEY_CONTEXT_MK_SIZE_M           0xf
  77 #define KEY_CONTEXT_MK_SIZE_V(x)        ((x) << KEY_CONTEXT_MK_SIZE_S)
  78 #define KEY_CONTEXT_MK_SIZE_G(x)        \
  79         (((x) >> KEY_CONTEXT_MK_SIZE_S) & KEY_CONTEXT_MK_SIZE_M)
  80
  81 #define KEY_CONTEXT_OPAD_PRESENT_S      11
  82 #define KEY_CONTEXT_OPAD_PRESENT_M      0x1
  83 #define KEY_CONTEXT_OPAD_PRESENT_V(x)   ((x) << KEY_CONTEXT_OPAD_PRESENT_S)
  84 #define KEY_CONTEXT_OPAD_PRESENT_G(x)   \
  85         (((x) >> KEY_CONTEXT_OPAD_PRESENT_S) & \
  86          KEY_CONTEXT_OPAD_PRESENT_M)
  87 #define KEY_CONTEXT_OPAD_PRESENT_F      KEY_CONTEXT_OPAD_PRESENT_V(1U)
  88
  89 #define CHCR_HASH_MAX_DIGEST_SIZE 64
  90 #define CHCR_MAX_SHA_DIGEST_SIZE 64
  91
  92 #define IPSEC_TRUNCATED_ICV_SIZE 12
  93 #define TLS_TRUNCATED_HMAC_SIZE 10
  94 #define CBCMAC_DIGEST_SIZE 16
  95 #define MAX_HASH_NAME 20
  96
  97 #define SHA1_INIT_STATE_5X4B    5
  98 #define SHA256_INIT_STATE_8X4B  8
  99 #define SHA512_INIT_STATE_8X8B  8
 100 #define SHA1_INIT_STATE         SHA1_INIT_STATE_5X4B
 101 #define SHA224_INIT_STATE       SHA256_INIT_STATE_8X4B
 102 #define SHA256_INIT_STATE       SHA256_INIT_STATE_8X4B
 103 #define SHA384_INIT_STATE       SHA512_INIT_STATE_8X8B
 104 #define SHA512_INIT_STATE       SHA512_INIT_STATE_8X8B
 105
 106 #define DUMMY_BYTES 16
 107
 108 #define IPAD_DATA 0x36363636
 109 #define OPAD_DATA 0x5c5c5c5c
 110
 111 #define TRANSHDR_SIZE(alignedkctx_len)\
 112         (sizeof(struct ulptx_idata) +\
 113          sizeof(struct ulp_txpkt) +\
 114          sizeof(struct fw_crypto_lookaside_wr) +\
 115          sizeof(struct cpl_tx_sec_pdu) +\
 116          (alignedkctx_len))
 117 #define CIPHER_TRANSHDR_SIZE(alignedkctx_len, sge_pairs) \
 118         (TRANSHDR_SIZE(alignedkctx_len) + sge_pairs +\
 119          sizeof(struct cpl_rx_phys_dsgl))
 120 #define HASH_TRANSHDR_SIZE(alignedkctx_len)\
 121         (TRANSHDR_SIZE(alignedkctx_len) + DUMMY_BYTES)
 122
 123 #define SEC_CPL_OFFSET (sizeof(struct fw_crypto_lookaside_wr) + \
 124                         sizeof(struct ulp_txpkt) + \
 125                         sizeof(struct ulptx_idata))
 126
 127 #define FILL_SEC_CPL_OP_IVINSR(id, len, hldr, ofst)      \
 128         htonl( \
 129                CPL_TX_SEC_PDU_OPCODE_V(CPL_TX_SEC_PDU) | \
 130                CPL_TX_SEC_PDU_RXCHID_V((id)) | \
 131                CPL_TX_SEC_PDU_ACKFOLLOWS_V(0) | \
 132                CPL_TX_SEC_PDU_ULPTXLPBK_V(1) | \
 133                CPL_TX_SEC_PDU_CPLLEN_V((len)) | \
 134                CPL_TX_SEC_PDU_PLACEHOLDER_V((hldr)) | \
 135                CPL_TX_SEC_PDU_IVINSRTOFST_V((ofst)))
 136
 137 #define  FILL_SEC_CPL_CIPHERSTOP_HI(a_start, a_stop, c_start, c_stop_hi) \
 138         htonl( \
 139                CPL_TX_SEC_PDU_AADSTART_V((a_start)) | \
 140                CPL_TX_SEC_PDU_AADSTOP_V((a_stop)) | \
 141                CPL_TX_SEC_PDU_CIPHERSTART_V((c_start)) | \
 142                CPL_TX_SEC_PDU_CIPHERSTOP_HI_V((c_stop_hi)))
 143
 144 #define  FILL_SEC_CPL_AUTHINSERT(c_stop_lo, a_start, a_stop, a_inst) \
 145         htonl( \
 146                CPL_TX_SEC_PDU_CIPHERSTOP_LO_V((c_stop_lo)) | \
 147                 CPL_TX_SEC_PDU_AUTHSTART_V((a_start)) | \
 148                 CPL_TX_SEC_PDU_AUTHSTOP_V((a_stop)) | \
 149                 CPL_TX_SEC_PDU_AUTHINSERT_V((a_inst)))
 150
 151 #define  FILL_SEC_CPL_SCMD0_SEQNO(ctrl, seq, cmode, amode, opad, size, nivs)  \
 152                 htonl( \
 153                 SCMD_SEQ_NO_CTRL_V(0) | \
 154                 SCMD_STATUS_PRESENT_V(0) | \
 155                 SCMD_PROTO_VERSION_V(CHCR_SCMD_PROTO_VERSION_GENERIC) | \
 156                 SCMD_ENC_DEC_CTRL_V((ctrl)) | \
 157                 SCMD_CIPH_AUTH_SEQ_CTRL_V((seq)) | \
 158                 SCMD_CIPH_MODE_V((cmode)) | \
 159                 SCMD_AUTH_MODE_V((amode)) | \
 160                 SCMD_HMAC_CTRL_V((opad)) | \
 161                 SCMD_IV_SIZE_V((size)) | \
 162                 SCMD_NUM_IVS_V((nivs)))
 163
 164 #define FILL_SEC_CPL_IVGEN_HDRLEN(last, more, ctx_in, mac, ivdrop, len) htonl( \
 165                 SCMD_ENB_DBGID_V(0) | \
 166                 SCMD_IV_GEN_CTRL_V(0) | \
 167                 SCMD_LAST_FRAG_V((last)) | \
 168                 SCMD_MORE_FRAGS_V((more)) | \
 169                 SCMD_TLS_COMPPDU_V(0) | \
 170                 SCMD_KEY_CTX_INLINE_V((ctx_in)) | \
 171                 SCMD_TLS_FRAG_ENABLE_V(0) | \
 172                 SCMD_MAC_ONLY_V((mac)) |  \
 173                 SCMD_AADIVDROP_V((ivdrop)) | \
 174                 SCMD_HDR_LEN_V((len)))
 175
 176 #define  FILL_KEY_CTX_HDR(ck_size, mk_size, d_ck, opad, ctx_len) \
 177                 htonl(KEY_CONTEXT_VALID_V(1) | \
 178                       KEY_CONTEXT_CK_SIZE_V((ck_size)) | \
 179                       KEY_CONTEXT_MK_SIZE_V(mk_size) | \
 180                       KEY_CONTEXT_DUAL_CK_V((d_ck)) | \
 181                       KEY_CONTEXT_OPAD_PRESENT_V((opad)) | \
 182                       KEY_CONTEXT_SALT_PRESENT_V(1) | \
 183                       KEY_CONTEXT_CTX_LEN_V((ctx_len)))
 184
 185 #define FILL_WR_OP_CCTX_SIZE(len, ctx_len) \
 186                 htonl( \
 187                         FW_CRYPTO_LOOKASIDE_WR_OPCODE_V( \
 188                         FW_CRYPTO_LOOKASIDE_WR) | \
 189                         FW_CRYPTO_LOOKASIDE_WR_COMPL_V(0) | \
 190                         FW_CRYPTO_LOOKASIDE_WR_IMM_LEN_V((len)) | \
 191                         FW_CRYPTO_LOOKASIDE_WR_CCTX_LOC_V(1) | \
 192                         FW_CRYPTO_LOOKASIDE_WR_CCTX_SIZE_V((ctx_len)))
 193
 194 #define FILL_WR_RX_Q_ID(cid, qid, wr_iv) \
 195                 htonl( \
 196                         FW_CRYPTO_LOOKASIDE_WR_RX_CHID_V((cid)) | \
 197                         FW_CRYPTO_LOOKASIDE_WR_RX_Q_ID_V((qid)) | \
 198                         FW_CRYPTO_LOOKASIDE_WR_LCB_V(0) | \
 199                         FW_CRYPTO_LOOKASIDE_WR_IV_V((wr_iv)))
 200
 201 #define FILL_ULPTX_CMD_DEST(cid) \
 202         htonl(ULPTX_CMD_V(ULP_TX_PKT) | \
 203               ULP_TXPKT_DEST_V(0) | \
 204               ULP_TXPKT_DATAMODIFY_V(0) | \
 205               ULP_TXPKT_CHANNELID_V((cid)) | \
 206               ULP_TXPKT_RO_V(1) | \
 207               ULP_TXPKT_FID_V(0))
 208
 209 #define KEYCTX_ALIGN_PAD(bs) ({unsigned int _bs = (bs);\
 210                               _bs == SHA1_DIGEST_SIZE ? 12 : 0; })
 211
 212 #define FILL_PLD_SIZE_HASH_SIZE(payload_sgl_len, sgl_lengths, total_frags) \
 213         htonl(FW_CRYPTO_LOOKASIDE_WR_PLD_SIZE_V(payload_sgl_len ? \
 214                                                 sgl_lengths[total_frags] : 0) |\
 215               FW_CRYPTO_LOOKASIDE_WR_HASH_SIZE_V(0))
 216
 217 #define FILL_LEN_PKD(calc_tx_flits_ofld, skb) \
 218         htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP((\
 219                                            calc_tx_flits_ofld(skb) * 8), 16)))
 220
 221 #define FILL_CMD_MORE(immdatalen) htonl(ULPTX_CMD_V(ULP_TX_SC_IMM) |\
 222                                         ULP_TX_SC_MORE_V((immdatalen) ? 0 : 1))
 223
 224 #define MAX_NK 8
 225 #define CRYPTO_MAX_IMM_TX_PKT_LEN 256
 226
 227 struct algo_param {
 228         unsigned int auth_mode;
 229         unsigned int mk_size;
 230         unsigned int result_size;
 231 };
 232
 233 struct hash_wr_param {
 234         unsigned int opad_needed;
 235         unsigned int more;
 236         unsigned int last;
 237         struct algo_param alg_prm;
 238         unsigned int sg_len;
 239         unsigned int bfr_len;
 240         u64 scmd1;
 241 };
 242
 243 enum {
 244         AES_KEYLENGTH_128BIT = 128,
 245         AES_KEYLENGTH_192BIT = 192,
 246         AES_KEYLENGTH_256BIT = 256
 247 };
 248
 249 enum {
 250         KEYLENGTH_3BYTES = 3,
 251         KEYLENGTH_4BYTES = 4,
 252         KEYLENGTH_6BYTES = 6,
 253         KEYLENGTH_8BYTES = 8
 254 };
 255
 256 enum {
 257         NUMBER_OF_ROUNDS_10 = 10,
 258         NUMBER_OF_ROUNDS_12 = 12,
 259         NUMBER_OF_ROUNDS_14 = 14,
 260 };
 261
 262 /*
 263  * CCM defines values of 4, 6, 8, 10, 12, 14, and 16 octets,
 264  * where they indicate the size of the integrity check value (ICV)
 265  */
 266 enum {
 267         AES_CCM_ICV_4   = 4,
 268         AES_CCM_ICV_6   = 6,
 269         AES_CCM_ICV_8   = 8,
 270         AES_CCM_ICV_10  = 10,
 271         AES_CCM_ICV_12  = 12,
 272         AES_CCM_ICV_14  = 14,
 273         AES_CCM_ICV_16 = 16
 274 };
 275
 276 struct hash_op_params {
 277         unsigned char mk_size;
 278         unsigned char pad_align;
 279         unsigned char auth_mode;
 280         char hash_name[MAX_HASH_NAME];
 281         unsigned short block_size;
 282         unsigned short word_size;
 283         unsigned short ipad_size;
 284 };
 285
 286 struct phys_sge_pairs {
 287         __be16 len[8];
 288         __be64 addr[8];
 289 };
 290
 291 struct phys_sge_parm {
 292         unsigned int nents;
 293         unsigned int obsize;
 294         unsigned short qid;
 295         unsigned char align;
 296 };
 297
 298 struct crypto_result {
 299         struct completion completion;
 300         int err;
 301 };
 302
 303 static const u32 sha1_init[SHA1_DIGEST_SIZE / 4] = {
 304                 SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4,
 305 };
 306
 307 static const u32 sha224_init[SHA256_DIGEST_SIZE / 4] = {
 308                 SHA224_H0, SHA224_H1, SHA224_H2, SHA224_H3,
 309                 SHA224_H4, SHA224_H5, SHA224_H6, SHA224_H7,
 310 };
 311
 312 static const u32 sha256_init[SHA256_DIGEST_SIZE / 4] = {
 313                 SHA256_H0, SHA256_H1, SHA256_H2, SHA256_H3,
 314                 SHA256_H4, SHA256_H5, SHA256_H6, SHA256_H7,
 315 };
 316
 317 static const u64 sha384_init[SHA512_DIGEST_SIZE / 8] = {
 318                 SHA384_H0, SHA384_H1, SHA384_H2, SHA384_H3,
 319                 SHA384_H4, SHA384_H5, SHA384_H6, SHA384_H7,
 320 };
 321
 322 static const u64 sha512_init[SHA512_DIGEST_SIZE / 8] = {
 323                 SHA512_H0, SHA512_H1, SHA512_H2, SHA512_H3,
 324                 SHA512_H4, SHA512_H5, SHA512_H6, SHA512_H7,
 325 };
 326
 327 static inline void copy_hash_init_values(char *key, int digestsize)
 328 {
 329         u8 i;
 330         __be32 *dkey = (__be32 *)key;
 331         u64 *ldkey = (u64 *)key;
 332         __be64 *sha384 = (__be64 *)sha384_init;
 333         __be64 *sha512 = (__be64 *)sha512_init;
 334
 335         switch (digestsize) {
 336         case SHA1_DIGEST_SIZE:
 337                 for (i = 0; i < SHA1_INIT_STATE; i++)
 338                         dkey[i] = cpu_to_be32(sha1_init[i]);
 339                 break;
 340         case SHA224_DIGEST_SIZE:
 341                 for (i = 0; i < SHA224_INIT_STATE; i++)
 342                         dkey[i] = cpu_to_be32(sha224_init[i]);
 343                 break;
 344         case SHA256_DIGEST_SIZE:
 345                 for (i = 0; i < SHA256_INIT_STATE; i++)
 346                         dkey[i] = cpu_to_be32(sha256_init[i]);
 347                 break;
 348         case SHA384_DIGEST_SIZE:
 349                 for (i = 0; i < SHA384_INIT_STATE; i++)
 350                         ldkey[i] = be64_to_cpu(sha384[i]);
 351                 break;
 352         case SHA512_DIGEST_SIZE:
 353                 for (i = 0; i < SHA512_INIT_STATE; i++)
 354                         ldkey[i] = be64_to_cpu(sha512[i]);
 355                 break;
 356         }
 357 }
 358
 359 static const u8 sgl_lengths[20] = {
 360         0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15
 361 };
 362
 363 /* Number of len fields(8) * size of one addr field */
 364 #define PHYSDSGL_MAX_LEN_SIZE 16
 365
 366 static inline u16 get_space_for_phys_dsgl(unsigned int sgl_entr)
 367 {
 368         /* len field size + addr field size */
 369         return ((sgl_entr >> 3) + ((sgl_entr % 8) ?
 370                                    1 : 0)) * PHYSDSGL_MAX_LEN_SIZE +
 371                 (sgl_entr << 3) + ((sgl_entr % 2 ? 1 : 0) << 3);
 372 }
 373
 374 /* The AES s-transform matrix (s-box). */
 375 static const u8 aes_sbox[256] = {
 376         99,  124, 119, 123, 242, 107, 111, 197, 48,  1,   103, 43,  254, 215,
 377         171, 118, 202, 130, 201, 125, 250, 89,  71,  240, 173, 212, 162, 175,
 378         156, 164, 114, 192, 183, 253, 147, 38,  54,  63,  247, 204, 52,  165,
 379         229, 241, 113, 216, 49,  21, 4,   199, 35,  195, 24,  150, 5, 154, 7,
 380         18,  128, 226, 235, 39,  178, 117, 9,   131, 44,  26,  27,  110, 90,
 381         160, 82,  59,  214, 179, 41,  227, 47,  132, 83,  209, 0,   237, 32,
 382         252, 177, 91,  106, 203, 190, 57,  74,  76,  88,  207, 208, 239, 170,
 383         251, 67,  77,  51,  133, 69,  249, 2,   127, 80,  60,  159, 168, 81,
 384         163, 64,  143, 146, 157, 56,  245, 188, 182, 218, 33,  16,  255, 243,
 385         210, 205, 12,  19,  236, 95,  151, 68,  23,  196, 167, 126, 61,  100,
 386         93,  25,  115, 96,  129, 79,  220, 34,  42,  144, 136, 70,  238, 184,
 387         20,  222, 94,  11,  219, 224, 50,  58,  10,  73,  6,   36,  92,  194,
 388         211, 172, 98,  145, 149, 228, 121, 231, 200, 55,  109, 141, 213, 78,
 389         169, 108, 86,  244, 234, 101, 122, 174, 8, 186, 120, 37,  46,  28, 166,
 390         180, 198, 232, 221, 116, 31,  75,  189, 139, 138, 112, 62,  181, 102,
 391         72,  3,   246, 14,  97,  53,  87,  185, 134, 193, 29,  158, 225, 248,
 392         152, 17,  105, 217, 142, 148, 155, 30,  135, 233, 206, 85,  40,  223,
 393         140, 161, 137, 13,  191, 230, 66,  104, 65,  153, 45,  15,  176, 84,
 394         187, 22
 395 };
 396
 397 static u32 aes_ks_subword(const u32 w)
 398 {
 399         u8 bytes[4];
 400
 401         *(u32 *)(&bytes[0]) = w;
 402         bytes[0] = aes_sbox[bytes[0]];
 403         bytes[1] = aes_sbox[bytes[1]];
 404         bytes[2] = aes_sbox[bytes[2]];
 405         bytes[3] = aes_sbox[bytes[3]];
 406         return *(u32 *)(&bytes[0]);
 407 }
 408
 409 static u32 round_constant[11] = {
 410         0x01000000, 0x02000000, 0x04000000, 0x08000000,
 411         0x10000000, 0x20000000, 0x40000000, 0x80000000,
 412         0x1B000000, 0x36000000, 0x6C000000
 413 };
 414
 415 /* dec_key - OUTPUT - Reverse round key
 416  * key - INPUT - key
 417  * keylength - INPUT - length of the key in number of bits
 418  */
 419 static inline void get_aes_decrypt_key(unsigned char *dec_key,
 420                                        const unsigned char *key,
 421                                        unsigned int keylength)
 422 {
 423         u32 temp;
 424         u32 w_ring[MAX_NK];
 425         int i, j, k = 0;
 426         u8  nr, nk;
 427
 428         switch (keylength) {
 429         case AES_KEYLENGTH_128BIT:
 430                 nk = KEYLENGTH_4BYTES;
 431                 nr = NUMBER_OF_ROUNDS_10;
 432                 break;
 433
 434         case AES_KEYLENGTH_192BIT:
 435                 nk = KEYLENGTH_6BYTES;
 436                 nr = NUMBER_OF_ROUNDS_12;
 437                 break;
 438         case AES_KEYLENGTH_256BIT:
 439                 nk = KEYLENGTH_8BYTES;
 440                 nr = NUMBER_OF_ROUNDS_14;
 441                 break;
 442         default:
 443                 return;
 444         }
 445         for (i = 0; i < nk; i++ )
 446                 w_ring[i] = be32_to_cpu(*(u32 *)&key[4 * i]);
 447
 448         i = 0;
 449         temp = w_ring[nk - 1];
 450         while(i + nk < (nr + 1) * 4) {
 451                 if(!(i % nk)) {
 452                         /* RotWord(temp) */
 453                         temp = (temp << 8) | (temp >> 24);
 454                         temp = aes_ks_subword(temp);
 455                         temp ^= round_constant[i / nk];
 456                 }
 457                 else if (nk == 8 && (i % 4 == 0))
 458                         temp = aes_ks_subword(temp);
 459                 w_ring[i % nk] ^= temp;
 460                 temp = w_ring[i % nk];
 461                 i++;
 462         }
 463         for (k = 0, j = i % nk; k < nk; k++) {
 464                 *((u32 *)dec_key + k) = htonl(w_ring[j]);
 465                 j--;
 466                 if(j < 0)
 467                         j += nk;
 468         }
 469 }
 470
 471 #endif /* __CHCR_ALGO_H__ */