Google
  Web www.spinics.net

Re: Looking for comments on a Linux driver for HW accelerated Kasumi+F8+F9 algorithms.

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


On 5/21/07, M. T. Reddy <mtreddy@xxxxxxxxx> wrote:
Please comment on the following patch for HW accelerated kasumi + f8 and f8 encryption engine.
Regards,
Marri
------------------------------------- patch ---------------------------------
--- may03_denx/drivers/crypto/Kconfig    2007-05-03 08:39: 15.000000000 -0700
+++ 0323_denx/drivers/crypto/Kconfig    2007-05-15 13:40:56.789633768 -0700
@@ -37,6 +37,13 @@
       If unsure say M. The compiled module will be
       called padlock-aes.ko

+config CRYPTO_KASUMI
+    bool "Support for Kasumi driver"
+    depends on 440EPX
+    default N
+    help
+      Used in encrypting and decrypting data.
+
 config CRYPTO_DEV_PADLOCK_SHA
     tristate "PadLock driver for SHA1 and SHA256 algorithms"
     depends on CRYPTO_DEV_PADLOCK
--- may03_denx/drivers/crypto/Makefile    2007-05-03 08:39:15.000000000 -0700
+++ 0323_denx/drivers/crypto/Makefile    2007-04-25 13:39:52.000000000 -0700
@@ -2,3 +2,4 @@
  obj-$(CONFIG_CRYPTO_DEV_PADLOCK_AES) += padlock-aes.o
 obj-$(CONFIG_CRYPTO_DEV_PADLOCK_SHA) += padlock-sha.o
 obj-$(CONFIG_CRYPTO_DEV_GEODE) += geode-aes.o
+obj-$(CONFIG_KASUMI_CRYPTO) +=kasumi.o
--- may03_denx/drivers/crypto/kasumi.h    1969-12-31 16:00: 00.000000000 -0800
+++ 0323_denx/drivers/crypto/kasumi.h    2007-05-15 15:16:27.046502312 -0700
@@ -0,0 +1,122 @@
+/**********************************************************************
+ *
+ * kasumi.h
 + * Cryptographic Driver APIs.
+ *
+ * Support for Kasumi F8 and F9 hardware crypto engine.
+ * author: tmarri@xxxxxxxx
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ *
+ *
+ * DISCLAIMER
+ *
+ * This software is provided 'as is' with no explicit or implied warranties
+ * in respect of its properties, including, but not limited to, correctness
+ * and/or fitness for purpose.
+ * ---------------------------------------------------------------------------
+ */
+#define    MULTIPLE_DATA_ENC 1
+
+#define KASUMI_TEST    0
+
+/* Dynamic major number */
+#define KASUMI_MAJOR    0
+
+/* IOCTL numbers */
+#define KASUMI_IOCTL_ENCRYPT    0x100
+#define KASUMI_IOCTL_DECRYPT    0x101
+#define KASUMI_IOCTL_F8_MODE    0x102
+#define KASUMI_IOCTL_F9_MODE    0x103
+
+#define SDR0_SRST1        0x201
+#define DCR_PLB4A0        0x81
+#define DCR_UIC0_SR    0xC0
+#define DCR_UIC0_ER    0xC2
+
+/* Need to disable READ pipeline to avoid hang on PLB bus */
+#define DISABLE_RD_PIPE_LINE    0xf9ffffff
+#define KASUMI_RESET_MSK        0x00002000
+#define KASU0_BASE                0x0E0180000ULL
 +
+#define KASU0_DATA_IN0        0x0
+#define KASU0_DATA_OUT0    0x0
+#define KASU0_DATA_IN1        0x4
+#define KASU0_DATA_OUT1    0x4
+#define KASU0_CTRL            0x8
+#define KASU0_STATUS        0x8
+#define KASU0_MODE        0xc
+#define KASU0_KEY0        0x10
+#define KASU0_KEY1        0x14
+#define KASU0_KEY2        0x18
+#define KASU0_KEY3        0x1c
+#define KASU0_COUNT    0x20
+#define KASU0_CONFIG    0x24
+#define KASU0_FRESH    0x28
+
+#define KASUMI_DEC_MODE    0x02000000
+#define KASUMI_ENC_MODE    0x03000000
+#define KASUMI_F8_ENC_MODE    0x05000000
+#define KASUMI_F8_DEC_MODE    0x04000000
+#define KASUMI_F9_ENC_MODE    0x09000000
+#define KASUMI_F9_DEC_MODE    0x08000000
+
+#define KASUMI_DATA_READY    0x01000000
+
+#define KASUMI_VAL_KEYS    0x04000000
+#define KASUMI_VAL_MODE    0x02000000
+#define KASUMI_VAL_DATA    0x08000000
+#define KASUMI_VAL_CFG        0x10000000
+#define KASUMI_VAL_COUNT    0x20000000
+#define KASUMI_VAL_FRESH    0x40000000
+
+#define kasumi_byte_swap(x)        ((((uint)x & 0xff000000) >> 24) | \
+                                (((uint)x & 0x00ff0000) >> 8) | \
+                                (((uint)x & 0x0000ff00) << 8) | \
+                                (((uint)x & 0x000000ff) << 24))
+
+struct kasumi_desc {
+    uint mode;
+    uint count;
+    uint config;
+    uint fresh;
+    uint key0;
+    uint key1;
+    uint key2;
+    uint key3;
+    uint *data_in;
+    uint *data_out;
+};
+struct kasumi_regs{
+    uint    *ctrl;
+    uint    *status;
+    uint    *mode;
+    uint    *key0;
+    uint    *key1;
+    uint    *key2;
+    uint    *key3;
+    uint    *data_in0;
+    uint    *data_in1;
+    uint    *data_out0;
+    uint    *data_out1;
+    uint    *count;
+    uint    *config;
+    uint    *fresh;
+};
+
+struct kasumi_f8_f9_desc {
+    struct kasumi_desc kd;
+    uint len;
+    uint bearer;
+    uint direction;
+};
+int kasumi_f9_encrypt(struct kasumi_desc *test, uint len, uint direction);
+int kasumi_f8_encrypt(struct kasumi_desc *test, uint len, uint bearer,
+              uint direction);
+int kasumi_decrypt(struct kasumi_desc *test);
+int kasumi_encrypt(struct kasumi_desc *test);
--- may03_denx/drivers/crypto/kasumi.c    1969-12-31 16:00:00.000000000 -0800
+++ 0323_denx/drivers/crypto/kasumi.c    2007-05-15 15:16: 27.045502464 -0700
@@ -0,0 +1,898 @@
+/*
+ * Cryptographic Driver APIs.
+ *
+ * Support for Kasumi F8 and F9 hardware crypto engine.
+ * author: tmarri@xxxxxxxx
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ *
+ *
+ * DISCLAIMER
+ *
+ * This software is provided 'as is' with no explicit or implied warranties
+ * in respect of its properties, including, but not limited to, correctness
+ * and/or fitness for purpose.
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <asm/io.h>
+#include <linux/fcntl.h>
+#include <linux/cdev.h>
+#include <linux/seq_file.h>
+#include <linux/fs.h>        /* everything... */
+
+#include <asm/system.h>
+#include <asm/uaccess.h>    /* copy_*_user */
+
+#include <asm/ibm44x.h>
+#include "kasumi.h "
+
+static int kasumi_major = KASUMI_MAJOR;
+static uint data_in[512], data_out[512];
+static uint *kasumi_base;
+static struct kasumi_regs kreg;
+
+#ifdef KASUMI_TEST
+/*
+** Function to test KASUMI encrypt and decrypt modes
+*/
+static int kasumi_test(void)
+{
+    struct kasumi_desc test_in, test_out;
+    uint data_in0[2], data_in1[2], data_out0[2], data_out1[2];
+
+    test_in.key0 = 0x9F45D62B;
+    test_in.key1 = 0x00B3C582;
+    test_in.key2 = 0x10492C95;
+    test_in.key3 = 0x48FF8148;
+    data_in0[0] = 0xEA024714;
+    data_in0[1] = 0xAD5C4D84;
+    test_in.data_in = &data_in0[0];
+    test_in.data_out = &data_out0[0];
+
+    printk(KERN_INFO "Encryption test\n");
+    kasumi_encrypt(&test_in);
+
+    test_out.key0 = 0x9F45D62B;
+    test_out.key1 = 0x00B3C582;
+    test_out.key2 = 0x10492C95;
+    test_out.key3 = 0x48FF8148;
+    test_out.data_in = &data_in1[0];
+    test_out.data_out = &data_out1[0];
+    test_out.data_in[0] = data_out0[0];
+    test_out.data_in[1] = data_out0[1];
+
+    printk(KERN_INFO "Decryption test\n");
+    kasumi_decrypt(&test_out);
+    printk(KERN_INFO "data_out0[0]=0x%x\n", data_out0[0]);
+    printk(KERN_INFO "data_out0[1]=0x%x\n", data_out0[1]);
+    printk(KERN_INFO "data_out1[0]=0x%x\n", data_out1[0]);
+    printk(KERN_INFO "data_out1[1]=0x%x\n", data_out1[1]);
+
+    if (data_in0[0] == data_out1[0])
+        printk(KERN_INFO " Data 0 matched\n");
+    else
+        printk(KERN_INFO " Data 0 NOT matched\n");
+    if (data_in0[1] == data_out1[1])
+        printk(KERN_INFO " Data 1 matched\n");
+    else
+        printk(KERN_INFO " Data 1 NOT matched\n");
+    return 0;
+}
+
+/*
+** Function to test F* mode of encryption
+*/
+static void kasumi_test_f8_1(void)
+{
+    int len = 0x31E, bearer = 0xc, direction = 1;
+    struct kasumi_desc test_in;
+    struct kasumi_desc test_out;
+    int i = 0;
+    uint data_in[32] = {
+        0x7EC61272, 0x743BF161, 0x4726446A, 0x6C38CED1,
+        0x66F6CA76, 0xEB543004, 0x4286346C, 0xEF130F92,
+        0x922B0345, 0x0D3A9975, 0xE5BD2EA0, 0xEB55AD8E,
+        0x1B199E3E, 0xC4316020, 0xE9A1B285, 0xE7627953,
+        0x59B7BDFD, 0x39BEF4B2, 0x484583D5, 0xAFE082AE,
+        0xE638BF5F, 0xD5A60619, 0x3901A08F, 0x4AB41AAB, 0x9B134880
+    };
+    uint data_cmp[32] = {
+        0xD1E2DE70, 0xEEF86C69, 0x64FB542B, 0xC2D460AA,
+        0xBFAA10A4, 0xA093262B, 0x7D199E70, 0x6FC2D489,
+        0x15532969, 0x10F3A973, 0x012682E4, 0x1C4E2B02,
+        0xBE2017B7, 0x253BBF93, 0x09DE5819, 0xCB42E819,
+        0x56F4C99B, 0xC9765CAF, 0x53B1D0BB, 0x8279826A,
+        0xDBBC5522, 0xE915C120, 0xA618A5A7, 0xF5E89708, 0x9339650F
+    };
+    uint data_out0[32];
+    uint data_out1[32];
+
+    test_in.key0 = 0x2BD6459F;
+    test_in.key1 = 0x82C5B300;
+    test_in.key2 = 0x952C4910;
+    test_in.key3 = 0x4881FF48;
+
+    test_in.count = 0x72A4F20F;
+
+    printk(KERN_INFO "in CFG=0x%x\n", test_in.config);
+    test_in.data_in = &data_in[0];
+    test_in.data_out = &data_out0[0];
+    kasumi_f8_encrypt(&test_in, len, bearer, direction);
+
+    i = 0;
+    for (i = 0; i < 32; i++) {
+        if (data_out0[i] != data_cmp[i])
+            printk(KERN_INFO
+                   "data MISS match data recieved=0x%x expected =0x%x\n\nn",
+                   data_out0[i], data_cmp[i]);
+        else
+            printk(KERN_INFO "data MATCHED\n");
+
+    }
+}
+
+/*
+** Function to test F9 mode of encryption
+*/
+static void kasumi_test_f9(void)
+{
+    struct kasumi_desc test_in;
+    int i = 0;
+    uint direction = 0, len = 189;
+    uint data_in[6] = {
+        0x6B227737,
+        0x296F393C,
+        0x8079353E,
+        0xDC87E2E8,
+        0x05D2EC49,
+        0xA4F2D8E0
+    };
+    uint data_out[2];
+
+    test_in.key0 = 0x2BD6459F;
+    test_in.key1 = 0x82C5B300;
+    test_in.key2 = 0x952C4910;
+    test_in.key3 = 0x4881FF48;
+    test_in.fresh = 0x05D2EC49;
+    test_in.count = 0x38A6F056;
+
+    for (i = 0; i < 6; i++)
+        data_in[i] = kasumi_byte_swap(data_in[i]);
+    test_in.data_in = &data_in[0];
+    test_in.data_out = &data_out[0];
+    kasumi_f9_encrypt(&test_in, len, direction);
+    if (data_out[0] == 0xf63bd72c)
+        printk(KERN_INFO
+               " F9 test passed Expected data = 0x%x data recieved=0x%x\n",
+               0xf63bd72c, data_out[0]);
+    else
+        printk(KERN_INFO
+               " \n F9 test Failed Expected data = 0x%x data recieved=0x%x\n",
+               0xf63bd72c, data_out[0]);
+
+}
+#endif
+
+/*
+**FUNCTION:kasumi_encrypt_decrypt()
+** args: kd is kasumi descriptor which holds all the requred data to do kasumi
+** mode encryption and decryption
+** Description:  This function follows the kasumi algorithm to encrypt and decrypt.
+**  1. Check for interrupt bit KDA(Kasumi Data Availability)
+**  2. check for data availability bit in CTRL register and write 1 to clear it
+**  3. Set keys
+**  4. set mode
+**  5. set inputdata
+**  6. validate keys , mode and data
+**  7. wait for the data availability and then read the data.
+**   This function can only do 64bit data encryption at given time
+**   Please check the test() in the comment section.
+*/
+static int kasumi_encrypt_decrypt(struct kasumi_desc *kd)
+{
+    uint time_out = 100;
+
+    /*
+     * CTRL_STATUS[0] to reset the DATA out mechanism
+     */
+    printk(KERN_WARNING "kreg.ctrl 0x%x\n", kreg.ctrl);
+    out_be32(kreg.ctrl, in_be32(kreg.ctrl) | KASUMI_DATA_READY);
+    /*
+     * Check for interrupt bit for data availability bit set .
+     * if set clear it
+     */
+    if (mfdcr(DCR_UIC0_SR) & 0x08000000) {
+        mtdcr(DCR_UIC0_SR, (mfdcr(DCR_UIC0_SR) & ~0x08000000));
+    }
+
+    /*
+     * Check if KASUMI is ready  for data input
+     */
+    if (!mfdcr(DCR_UIC0_SR) & 0x10000000)
+        printk(KERN_INFO "KASUMI is ready for data\n");
+
+    /*
+     * need keys
+     */
+    out_be32(kreg.key0, kd->key0);
+    out_be32(kreg.key1, kd->key1);
+    out_be32(kreg.key2, kd->key2);
+    out_be32(kreg.key3, kd->key3);
+    /*
+     * Check for correct  mode
+     */
+    if ((kd->mode != KASUMI_ENC_MODE) && (kd->mode != KASUMI_DEC_MODE)) {
+        printk(KERN_INFO "KASUMI ERROR: invalid mode\n\n");
+        return -1;
+    }
+
+    /*
+     * set mode
+     */
+    out_be32(kreg.mode, kd->mode);
+    /*
+     * write data
+     */
+    if ((kd->data_in != NULL) && (kd->data_in)) {
+        out_be32(kreg.data_in0 , kd->data_in[0]);
+        out_be32(kreg.data_in1, kd->data_in[1]);
+    } else {
+        printk(KERN_INFO "No data passed\n");
+        return -1;
+    }
+
+    /*
+     * validate data CTRL_STAT[4]
+     * Validate mode CTRL_STA[1] = 1
+     * vlaidatkeys keys CTRL_STAT[2] = 1
+     */
+    out_be32(kreg.ctrl, in_be32(kreg.ctrl) | (KASUMI_VAL_DATA |
+                          KASUMI_VAL_KEYS |
+                          KASUMI_VAL_MODE));
+    /*
+     * Just in case DATA validation not finished
+     */
+    time_out = 100;
+    while (in_be32(kreg.ctrl) & KASUMI_VAL_DATA) {
+        time_out--;
+        mdelay(1);
+        if (time_out <= 0) {
+            printk(KERN_INFO
+                   "ERROR: at line %d Timed out KASU0_CTRL=0x%x\n",
+                   __LINE__, in_be32(kreg.ctrl));
+            break;
+        }
+    }
+
+    /*
+     * Check if data available bit is set
+     */
+    if (!mfdcr(DCR_UIC0_SR) & 0x08000000)
+        printk(KERN_WARNING
+               "KASUMI data NOT available and  NO KDA interrupt occured\n");
+
+    /*
+     * Is data avaialbel
+     */
+    time_out = 100;
+    while (!(in_be32(kreg.status) & KASUMI_DATA_READY)) {
+        time_out--;
+        mdelay(1);
+        if (time_out <= 0) {
+            printk(KERN_INFO "line %d Timed out KASU0_CTRL=0x%x\n",
+                   __LINE__, in_be32(kreg.ctrl));
+            break;
+        }
+    }
+
+    if (!(in_be32(kreg.status ) & KASUMI_DATA_READY))
+        printk(KERN_WARNING "Data is not ready\n");
+
+    kd->data_out[0] = in_be32(kreg.data_out0);
+    kd->data_out[1] = in_be32(kreg.data_out1);
+    return 0;
+}
+
+/*
+** Kasumi encryption function calls the kasumi_encrypt_decrypt()
+**
+*/
+int kasumi_encrypt(struct kasumi_desc *test)
+{
+    test->mode = KASUMI_ENC_MODE;
+    if (kasumi_encrypt_decrypt(test) != 0) {
+        printk(KERN_INFO "kasumi_encrypt_decrypt returned error");
+        return -1;
+    } else
+        return 0;
+
+}
+
+/*
+** Kasumi encryption function calls the kasumi_encrypt_decrypt()
+**
+*/
+int kasumi_decrypt(struct kasumi_desc *test)
+{
+    test->mode = KASUMI_DEC_MODE;
+    if (kasumi_encrypt_decrypt(test) != 0) {
+        printk(KERN_INFO "kasumi_encrypt_decrypt returned error");
+        return -1;
+    } else
+        return 0;
+
+}
+
+/*
+**
+**FUNCTION:kasumi_encrypt_decrypt()
+**args: kd is kasumi descriptor which holds all the requred data to do kasumi mode encryption and decryption
+**Description:  This function follows the kasumi algorithm to encrypt and decrypt.
+**  1. Check for interrupt bit KDA(Kasumi Data Availability)
+**  2. check for data availability bit in CTRL register and write 1 to clear it
+**  3. Set keys
+**  4. set mode
+**  5. set config
+**  6. set count
+**  7. set inputdata
+**  8. validate keys , mode , config , count and data
+**  9. wait for the data availability and then read the data.
+**   This function can encrypt block data
+**   Please check the test_f8_1() in the comment section.
+*/
+static int kasumi_f8_encrypt_decrypt(struct kasumi_desc *kd)
+{
+    int time_out = 10000;
+    int len = 0;
+    int i = 0;
+
+    len = ((kd->config & 0xff) << 8) | ((kd->config & 0xff00) >> 8);
+    /*Reset data out mechanism */
+    /*CTRL_STATUS[0] to reset the DATA out mechanism */
+    out_be32(kreg.ctrl, in_be32(kreg.ctrl) | KASUMI_DATA_READY);
+
+    if (mfdcr(DCR_UIC0_SR) & 0x08000000)
+        mtdcr(DCR_UIC0_SR, (mfdcr(DCR_UIC0_SR) & ~0x08000000));
+
+    if (!mfdcr(DCR_UIC0_SR) & 0x10000000)
+        printk(KERN_INFO "KASUMI is NOT ready for data\n");
+
+    /*need keys */
+
+    out_be32(kreg.key0, kd->key0);
+    out_be32(kreg.key1, kd->key1);
+    out_be32(kreg.key2, kd->key2);
+    out_be32(kreg.key3, kd->key3);
+    /*write config */
+    out_be32(kreg.config, kd->config);
+    /* Write count */
+    out_be32(kreg.count, kd->count);
+    /*set mode */
+    if (kd->mode != KASUMI_F8_ENC_MODE) {
+        printk(KERN_INFO "KASUMI Invalid mode\n");
+        return -1;
+    }
+
+    out_be32(kreg.mode, kd->mode);
+
+    /*
+     * write data
+     * validate data CTRL_STAT[4]
+     * Validate mode CTRL_STA[1] = 1
+     * vlaidatkeys keys CTRL_STAT[2] = 1
+     * vlaidatkeys count and config
+     */
+    out_be32(kreg.ctrl, in_be32(kreg.ctrl) | (KASUMI_VAL_CFG |
+                          KASUMI_VAL_COUNT |
+                          KASUMI_VAL_KEYS |
+                          KASUMI_VAL_MODE));
+    time_out = 100;
+    /*
+     ** Just in case DATA validation is not finished
+     */
+    while (in_be32( kreg.ctrl) & (KASUMI_VAL_CFG | KASUMI_VAL_COUNT |
+                     KASUMI_VAL_KEYS | KASUMI_VAL_MODE)) {
+        time_out--;
+        mdelay(1);
+        if (time_out <= 0) {
+            printk(KERN_INFO
+                   " KASUMI:line %d Timed out KASU0_CTRL=0x%x\n",
+                   __LINE__, in_be32(kreg.ctrl));
+            break;
+        }
+
+    }
+
+    if (in_be32(kreg.ctrl )
+        & (KASUMI_VAL_CFG | KASUMI_VAL_COUNT |
+           KASUMI_VAL_KEYS | KASUMI_VAL_MODE))
+        printk(KERN_WARNING
+               " CFG COUNT KEYS MODE validation NOT complete\n");
 +    /*
+     ** Here we encode 64bits a time till whole block is encrypted
+     */
+    while (len > 0) {
+        if ((&kd->data_in[i] != NULL) && (&kd->data_in[i + 1] != NULL)) {
 +            out_be32(kreg.data_in0, kd->data_in[i]);
+            out_be32(kreg.data_in1, kd->data_in[i + 1]);
+        } else {
+            printk(KERN_INFO "No data passed\n");
+            break;
+        }
+
+        out_be32(kreg.ctrl, in_be32(kreg.ctrl) | KASUMI_VAL_DATA);
+        time_out = 100;
+        while (in_be32(kreg.ctrl) & (KASUMI_VAL_DATA)) {
+            time_out--;
+            if (time_out <= 0) {
+                printk(KERN_INFO
+                       "KASUMI: line %d Timed out KASU0_CTRL=0x%x\n",
+                       __LINE__, in_be32(kreg.ctrl));
+                break;
+            }
+        }
+
+        if (in_be32(kreg.ctrl) & (KASUMI_VAL_DATA))
+            printk(KERN_WARNING "Data validation NOT complete\n");
+
+        time_out = 100;
+        while (!(in_be32( kreg.status) & KASUMI_DATA_READY)) {
+            mdelay(1);
+            time_out--;
+            if (time_out <= 0) {
+                printk(KERN_INFO
+                       "line %d Timed out KASU0_CTRL=0x%x\n",
+                       __LINE__, in_be32(kreg.ctrl));
+                break;
+            }
+
+        }
+
+        if (!(in_be32(kreg.status) & KASUMI_DATA_READY)) {
+            printk(KERN_WARNING "Data is not ready\n");
+            break;
+        }
+
+        kd->data_out[i] = kasumi_byte_swap(in_be32(kreg.data_out0));
+        kd->data_out[i + 1] = kasumi_byte_swap(in_be32(kreg.data_out1));
+        /*
+         ** CTRL_STATUS[0] to reset the DATA out mechanism
+         */
+        out_be32(kreg.ctrl, KASUMI_DATA_READY);
+        if (!mfdcr(DCR_UIC0_SR) & 0x10000000)
+            printk(KERN_WARNING "KASUMI is NOT ready for data\n");
+
+        i += 2;
+        len = len - 64;
+    }
+
+    return 0;
+}
+
+/*
+** arg1: hte filled kasumi_desc structure pointer
+** arg2:  len
+** arg3:  bearer
+** arg4:  direction
+*/
+int kasumi_f8_encrypt(struct kasumi_desc *test, uint len, uint bearer,
+              uint direction)
+{
+    int i = 0;
+
+    test->config = (len << 16 | bearer << 1 | direction);
+    test->mode = KASUMI_F8_ENC_MODE;
+    test->key0 = kasumi_byte_swap(test->key0);
+    test->key1 = kasumi_byte_swap(test->key1);
+    test->key2 = kasumi_byte_swap(test->key2);
+    test->key3 = kasumi_byte_swap(test->key3);
+    test->count = kasumi_byte_swap(test->count);
+    test->config = kasumi_byte_swap(test->config);
+    len = len / (32);
+
+    for (i = 0; i <= len; i++)
+        test->data_in[i] = kasumi_byte_swap(test->data_in[i]);
+
+    if (kasumi_f8_encrypt_decrypt(test) != 0) {
+        printk(KERN_INFO
+               "kasumi_f8_encrypt_decrypt() returned error\n");
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+**
+**FUNCTION:kasumi_encrypt_decrypt()
+**args: kd is kasumi descriptor which holds all the requred data to do kasumi mode encryption and decryption
+**Description:  This function follows the kasumi algorithm to encrypt and decrypt.
+**  1. Check for interrupt bit KDA(Kasumi Data Availability)
+**  2. check for data availability bit in CTRL register and write 1 to clear it
+**  3. Set keys
+**  4. set mode
+**  5. set config
+**  6. set count
+**  7. set inputdata
+**  8. validate keys , mode , config , count and data
+**  9. wait for the data availability and then read the data.
+**   This function can encrypt block data
+**   Please check the test_f9_1() in the comment section.
+*/
+int kasumi_f9(struct kasumi_desc *kd)
+{
+    int time_out = 10000;
+    int len = 0;
+    int i = 0;
+
+    /*
+     ** Get the lenght of the block we are going to encode
+     */
+    len = ((kd->config & 0xff) << 8) | ((kd->config & 0xff00) >> 8);
+
+    /*
+     ** CTRL_STATUS[0] to reset the DATA out mechanism
+     */
+    out_be32(kreg.ctrl, in_be32(kreg.ctrl) | KASUMI_DATA_READY);
+    if (mfdcr(DCR_UIC0_SR) & 0x08000000)
+        mtdcr(DCR_UIC0_SR, (mfdcr(DCR_UIC0_SR) & ~0x08000000));
+
+    if (!(mfdcr(DCR_UIC0_SR) & 0x10000000))
+        printk(KERN_INFO "KASUMI is ready for data\n");
+
+    /*
+     ** need keys
+     */
+    out_be32(kreg.key0, kd->key0);
 +    out_be32(kreg.key1, kd->key1);
+    out_be32(kreg.key2, kd->key2);
+    out_be32(kreg.key3, kd->key3);
+    /*
+     ** write config
+     */
+    out_be32(kreg.config, kd->config);
+    /*
+     ** Write count
+     */
+    out_be32(kreg.count, kd->count);
+    /*
+     ** set fresh
+     */
+    out_be32(kreg.fresh, kd->fresh);
+    /*
+     ** set mode
+     */
+    if (kd->mode != KASUMI_F9_ENC_MODE) {
+        printk(KERN_INFO "KASUMI Invalid mode\n");
+        return -1;
+    }
+
+    out_be32(kreg.mode, kd->mode);
+    /*
+     * write data
+     * validate data CTRL_STAT[4]
+     * Validate mode CTRL_STA[1] = 1
+     * vlaidatkeys keys CTRL_STAT[2] = 1
+     * vlaidatkeys count and config
+     */
+    out_be32(kreg.ctrl,
+         in_be32(kreg.ctrl) |
+         (KASUMI_VAL_CFG | KASUMI_VAL_COUNT | KASUMI_VAL_KEYS |
+          KASUMI_VAL_MODE | KASUMI_VAL_FRESH));
+    time_out = 100;
+    /*
+     ** Just in case validation is not complete.
+     */
+    while (in_be32(kreg.ctrl) & (KASUMI_VAL_CFG |
+                     KASUMI_VAL_COUNT | KASUMI_VAL_KEYS
+                     | KASUMI_VAL_MODE | KASUMI_VAL_FRESH)) {
+        time_out--;
+        mdelay(1);
+        if (time_out <= 0) {
+            printk(KERN_INFO "line %d Timed out KASU0_CTRL=0x%x\n",
+                   __LINE__, in_be32(kreg.ctrl));
+            break;
+        }
+    }
+
+    if (in_be32(kreg.ctrl) & (KASUMI_VAL_CFG |
+                  KASUMI_VAL_COUNT | KASUMI_VAL_KEYS
 +                  | KASUMI_VAL_MODE | KASUMI_VAL_FRESH))
+        printk(KERN_WARNING
+               " CFG COUNT KEYS MODE validation NOT complete\n");
+
+    /*
+     **  Loop around this code till we encode all 64bit data blocks
+     */
+    while (len > 0) {
+
+        if ((&kd->data_in[i] != NULL) && (&kd->data_in[i + 1] != NULL)) {
+            out_be32(kreg.data_in0, kd->data_in[i]);
+            out_be32( kreg.data_in1, kd->data_in[i + 1]);
+        } else {
+            printk(KERN_INFO "No data passed\n");
+            return -1;
+        }
+
+        out_be32(kreg.ctrl, in_be32(kreg.ctrl) | KASUMI_VAL_DATA);
+        time_out = 100;
+
+        while (in_be32(kreg.ctrl) & (KASUMI_VAL_DATA)) {
+            time_out--;
+            mdelay(1);
+            if (time_out <= 0) {
+                printk(KERN_INFO
+                       "line %d Timed out KASU0_CTRL=0x%x\n",
+                       __LINE__, in_be32(kreg.ctrl));
+                break;
+            }
+        }
+
+        if (in_be32( kreg.ctrl) & (KASUMI_VAL_DATA)) {
+            printk(KERN_INFO "Data validation NOT complete\n");
+        }
+
+        if (!(mfdcr(DCR_UIC0_SR) & 0x10000000))
+            printk(KERN_INFO "KASUMI is NOT ready for data\n");
+
+        i += 2;
+        len = len - 64;
+    }
+
+    if (!(mfdcr(DCR_UIC0_SR) & 0x08000000))
+        printk(KERN_INFO
+               "KASUMI data NOT available and  NO KDA interrupt occured\n");
+
+    /*
+     ** Is data avaialbel
+     */
+    time_out = 100;
+    while (!(in_be32(kreg.status) & KASUMI_DATA_READY)) {
+        time_out--;
+        mdelay(1);
+        if (time_out <= 0) {
+            printk(KERN_INFO "line %d Timed out KASU0_CTRL=0x%x\n",
+                   __LINE__, in_be32(kreg.ctrl));
+        }
+
+    }
+
+    if (!(in_be32(kreg.status) & KASUMI_DATA_READY))
+        printk(KERN_WARNING "Data is not ready\n");
+    kd->data_out[0] = kasumi_byte_swap(in_be32(kreg.data_out0));
+    kd->data_out[1] = kasumi_byte_swap(in_be32(kreg.data_out1));
+    out_be32( kreg.ctrl, KASUMI_DATA_READY);
+    return 0;
+}
+
+/*
+** arg1: kasumi_desc structure
+**  arg2: len
+**  arg3: direction
+*/
+int kasumi_f9_encrypt(struct kasumi_desc *test, uint len, uint direction)
+{
+    test->config = (len << 16 | direction);
+    test->config = (0x00BD0000);
+    test->mode = KASUMI_F9_ENC_MODE;
+    test->key0 = kasumi_byte_swap(test->key0);
+    test->key1 = kasumi_byte_swap(test->key1);
+    test->key2 = kasumi_byte_swap(test->key2);
+    test->key3 = kasumi_byte_swap(test->key3);
+    test->count = kasumi_byte_swap(test->count);
+    test->config = kasumi_byte_swap(test->config);
+    test->fresh = kasumi_byte_swap(test->fresh);
+
+    if (kasumi_f9(test) != 0) {
+        printk(KERN_INFO
+               "kasumi_f8_encrypt_decrypt() returned error\n");
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+**IOCTL function to let this driver usaed from user space.
+**
+*/
+static int kasumi_ioctl(struct inode *inode, struct file *filep,
+            unsigned int cmd, unsigned long arg)
+{
+    int kerr = 0;
+    struct kasumi_f8_f9_desc kd_f89;
+
+    kd_f89.kd.data_in = &data_in[0];
+    kd_f89.kd.data_out = &data_out[0];
+
+    switch (cmd) {
+    case KASUMI_IOCTL_ENCRYPT:
+        {
+            copy_from_user(&kd_f89,
+                       (struct kasumi_f8_f9_desc __user *)arg,
+                       sizeof(struct kasumi_f8_f9_desc));
+            kerr = kasumi_encrypt(&kd_f89.kd);
+            copy_to_user(&kd_f89,
+                     (struct kasumi_f8_f9_desc __user *)arg,
+                     sizeof(struct kasumi_f8_f9_desc));
+
+            if (kerr < 0)
+                return kerr;
+            return 0;
+            break;
+        }
+    case KASUMI_IOCTL_DECRYPT:
+        {
+            printk(KERN_INFO "kd_f89.kd.data_in[0]=0x%x\n",
+                   kd_f89.kd.data_in[0]);
+            printk(KERN_INFO "kd_f89.kd.data_in[1]=0x%x\n",
+                   kd_f89.kd.data_in[1]);
+            copy_from_user(&kd_f89,
+                       (struct kasumi_f8_f9_desc __user *)arg,
+                       sizeof(struct kasumi_f8_f9_desc));
+            kerr = kasumi_decrypt(&kd_f89.kd);
+            copy_to_user(&kd_f89,
+                     (struct kasumi_f8_f9_desc __user *)arg,
+                     sizeof(struct kasumi_f8_f9_desc));
+            if (kerr < 0)
+                return kerr;
+            break;
+        }
+    case KASUMI_IOCTL_F8_MODE:
+        {
+            copy_from_user(&kd_f89,
+                       (struct kasumi_f8_f9_desc __user *)arg,
+                       sizeof(struct kasumi_f8_f9_desc));
+            kerr =
+                kasumi_f8_encrypt(&kd_f89.kd, kd_f89.len,
 +                          kd_f89.bearer, kd_f89.direction);
+            copy_to_user(&kd_f89,
+                     (struct kasumi_f8_f9_desc __user *)arg,
+                     sizeof(struct kasumi_f8_f9_desc));
+            if (kerr < 0)
+                return kerr;
+            break;
+        }
+    case KASUMI_IOCTL_F9_MODE:
+        {
+            copy_from_user(&kd_f89,
+                       (struct kasumi_f8_f9_desc __user *)arg,
+                       sizeof(struct kasumi_f8_f9_desc));
+            kerr =
+                kasumi_f9_encrypt(&kd_f89.kd, kd_f89.len,
+                          kd_f89.direction);
+            copy_to_user(&kd_f89,
+                     (struct kasumi_f8_f9_desc __user *)arg,
+                     sizeof(struct kasumi_f8_f9_desc));
+            if (kerr < 0)
+                return kerr;
+            break;
+        }
+    default:
+        return -ENOTTY;
+    }
+
+    return 0;
+}
+
+/*
+** file operations
+*/
+struct file_operations kasumi_fops = {
+    .ioctl = kasumi_ioctl,
+};
+
+/*
 +** Moudle initialization
+**/
+int kasumi_init_module(void)
+{
+    int kerr = 0;
+    dev_t dev = MKDEV(kasumi_major, 0);
+    struct cdev *k_cdev = cdev_alloc();
+
+    printk(KERN_INFO "Loading Kasumi Driver\n");
+    if (kasumi_major)
+        kerr = register_chrdev_region(dev, 1, "kasumi");
+    else {
+        kerr = alloc_chrdev_region(&dev, 0, 1, "kasumi");
+        kasumi_major = MAJOR(dev);
+    }
+
+    if (kerr < 0) {
+        printk(KERN_ERR "KASUMI:Failed to get major number");
+        return kerr;
+    }
+
+    cdev_init(k_cdev, &kasumi_fops);
+    k_cdev->owner = THIS_MODULE;
+    k_cdev->ops = &kasumi_fops;
+    kerr = cdev_add(k_cdev, MKDEV(kasumi_major, 0), 1);
+    if (kerr < 0)
+        return kerr;
+
+    /*
+     * setup register base address
+     */
+    kasumi_base = ioremap64(0x0E0180000ULL, 0x80);
+    if (!kasumi_base) {
+        printk(KERN_INFO "ioremap falied for address 0xE0180000\n");
+        return -1;
+    }
+
+    /*
+     **Register address assignments
+     **
+     */
+    kreg.ctrl = ((uint *) ((u8 *) kasumi_base + KASU0_CTRL));
+    kreg.status = ((uint *) ((u8 *) kasumi_base + KASU0_STATUS));
+    kreg.mode = ((uint *) ((u8 *) kasumi_base + KASU0_MODE));
+    kreg.key0 = ((uint *) ((u8 *) kasumi_base + KASU0_KEY0));
+    kreg.key1 = ((uint *) ((u8 *) kasumi_base + KASU0_KEY1));
+    kreg.key2 = ((uint *) ((u8 *) kasumi_base + KASU0_KEY2));
+    kreg.key3 = ((uint *) ((u8 *) kasumi_base + KASU0_KEY3));
+    kreg.count = ((uint *) ((u8 *) kasumi_base + KASU0_COUNT));
+    kreg.config = ((uint *) ((u8 *) kasumi_base + KASU0_CONFIG));
+    kreg.fresh = ((uint *) ((u8 *) kasumi_base + KASU0_FRESH));
+    kreg.data_in0  = ((uint *) ((u8 *) kasumi_base + KASU0_DATA_IN0));
+    kreg.data_in1 = ((uint *) ((u8 *) kasumi_base + KASU0_DATA_IN1));
+    kreg.data_out0 = ((uint *) ((u8 *) kasumi_base + KASU0_DATA_OUT0));
+    kreg.data_out1  = ((uint *) ((u8 *) kasumi_base + KASU0_DATA_OUT1));
+
+    /*
+     ** reset KASUMI core
+     */
+    SDR_WRITE(SDR0_SRST1, SDR_READ(SDR0_SRST1) | KASUMI_RESET_MSK);
+    SDR_WRITE(SDR0_SRST1, SDR_READ(SDR0_SRST1) & (~KASUMI_RESET_MSK));
+    /*
+     ** Disable the read pipe line. Otherwise it may cause hang on PLB
+     */
+    mtdcr(DCR_PLB4A0, mfdcr(DCR_PLB4A0) & DISABLE_RD_PIPE_LINE);
+    mtdcr(DCR_UIC0_ER, (mfdcr(DCR_UIC0_ER) | 0x18000000));
+
+    /*
+     ** Kasumi test
+     */
+#ifdef KASUMI_TEST
+    kasumi_test();
+    /*
+     ** f8 mode
+     */
+    kasumi_test_f8_1();
+    /*
+     ** f9 mode
+     */
+    kasumi_test_f9();
+#endif
+    return 0;
+}
+
+/*
+ * Cleanup module
+ */
+void kasumi_cleanup_module(void)
+{
+    iounmap(kasumi_base);
+    printk(KERN_INFO "Exiting Kasumi Driver\n");
+}
 +
+EXPORT_SYMBOL(kasumi_f9_encrypt);
+EXPORT_SYMBOL(kasumi_f8_encrypt);
+EXPORT_SYMBOL(kasumi_encrypt);
+EXPORT_SYMBOL(kasumi_decrypt);
+module_init(kasumi_init_module);
+module_exit(kasumi_cleanup_module);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Tirumala Marri <tmarri@xxxxxxxx>");
+MODULE_DESCRIPTION("Kasumi security engine driver");



--
Marri T Reddy
San Jose,CA
No day but today



--
Marri T Reddy
San Jose,CA
No day but today

-
Linux-crypto:  cryptography in and on the Linux system
Archive:       http://mail.nl.linux.org/linux-crypto/


[Home]     [Kernel]     [Linux Crypto]     [Gnu Crypto]     [Gnu Classpath]     [Netfilter]     [Bugtraq]     [Network Security Reading]

Add to Google