1/* 2 * Intel Wireless WiMAX Connection 2400m 3 * Declarations for bus-generic internal APIs 4 * 5 * 6 * Copyright (C) 2007-2008 Intel Corporation. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * * Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * * Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * * Neither the name of Intel Corporation nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 * 34 * 35 * Intel Corporation <linux-wimax@intel.com> 36 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> 37 * Yanir Lubetkin <yanirx.lubetkin@intel.com> 38 * - Initial implementation 39 * 40 * 41 * GENERAL DRIVER ARCHITECTURE 42 * 43 * The i2400m driver is split in the following two major parts: 44 * 45 * - bus specific driver 46 * - bus generic driver (this part) 47 * 48 * The bus specific driver sets up stuff specific to the bus the 49 * device is connected to (USB, SDIO, PCI, tam-tam...non-authoritative 50 * nor binding list) which is basically the device-model management 51 * (probe/disconnect, etc), moving data from device to kernel and 52 * back, doing the power saving details and reseting the device. 53 * 54 * For details on each bus-specific driver, see it's include file, 55 * i2400m-BUSNAME.h 56 * 57 * The bus-generic functionality break up is: 58 * 59 * - Firmware upload: fw.c - takes care of uploading firmware to the 60 * device. bus-specific driver just needs to provides a way to 61 * execute boot-mode commands and to reset the device. 62 * 63 * - RX handling: rx.c - receives data from the bus-specific code and 64 * feeds it to the network or WiMAX stack or uses it to modify 65 * the driver state. bus-specific driver only has to receive 66 * frames and pass them to this module. 67 * 68 * - TX handling: tx.c - manages the TX FIFO queue and provides means 69 * for the bus-specific TX code to pull data from the FIFO 70 * queue. bus-specific code just pulls frames from this module 71 * to sends them to the device. 72 * 73 * - netdev glue: netdev.c - interface with Linux networking 74 * stack. Pass around data frames, and configure when the 75 * device is up and running or shutdown (through ifconfig up / 76 * down). Bus-generic only. 77 * 78 * - control ops: control.c - implements various commmands for 79 * controlling the device. bus-generic only. 80 * 81 * - device model glue: driver.c - implements helpers for the 82 * device-model glue done by the bus-specific layer 83 * (setup/release the driver resources), turning the device on 84 * and off, handling the device reboots/resets and a few simple 85 * WiMAX stack ops. 86 * 87 * Code is also broken up in linux-glue / device-glue. 88 * 89 * Linux glue contains functions that deal mostly with gluing with the 90 * rest of the Linux kernel. 91 * 92 * Device-glue are functions that deal mostly with the way the device 93 * does things and talk the device's language. 94 * 95 * device-glue code is licensed BSD so other open source OSes can take 96 * it to implement their drivers. 97 * 98 * 99 * APIs AND HEADER FILES 100 * 101 * This bus generic code exports three APIs: 102 * 103 * - HDI (host-device interface) definitions common to all busses 104 * (include/linux/wimax/i2400m.h); these can be also used by user 105 * space code. 106 * - internal API for the bus-generic code 107 * - external API for the bus-specific drivers 108 * 109 * 110 * LIFE CYCLE: 111 * 112 * When the bus-specific driver probes, it allocates a network device 113 * with enough space for it's data structue, that must contain a 114 * &struct i2400m at the top. 115 * 116 * On probe, it needs to fill the i2400m members marked as [fill], as 117 * well as i2400m->wimax_dev.net_dev and call i2400m_setup(). The 118 * i2400m driver will only register with the WiMAX and network stacks; 119 * the only access done to the device is to read the MAC address so we 120 * can register a network device. 121 * 122 * The high-level call flow is: 123 * 124 * bus_probe() 125 * i2400m_setup() 126 * i2400m->bus_setup() 127 * boot rom initialization / read mac addr 128 * network / WiMAX stacks registration 129 * i2400m_dev_start() 130 * i2400m->bus_dev_start() 131 * i2400m_dev_initialize() 132 * 133 * The reverse applies for a disconnect() call: 134 * 135 * bus_disconnect() 136 * i2400m_release() 137 * i2400m_dev_stop() 138 * i2400m_dev_shutdown() 139 * i2400m->bus_dev_stop() 140 * network / WiMAX stack unregistration 141 * i2400m->bus_release() 142 * 143 * At this point, control and data communications are possible. 144 * 145 * While the device is up, it might reset. The bus-specific driver has 146 * to catch that situation and call i2400m_dev_reset_handle() to deal 147 * with it (reset the internal driver structures and go back to square 148 * one). 149 */ 150 151#ifndef __I2400M_H__ 152#define __I2400M_H__ 153 154#include <linux/usb.h> 155#include <linux/netdevice.h> 156#include <linux/completion.h> 157#include <linux/rwsem.h> 158#include <asm/atomic.h> 159#include <net/wimax.h> 160#include <linux/wimax/i2400m.h> 161#include <asm/byteorder.h> 162 163enum { 164/* netdev interface */ 165 /* 166 * Out of NWG spec (R1_v1.2.2), 3.3.3 ASN Bearer Plane MTU Size 167 * 168 * The MTU is 1400 or less 169 */ 170 I2400M_MAX_MTU = 1400, 171}; 172 173/* Misc constants */ 174enum { 175 /* Size of the Boot Mode Command buffer */ 176 I2400M_BM_CMD_BUF_SIZE = 16 * 1024, 177 I2400M_BM_ACK_BUF_SIZE = 256, 178}; 179 180enum { 181 /* Maximum number of bus reset can be retried */ 182 I2400M_BUS_RESET_RETRIES = 3, 183}; 184 185/** 186 * struct i2400m_poke_table - Hardware poke table for the Intel 2400m 187 * 188 * This structure will be used to create a device specific poke table 189 * to put the device in a consistant state at boot time. 190 * 191 * @address: The device address to poke 192 * 193 * @data: The data value to poke to the device address 194 * 195 */ 196struct i2400m_poke_table{ 197 __le32 address; 198 __le32 data; 199}; 200 201#define I2400M_FW_POKE(a, d) { \ 202 .address = cpu_to_le32(a), \ 203 .data = cpu_to_le32(d) \ 204} 205 206 207/** 208 * i2400m_reset_type - methods to reset a device 209 * 210 * @I2400M_RT_WARM: Reset without device disconnection, device handles 211 * are kept valid but state is back to power on, with firmware 212 * re-uploaded. 213 * @I2400M_RT_COLD: Tell the device to disconnect itself from the bus 214 * and reconnect. Renders all device handles invalid. 215 * @I2400M_RT_BUS: Tells the bus to reset the device; last measure 216 * used when both types above don't work. 217 */ 218enum i2400m_reset_type { 219 I2400M_RT_WARM, /* first measure */ 220 I2400M_RT_COLD, /* second measure */ 221 I2400M_RT_BUS, /* call in artillery */ 222}; 223 224struct i2400m_reset_ctx; 225struct i2400m_roq; 226struct i2400m_barker_db; 227 228/** 229 * struct i2400m - descriptor for an Intel 2400m 230 * 231 * Members marked with [fill] must be filled out/initialized before 232 * calling i2400m_setup(). 233 * 234 * Note the @bus_setup/@bus_release, @bus_dev_start/@bus_dev_release 235 * call pairs are very much doing almost the same, and depending on 236 * the underlying bus, some stuff has to be put in one or the 237 * other. The idea of setup/release is that they setup the minimal 238 * amount needed for loading firmware, where us dev_start/stop setup 239 * the rest needed to do full data/control traffic. 240 * 241 * @bus_tx_block_size: [fill] SDIO imposes a 256 block size, USB 16, 242 * so we have a tx_blk_size variable that the bus layer sets to 243 * tell the engine how much of that we need. 244 * 245 * @bus_tx_room_min: [fill] Minimum room required while allocating 246 * TX queue's buffer space for message header. SDIO requires 247 * 224 bytes and USB 16 bytes. Refer bus specific driver code 248 * for details. 249 * 250 * @bus_pl_size_max: [fill] Maximum payload size. 251 * 252 * @bus_setup: [optional fill] Function called by the bus-generic code 253 * [i2400m_setup()] to setup the basic bus-specific communications 254 * to the the device needed to load firmware. See LIFE CYCLE above. 255 * 256 * NOTE: Doesn't need to upload the firmware, as that is taken 257 * care of by the bus-generic code. 258 * 259 * @bus_release: [optional fill] Function called by the bus-generic 260 * code [i2400m_release()] to shutdown the basic bus-specific 261 * communications to the the device needed to load firmware. See 262 * LIFE CYCLE above. 263 * 264 * This function does not need to reset the device, just tear down 265 * all the host resources created to handle communication with 266 * the device. 267 * 268 * @bus_dev_start: [optional fill] Function called by the bus-generic 269 * code [i2400m_dev_start()] to do things needed to start the 270 * device. See LIFE CYCLE above. 271 * 272 * NOTE: Doesn't need to upload the firmware, as that is taken 273 * care of by the bus-generic code. 274 * 275 * @bus_dev_stop: [optional fill] Function called by the bus-generic 276 * code [i2400m_dev_stop()] to do things needed for stopping the 277 * device. See LIFE CYCLE above. 278 * 279 * This function does not need to reset the device, just tear down 280 * all the host resources created to handle communication with 281 * the device. 282 * 283 * @bus_tx_kick: [fill] Function called by the bus-generic code to let 284 * the bus-specific code know that there is data available in the 285 * TX FIFO for transmission to the device. 286 * 287 * This function cannot sleep. 288 * 289 * @bus_reset: [fill] Function called by the bus-generic code to reset 290 * the device in in various ways. Doesn't need to wait for the 291 * reset to finish. 292 * 293 * If warm or cold reset fail, this function is expected to do a 294 * bus-specific reset (eg: USB reset) to get the device to a 295 * working state (even if it implies device disconecction). 296 * 297 * Note the warm reset is used by the firmware uploader to 298 * reinitialize the device. 299 * 300 * IMPORTANT: this is called very early in the device setup 301 * process, so it cannot rely on common infrastructure being laid 302 * out. 303 * 304 * IMPORTANT: don't call reset on RT_BUS with i2400m->init_mutex 305 * held, as the .pre/.post reset handlers will deadlock. 306 * 307 * @bus_bm_retries: [fill] How many times shall a firmware upload / 308 * device initialization be retried? Different models of the same 309 * device might need different values, hence it is set by the 310 * bus-specific driver. Note this value is used in two places, 311 * i2400m_fw_dnload() and __i2400m_dev_start(); they won't become 312 * multiplicative (__i2400m_dev_start() calling N times 313 * i2400m_fw_dnload() and this trying N times to download the 314 * firmware), as if __i2400m_dev_start() only retries if the 315 * firmware crashed while initializing the device (not in a 316 * general case). 317 * 318 * @bus_bm_cmd_send: [fill] Function called to send a boot-mode 319 * command. Flags are defined in 'enum i2400m_bm_cmd_flags'. This 320 * is synchronous and has to return 0 if ok or < 0 errno code in 321 * any error condition. 322 * 323 * @bus_bm_wait_for_ack: [fill] Function called to wait for a 324 * boot-mode notification (that can be a response to a previously 325 * issued command or an asynchronous one). Will read until all the 326 * indicated size is read or timeout. Reading more or less data 327 * than asked for is an error condition. Return 0 if ok, < 0 errno 328 * code on error. 329 * 330 * The caller to this function will check if the response is a 331 * barker that indicates the device going into reset mode. 332 * 333 * @bus_fw_names: [fill] a NULL-terminated array with the names of the 334 * firmware images to try loading. This is made a list so we can 335 * support backward compatibility of firmware releases (eg: if we 336 * can't find the default v1.4, we try v1.3). In general, the name 337 * should be i2400m-fw-X-VERSION.sbcf, where X is the bus name. 338 * The list is tried in order and the first one that loads is 339 * used. The fw loader will set i2400m->fw_name to point to the 340 * active firmware image. 341 * 342 * @bus_bm_mac_addr_impaired: [fill] Set to true if the device's MAC 343 * address provided in boot mode is kind of broken and needs to 344 * be re-read later on. 345 * 346 * @bus_bm_pokes_table: [fill/optional] A table of device addresses 347 * and values that will be poked at device init time to move the 348 * device to the correct state for the type of boot/firmware being 349 * used. This table MUST be terminated with (0x000000, 350 * 0x00000000) or bad things will happen. 351 * 352 * 353 * @wimax_dev: WiMAX generic device for linkage into the kernel WiMAX 354 * stack. Due to the way a net_device is allocated, we need to 355 * force this to be the first field so that we can get from 356 * netdev_priv() the right pointer. 357 * 358 * @updown: the device is up and ready for transmitting control and 359 * data packets. This implies @ready (communication infrastructure 360 * with the device is ready) and the device's firmware has been 361 * loaded and the device initialized. 362 * 363 * Write to it only inside a i2400m->init_mutex protected area 364 * followed with a wmb(); rmb() before accesing (unless locked 365 * inside i2400m->init_mutex). Read access can be loose like that 366 * [just using rmb()] because the paths that use this also do 367 * other error checks later on. 368 * 369 * @ready: Communication infrastructure with the device is ready, data 370 * frames can start to be passed around (this is lighter than 371 * using the WiMAX state for certain hot paths). 372 * 373 * Write to it only inside a i2400m->init_mutex protected area 374 * followed with a wmb(); rmb() before accesing (unless locked 375 * inside i2400m->init_mutex). Read access can be loose like that 376 * [just using rmb()] because the paths that use this also do 377 * other error checks later on. 378 * 379 * @rx_reorder: 1 if RX reordering is enabled; this can only be 380 * set at probe time. 381 * 382 * @state: device's state (as reported by it) 383 * 384 * @state_wq: waitqueue that is woken up whenever the state changes 385 * 386 * @tx_lock: spinlock to protect TX members 387 * 388 * @tx_buf: FIFO buffer for TX; we queue data here 389 * 390 * @tx_in: FIFO index for incoming data. Note this doesn't wrap around 391 * and it is always greater than @tx_out. 392 * 393 * @tx_out: FIFO index for outgoing data 394 * 395 * @tx_msg: current TX message that is active in the FIFO for 396 * appending payloads. 397 * 398 * @tx_sequence: current sequence number for TX messages from the 399 * device to the host. 400 * 401 * @tx_msg_size: size of the current message being transmitted by the 402 * bus-specific code. 403 * 404 * @tx_pl_num: total number of payloads sent 405 * 406 * @tx_pl_max: maximum number of payloads sent in a TX message 407 * 408 * @tx_pl_min: minimum number of payloads sent in a TX message 409 * 410 * @tx_num: number of TX messages sent 411 * 412 * @tx_size_acc: number of bytes in all TX messages sent 413 * (this is different to net_dev's statistics as it also counts 414 * control messages). 415 * 416 * @tx_size_min: smallest TX message sent. 417 * 418 * @tx_size_max: biggest TX message sent. 419 * 420 * @rx_lock: spinlock to protect RX members and rx_roq_refcount. 421 * 422 * @rx_pl_num: total number of payloads received 423 * 424 * @rx_pl_max: maximum number of payloads received in a RX message 425 * 426 * @rx_pl_min: minimum number of payloads received in a RX message 427 * 428 * @rx_num: number of RX messages received 429 * 430 * @rx_size_acc: number of bytes in all RX messages received 431 * (this is different to net_dev's statistics as it also counts 432 * control messages). 433 * 434 * @rx_size_min: smallest RX message received. 435 * 436 * @rx_size_max: buggest RX message received. 437 * 438 * @rx_roq: RX ReOrder queues. (fw >= v1.4) When packets are received 439 * out of order, the device will ask the driver to hold certain 440 * packets until the ones that are received out of order can be 441 * delivered. Then the driver can release them to the host. See 442 * drivers/net/i2400m/rx.c for details. 443 * 444 * @rx_roq_refcount: refcount rx_roq. This refcounts any access to 445 * rx_roq thus preventing rx_roq being destroyed when rx_roq 446 * is being accessed. rx_roq_refcount is protected by rx_lock. 447 * 448 * @rx_reports: reports received from the device that couldn't be 449 * processed because the driver wasn't still ready; when ready, 450 * they are pulled from here and chewed. 451 * 452 * @rx_reports_ws: Work struct used to kick a scan of the RX reports 453 * list and to process each. 454 * 455 * @src_mac_addr: MAC address used to make ethernet packets be coming 456 * from. This is generated at i2400m_setup() time and used during 457 * the life cycle of the instance. See i2400m_fake_eth_header(). 458 * 459 * @init_mutex: Mutex used for serializing the device bringup 460 * sequence; this way if the device reboots in the middle, we 461 * don't try to do a bringup again while we are tearing down the 462 * one that failed. 463 * 464 * Can't reuse @msg_mutex because from within the bringup sequence 465 * we need to send messages to the device and thus use @msg_mutex. 466 * 467 * @msg_mutex: mutex used to send control commands to the device (we 468 * only allow one at a time, per host-device interface design). 469 * 470 * @msg_completion: used to wait for an ack to a control command sent 471 * to the device. 472 * 473 * @ack_skb: used to store the actual ack to a control command if the 474 * reception of the command was successful. Otherwise, a ERR_PTR() 475 * errno code that indicates what failed with the ack reception. 476 * 477 * Only valid after @msg_completion is woken up. Only updateable 478 * if @msg_completion is armed. Only touched by 479 * i2400m_msg_to_dev(). 480 * 481 * Protected by @rx_lock. In theory the command execution flow is 482 * sequential, but in case the device sends an out-of-phase or 483 * very delayed response, we need to avoid it trampling current 484 * execution. 485 * 486 * @bm_cmd_buf: boot mode command buffer for composing firmware upload 487 * commands. 488 * 489 * USB can't r/w to stack, vmalloc, etc...as well, we end up 490 * having to alloc/free a lot to compose commands, so we use these 491 * for stagging and not having to realloc all the time. 492 * 493 * This assumes the code always runs serialized. Only one thread 494 * can call i2400m_bm_cmd() at the same time. 495 * 496 * @bm_ack_buf: boot mode acknoledge buffer for staging reception of 497 * responses to commands. 498 * 499 * See @bm_cmd_buf. 500 * 501 * @work_queue: work queue for processing device reports. This 502 * workqueue cannot be used for processing TX or RX to the device, 503 * as from it we'll process device reports, which might require 504 * further communication with the device. 505 * 506 * @debugfs_dentry: hookup for debugfs files. 507 * These have to be in a separate directory, a child of 508 * (wimax_dev->debugfs_dentry) so they can be removed when the 509 * module unloads, as we don't keep each dentry. 510 * 511 * @fw_name: name of the firmware image that is currently being used. 512 * 513 * @fw_version: version of the firmware interface, Major.minor, 514 * encoded in the high word and low word (major << 16 | minor). 515 * 516 * @fw_hdrs: NULL terminated array of pointers to the firmware 517 * headers. This is only available during firmware load time. 518 * 519 * @fw_cached: Used to cache firmware when the system goes to 520 * suspend/standby/hibernation (as on resume we can't read it). If 521 * NULL, no firmware was cached, read it. If ~0, you can't read 522 * any firmware files (the system still didn't come out of suspend 523 * and failed to cache one), so abort; otherwise, a valid cached 524 * firmware to be used. Access to this variable is protected by 525 * the spinlock i2400m->rx_lock. 526 * 527 * @barker: barker type that the device uses; this is initialized by 528 * i2400m_is_boot_barker() the first time it is called. Then it 529 * won't change during the life cycle of the device and everytime 530 * a boot barker is received, it is just verified for it being the 531 * same. 532 * 533 * @pm_notifier: used to register for PM events 534 * 535 * @bus_reset_retries: counter for the number of bus resets attempted for 536 * this boot. It's not for tracking the number of bus resets during 537 * the whole driver life cycle (from insmod to rmmod) but for the 538 * number of dev_start() executed until dev_start() returns a success 539 * (ie: a good boot means a dev_stop() followed by a successful 540 * dev_start()). dev_reset_handler() increments this counter whenever 541 * it is triggering a bus reset. It checks this counter to decide if a 542 * subsequent bus reset should be retried. dev_reset_handler() retries 543 * the bus reset until dev_start() succeeds or the counter reaches 544 * I2400M_BUS_RESET_RETRIES. The counter is cleared to 0 in 545 * dev_reset_handle() when dev_start() returns a success, 546 * ie: a successul boot is completed. 547 * 548 * @alive: flag to denote if the device *should* be alive. This flag is 549 * everything like @updown (see doc for @updown) except reflecting 550 * the device state *we expect* rather than the actual state as denoted 551 * by @updown. It is set 1 whenever @updown is set 1 in dev_start(). 552 * Then the device is expected to be alive all the time 553 * (i2400m->alive remains 1) until the driver is removed. Therefore 554 * all the device reboot events detected can be still handled properly 555 * by either dev_reset_handle() or .pre_reset/.post_reset as long as 556 * the driver presents. It is set 0 along with @updown in dev_stop(). 557 * 558 * @error_recovery: flag to denote if we are ready to take an error recovery. 559 * 0 for ready to take an error recovery; 1 for not ready. It is 560 * initialized to 1 while probe() since we don't tend to take any error 561 * recovery during probe(). It is decremented by 1 whenever dev_start() 562 * succeeds to indicate we are ready to take error recovery from now on. 563 * It is checked every time we wanna schedule an error recovery. If an 564 * error recovery is already in place (error_recovery was set 1), we 565 * should not schedule another one until the last one is done. 566 */ 567struct i2400m { 568 struct wimax_dev wimax_dev; /* FIRST! See doc */ 569 570 unsigned updown:1; /* Network device is up or down */ 571 unsigned boot_mode:1; /* is the device in boot mode? */ 572 unsigned sboot:1; /* signed or unsigned fw boot */ 573 unsigned ready:1; /* Device comm infrastructure ready */ 574 unsigned rx_reorder:1; /* RX reorder is enabled */ 575 u8 trace_msg_from_user; /* echo rx msgs to 'trace' pipe */ 576 /* typed u8 so /sys/kernel/debug/u8 can tweak */ 577 enum i2400m_system_state state; 578 wait_queue_head_t state_wq; /* Woken up when on state updates */ 579 580 size_t bus_tx_block_size; 581 size_t bus_tx_room_min; 582 size_t bus_pl_size_max; 583 unsigned bus_bm_retries; 584 585 int (*bus_setup)(struct i2400m *); 586 int (*bus_dev_start)(struct i2400m *); 587 void (*bus_dev_stop)(struct i2400m *); 588 void (*bus_release)(struct i2400m *); 589 void (*bus_tx_kick)(struct i2400m *); 590 int (*bus_reset)(struct i2400m *, enum i2400m_reset_type); 591 ssize_t (*bus_bm_cmd_send)(struct i2400m *, 592 const struct i2400m_bootrom_header *, 593 size_t, int flags); 594 ssize_t (*bus_bm_wait_for_ack)(struct i2400m *, 595 struct i2400m_bootrom_header *, size_t); 596 const char **bus_fw_names; 597 unsigned bus_bm_mac_addr_impaired:1; 598 const struct i2400m_poke_table *bus_bm_pokes_table; 599 600 spinlock_t tx_lock; /* protect TX state */ 601 void *tx_buf; 602 size_t tx_in, tx_out; 603 struct i2400m_msg_hdr *tx_msg; 604 size_t tx_sequence, tx_msg_size; 605 /* TX stats */ 606 unsigned tx_pl_num, tx_pl_max, tx_pl_min, 607 tx_num, tx_size_acc, tx_size_min, tx_size_max; 608 609 /* RX stuff */ 610 /* protect RX state and rx_roq_refcount */ 611 spinlock_t rx_lock; 612 unsigned rx_pl_num, rx_pl_max, rx_pl_min, 613 rx_num, rx_size_acc, rx_size_min, rx_size_max; 614 struct i2400m_roq *rx_roq; /* access is refcounted */ 615 struct kref rx_roq_refcount; /* refcount access to rx_roq */ 616 u8 src_mac_addr[ETH_HLEN]; 617 struct list_head rx_reports; /* under rx_lock! */ 618 struct work_struct rx_report_ws; 619 620 struct mutex msg_mutex; /* serialize command execution */ 621 struct completion msg_completion; 622 struct sk_buff *ack_skb; /* protected by rx_lock */ 623 624 void *bm_ack_buf; /* for receiving acks over USB */ 625 void *bm_cmd_buf; /* for issuing commands over USB */ 626 627 struct workqueue_struct *work_queue; 628 629 struct mutex init_mutex; /* protect bringup seq */ 630 struct i2400m_reset_ctx *reset_ctx; /* protected by init_mutex */ 631 632 struct work_struct wake_tx_ws; 633 struct sk_buff *wake_tx_skb; 634 635 struct dentry *debugfs_dentry; 636 const char *fw_name; /* name of the current firmware image */ 637 unsigned long fw_version; /* version of the firmware interface */ 638 const struct i2400m_bcf_hdr **fw_hdrs; 639 struct i2400m_fw *fw_cached; /* protected by rx_lock */ 640 struct i2400m_barker_db *barker; 641 642 struct notifier_block pm_notifier; 643 644 /* counting bus reset retries in this boot */ 645 atomic_t bus_reset_retries; 646 647 /* if the device is expected to be alive */ 648 unsigned alive; 649 650 /* 0 if we are ready for error recovery; 1 if not ready */ 651 atomic_t error_recovery; 652 653}; 654 655 656/* 657 * Bus-generic internal APIs 658 * ------------------------- 659 */ 660 661static inline 662struct i2400m *wimax_dev_to_i2400m(struct wimax_dev *wimax_dev) 663{ 664 return container_of(wimax_dev, struct i2400m, wimax_dev); 665} 666 667static inline 668struct i2400m *net_dev_to_i2400m(struct net_device *net_dev) 669{ 670 return wimax_dev_to_i2400m(netdev_priv(net_dev)); 671} 672 673/* 674 * Boot mode support 675 */ 676 677/** 678 * i2400m_bm_cmd_flags - flags to i2400m_bm_cmd() 679 * 680 * @I2400M_BM_CMD_RAW: send the command block as-is, without doing any 681 * extra processing for adding CRC. 682 */ 683enum i2400m_bm_cmd_flags { 684 I2400M_BM_CMD_RAW = 1 << 2, 685}; 686 687/** 688 * i2400m_bri - Boot-ROM indicators 689 * 690 * Flags for i2400m_bootrom_init() and i2400m_dev_bootstrap() [which 691 * are passed from things like i2400m_setup()]. Can be combined with 692 * |. 693 * 694 * @I2400M_BRI_SOFT: The device rebooted already and a reboot 695 * barker received, proceed directly to ack the boot sequence. 696 * @I2400M_BRI_NO_REBOOT: Do not reboot the device and proceed 697 * directly to wait for a reboot barker from the device. 698 * @I2400M_BRI_MAC_REINIT: We need to reinitialize the boot 699 * rom after reading the MAC address. This is quite a dirty hack, 700 * if you ask me -- the device requires the bootrom to be 701 * intialized after reading the MAC address. 702 */ 703enum i2400m_bri { 704 I2400M_BRI_SOFT = 1 << 1, 705 I2400M_BRI_NO_REBOOT = 1 << 2, 706 I2400M_BRI_MAC_REINIT = 1 << 3, 707}; 708 709extern void i2400m_bm_cmd_prepare(struct i2400m_bootrom_header *); 710extern int i2400m_dev_bootstrap(struct i2400m *, enum i2400m_bri); 711extern int i2400m_read_mac_addr(struct i2400m *); 712extern int i2400m_bootrom_init(struct i2400m *, enum i2400m_bri); 713extern int i2400m_is_boot_barker(struct i2400m *, const void *, size_t); 714static inline 715int i2400m_is_d2h_barker(const void *buf) 716{ 717 const __le32 *barker = buf; 718 return le32_to_cpu(*barker) == I2400M_D2H_MSG_BARKER; 719} 720extern void i2400m_unknown_barker(struct i2400m *, const void *, size_t); 721 722/* Make/grok boot-rom header commands */ 723 724static inline 725__le32 i2400m_brh_command(enum i2400m_brh_opcode opcode, unsigned use_checksum, 726 unsigned direct_access) 727{ 728 return cpu_to_le32( 729 I2400M_BRH_SIGNATURE 730 | (direct_access ? I2400M_BRH_DIRECT_ACCESS : 0) 731 | I2400M_BRH_RESPONSE_REQUIRED /* response always required */ 732 | (use_checksum ? I2400M_BRH_USE_CHECKSUM : 0) 733 | (opcode & I2400M_BRH_OPCODE_MASK)); 734} 735 736static inline 737void i2400m_brh_set_opcode(struct i2400m_bootrom_header *hdr, 738 enum i2400m_brh_opcode opcode) 739{ 740 hdr->command = cpu_to_le32( 741 (le32_to_cpu(hdr->command) & ~I2400M_BRH_OPCODE_MASK) 742 | (opcode & I2400M_BRH_OPCODE_MASK)); 743} 744 745static inline 746unsigned i2400m_brh_get_opcode(const struct i2400m_bootrom_header *hdr) 747{ 748 return le32_to_cpu(hdr->command) & I2400M_BRH_OPCODE_MASK; 749} 750 751static inline 752unsigned i2400m_brh_get_response(const struct i2400m_bootrom_header *hdr) 753{ 754 return (le32_to_cpu(hdr->command) & I2400M_BRH_RESPONSE_MASK) 755 >> I2400M_BRH_RESPONSE_SHIFT; 756} 757 758static inline 759unsigned i2400m_brh_get_use_checksum(const struct i2400m_bootrom_header *hdr) 760{ 761 return le32_to_cpu(hdr->command) & I2400M_BRH_USE_CHECKSUM; 762} 763 764static inline 765unsigned i2400m_brh_get_response_required( 766 const struct i2400m_bootrom_header *hdr) 767{ 768 return le32_to_cpu(hdr->command) & I2400M_BRH_RESPONSE_REQUIRED; 769} 770 771static inline 772unsigned i2400m_brh_get_direct_access(const struct i2400m_bootrom_header *hdr) 773{ 774 return le32_to_cpu(hdr->command) & I2400M_BRH_DIRECT_ACCESS; 775} 776 777static inline 778unsigned i2400m_brh_get_signature(const struct i2400m_bootrom_header *hdr) 779{ 780 return (le32_to_cpu(hdr->command) & I2400M_BRH_SIGNATURE_MASK) 781 >> I2400M_BRH_SIGNATURE_SHIFT; 782} 783 784 785/* 786 * Driver / device setup and internal functions 787 */ 788extern void i2400m_init(struct i2400m *); 789extern int i2400m_reset(struct i2400m *, enum i2400m_reset_type); 790extern void i2400m_netdev_setup(struct net_device *net_dev); 791extern int i2400m_sysfs_setup(struct device_driver *); 792extern void i2400m_sysfs_release(struct device_driver *); 793extern int i2400m_tx_setup(struct i2400m *); 794extern void i2400m_wake_tx_work(struct work_struct *); 795extern void i2400m_tx_release(struct i2400m *); 796 797extern int i2400m_rx_setup(struct i2400m *); 798extern void i2400m_rx_release(struct i2400m *); 799 800extern void i2400m_fw_cache(struct i2400m *); 801extern void i2400m_fw_uncache(struct i2400m *); 802 803extern void i2400m_net_rx(struct i2400m *, struct sk_buff *, unsigned, 804 const void *, int); 805extern void i2400m_net_erx(struct i2400m *, struct sk_buff *, 806 enum i2400m_cs); 807extern void i2400m_net_wake_stop(struct i2400m *); 808enum i2400m_pt; 809extern int i2400m_tx(struct i2400m *, const void *, size_t, enum i2400m_pt); 810 811#ifdef CONFIG_DEBUG_FS 812extern int i2400m_debugfs_add(struct i2400m *); 813extern void i2400m_debugfs_rm(struct i2400m *); 814#else 815static inline int i2400m_debugfs_add(struct i2400m *i2400m) 816{ 817 return 0; 818} 819static inline void i2400m_debugfs_rm(struct i2400m *i2400m) {} 820#endif 821 822/* Initialize/shutdown the device */ 823extern int i2400m_dev_initialize(struct i2400m *); 824extern void i2400m_dev_shutdown(struct i2400m *); 825 826extern struct attribute_group i2400m_dev_attr_group; 827 828 829/* HDI message's payload description handling */ 830 831static inline 832size_t i2400m_pld_size(const struct i2400m_pld *pld) 833{ 834 return I2400M_PLD_SIZE_MASK & le32_to_cpu(pld->val); 835} 836 837static inline 838enum i2400m_pt i2400m_pld_type(const struct i2400m_pld *pld) 839{ 840 return (I2400M_PLD_TYPE_MASK & le32_to_cpu(pld->val)) 841 >> I2400M_PLD_TYPE_SHIFT; 842} 843 844static inline 845void i2400m_pld_set(struct i2400m_pld *pld, size_t size, 846 enum i2400m_pt type) 847{ 848 pld->val = cpu_to_le32( 849 ((type << I2400M_PLD_TYPE_SHIFT) & I2400M_PLD_TYPE_MASK) 850 | (size & I2400M_PLD_SIZE_MASK)); 851} 852 853 854/* 855 * API for the bus-specific drivers 856 * -------------------------------- 857 */ 858 859static inline 860struct i2400m *i2400m_get(struct i2400m *i2400m) 861{ 862 dev_hold(i2400m->wimax_dev.net_dev); 863 return i2400m; 864} 865 866static inline 867void i2400m_put(struct i2400m *i2400m) 868{ 869 dev_put(i2400m->wimax_dev.net_dev); 870} 871 872extern int i2400m_dev_reset_handle(struct i2400m *, const char *); 873extern int i2400m_pre_reset(struct i2400m *); 874extern int i2400m_post_reset(struct i2400m *); 875extern void i2400m_error_recovery(struct i2400m *); 876 877/* 878 * _setup()/_release() are called by the probe/disconnect functions of 879 * the bus-specific drivers. 880 */ 881extern int i2400m_setup(struct i2400m *, enum i2400m_bri bm_flags); 882extern void i2400m_release(struct i2400m *); 883 884extern int i2400m_rx(struct i2400m *, struct sk_buff *); 885extern struct i2400m_msg_hdr *i2400m_tx_msg_get(struct i2400m *, size_t *); 886extern void i2400m_tx_msg_sent(struct i2400m *); 887 888 889/* 890 * Utility functions 891 */ 892 893static inline 894struct device *i2400m_dev(struct i2400m *i2400m) 895{ 896 return i2400m->wimax_dev.net_dev->dev.parent; 897} 898 899/* 900 * Helper for scheduling simple work functions 901 * 902 * This struct can get any kind of payload attached (normally in the 903 * form of a struct where you pack the stuff you want to pass to the 904 * _work function). 905 */ 906struct i2400m_work { 907 struct work_struct ws; 908 struct i2400m *i2400m; 909 size_t pl_size; 910 u8 pl[0]; 911}; 912 913extern int i2400m_schedule_work(struct i2400m *, 914 void (*)(struct work_struct *), gfp_t, 915 const void *, size_t); 916 917extern int i2400m_msg_check_status(const struct i2400m_l3l4_hdr *, 918 char *, size_t); 919extern int i2400m_msg_size_check(struct i2400m *, 920 const struct i2400m_l3l4_hdr *, size_t); 921extern struct sk_buff *i2400m_msg_to_dev(struct i2400m *, const void *, size_t); 922extern void i2400m_msg_to_dev_cancel_wait(struct i2400m *, int); 923extern void i2400m_msg_ack_hook(struct i2400m *, 924 const struct i2400m_l3l4_hdr *, size_t); 925extern void i2400m_report_hook(struct i2400m *, 926 const struct i2400m_l3l4_hdr *, size_t); 927extern void i2400m_report_hook_work(struct work_struct *); 928extern int i2400m_cmd_enter_powersave(struct i2400m *); 929extern int i2400m_cmd_get_state(struct i2400m *); 930extern int i2400m_cmd_exit_idle(struct i2400m *); 931extern struct sk_buff *i2400m_get_device_info(struct i2400m *); 932extern int i2400m_firmware_check(struct i2400m *); 933extern int i2400m_set_init_config(struct i2400m *, 934 const struct i2400m_tlv_hdr **, size_t); 935extern int i2400m_set_idle_timeout(struct i2400m *, unsigned); 936 937static inline 938struct usb_endpoint_descriptor *usb_get_epd(struct usb_interface *iface, int ep) 939{ 940 return &iface->cur_altsetting->endpoint[ep].desc; 941} 942 943extern int i2400m_op_rfkill_sw_toggle(struct wimax_dev *, 944 enum wimax_rf_state); 945extern void i2400m_report_tlv_rf_switches_status( 946 struct i2400m *, const struct i2400m_tlv_rf_switches_status *); 947 948/* 949 * Helpers for firmware backwards compability 950 * 951 * As we aim to support at least the firmware version that was 952 * released with the previous kernel/driver release, some code will be 953 * conditionally executed depending on the firmware version. On each 954 * release, the code to support fw releases past the last two ones 955 * will be purged. 956 * 957 * By making it depend on this macros, it is easier to keep it a tab 958 * on what has to go and what not. 959 */ 960static inline 961unsigned i2400m_le_v1_3(struct i2400m *i2400m) 962{ 963 /* running fw is lower or v1.3 */ 964 return i2400m->fw_version <= 0x00090001; 965} 966 967static inline 968unsigned i2400m_ge_v1_4(struct i2400m *i2400m) 969{ 970 /* running fw is higher or v1.4 */ 971 return i2400m->fw_version >= 0x00090002; 972} 973 974 975/* 976 * Do a millisecond-sleep for allowing wireshark to dump all the data 977 * packets. Used only for debugging. 978 */ 979static inline 980void __i2400m_msleep(unsigned ms) 981{ 982} 983 984 985/* module initialization helpers */ 986extern int i2400m_barker_db_init(const char *); 987extern void i2400m_barker_db_exit(void); 988 989 990 991#endif /* #ifndef __I2400M_H__ */ 992