drivers/net/wireless/mediatek/mt76/mt76x0/usb_mcu.c

   1 /*
   2  * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include <linux/kernel.h>
  17 #include <linux/firmware.h>
  18
  19 #include "mt76x0.h"
  20 #include "mcu.h"
  21 #include "../mt76x02_usb.h"
  22
  23 #define MCU_FW_URB_MAX_PAYLOAD          0x38f8
  24 #define MCU_FW_URB_SIZE                 (MCU_FW_URB_MAX_PAYLOAD + 12)
  25
  26 static int
  27 mt76x0u_upload_firmware(struct mt76x02_dev *dev,
  28                         const struct mt76x02_fw_header *hdr)
  29 {
  30         u8 *fw_payload = (u8 *)(hdr + 1);
  31         u32 ilm_len, dlm_len;
  32         void *ivb;
  33         int err;
  34
  35         ivb = kmemdup(fw_payload, MT_MCU_IVB_SIZE, GFP_KERNEL);
  36         if (!ivb)
  37                 return -ENOMEM;
  38
  39         ilm_len = le32_to_cpu(hdr->ilm_len) - MT_MCU_IVB_SIZE;
  40         dev_dbg(dev->mt76.dev, "loading FW - ILM %u + IVB %u\n",
  41                 ilm_len, MT_MCU_IVB_SIZE);
  42         err = mt76x02u_mcu_fw_send_data(dev, fw_payload + MT_MCU_IVB_SIZE,
  43                                         ilm_len, MCU_FW_URB_MAX_PAYLOAD,
  44                                         MT_MCU_IVB_SIZE);
  45         if (err)
  46                 goto out;
  47
  48         dlm_len = le32_to_cpu(hdr->dlm_len);
  49         dev_dbg(dev->mt76.dev, "loading FW - DLM %u\n", dlm_len);
  50         err = mt76x02u_mcu_fw_send_data(dev,
  51                                         fw_payload + le32_to_cpu(hdr->ilm_len),
  52                                         dlm_len, MCU_FW_URB_MAX_PAYLOAD,
  53                                         MT_MCU_DLM_OFFSET);
  54         if (err)
  55                 goto out;
  56
  57         err = mt76u_vendor_request(&dev->mt76, MT_VEND_DEV_MODE,
  58                                    USB_DIR_OUT | USB_TYPE_VENDOR,
  59                                    0x12, 0, ivb, MT_MCU_IVB_SIZE);
  60         if (err < 0)
  61                 goto out;
  62
  63         if (!mt76_poll_msec(dev, MT_MCU_COM_REG0, 1, 1, 1000)) {
  64                 dev_err(dev->mt76.dev, "Firmware failed to start\n");
  65                 err = -ETIMEDOUT;
  66                 goto out;
  67         }
  68
  69         dev_dbg(dev->mt76.dev, "Firmware running!\n");
  70
  71 out:
  72         kfree(ivb);
  73
  74         return err;
  75 }
  76
  77 static int mt76x0_get_firmware(struct mt76x02_dev *dev,
  78                                const struct firmware **fw)
  79 {
  80         int err;
  81
  82         /* try to load mt7610e fw if available
  83          * otherwise fall back to mt7610u one
  84          */
  85         err = firmware_request_nowarn(fw, MT7610E_FIRMWARE, dev->mt76.dev);
  86         if (err) {
  87                 dev_info(dev->mt76.dev, "%s not found, switching to %s",
  88                          MT7610E_FIRMWARE, MT7610U_FIRMWARE);
  89                 return request_firmware(fw, MT7610U_FIRMWARE,
  90                                         dev->mt76.dev);
  91         }
  92         return 0;
  93 }
  94
  95 static int mt76x0u_load_firmware(struct mt76x02_dev *dev)
  96 {
  97         const struct firmware *fw;
  98         const struct mt76x02_fw_header *hdr;
  99         int len, ret;
 100         u32 val;
 101
 102         mt76_wr(dev, MT_USB_DMA_CFG, (MT_USB_DMA_CFG_RX_BULK_EN |
 103                                       MT_USB_DMA_CFG_TX_BULK_EN));
 104
 105         if (mt76x0_firmware_running(dev))
 106                 return 0;
 107
 108         ret = mt76x0_get_firmware(dev, &fw);
 109         if (ret)
 110                 return ret;
 111
 112         if (!fw || !fw->data || fw->size < sizeof(*hdr))
 113                 goto err_inv_fw;
 114
 115         hdr = (const struct mt76x02_fw_header *)fw->data;
 116
 117         if (le32_to_cpu(hdr->ilm_len) <= MT_MCU_IVB_SIZE)
 118                 goto err_inv_fw;
 119
 120         len = sizeof(*hdr);
 121         len += le32_to_cpu(hdr->ilm_len);
 122         len += le32_to_cpu(hdr->dlm_len);
 123
 124         if (fw->size != len)
 125                 goto err_inv_fw;
 126
 127         val = le16_to_cpu(hdr->fw_ver);
 128         dev_dbg(dev->mt76.dev,
 129                 "Firmware Version: %d.%d.%02d Build: %x Build time: %.16s\n",
 130                 (val >> 12) & 0xf, (val >> 8) & 0xf, val & 0xf,
 131                 le16_to_cpu(hdr->build_ver), hdr->build_time);
 132
 133         len = le32_to_cpu(hdr->ilm_len);
 134
 135         mt76_wr(dev, 0x1004, 0x2c);
 136
 137         mt76_set(dev, MT_USB_DMA_CFG,
 138                  (MT_USB_DMA_CFG_RX_BULK_EN | MT_USB_DMA_CFG_TX_BULK_EN) |
 139                  FIELD_PREP(MT_USB_DMA_CFG_RX_BULK_AGG_TOUT, 0x20));
 140         mt76x02u_mcu_fw_reset(dev);
 141         usleep_range(5000, 6000);
 142 /*
 143         mt76x0_rmw(dev, MT_PBF_CFG, 0, (MT_PBF_CFG_TX0Q_EN |
 144                                          MT_PBF_CFG_TX1Q_EN |
 145                                          MT_PBF_CFG_TX2Q_EN |
 146                                          MT_PBF_CFG_TX3Q_EN));
 147 */
 148
 149         mt76_wr(dev, MT_FCE_PSE_CTRL, 1);
 150
 151         /* FCE tx_fs_base_ptr */
 152         mt76_wr(dev, MT_TX_CPU_FROM_FCE_BASE_PTR, 0x400230);
 153         /* FCE tx_fs_max_cnt */
 154         mt76_wr(dev, MT_TX_CPU_FROM_FCE_MAX_COUNT, 1);
 155         /* FCE pdma enable */
 156         mt76_wr(dev, MT_FCE_PDMA_GLOBAL_CONF, 0x44);
 157         /* FCE skip_fs_en */
 158         mt76_wr(dev, MT_FCE_SKIP_FS, 3);
 159
 160         val = mt76_rr(dev, MT_USB_DMA_CFG);
 161         val |= MT_USB_DMA_CFG_UDMA_TX_WL_DROP;
 162         mt76_wr(dev, MT_USB_DMA_CFG, val);
 163         val &= ~MT_USB_DMA_CFG_UDMA_TX_WL_DROP;
 164         mt76_wr(dev, MT_USB_DMA_CFG, val);
 165
 166         ret = mt76x0u_upload_firmware(dev, hdr);
 167         release_firmware(fw);
 168
 169         mt76_wr(dev, MT_FCE_PSE_CTRL, 1);
 170
 171         return ret;
 172
 173 err_inv_fw:
 174         dev_err(dev->mt76.dev, "Invalid firmware image\n");
 175         release_firmware(fw);
 176         return -ENOENT;
 177 }
 178
 179 int mt76x0u_mcu_init(struct mt76x02_dev *dev)
 180 {
 181         int ret;
 182
 183         ret = mt76x0u_load_firmware(dev);
 184         if (ret < 0)
 185                 return ret;
 186
 187         set_bit(MT76_STATE_MCU_RUNNING, &dev->mt76.state);
 188
 189         return 0;
 190 }