xref: /openbmc/linux/drivers/staging/ks7010/ks_wlan.h (revision a2b0b416)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  *   Driver for KeyStream IEEE802.11 b/g wireless LAN cards.
4  *
5  *   Copyright (C) 2006-2008 KeyStream Corp.
6  *   Copyright (C) 2009 Renesas Technology Corp.
7  */
8 
9 #ifndef _KS_WLAN_H
10 #define _KS_WLAN_H
11 
12 #include <linux/atomic.h>
13 #include <linux/circ_buf.h>
14 #include <linux/completion.h>
15 #include <linux/netdevice.h>
16 #include <linux/sched.h>
17 #include <linux/spinlock.h>
18 #include <linux/wireless.h>
19 
20 struct ks_wlan_parameter {
21 	u8 operation_mode;
22 	u8 channel;
23 	u8 tx_rate;
24 	struct {
25 		u8 size;
26 		u8 body[16];
27 	} rate_set;
28 	u8 bssid[ETH_ALEN];
29 	struct {
30 		u8 size;
31 		u8 body[32 + 1];
32 	} ssid;
33 	u8 preamble;
34 	u8 power_mgmt;
35 	u32 scan_type;
36 #define BEACON_LOST_COUNT_MAX 65535
37 	u32 beacon_lost_count;
38 	u32 rts;
39 	u32 fragment;
40 	u32 privacy_invoked;
41 	u32 wep_index;
42 	struct {
43 		u8 size;
44 		u8 val[13 * 2 + 1];
45 	} wep_key[4];
46 	u16 authenticate_type;
47 	u16 phy_type;
48 	u16 cts_mode;
49 	u16 phy_info_timer;
50 };
51 
52 enum {
53 	DEVICE_STATE_OFF = 0,	/* this means hw_unavailable is != 0 */
54 	DEVICE_STATE_PREBOOT,	/* we are in a pre-boot state (empty RAM) */
55 	DEVICE_STATE_BOOT,	/* boot state (fw upload, run fw) */
56 	DEVICE_STATE_PREINIT,	/* pre-init state */
57 	DEVICE_STATE_INIT,	/* init state (restore MIB backup to device) */
58 	DEVICE_STATE_READY,	/* driver&device are in operational state */
59 	DEVICE_STATE_SLEEP	/* device in sleep mode */
60 };
61 
62 /* SME flag */
63 #define SME_MODE_SET	    BIT(0)
64 #define SME_RTS             BIT(1)
65 #define SME_FRAG            BIT(2)
66 #define SME_WEP_FLAG        BIT(3)
67 #define SME_WEP_INDEX       BIT(4)
68 #define SME_WEP_VAL1        BIT(5)
69 #define SME_WEP_VAL2        BIT(6)
70 #define SME_WEP_VAL3        BIT(7)
71 #define SME_WEP_VAL4        BIT(8)
72 #define SME_WEP_VAL_MASK    GENMASK(8, 5)
73 #define SME_RSN             BIT(9)
74 #define SME_RSN_MULTICAST   BIT(10)
75 #define SME_RSN_UNICAST	    BIT(11)
76 #define SME_RSN_AUTH	    BIT(12)
77 
78 #define SME_AP_SCAN         BIT(13)
79 #define SME_MULTICAST       BIT(14)
80 
81 /* SME Event */
82 enum {
83 	SME_START,
84 
85 	SME_MULTICAST_REQUEST,
86 	SME_MACADDRESS_SET_REQUEST,
87 	SME_BSS_SCAN_REQUEST,
88 	SME_SET_FLAG,
89 	SME_SET_TXKEY,
90 	SME_SET_KEY1,
91 	SME_SET_KEY2,
92 	SME_SET_KEY3,
93 	SME_SET_KEY4,
94 	SME_SET_PMK_TSC,
95 	SME_SET_GMK1_TSC,
96 	SME_SET_GMK2_TSC,
97 	SME_SET_GMK3_TSC,
98 	SME_SET_PMKSA,
99 	SME_POW_MNGMT_REQUEST,
100 	SME_PHY_INFO_REQUEST,
101 	SME_MIC_FAILURE_REQUEST,
102 	SME_GET_MAC_ADDRESS,
103 	SME_GET_PRODUCT_VERSION,
104 	SME_STOP_REQUEST,
105 	SME_RTS_THRESHOLD_REQUEST,
106 	SME_FRAGMENTATION_THRESHOLD_REQUEST,
107 	SME_WEP_INDEX_REQUEST,
108 	SME_WEP_KEY1_REQUEST,
109 	SME_WEP_KEY2_REQUEST,
110 	SME_WEP_KEY3_REQUEST,
111 	SME_WEP_KEY4_REQUEST,
112 	SME_WEP_FLAG_REQUEST,
113 	SME_RSN_UCAST_REQUEST,
114 	SME_RSN_MCAST_REQUEST,
115 	SME_RSN_AUTH_REQUEST,
116 	SME_RSN_ENABLED_REQUEST,
117 	SME_RSN_MODE_REQUEST,
118 	SME_WPS_ENABLE_REQUEST,
119 	SME_WPS_PROBE_REQUEST,
120 	SME_SET_GAIN,
121 	SME_GET_GAIN,
122 	SME_SLEEP_REQUEST,
123 	SME_SET_REGION,
124 	SME_MODE_SET_REQUEST,
125 	SME_START_REQUEST,
126 	SME_GET_EEPROM_CKSUM,
127 
128 	SME_MIC_FAILURE_CONFIRM,
129 	SME_START_CONFIRM,
130 
131 	SME_MULTICAST_CONFIRM,
132 	SME_BSS_SCAN_CONFIRM,
133 	SME_GET_CURRENT_AP,
134 	SME_POW_MNGMT_CONFIRM,
135 	SME_PHY_INFO_CONFIRM,
136 	SME_STOP_CONFIRM,
137 	SME_RTS_THRESHOLD_CONFIRM,
138 	SME_FRAGMENTATION_THRESHOLD_CONFIRM,
139 	SME_WEP_INDEX_CONFIRM,
140 	SME_WEP_KEY1_CONFIRM,
141 	SME_WEP_KEY2_CONFIRM,
142 	SME_WEP_KEY3_CONFIRM,
143 	SME_WEP_KEY4_CONFIRM,
144 	SME_WEP_FLAG_CONFIRM,
145 	SME_RSN_UCAST_CONFIRM,
146 	SME_RSN_MCAST_CONFIRM,
147 	SME_RSN_AUTH_CONFIRM,
148 	SME_RSN_ENABLED_CONFIRM,
149 	SME_RSN_MODE_CONFIRM,
150 	SME_MODE_SET_CONFIRM,
151 	SME_SLEEP_CONFIRM,
152 
153 	SME_RSN_SET_CONFIRM,
154 	SME_WEP_SET_CONFIRM,
155 	SME_TERMINATE,
156 
157 	SME_EVENT_SIZE
158 };
159 
160 /* SME Status */
161 enum {
162 	SME_IDLE,
163 	SME_SETUP,
164 	SME_DISCONNECT,
165 	SME_CONNECT
166 };
167 
168 #define	SME_EVENT_BUFF_SIZE	128
169 
170 struct sme_info {
171 	int sme_status;
172 	int event_buff[SME_EVENT_BUFF_SIZE];
173 	unsigned int qhead;
174 	unsigned int qtail;
175 	spinlock_t sme_spin;
176 	unsigned long sme_flag;
177 };
178 
179 struct hostt {
180 	int buff[SME_EVENT_BUFF_SIZE];
181 	unsigned int qhead;
182 	unsigned int qtail;
183 };
184 
185 #define RSN_IE_BODY_MAX 64
186 struct rsn_ie {
187 	u8 id;	/* 0xdd = WPA or 0x30 = RSN */
188 	u8 size;	/* max ? 255 ? */
189 	u8 body[RSN_IE_BODY_MAX];
190 } __packed;
191 
192 #define WPA_INFO_ELEM_ID 0xdd
193 #define RSN_INFO_ELEM_ID 0x30
194 
195 #define WPS_IE_BODY_MAX 255
196 struct wps_ie {
197 	u8 id;	/* 221 'dd <len> 00 50 F2 04' */
198 	u8 size;	/* max ? 255 ? */
199 	u8 body[WPS_IE_BODY_MAX];
200 } __packed;
201 
202 struct local_ap {
203 	u8 bssid[6];
204 	u8 rssi;
205 	u8 sq;
206 	struct {
207 		u8 size;
208 		u8 body[32];
209 		u8 ssid_pad;
210 	} ssid;
211 	struct {
212 		u8 size;
213 		u8 body[16];
214 		u8 rate_pad;
215 	} rate_set;
216 	u16 capability;
217 	u8 channel;
218 	u8 noise;
219 	struct rsn_ie wpa_ie;
220 	struct rsn_ie rsn_ie;
221 	struct wps_ie wps_ie;
222 };
223 
224 #define LOCAL_APLIST_MAX 31
225 #define LOCAL_CURRENT_AP LOCAL_APLIST_MAX
226 struct local_aplist {
227 	int size;
228 	struct local_ap ap[LOCAL_APLIST_MAX + 1];
229 };
230 
231 struct local_gain {
232 	u8 tx_mode;
233 	u8 rx_mode;
234 	u8 tx_gain;
235 	u8 rx_gain;
236 };
237 
238 struct local_eeprom_sum {
239 	u8 type;
240 	u8 result;
241 };
242 
243 enum {
244 	EEPROM_OK,
245 	EEPROM_CHECKSUM_NONE,
246 	EEPROM_FW_NOT_SUPPORT,
247 	EEPROM_NG,
248 };
249 
250 /* Power Save Status */
251 enum {
252 	PS_NONE,
253 	PS_ACTIVE_SET,
254 	PS_SAVE_SET,
255 	PS_CONF_WAIT,
256 	PS_SNOOZE,
257 	PS_WAKEUP
258 };
259 
260 struct power_save_status {
261 	atomic_t status;	/* initialvalue 0 */
262 	struct completion wakeup_wait;
263 	atomic_t confirm_wait;
264 	atomic_t snooze_guard;
265 };
266 
267 struct sleep_status {
268 	atomic_t status;	/* initialvalue 0 */
269 	atomic_t doze_request;
270 	atomic_t wakeup_request;
271 };
272 
273 /* WPA */
274 struct scan_ext {
275 	unsigned int flag;
276 	char ssid[IW_ESSID_MAX_SIZE + 1];
277 };
278 
279 #define CIPHER_ID_WPA_NONE    "\x00\x50\xf2\x00"
280 #define CIPHER_ID_WPA_WEP40   "\x00\x50\xf2\x01"
281 #define CIPHER_ID_WPA_TKIP    "\x00\x50\xf2\x02"
282 #define CIPHER_ID_WPA_CCMP    "\x00\x50\xf2\x04"
283 #define CIPHER_ID_WPA_WEP104  "\x00\x50\xf2\x05"
284 
285 #define CIPHER_ID_WPA2_NONE   "\x00\x0f\xac\x00"
286 #define CIPHER_ID_WPA2_WEP40  "\x00\x0f\xac\x01"
287 #define CIPHER_ID_WPA2_TKIP   "\x00\x0f\xac\x02"
288 #define CIPHER_ID_WPA2_CCMP   "\x00\x0f\xac\x04"
289 #define CIPHER_ID_WPA2_WEP104 "\x00\x0f\xac\x05"
290 
291 #define CIPHER_ID_LEN    4
292 
293 enum {
294 	KEY_MGMT_802_1X,
295 	KEY_MGMT_PSK,
296 	KEY_MGMT_WPANONE,
297 };
298 
299 #define KEY_MGMT_ID_WPA_NONE     "\x00\x50\xf2\x00"
300 #define KEY_MGMT_ID_WPA_1X       "\x00\x50\xf2\x01"
301 #define KEY_MGMT_ID_WPA_PSK      "\x00\x50\xf2\x02"
302 #define KEY_MGMT_ID_WPA_WPANONE  "\x00\x50\xf2\xff"
303 
304 #define KEY_MGMT_ID_WPA2_NONE    "\x00\x0f\xac\x00"
305 #define KEY_MGMT_ID_WPA2_1X      "\x00\x0f\xac\x01"
306 #define KEY_MGMT_ID_WPA2_PSK     "\x00\x0f\xac\x02"
307 #define KEY_MGMT_ID_WPA2_WPANONE "\x00\x0f\xac\xff"
308 
309 #define KEY_MGMT_ID_LEN  4
310 
311 #define MIC_KEY_SIZE 8
312 
313 struct wpa_key {
314 	u32 ext_flags;	/* IW_ENCODE_EXT_xxx */
315 	u8 tx_seq[IW_ENCODE_SEQ_MAX_SIZE];	/* LSB first */
316 	u8 rx_seq[IW_ENCODE_SEQ_MAX_SIZE];	/* LSB first */
317 	struct sockaddr addr;	/* ff:ff:ff:ff:ff:ff for broadcast/multicast
318 				 * (group) keys or unicast address for
319 				 * individual keys
320 				 */
321 	u16 alg;
322 	u16 key_len;	/* WEP: 5 or 13, TKIP: 32, CCMP: 16 */
323 	u8 key_val[IW_ENCODING_TOKEN_MAX];
324 	u8 tx_mic_key[MIC_KEY_SIZE];
325 	u8 rx_mic_key[MIC_KEY_SIZE];
326 };
327 
328 #define WPA_KEY_INDEX_MAX 4
329 #define WPA_RX_SEQ_LEN 6
330 
331 struct mic_failure {
332 	u16 failure;	/* MIC Failure counter 0 or 1 or 2 */
333 	u16 counter;	/* 1sec counter 0-60 */
334 	u32 last_failure_time;
335 	int stop;
336 };
337 
338 struct wpa_status {
339 	int wpa_enabled;
340 	bool rsn_enabled;
341 	int version;
342 	int pairwise_suite;	/* unicast cipher */
343 	int group_suite;	/* multicast cipher */
344 	int key_mgmt_suite;
345 	int auth_alg;
346 	int txkey;
347 	struct wpa_key key[WPA_KEY_INDEX_MAX];
348 	struct scan_ext scan_ext;
349 	struct mic_failure mic_failure;
350 };
351 
352 #include <linux/list.h>
353 #define PMK_LIST_MAX 8
354 struct pmk_list {
355 	u16 size;
356 	struct list_head head;
357 	struct pmk {
358 		struct list_head list;
359 		u8 bssid[ETH_ALEN];
360 		u8 pmkid[IW_PMKID_LEN];
361 	} pmk[PMK_LIST_MAX];
362 };
363 
364 struct wps_status {
365 	int wps_enabled;
366 	int ielen;
367 	u8 ie[255];
368 };
369 
370 /* Tx Device struct */
371 #define	TX_DEVICE_BUFF_SIZE	1024
372 
373 struct ks_wlan_private;
374 
375 /**
376  * struct tx_device_buffer - Queue item for the tx queue.
377  * @sendp: Pointer to the send request data.
378  * @size: Size of @sendp data.
379  * @complete_handler: Function called once data write to device is complete.
380  * @arg1: First argument to @complete_handler.
381  * @arg2: Second argument to @complete_handler.
382  */
383 struct tx_device_buffer {
384 	unsigned char *sendp;
385 	unsigned int size;
386 	void (*complete_handler)(struct ks_wlan_private *priv,
387 				 struct sk_buff *skb);
388 	struct sk_buff *skb;
389 };
390 
391 /**
392  * struct tx_device - Tx buffer queue.
393  * @tx_device_buffer: Queue buffer.
394  * @qhead: Head of tx queue.
395  * @qtail: Tail of tx queue.
396  * @tx_dev_lock: Queue lock.
397  */
398 struct tx_device {
399 	struct tx_device_buffer tx_dev_buff[TX_DEVICE_BUFF_SIZE];
400 	unsigned int qhead;
401 	unsigned int qtail;
402 	spinlock_t tx_dev_lock;	/* protect access to the queue */
403 };
404 
405 /* Rx Device struct */
406 #define	RX_DATA_SIZE	(2 + 2 + 2347 + 1)
407 #define	RX_DEVICE_BUFF_SIZE	32
408 
409 /**
410  * struct rx_device_buffer - Queue item for the rx queue.
411  * @data: rx data.
412  * @size: Size of @data.
413  */
414 struct rx_device_buffer {
415 	unsigned char data[RX_DATA_SIZE];
416 	unsigned int size;
417 };
418 
419 /**
420  * struct rx_device - Rx buffer queue.
421  * @rx_device_buffer: Queue buffer.
422  * @qhead: Head of rx queue.
423  * @qtail: Tail of rx queue.
424  * @rx_dev_lock: Queue lock.
425  */
426 struct rx_device {
427 	struct rx_device_buffer rx_dev_buff[RX_DEVICE_BUFF_SIZE];
428 	unsigned int qhead;
429 	unsigned int qtail;
430 	spinlock_t rx_dev_lock;	/* protect access to the queue */
431 };
432 
433 struct ks_wlan_private {
434 	/* hardware information */
435 	void *if_hw;
436 	struct workqueue_struct *wq;
437 	struct delayed_work rw_dwork;
438 	struct tasklet_struct rx_bh_task;
439 
440 	struct net_device *net_dev;
441 	struct net_device_stats nstats;
442 	struct iw_statistics wstats;
443 
444 	struct completion confirm_wait;
445 
446 	/* trx device & sme */
447 	struct tx_device tx_dev;
448 	struct rx_device rx_dev;
449 	struct sme_info sme_i;
450 	u8 *rxp;
451 	unsigned int rx_size;
452 	struct work_struct sme_work;
453 	struct work_struct wakeup_work;
454 	int scan_ind_count;
455 
456 	unsigned char eth_addr[ETH_ALEN];
457 
458 	struct local_aplist aplist;
459 	struct local_ap current_ap;
460 	struct power_save_status psstatus;
461 	struct sleep_status sleepstatus;
462 	struct wpa_status wpa;
463 	struct pmk_list pmklist;
464 	/* wireless parameter */
465 	struct ks_wlan_parameter reg;
466 	u8 current_rate;
467 
468 	char nick[IW_ESSID_MAX_SIZE + 1];
469 
470 	spinlock_t multicast_spin;
471 
472 	spinlock_t dev_read_lock;
473 	wait_queue_head_t devread_wait;
474 
475 	unsigned int need_commit;	/* for ioctl */
476 
477 	/* DeviceIoControl */
478 	bool is_device_open;
479 	atomic_t event_count;
480 	atomic_t rec_count;
481 	int dev_count;
482 #define DEVICE_STOCK_COUNT 20
483 	unsigned char *dev_data[DEVICE_STOCK_COUNT];
484 	int dev_size[DEVICE_STOCK_COUNT];
485 
486 	/* ioctl : IOCTL_FIRMWARE_VERSION */
487 	unsigned char firmware_version[128 + 1];
488 	int version_size;
489 
490 	bool mac_address_valid;
491 
492 	int dev_state;
493 
494 	struct sk_buff *skb;
495 	unsigned int cur_rx;	/* Index into the Rx buffer of next Rx pkt. */
496 #define FORCE_DISCONNECT    0x80000000
497 #define CONNECT_STATUS_MASK 0x7FFFFFFF
498 	u32 connect_status;
499 	int infra_status;
500 	u8 scan_ssid_len;
501 	u8 scan_ssid[IW_ESSID_MAX_SIZE + 1];
502 	struct local_gain gain;
503 	struct wps_status wps;
504 	u8 sleep_mode;
505 
506 	u8 region;
507 	struct local_eeprom_sum eeprom_sum;
508 	u8 eeprom_checksum;
509 
510 	struct hostt hostt;
511 
512 	unsigned long last_doze;
513 	unsigned long last_wakeup;
514 
515 	unsigned int wakeup_count;	/* for detect wakeup loop */
516 };
517 
inc_txqhead(struct ks_wlan_private * priv)518 static inline void inc_txqhead(struct ks_wlan_private *priv)
519 {
520 	priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE;
521 }
522 
inc_txqtail(struct ks_wlan_private * priv)523 static inline void inc_txqtail(struct ks_wlan_private *priv)
524 {
525 	priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE;
526 }
527 
txq_has_space(struct ks_wlan_private * priv)528 static inline bool txq_has_space(struct ks_wlan_private *priv)
529 {
530 	return (CIRC_SPACE(priv->tx_dev.qhead, priv->tx_dev.qtail,
531 			   TX_DEVICE_BUFF_SIZE) > 0);
532 }
533 
inc_rxqhead(struct ks_wlan_private * priv)534 static inline void inc_rxqhead(struct ks_wlan_private *priv)
535 {
536 	priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE;
537 }
538 
inc_rxqtail(struct ks_wlan_private * priv)539 static inline void inc_rxqtail(struct ks_wlan_private *priv)
540 {
541 	priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE;
542 }
543 
rxq_has_space(struct ks_wlan_private * priv)544 static inline bool rxq_has_space(struct ks_wlan_private *priv)
545 {
546 	return (CIRC_SPACE(priv->rx_dev.qhead, priv->rx_dev.qtail,
547 			   RX_DEVICE_BUFF_SIZE) > 0);
548 }
549 
txq_count(struct ks_wlan_private * priv)550 static inline unsigned int txq_count(struct ks_wlan_private *priv)
551 {
552 	return CIRC_CNT_TO_END(priv->tx_dev.qhead, priv->tx_dev.qtail,
553 			       TX_DEVICE_BUFF_SIZE);
554 }
555 
rxq_count(struct ks_wlan_private * priv)556 static inline unsigned int rxq_count(struct ks_wlan_private *priv)
557 {
558 	return CIRC_CNT_TO_END(priv->rx_dev.qhead, priv->rx_dev.qtail,
559 			       RX_DEVICE_BUFF_SIZE);
560 }
561 
562 int ks_wlan_net_start(struct net_device *dev);
563 int ks_wlan_net_stop(struct net_device *dev);
564 bool is_connect_status(u32 status);
565 bool is_disconnect_status(u32 status);
566 
567 #endif /* _KS_WLAN_H */
568