char buf[128];
        unsigned long now;
        struct mic_failure_t *mic_failure;
-       struct michel_mic_t michel_mic;
+       struct michael_mic_t michael_mic;
        union iwreq_data wrqu;
        unsigned int key_index = auth_type - 1;
        struct wpa_key_t *key = &priv->wpa.key[key_index];
                memcpy(&RecvMIC[0], (priv->rxp) + ((priv->rx_size) - 8), 8);
                priv->rx_size = priv->rx_size - 8;
                if (auth_type > 0 && auth_type < 4) {   /* auth_type check */
-                       MichaelMICFunction(&michel_mic,
+                       MichaelMICFunction(&michael_mic,
                                           (uint8_t *)key->rx_mic_key,
                                           (uint8_t *)priv->rxp,
                                           (int)priv->rx_size,
                                           (uint8_t)0,  /* priority */
-                                          (uint8_t *)michel_mic.Result);
+                                          (uint8_t *)michael_mic.Result);
                }
-               if (memcmp(michel_mic.Result, RecvMIC, 8)) {
+               if (memcmp(michael_mic.Result, RecvMIC, 8)) {
                        now = jiffies;
                        mic_failure = &priv->wpa.mic_failure;
                        /* MIC FAILURE */
        int result = 0;
        unsigned short eth_proto;
        struct ether_hdr *eth_hdr;
-       struct michel_mic_t michel_mic;
+       struct michael_mic_t michael_mic;
        unsigned short keyinfo = 0;
        struct ieee802_1x_hdr *aa1x_hdr;
        struct wpa_eapol_key *eap_key;
                        pp->auth_type = cpu_to_le16((uint16_t)TYPE_AUTH);       /* no encryption */
                } else {
                        if (priv->wpa.pairwise_suite == IW_AUTH_CIPHER_TKIP) {
-                               MichaelMICFunction(&michel_mic, (uint8_t *)priv->wpa.key[0].tx_mic_key, (uint8_t *)&pp->data[0], (int)packet_len, (uint8_t)0,   /* priority */
-                                                  (uint8_t *)michel_mic.
+                               MichaelMICFunction(&michael_mic, (uint8_t *)priv->wpa.key[0].tx_mic_key, (uint8_t *)&pp->data[0], (int)packet_len, (uint8_t)0,  /* priority */
+                                                  (uint8_t *)michael_mic.
                                                   Result);
-                               memcpy(p, michel_mic.Result, 8);
+                               memcpy(p, michael_mic.Result, 8);
                                length += 8;
                                packet_len += 8;
                                p += 8;
 
 } while (0)
 
 static
-void MichaelInitializeFunction(struct michel_mic_t *Mic, uint8_t *key)
+void MichaelInitializeFunction(struct michael_mic_t *Mic, uint8_t *key)
 {
        // Set the key
        Mic->K0 = getUInt32(key, 0);
 } while (0)
 
 static
-void MichaelAppend(struct michel_mic_t *Mic, uint8_t *src, int nBytes)
+void MichaelAppend(struct michael_mic_t *Mic, uint8_t *src, int nBytes)
 {
        int addlen;
 
 }
 
 static
-void MichaelGetMIC(struct michel_mic_t *Mic, uint8_t *dst)
+void MichaelGetMIC(struct michael_mic_t *Mic, uint8_t *dst)
 {
        u8 *data = Mic->M;
 
        MichaelClear(Mic);
 }
 
-void MichaelMICFunction(struct michel_mic_t *Mic, u8 *Key,
+void MichaelMICFunction(struct michael_mic_t *Mic, u8 *Key,
                        u8 *Data, int Len, u8 priority,
                        u8 *Result)
 {
 
  *   published by the Free Software Foundation.
  */
 
-/* MichelMIC routine define */
-struct michel_mic_t {
+/* MichaelMIC routine define */
+struct michael_mic_t {
        u32 K0; // Key
        u32 K1; // Key
        u32 L;  // Current state
        u8 Result[8];
 };
 
-void MichaelMICFunction(struct michel_mic_t *Mic, u8 *Key,
+void MichaelMICFunction(struct michael_mic_t *Mic, u8 *Key,
                        u8 *Data, int Len, u8 priority,
                        u8 *Result);