drivers/uwb/i1480/dfu/i1480-dfu.h

   1 /*
   2  * i1480 Device Firmware Upload
   3  *
   4  * Copyright (C) 2005-2006 Intel Corporation
   5  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License version
   9  * 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19  * 02110-1301, USA.
  20  *
  21  *
  22  * This driver is the firmware uploader for the Intel Wireless UWB
  23  * Link 1480 device (both in the USB and PCI incarnations).
  24  *
  25  * The process is quite simple: we stop the device, write the firmware
  26  * to its memory and then restart it. Wait for the device to let us
  27  * know it is done booting firmware. Ready.
  28  *
  29  * We might have to upload before or after a phy firmware (which might
  30  * be done in two methods, using a normal firmware image or through
  31  * the MPI port).
  32  *
  33  * Because USB and PCI use common methods, we just make ops out of the
  34  * common operations (read, write, wait_init_done and cmd) and
  35  * implement them in usb.c and pci.c.
  36  *
  37  * The flow is (some parts omitted):
  38  *
  39  * i1480_{usb,pci}_probe()        On enumerate/discovery
  40  *   i1480_fw_upload()
  41  *     i1480_pre_fw_upload()
  42  *       __mac_fw_upload()
  43  *         fw_hdrs_load()
  44  *         mac_fw_hdrs_push()
  45  *           i1480->write()       [i1480_{usb,pci}_write()]
  46  *           i1480_fw_cmp()
  47  *             i1480->read()      [i1480_{usb,pci}_read()]
  48  *     i1480_mac_fw_upload()
  49  *       __mac_fw_upload()
  50  *       i1480->setup(()
  51  *       i1480->wait_init_done()
  52  *       i1480_cmd_reset()
  53  *         i1480->cmd()           [i1480_{usb,pci}_cmd()]
  54  *         ...
  55  *     i1480_phy_fw_upload()
  56  *       request_firmware()
  57  *       i1480_mpi_write()
  58  *         i1480->cmd()           [i1480_{usb,pci}_cmd()]
  59  *       i1480_check_info()
  60  *
  61  * Once the probe function enumerates the device and uploads the
  62  * firmware, we just exit with -ENODEV, as we don't really want to
  63  * attach to the device.
  64  */
  65 #ifndef __i1480_DFU_H__
  66 #define __i1480_DFU_H__
  67
  68 #include <linux/uwb/spec.h>
  69 #include <linux/types.h>
  70 #include <linux/completion.h>
  71
  72 #define i1480_FW_UPLOAD_MODE_MASK (cpu_to_le32(0x00000018))
  73
  74 #if i1480_FW > 0x00000302
  75 #define i1480_RCEB_EXTENDED
  76 #endif
  77
  78 struct uwb_rccb;
  79 struct uwb_rceb;
  80
  81 /*
  82  * Common firmware upload handlers
  83  *
  84  * Normally you embed this struct in another one specific to your hw.
  85  *
  86  * @write       Write to device's memory from buffer.
  87  * @read        Read from device's memory to i1480->evt_buf.
  88  * @setup       Setup device after basic firmware is uploaded
  89  * @wait_init_done
  90  *              Wait for the device to send a notification saying init
  91  *              is done.
  92  * @cmd         FOP for issuing the command to the hardware. The
  93  *              command data is contained in i1480->cmd_buf and the size
  94  *              is supplied as an argument. The command replied is put
  95  *              in i1480->evt_buf and the size in i1480->evt_result (or if
  96  *              an error, a < 0 errno code).
  97  *
  98  * @cmd_buf     Memory buffer used to send commands to the device.
  99  *              Allocated by the upper layers i1480_fw_upload().
 100  *              Size has to be @buf_size.
 101  * @evt_buf     Memory buffer used to place the async notifications
 102  *              received by the hw. Allocated by the upper layers
 103  *              i1480_fw_upload().
 104  *              Size has to be @buf_size.
 105  * @cmd_complete
 106  *              Low level driver uses this to notify code waiting afor
 107  *              an event that the event has arrived and data is in
 108  *              i1480->evt_buf (and size/result in i1480->evt_result).
 109  * @hw_rev
 110  *              Use this value to activate dfu code to support new revisions
 111  *              of hardware.  i1480_init() sets this to a default value.
 112  *              It should be updated by the USB and PCI code.
 113  */
 114 struct i1480 {
 115         struct device *dev;
 116
 117         int (*write)(struct i1480 *, u32 addr, const void *, size_t);
 118         int (*read)(struct i1480 *, u32 addr, size_t);
 119         int (*rc_setup)(struct i1480 *);
 120         void (*rc_release)(struct i1480 *);
 121         int (*wait_init_done)(struct i1480 *);
 122         int (*cmd)(struct i1480 *, const char *cmd_name, size_t cmd_size);
 123         const char *pre_fw_name;
 124         const char *mac_fw_name;
 125         const char *mac_fw_name_deprecate;      /* FIXME: Will go away */
 126         const char *phy_fw_name;
 127         u8 hw_rev;
 128
 129         size_t buf_size;        /* size of both evt_buf and cmd_buf */
 130         void *evt_buf, *cmd_buf;
 131         ssize_t evt_result;
 132         struct completion evt_complete;
 133
 134         u8 quirk_no_check_info:1;
 135 };
 136
 137 static inline
 138 void i1480_init(struct i1480 *i1480)
 139 {
 140         i1480->hw_rev = 1;
 141         init_completion(&i1480->evt_complete);
 142 }
 143
 144 extern int i1480_fw_upload(struct i1480 *);
 145 extern int i1480_pre_fw_upload(struct i1480 *);
 146 extern int i1480_mac_fw_upload(struct i1480 *);
 147 extern int i1480_phy_fw_upload(struct i1480 *);
 148 extern ssize_t i1480_cmd(struct i1480 *, const char *, size_t, size_t);
 149 extern int i1480_rceb_check(const struct i1480 *,
 150                             const struct uwb_rceb *, const char *, u8,
 151                             unsigned, unsigned);
 152
 153 enum {
 154         /* Vendor specific command type */
 155         i1480_CET_VS1 =                 0xfd,
 156         /* i1480 commands */
 157         i1480_CMD_SET_IP_MAS =          0x000e,
 158         i1480_CMD_GET_MAC_PHY_INFO =    0x0003,
 159         i1480_CMD_MPI_WRITE =           0x000f,
 160         i1480_CMD_MPI_READ =            0x0010,
 161         /* i1480 events */
 162 #if i1480_FW > 0x00000302
 163         i1480_EVT_CONFIRM =             0x0002,
 164         i1480_EVT_RM_INIT_DONE =        0x0101,
 165         i1480_EVT_DEV_ADD =             0x0103,
 166         i1480_EVT_DEV_RM =              0x0104,
 167         i1480_EVT_DEV_ID_CHANGE =       0x0105,
 168         i1480_EVT_GET_MAC_PHY_INFO =    i1480_CMD_GET_MAC_PHY_INFO,
 169 #else
 170         i1480_EVT_CONFIRM =             0x0002,
 171         i1480_EVT_RM_INIT_DONE =        0x0101,
 172         i1480_EVT_DEV_ADD =             0x0103,
 173         i1480_EVT_DEV_RM =              0x0104,
 174         i1480_EVT_DEV_ID_CHANGE =       0x0105,
 175         i1480_EVT_GET_MAC_PHY_INFO =    i1480_EVT_CONFIRM,
 176 #endif
 177 };
 178
 179
 180 struct i1480_evt_confirm {
 181         struct uwb_rceb rceb;
 182 #ifdef i1480_RCEB_EXTENDED
 183         __le16 wParamLength;
 184 #endif
 185         u8 bResultCode;
 186 } __attribute__((packed));
 187
 188
 189 struct i1480_rceb {
 190         struct uwb_rceb rceb;
 191 #ifdef i1480_RCEB_EXTENDED
 192         __le16 wParamLength;
 193 #endif
 194 } __attribute__((packed));
 195
 196
 197 /**
 198  * Get MAC & PHY Information confirm event structure
 199  *
 200  * Confirm event returned by the command.
 201  */
 202 struct i1480_evt_confirm_GMPI {
 203 #if i1480_FW > 0x00000302
 204         struct uwb_rceb rceb;
 205         __le16 wParamLength;
 206         __le16 status;
 207         u8 mac_addr[6];         /* EUI-64 bit IEEE address [still 8 bytes?] */
 208         u8 dev_addr[2];
 209         __le16 mac_fw_rev;      /* major = v >> 8; minor = v & 0xff */
 210         u8 hw_rev;
 211         u8 phy_vendor;
 212         u8 phy_rev;             /* major v = >> 8; minor = v & 0xff */
 213         __le16 mac_caps;
 214         u8 phy_caps[3];
 215         u8 key_stores;
 216         __le16 mcast_addr_stores;
 217         u8 sec_mode_supported;
 218 #else
 219         struct uwb_rceb rceb;
 220         u8 status;
 221         u8 mac_addr[8];         /* EUI-64 bit IEEE address [still 8 bytes?] */
 222         u8 dev_addr[2];
 223         __le16 mac_fw_rev;      /* major = v >> 8; minor = v & 0xff */
 224         __le16 phy_fw_rev;      /* major v = >> 8; minor = v & 0xff */
 225         __le16 mac_caps;
 226         u8 phy_caps;
 227         u8 key_stores;
 228         __le16 mcast_addr_stores;
 229         u8 sec_mode_supported;
 230 #endif
 231 } __attribute__((packed));
 232
 233
 234 struct i1480_cmd_mpi_write {
 235         struct uwb_rccb rccb;
 236         __le16 size;
 237         u8 data[];
 238 };
 239
 240
 241 struct i1480_cmd_mpi_read {
 242         struct uwb_rccb rccb;
 243         __le16 size;
 244         struct {
 245                 u8 page, offset;
 246         } __attribute__((packed)) data[];
 247 } __attribute__((packed));
 248
 249
 250 struct i1480_evt_mpi_read {
 251         struct uwb_rceb rceb;
 252 #ifdef i1480_RCEB_EXTENDED
 253         __le16 wParamLength;
 254 #endif
 255         u8 bResultCode;
 256         __le16 size;
 257         struct {
 258                 u8 page, offset, value;
 259         } __attribute__((packed)) data[];
 260 } __attribute__((packed));
 261
 262
 263 #endif /* #ifndef __i1480_DFU_H__ */