|
Linux Kernel
3.7.1
|
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
|
Linux Kernel
3.7.1
|
Go to the source code of this file.
Data Structures | |
| struct | wimax_dev |
Functions | |
: [fill] A way to identify this device. We need to register a | |
struct wimax_dev - Generic WiMAX device : [fill] Pointer to the &struct net_device this WiMAX device implements. : [fill] Driver-specific operation to handle a raw message from user space to the driver. The driver can send messages to user space using with wimax_msg_to_user(). : [fill] Driver-specific operation to act on userspace (or any other agent) requesting the WiMAX device to change the RF Kill software switch (WIMAX_RF_ON or WIMAX_RF_OFF). If such hardware support is not present, it is assumed the radio cannot be switched off and it is always on (and the stack will error out when trying to switch it off). In such case, this function pointer can be left as NULL. : [fill] Driver specific operation to reset the device. This operation should always attempt first a warm reset that does not disconnect the device from the bus and return 0. If that fails, it should resort to some sort of cold or bus reset (even if it implies a bus disconnection and device disappearance). In that case, -ENODEV should be returned to indicate the device is gone. This operation has to be synchronous, and return only when the reset is complete. In case of having had to resort to bus/cold reset implying a device disconnection, the call is allowed to return inmediately. NOTE: wimax_dev->mutex is NOT locked when this op is being called; however, wimax_dev->mutex_reset IS locked to ensure serialization of calls to wimax_reset(). See wimax_reset()'s documentation. name with many subsystems (rfkill, workqueue creation, etc). We can't use the network device name as that might change and in some instances we don't know it yet (until we don't call register_netdev()). So we generate an unique one using the driver name and device bus id, place it here and use it across the board. Recommended naming: DRIVERNAME-BUSNAME:BUSID (dev->bus->name, dev->bus_id). : [private] link to the list of wimax devices kept by id-table.c. Protected by it's own spinlock. : [private] Serializes all concurrent access and execution of operations. : [private] Serializes reset operations. Needs to be a different mutex because as part of the reset operation, the driver has to call back into the stack to do things such as state change, that require wimax_dev->mutex. : [private] Current state of the WiMAX device. : [private] integration into the RF-Kill infrastructure. : [private] State of the software radio switch (OFF/ON) : [private] State of the hardware radio switch (OFF/ON) : [private] Used to hook up a debugfs entry. This shows up in the debugfs root as wimax\:DEVICENAME. Description: This structure defines a common interface to access all WiMAX devices from different vendors and provides a common API as well as a free-form device-specific messaging channel. Usage:
When the device is initialized (at a. Move the device to WIMAX_ST_UNINITIALIZED. This is needed so some API calls that shouldn't work until the device is ready can be blocked. b. Initialize the device. Make sure to turn the SW radio switch off and move the device to state WIMAX_ST_RADIO_OFF when done. When just initialized, a device should be left in RADIO OFF state until user space devices to turn it on. c. Query the device for the state of the hardware rfkill switch and call wimax_rfkill_report_hw() and wimax_rfkill_report_sw() as needed. See below. wimax_dev_rm() undoes before unregistering the network device. Once wimax_dev_add() is called, the driver can get called on the wimax_dev->op_* function pointers CONCURRENCY: The stack provides a mutex for each device that will disallow API calls happening concurrently; thus, op calls into the driver through the wimax_dev->op*() function pointers will always be serialized and never concurrent. For locking, take wimax_dev->mutex is taken; (most) operations in the API have to check for wimax_dev_is_ready() to return 0 before continuing (this is done internally). REFERENCE COUNTING: The WiMAX device is reference counted by the associated network device. The only operation that can be used to reference the device is wimax_dev_get_by_genl_info(), and the reference it acquires has to be released with dev_put(wimax_dev->net_dev). RFKILL: At startup, both HW and SW radio switchess are assumed to be off. At initialization time [after calling wimax_dev_add()], have the driver query the device for the status of the software and hardware RF kill switches and call wimax_report_rfkill_hw() and wimax_rfkill_report_sw() to indicate their state. If any is missing, just call it to indicate it is ON (radio always on). Whenever the driver detects a change in the state of the RF kill switches, it should call wimax_report_rfkill_hw() or wimax_report_rfkill_sw() to report it to the stack. | |
| void | wimax_dev_init (struct wimax_dev *) |
| int | wimax_dev_add (struct wimax_dev *, struct net_device *) |
| void | wimax_dev_rm (struct wimax_dev *) |
| void | wimax_state_change (struct wimax_dev *, enum wimax_st) |
| enum wimax_st | wimax_state_get (struct wimax_dev *) |
| void | wimax_report_rfkill_hw (struct wimax_dev *, enum wimax_rf_state) |
| void | wimax_report_rfkill_sw (struct wimax_dev *, enum wimax_rf_state) |
| struct sk_buff * | wimax_msg_alloc (struct wimax_dev *, const char *, const void *, size_t, gfp_t) |
| int | wimax_msg_send (struct wimax_dev *, struct sk_buff *) |
| int | wimax_msg (struct wimax_dev *, const char *, const void *, size_t, gfp_t) |
| const void * | wimax_msg_data_len (struct sk_buff *, size_t *) |
| const void * | wimax_msg_data (struct sk_buff *) |
| ssize_t | wimax_msg_len (struct sk_buff *) |
| int | wimax_rfkill (struct wimax_dev *, enum wimax_rf_state) |
| int | wimax_reset (struct wimax_dev *) |
| int wimax_dev_add | ( | struct wimax_dev * | wimax_dev, |
| struct net_device * | net_dev | ||
| ) |
wimax_dev_add - Register a new WiMAX device
: WiMAX device descriptor (as embedded in your 's priv data). You must have called wimax_dev_init() on it before.
: net device the is associated with. The function expects SET_NETDEV_DEV() and register_netdev() were already called on it.
Registers the new WiMAX device, sets up the user-kernel control interface (generic netlink) and common WiMAX infrastructure.
Note that the parts that will allow interaction with user space are setup at the very end, when the rest is in place, as once that happens, the driver might get user space control requests via netlink or from debugfs that might translate into calls into wimax_dev->op_*().
wimax_dev_rm - Unregister an existing WiMAX device
: WiMAX device descriptor
Unregisters a WiMAX device previously registered for use with wimax_add_rm().
IMPORTANT! Must call before calling unregister_netdev().
After this function returns, you will not get any more user space control requests (via netlink or debugfs) and thus to wimax_dev->ops.
Reentrancy control is ensured by setting the state to __WIMAX_ST_QUIESCING. rfkill operations coming through wimax_*rfkill*() will be stopped by the quiescing state; ops coming from the rfkill subsystem will be stopped by the support being removed by wimax_rfkill_rm().
| int wimax_msg | ( | struct wimax_dev * | wimax_dev, |
| const char * | pipe_name, | ||
| const void * | buf, | ||
| size_t | size, | ||
| gfp_t | gfp_flags | ||
| ) |
wimax_msg - Send a message to user space
: WiMAX device descriptor (properly referenced) : "named pipe" the message will be sent to : pointer to the message to send. : size of the buffer pointed to by (in bytes). : flags for memory allocation.
Returns: %0 if ok, negative errno code on error.
Description:
Sends a free-form message to user space on the device .
NOTES:
Once the is given to this function, who will own it and will release it when done (unless it returns error).
|
read |
wimax_msg_alloc - Create a new skb for sending a message to userspace
: WiMAX device descriptor : "named pipe" the message will be sent to : pointer to the message data to send : size of the message to send (in bytes), including the header. : flags for memory allocation.
Returns: %0 if ok, negative errno code on error
Description:
Allocates an skb that will contain the message to send to user space over the messaging pipe and initializes it, copying the payload.
Once this call is done, you can deliver it with wimax_msg_send().
IMPORTANT:
Don't use skb_push()/skb_pull()/skb_reserve() on the skb, as wimax_msg_send() depends on skb->data being placed at the beginning of the user message.
Unlike other WiMAX stack calls, this call can be used way early, even before wimax_dev_add() is called, as long as the wimax_dev->net_dev pointer is set to point to a proper net_dev. This is so that drivers can use it early in case they need to send stuff around or communicate with user space.
wimax_msg_data - Return a pointer to a message's payload
: Pointer to a message created with wimax_msg_alloc()
wimax_msg_len - Return a message's payload length
: Pointer to a message created with wimax_msg_alloc()
wimax_msg_send - Send a pre-allocated message to user space
: WiMAX device descriptor
: &struct sk_buff returned by wimax_msg_alloc(). Note the ownership of is transferred to this function.
Returns: 0 if ok, < 0 errno code on error
Description:
Sends a free-form message that was preallocated with wimax_msg_alloc() and filled up.
Assumes that once you pass an skb to this function for sending, it owns it and will release it when done (on success).
IMPORTANT:
Don't use skb_push()/skb_pull()/skb_reserve() on the skb, as wimax_msg_send() depends on skb->data being placed at the beginning of the user message.
Unlike other WiMAX stack calls, this call can be used way early, even before wimax_dev_add() is called, as long as the wimax_dev->net_dev pointer is set to point to a proper net_dev. This is so that drivers can use it early in case they need to send stuff around or communicate with user space.
| void wimax_report_rfkill_hw | ( | struct wimax_dev * | wimax_dev, |
| enum wimax_rf_state | state | ||
| ) |
wimax_report_rfkill_hw - Reports changes in the hardware RF switch
: WiMAX device descriptor
: New state of the RF Kill switch. WIMAX_RF_ON radio on, WIMAX_RF_OFF radio off.
When the device detects a change in the state of thehardware RF switch, it must call this function to let the WiMAX kernel stack know that the state has changed so it can be properly propagated.
The WiMAX stack caches the state (the driver doesn't need to). As well, as the change is propagated it will come back as a request to change the software state to mirror the hardware state.
If the device doesn't have a hardware kill switch, just report it on initialization as always on (WIMAX_RF_ON, radio on).
Definition at line 93 of file op-rfkill.c.
| void wimax_report_rfkill_sw | ( | struct wimax_dev * | wimax_dev, |
| enum wimax_rf_state | state | ||
| ) |
wimax_report_rfkill_sw - Reports changes in the software RF switch
: WiMAX device descriptor
: New state of the RF kill switch. WIMAX_RF_ON radio on, WIMAX_RF_OFF radio off.
Reports changes in the software RF switch state to the the WiMAX stack.
The main use is during initialization, so the driver can query the device for its current software radio kill switch state and feed it to the system.
On the side, the device does not change the software state by itself. In practice, this can happen, as the device might decide to switch (in software) the radio off for different reasons.
Definition at line 149 of file op-rfkill.c.
wimax_reset - Reset a WiMAX device
: WiMAX device descriptor
Returns:
%0 if ok and a warm reset was done (the device still exists in the system).
-ENODEV if a cold/bus reset had to be done (device has disconnected and reconnected, so current handle is not valid any more).
-EINVAL if the device is not even registered.
Any other negative error code shall be considered as non-recoverable.
Description:
Called when wanting to reset the device for any reason. Device is taken back to power on status.
This call blocks; on successful return, the device has completed the reset process and is ready to operate.
Definition at line 69 of file op-reset.c.
| int wimax_rfkill | ( | struct wimax_dev * | wimax_dev, |
| enum wimax_rf_state | state | ||
| ) |
wimax_rfkill - Set the software RF switch state for a WiMAX device
: WiMAX device descriptor
: New RF state.
Returns:
>= 0 toggle state if ok, < 0 errno code on error. The toggle state is returned as a bitmap, bit 0 being the hardware RF state, bit 1 the software RF state.
0 means disabled (WIMAX_RF_ON, radio on), 1 means enabled radio off (WIMAX_RF_OFF).
Description:
Called by the user when he wants to request the WiMAX radio to be switched on (WIMAX_RF_ON) or off (WIMAX_RF_OFF). With WIMAX_RF_QUERY, just the current state is returned.
NOTE:
This call will block until the operation is complete.
Definition at line 301 of file op-rfkill.c.
wimax_state_change - Set the current state of a WiMAX device
: WiMAX device descriptor (properly referenced) : New state to switch to
This implements the state changes for the wimax devices. It will
NOTE: must be locked
1.8.2