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 tasklet_struct sme_task; 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 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 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 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 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 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 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 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 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