kernel/drivers/nfc/nxp-nci/firmware.c

   1 /*
   2  * Generic driver for NXP NCI NFC chips
   3  *
   4  * Copyright (C) 2014  NXP Semiconductors  All rights reserved.
   5  *
   6  * Author: Clément Perrochaud <clement.perrochaud@nxp.com>
   7  *
   8  * Derived from PN544 device driver:
   9  * Copyright (C) 2012  Intel Corporation. All rights reserved.
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms and conditions of the GNU General Public License,
  13  * version 2, as published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include <linux/completion.h>
  25 #include <linux/firmware.h>
  26 #include <linux/nfc.h>
  27 #include <linux/unaligned/access_ok.h>
  28
  29 #include "nxp-nci.h"
  30
  31 /* Crypto operations can take up to 30 seconds */
  32 #define NXP_NCI_FW_ANSWER_TIMEOUT       msecs_to_jiffies(30000)
  33
  34 #define NXP_NCI_FW_CMD_RESET            0xF0
  35 #define NXP_NCI_FW_CMD_GETVERSION       0xF1
  36 #define NXP_NCI_FW_CMD_CHECKINTEGRITY   0xE0
  37 #define NXP_NCI_FW_CMD_WRITE            0xC0
  38 #define NXP_NCI_FW_CMD_READ             0xA2
  39 #define NXP_NCI_FW_CMD_GETSESSIONSTATE  0xF2
  40 #define NXP_NCI_FW_CMD_LOG              0xA7
  41 #define NXP_NCI_FW_CMD_FORCE            0xD0
  42 #define NXP_NCI_FW_CMD_GET_DIE_ID       0xF4
  43
  44 #define NXP_NCI_FW_CHUNK_FLAG   0x0400
  45
  46 #define NXP_NCI_FW_RESULT_OK                            0x00
  47 #define NXP_NCI_FW_RESULT_INVALID_ADDR                  0x01
  48 #define NXP_NCI_FW_RESULT_GENERIC_ERROR                 0x02
  49 #define NXP_NCI_FW_RESULT_UNKNOWN_CMD                   0x0B
  50 #define NXP_NCI_FW_RESULT_ABORTED_CMD                   0x0C
  51 #define NXP_NCI_FW_RESULT_PLL_ERROR                     0x0D
  52 #define NXP_NCI_FW_RESULT_ADDR_RANGE_OFL_ERROR          0x1E
  53 #define NXP_NCI_FW_RESULT_BUFFER_OFL_ERROR              0x1F
  54 #define NXP_NCI_FW_RESULT_MEM_BSY                       0x20
  55 #define NXP_NCI_FW_RESULT_SIGNATURE_ERROR               0x21
  56 #define NXP_NCI_FW_RESULT_FIRMWARE_VERSION_ERROR        0x24
  57 #define NXP_NCI_FW_RESULT_PROTOCOL_ERROR                0x28
  58 #define NXP_NCI_FW_RESULT_SFWU_DEGRADED                 0x2A
  59 #define NXP_NCI_FW_RESULT_PH_STATUS_FIRST_CHUNK         0x2D
  60 #define NXP_NCI_FW_RESULT_PH_STATUS_NEXT_CHUNK          0x2E
  61 #define NXP_NCI_FW_RESULT_PH_STATUS_INTERNAL_ERROR_5    0xC5
  62
  63 void nxp_nci_fw_work_complete(struct nxp_nci_info *info, int result)
  64 {
  65         struct nxp_nci_fw_info *fw_info = &info->fw_info;
  66         int r;
  67
  68         if (info->phy_ops->set_mode) {
  69                 r = info->phy_ops->set_mode(info->phy_id, NXP_NCI_MODE_COLD);
  70                 if (r < 0 && result == 0)
  71                         result = -r;
  72         }
  73
  74         info->mode = NXP_NCI_MODE_COLD;
  75
  76         if (fw_info->fw) {
  77                 release_firmware(fw_info->fw);
  78                 fw_info->fw = NULL;
  79         }
  80
  81         nfc_fw_download_done(info->ndev->nfc_dev, fw_info->name, (u32) -result);
  82 }
  83
  84 /* crc_ccitt cannot be used since it is computed MSB first and not LSB first */
  85 static u16 nxp_nci_fw_crc(u8 const *buffer, size_t len)
  86 {
  87         u16 crc = 0xffff;
  88
  89         while (len--) {
  90                 crc = ((crc >> 8) | (crc << 8)) ^ *buffer++;
  91                 crc ^= (crc & 0xff) >> 4;
  92                 crc ^= (crc & 0xff) << 12;
  93                 crc ^= (crc & 0xff) << 5;
  94         }
  95
  96         return crc;
  97 }
  98
  99 static int nxp_nci_fw_send_chunk(struct nxp_nci_info *info)
 100 {
 101         struct nxp_nci_fw_info *fw_info = &info->fw_info;
 102         u16 header, crc;
 103         struct sk_buff *skb;
 104         size_t chunk_len;
 105         size_t remaining_len;
 106         int r;
 107
 108         skb = nci_skb_alloc(info->ndev, info->max_payload, GFP_KERNEL);
 109         if (!skb) {
 110                 r = -ENOMEM;
 111                 goto chunk_exit;
 112         }
 113
 114         chunk_len = info->max_payload - NXP_NCI_FW_HDR_LEN - NXP_NCI_FW_CRC_LEN;
 115         remaining_len = fw_info->frame_size - fw_info->written;
 116
 117         if (remaining_len > chunk_len) {
 118                 header = NXP_NCI_FW_CHUNK_FLAG;
 119         } else {
 120                 chunk_len = remaining_len;
 121                 header = 0x0000;
 122         }
 123
 124         header |= chunk_len & NXP_NCI_FW_FRAME_LEN_MASK;
 125         put_unaligned_be16(header, skb_put(skb, NXP_NCI_FW_HDR_LEN));
 126
 127         memcpy(skb_put(skb, chunk_len), fw_info->data + fw_info->written,
 128                chunk_len);
 129
 130         crc = nxp_nci_fw_crc(skb->data, chunk_len + NXP_NCI_FW_HDR_LEN);
 131         put_unaligned_be16(crc, skb_put(skb, NXP_NCI_FW_CRC_LEN));
 132
 133         r = info->phy_ops->write(info->phy_id, skb);
 134         if (r >= 0)
 135                 r = chunk_len;
 136
 137         kfree_skb(skb);
 138
 139 chunk_exit:
 140         return r;
 141 }
 142
 143 static int nxp_nci_fw_send(struct nxp_nci_info *info)
 144 {
 145         struct nxp_nci_fw_info *fw_info = &info->fw_info;
 146         long completion_rc;
 147         int r;
 148
 149         reinit_completion(&fw_info->cmd_completion);
 150
 151         if (fw_info->written == 0) {
 152                 fw_info->frame_size = get_unaligned_be16(fw_info->data) &
 153                                       NXP_NCI_FW_FRAME_LEN_MASK;
 154                 fw_info->data += NXP_NCI_FW_HDR_LEN;
 155                 fw_info->size -= NXP_NCI_FW_HDR_LEN;
 156         }
 157
 158         if (fw_info->frame_size > fw_info->size)
 159                 return -EMSGSIZE;
 160
 161         r = nxp_nci_fw_send_chunk(info);
 162         if (r < 0)
 163                 return r;
 164
 165         fw_info->written += r;
 166
 167         if (*fw_info->data == NXP_NCI_FW_CMD_RESET) {
 168                 fw_info->cmd_result = 0;
 169                 if (fw_info->fw)
 170                         schedule_work(&fw_info->work);
 171         } else {
 172                 completion_rc = wait_for_completion_interruptible_timeout(
 173                         &fw_info->cmd_completion, NXP_NCI_FW_ANSWER_TIMEOUT);
 174                 if (completion_rc == 0)
 175                         return -ETIMEDOUT;
 176         }
 177
 178         return 0;
 179 }
 180
 181 void nxp_nci_fw_work(struct work_struct *work)
 182 {
 183         struct nxp_nci_info *info;
 184         struct nxp_nci_fw_info *fw_info;
 185         int r;
 186
 187         fw_info = container_of(work, struct nxp_nci_fw_info, work);
 188         info = container_of(fw_info, struct nxp_nci_info, fw_info);
 189
 190         mutex_lock(&info->info_lock);
 191
 192         r = fw_info->cmd_result;
 193         if (r < 0)
 194                 goto exit_work;
 195
 196         if (fw_info->written == fw_info->frame_size) {
 197                 fw_info->data += fw_info->frame_size;
 198                 fw_info->size -= fw_info->frame_size;
 199                 fw_info->written = 0;
 200         }
 201
 202         if (fw_info->size > 0)
 203                 r = nxp_nci_fw_send(info);
 204
 205 exit_work:
 206         if (r < 0 || fw_info->size == 0)
 207                 nxp_nci_fw_work_complete(info, r);
 208         mutex_unlock(&info->info_lock);
 209 }
 210
 211 int nxp_nci_fw_download(struct nci_dev *ndev, const char *firmware_name)
 212 {
 213         struct nxp_nci_info *info = nci_get_drvdata(ndev);
 214         struct nxp_nci_fw_info *fw_info = &info->fw_info;
 215         int r;
 216
 217         mutex_lock(&info->info_lock);
 218
 219         if (!info->phy_ops->set_mode || !info->phy_ops->write) {
 220                 r = -ENOTSUPP;
 221                 goto fw_download_exit;
 222         }
 223
 224         if (!firmware_name || firmware_name[0] == '\0') {
 225                 r = -EINVAL;
 226                 goto fw_download_exit;
 227         }
 228
 229         strcpy(fw_info->name, firmware_name);
 230
 231         r = request_firmware(&fw_info->fw, firmware_name,
 232                              ndev->nfc_dev->dev.parent);
 233         if (r < 0)
 234                 goto fw_download_exit;
 235
 236         r = info->phy_ops->set_mode(info->phy_id, NXP_NCI_MODE_FW);
 237         if (r < 0) {
 238                 release_firmware(fw_info->fw);
 239                 goto fw_download_exit;
 240         }
 241
 242         info->mode = NXP_NCI_MODE_FW;
 243
 244         fw_info->data = fw_info->fw->data;
 245         fw_info->size = fw_info->fw->size;
 246         fw_info->written = 0;
 247         fw_info->frame_size = 0;
 248         fw_info->cmd_result = 0;
 249
 250         schedule_work(&fw_info->work);
 251
 252 fw_download_exit:
 253         mutex_unlock(&info->info_lock);
 254         return r;
 255 }
 256
 257 static int nxp_nci_fw_read_status(u8 stat)
 258 {
 259         switch (stat) {
 260         case NXP_NCI_FW_RESULT_OK:
 261                 return 0;
 262         case NXP_NCI_FW_RESULT_INVALID_ADDR:
 263                 return -EINVAL;
 264         case NXP_NCI_FW_RESULT_UNKNOWN_CMD:
 265                 return -EINVAL;
 266         case NXP_NCI_FW_RESULT_ABORTED_CMD:
 267                 return -EMSGSIZE;
 268         case NXP_NCI_FW_RESULT_ADDR_RANGE_OFL_ERROR:
 269                 return -EADDRNOTAVAIL;
 270         case NXP_NCI_FW_RESULT_BUFFER_OFL_ERROR:
 271                 return -ENOBUFS;
 272         case NXP_NCI_FW_RESULT_MEM_BSY:
 273                 return -ENOKEY;
 274         case NXP_NCI_FW_RESULT_SIGNATURE_ERROR:
 275                 return -EKEYREJECTED;
 276         case NXP_NCI_FW_RESULT_FIRMWARE_VERSION_ERROR:
 277                 return -EALREADY;
 278         case NXP_NCI_FW_RESULT_PROTOCOL_ERROR:
 279                 return -EPROTO;
 280         case NXP_NCI_FW_RESULT_SFWU_DEGRADED:
 281                 return -EHWPOISON;
 282         case NXP_NCI_FW_RESULT_PH_STATUS_FIRST_CHUNK:
 283                 return 0;
 284         case NXP_NCI_FW_RESULT_PH_STATUS_NEXT_CHUNK:
 285                 return 0;
 286         case NXP_NCI_FW_RESULT_PH_STATUS_INTERNAL_ERROR_5:
 287                 return -EINVAL;
 288         default:
 289                 return -EIO;
 290         }
 291 }
 292
 293 static u16 nxp_nci_fw_check_crc(struct sk_buff *skb)
 294 {
 295         u16 crc, frame_crc;
 296         size_t len = skb->len - NXP_NCI_FW_CRC_LEN;
 297
 298         crc = nxp_nci_fw_crc(skb->data, len);
 299         frame_crc = get_unaligned_be16(skb->data + len);
 300
 301         return (crc ^ frame_crc);
 302 }
 303
 304 void nxp_nci_fw_recv_frame(struct nci_dev *ndev, struct sk_buff *skb)
 305 {
 306         struct nxp_nci_info *info = nci_get_drvdata(ndev);
 307         struct nxp_nci_fw_info *fw_info = &info->fw_info;
 308
 309         complete(&fw_info->cmd_completion);
 310
 311         if (skb) {
 312                 if (nxp_nci_fw_check_crc(skb) != 0x00)
 313                         fw_info->cmd_result = -EBADMSG;
 314                 else
 315                         fw_info->cmd_result = nxp_nci_fw_read_status(
 316                                         *skb_pull(skb, NXP_NCI_FW_HDR_LEN));
 317                 kfree_skb(skb);
 318         } else {
 319                 fw_info->cmd_result = -EIO;
 320         }
 321
 322         if (fw_info->fw)
 323                 schedule_work(&fw_info->work);
 324 }
 325 EXPORT_SYMBOL(nxp_nci_fw_recv_frame);