]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/uwb/i1480/dfu/i1480-dfu.h
uwb: add the i1480 DFU driver
[linux-2.6.git] / 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__ */