/*
* VoodooWirelessDevice.h
* VoodooWireless
*
* Created by Prashant Vaibhav on 12/06/09.
* Copyright 2009 Prashant Vaibhav. All rights reserved.
*
*/
#ifndef _H_VOODOOWIRELESSDEVICE_H
#define _H_VOODOOWIRELESSDEVICE_H
#include <sys/types.h>
#include <sys/kpi_mbuf.h>
#include <IOKit/IOService.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/apple80211/IO80211Controller.h>
#include <IOKit/apple80211/IO80211Interface.h>
#include <IOKit/apple80211/IO80211WorkLoop.h>
#include <IOKit/network/IOOutputQueue.h>
#include "VoodooWirelessFamily.h"
#include "VoodooIEEE80211.h"
#include "VoodooWirelessDevice_Types.h"
using namespace org_voodoo_wireless;
class VoodooWirelessDevice : public IO80211Controller
{
public:
/* NOTE: None of the public functions need to be implemented by subclasses. Proper implementations
* is already provided by this superclass */
/* Basic IOKit functions */
virtual bool start ( IOService* provider );
virtual void stop ( IOService* provider );
IOReturn registerWithPolicyMaker ( IOService* policyMaker );
/* Network driver and apple80211 functions */
SInt32 apple80211Request ( UInt32 request_type, int request_number,
IO80211Interface* interface, void* data );
IOReturn enable ( IONetworkInterface* aNetif );
IOReturn disable ( IONetworkInterface* aNetif );
IOOutputQueue* createOutputQueue ( );
UInt32 outputPacket ( mbuf_t m, void* param );
IOReturn getMaxPacketSize ( UInt32 *maxSize ) const;
const OSString* newVendorString ( ) const;
const OSString* newModelString ( ) const;
const OSString* newRevisionString ( ) const;
IOReturn getHardwareAddress ( IOEthernetAddress* addr );
virtual IOReturn setPromiscuousMode ( IOEnetPromiscuousMode mode );
virtual IOReturn setMulticastMode ( IOEnetMulticastMode mode );
virtual IOReturn setMulticastList ( IOEthernetAddress* addr, UInt32 len );
virtual SInt32 monitorModeSetEnabled ( IO80211Interface * interface, bool enabled, UInt32 dlt );
protected:
struct ExpansionData {}; // reserved, for internal use only
ExpansionData* reserved; // reserved, for internal use only
/* Functions to init / shutdown the HW */
virtual IOReturn allocateResources ( ); // Allocate hw rings, memory etc. needed for power up
virtual void freeResources ( ); // Undo all allocations done in allocateResources()
virtual IOReturn turnPowerOn ( ); // Make the card ready for action
virtual IOReturn turnPowerOff ( ); // Turn the card off
/* Functions for establishing connections, scanning etc. */
virtual IOReturn startScan ( const ScanParameters* params,
const IEEE::ChannelList* channels );
virtual void abortScan ( );
virtual IOReturn associate ( const AssociationParameters* params );
virtual IOReturn disasssociate ( );
/* Various configuration functions */
virtual void getHardwareInfo ( HardwareInfo* info );
virtual IOReturn getConfiguration ( HardwareConfigType type, void* param );
virtual IOReturn setConfiguration ( HardwareConfigType type, void* param );
/* The following function should be called by subclasses to report events. */
void report ( DeviceResponseMessage msg, void* arg );
/* This is to be called by subclasses when it receives any frames from HW.
* "data" should be raw 802.11 frame.
* During scanning, beacon or probe response frames should be passed via this function
*/
void inputFrame ( RxFrameHeader hdr, mbuf_t data );
/* This function must be implemented by the subclass to output a raw 802.11 frame.
* Note that the mbuf_t could either be a single mbuf or a chain of 2 or more mbufs.
* The passed mbuf_t becomes property of the driver which should free it when it is no longer needed.
*/
virtual IOReturn outputFrame ( TxFrameHeader hdr, mbuf_t data );
private:
HardwareInfo _hwInfo;
uint32_t _flags;
IOSimpleLock* _simpleLock;
/* The following are reserved slots for future expansion */
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 0);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 1);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 2);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 3);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 4);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 5);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 6);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 7);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 8);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 9);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 10);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 11);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 12);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 13);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 14);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 15);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 16);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 17);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 18);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 19);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 20);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 21);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 22);
OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 23);
};
#endif//_H_VOODOOWIRELESSDEVICE_H
/*
* VoodooWirelessDevice_Types.h
* VoodooWireless
*
* Created by Prashant Vaibhav on 16/06/09.
* Copyright 2009 Prashant Vaibhav. All rights reserved.
*
*/
#ifndef _H_VOODOOWIRELESSDEVICE_TYPES_H
#define _H_VOODOOWIRELESSDEVICE_TYPES_H
#include <libkern/c++/OSSymbol.h>
#include <libkern/c++/OSString.h>
#include "VoodooWirelessFamily.h"
#include "VoodooIEEE80211.h"
namespace org_voodoo_wireless {
struct ScanParameters {
enum ScanType { scanTypeActive, scanTypePassive, scanTypeBackground };
ScanType scanType; // Type of scan (active/passive..)
IEEE::PHYModes scanPhyMode; // 11a,b,g or n on which to scan
IEEE::MACAddress bssid; // BSSID to which scan is directed
OSSymbol* ssid; // SSID (network name) to which scan is directed
uint32_t dwellTime; // Time to stay on each channel (ms)
uint32_t restTime; // Time to wait between channels (ms)
};
struct ScanResult {
IEEE::Channel channel; // channel on which this AP is operating
IEEE::Capability capability; // AP capability flags
IEEE::MACAddress bssid; // BSSID of access point
OSSymbol* ssid; // Network name
int noiseLevel; // background noise
int signalLevel; // signal strength
IEEE::RateSet supportedRates; // rates that the AP supports
uint32_t beaconInterval; // in ms
uint32_t age; // how old is this result (in ms)
IEList* extraIEs; // extra information elements sent in the probe response
};
struct AssociationParameters {
OSSymbol* ssid; // not needed usually, but providing anyway
IEEE::MACAddress bssid;
IEEE::Channel channel;
IEEE::Capability capability;
IEEE::RateSet supportedRates; // That the AP supports
uint32_t beaconInterval;
enum APMode { apModeAny, apModeAdHoc, apModeInfrastructure };
APMode connectionMode;
enum AuthType {
/* LSB signifies lower auth mode (to be OR'd with upper auth mode if needed) */
authTypeNone = 0, // Open authentication
authTypeShared = 1, // WEP key shared authentication
/* Upper auth modes (even number only as LSB is taken) */
authTypeWPA = 2,
authTypeWPAPSK = 4,
authTypeWPA2 = 6,
authTypeWPA2PSK = 8,
authtypeLEAP = 10,
authType8021X = 12,
authTypeWPS = 14
};
AuthType authType;
IEEE::WEPKey wepKey; // if key is zero length, then no WEP
IEList* extraIEs; // info elements used with RSN (WPA etc.)
bool closedNetwork; // indicates assoc request is for directed scanned network
};
struct RxFrameHeader {
/* information about an incoming frame */
IEEE::Channel channel;
IEEE::DataRate rate;
int signalLevel; // signal strength
bool decrypted; // whether HW has already decrypted this frame
};
struct TxFrameHeader {
IEEE::DataRate rate; // desired Tx rate (can be ignored by HW)
bool encrypted; // whether this frame is already encrypted
};
struct HardwareCapabilities {
/* Which features does the hardware support */
bool WEP :1; // the cipher. if 0, will fall back to software cipher
bool TKIP :1; // the cipher. if 0, will fall back to software cipher
bool TKIP_MIC :1; // hardware TKIP MIC support. if 0, fall back to full software TKIP
bool AES_CCMP :1; // the cipher. if 0, will fall back to software cipher
bool WPA1 :1; // connecting to WPA1. if 0, WPA1 will not be available at all
bool WPA2 :1; // connecting to WPA2. if 0, WPA2 will not be available at all
bool AdHocMode :1;
bool HostAPMode :1;
bool MonitorMode :1;
bool PowerManagement :1; // active 802.11 power management, not IOKit power management
bool TxPowerManagement:1; // transmit power can be set
bool WakeOneWireless :1;
bool ShortSlot :1;
bool ShortPreamble :1;
bool FrameBursting :1;
bool WMEQoS :1;
bool ShortGuardInterval20MHz :1;
bool ShortGuardInterval40MHz :1;
bool hardwareRoaming :1; // hardware can migrate to different APs on its own
};
enum PowerSavingModes {
powerSaveAlwaysOn = 1,
powerSaveNormal = 2, // middle-level power saving
powerSaveMaximum = 4 // maximum power savings
};
enum HardwareConfigType {
/* Which kind of config to get/set, when get/setConfig is called. Any of this can be ignored */
configTxPower, // param = int txPower
configRTSThreshold, // param = uint32_t threshInBytes
configFragmentationThreshold, // param = uint32_t threshInBytes
configShortRetryLimit, // param = uint32_t numRetries
configLongRetryLimit, // param = uint32_t numRetries
configCurrentTxRate, // param = IEEE::DataRate
configRateSet, // param = IEEE::RateSet [working rates, not HW supported rates]
configInterferenceMitigation, // param = bool turnOn [HW dependent, usually bluetooth interference]
config11GProtection // param = bool turnOn [used in mixed 11bg networks]
};
struct HardwareInfo {
/* Note: strings should not have been allocated already, they will be allocated
by the driver itself. Ownership is then passed to the superclass who must
release the strings. In other words, this struct should be zero filled
before being passed to subclass. */
OSString* manufacturer;
OSString* model;
OSString* hardwareRevision;
OSString* driverVersion;
OSString* firmwareVersion;
IEEE::MACAddress hardwareAddress;
IEEE::PHYModes supportedModes; // OR'd bits if it's multi-mode PHY
IEEE::ChannelList supportedChannels; // independent of locale
IEEE::RateSet supportedRates; // that hardware supports, not what it's using now
unsigned int maxTxPower; // in dBm, independent of locale
enum SNRUnit { unit_dBm, unit_Percent, unit_mW, unit_Other_Linear, unit_Other_Logarithmic };
SNRUnit snrUnit; // which units are noise/signal levels reported in
PowerSavingModes powerSavingModes; // which modes does hardware support
HardwareCapabilities capabilities;
uint32_t maxPacketSize; // largest packet size which this HW can transmit
uint32_t txQueueSize; // how many packets can be sent to HW's tx queue
};
enum DeviceResponseMessage {
msgNull = iokit_vendor_specific_msg(1), // XXX: not used
msgPowerOff, // HW power was turned off without being requested
msgPowerOn, // HW power was turned on without being requested
msgRadioOff, // PHY was turned off by user or power saving
msgRadioOn, // PHY was turned on by user or power saving
msgScanAborted, // scan was aborted (by HW, not as response to client request)
msgScanCompleted, // scanning all specified chanels is completed
msgChannelScanned, // scanning a specific channel is completed (arg=Channel*)
msgAuthenticationFailed, // authentication step failed
msgAuthenticationDone, // authentication step was done
msgAssociationFailed, // association with AP failed, arg=IEEE::ReasonCode*
msgAssociationDone, // association was finished successfully
msgDeassociationFailed, // deassoc request failed, arg=IEEE::ReasonCode*
msgDeassociationDone, // deassociated from AP, arg=IEEE::ReasonCode*
msgDeauthenticated, // deauthenticated from AP, arg=IEEE::ReasonCode*
msgNoiseLevelReport, // reporting noise level, arg=int* noiseLevel
msgSignalStrengthReport, // reporting signal strength, arg=int* signalStrength
msgChannelSwitch, // reporting AP channel switch, arg=Channel* newChan
msgLinkQualityReport, // reporting link quality, arg=int* qualityLevel
msgBeaconMissed, // reporting missed beacon, arg=uint32_t* howManyMissed
msgConfigChanged, // reporting a change in HW config (without being requested)
// arg=HardwareConfigType* type, client may call getConfig after this
msgMaxMessageNumber // XXX: used to check if msg num was out of bound
};
};
#endif
/*
* VoodooIEEE80211_Types.h
* VoodooWireless
*
* Created by Prashant Vaibhav on 16/06/09.
* Copyright 2009 Prashant Vaibhav. All rights reserved.
*
*/
#ifndef _H_VOODOOIEEE80211_TYPES_H
#define _H_VOODOOIEEE80211_TYPES_H
#include "VoodooWirelessFamily.h"
namespace org_voodoo_wireless {
namespace IEEE {
struct MACAddress {
/* Defining this again here because families should not have to use another
family's headers, and IOEthernetAddress is defined in IOEthernetFamily */
uint8_t bytes[6];
};
struct WEPKey {
uint8_t index; // 0 to 3
OSString* key; // 40 or 104 bits (5 or 13 bytes)
};
enum PHYModes {
dot11A = 1, // 5GHz OFDM
dot11B = 2, // 2.4GHz CCK
dot11G = 4, // 2.4GHz OFDM
dot11N = 8, // 2.4GHz or 5GHz MIMO
};
const size_t MAX_CHANNELS = 64;
const size_t MAX_RATES = 32;
struct Channel {
uint8_t number; // Channel number
uint16_t flags; // Channel type flags
enum Flags {
supportsActiveScanning = 0x1,
band2GHz = 0x2,
band5GHz = 0x4,
width10MHz = 0x8,
width20MHz = 0x10,
width40MHz = 0x20,
requiresDFS = 0x40, // dynamic frequency selection for 11a
supportsHostAPMode = 0x80,
supportsAdHocMode = 0x100,
extensionChannelIsAbove = 0x200 // in 11n mode, if ext. ch is above this ch. (otherwise below)
};
};
struct ChannelList {
size_t numItems;
Channel channel[MAX_CHANNELS];
};
enum DataRate {
rateIsBasic = 128, // basic rates should be OR'd with this value (ie. bit 7 = 1)
/* Rates are just uint32_t, in 0.5 Mbps units */
rate1Mbps = 2, // 1 Mbps CCK
rate2Mbps = 4, // 2 Mbps CCK
rate5Mbps = 10, // 5.5 Mbps CCK
rate6Mbps = 12, // 6 Mbps OFDM
rate9Mbps = 18, // 9 Mbps OFDM
rate11Mbps = 22, // 11 Mbps CCK
rate12Mbps = 24, // 12 Mbps OFDM
rate18Mbps = 36, // 18 Mbps OFDM
rate24Mbps = 48, // 24 Mbps OFDM
rate36Mbps = 72, // 36 Mbps OFDM
rate48Mbps = 96, // 48 Mbps OFDM
rate54Mbps = 108, // 54 Mbps OFDM
/* 11n MIMO rates to be added later */
};
struct RateSet {
size_t numItems;
DataRate rate[MAX_RATES];
};
enum ReasonCode {
// § 7.3.1.7 Table 7-22
reasonUnspecified = 1,
reasonPreviousAuthExpired = 2,
reasonDeauthBecauseSTALeft = 3,
reasonDisassocDueToInactivity = 4,
reasonAPFull = 5,
reasonClass2FrameRxWithoutAuth = 6,
reasonClass3FrameRxWithoutAssoc = 7,
reasonDisassocBecauseSTALeft = 8,
reasonNotAuthorized = 9,
reasonPowerCapsUnacceptable = 10,
reasonSupportedChannelsUnacceptable = 11,
reasonInvalidIE = 13, /* 12 is reserved */
reasonMICFailure = 14,
reason4WayHandshakeTimeout = 15,
reasonGroupKeyHandshakeTimeout = 16,
reasonIEMismatch = 17,
reasonInvalidGroupCipher = 18,
reasonInvalidPairwiseCipher = 19,
reasonInvalidAKMP = 20,
reasonUnsupportedRSNIE = 21,
reasonInvalidRSNIECaps = 22,
reason8021XAuthFailed = 23,
reasonCipherSuiteRejected = 24,
reasonQoS = 32, /* 25-31 reserved */
reasonQoSBandwidthUnavailable = 33,
reasonTooManyACKs = 34,
reasonTXOPsOutsideLimits = 35,
reasonPeerSTALeaving = 36,
reasonPeerSTAMechanismRejected = 37,
reasonPeerSTAMechanismNeedsSetup= 38,
reasonPeerSTATimeout = 39,
reasonPeerSTACipherUnsupported = 45, /* 40-44 reserved */
reasonPrivateUnspecified = 0xffff /* our own unspecified failure code */
};
struct IE {
enum ID {
/* § 7.3.2 Table 7-26 */
ieSSID = 0, ieSupportedRates = 1,
ieFHParamSet = 2, ieDSParamSet = 3,
ieCFParamSet = 4, ieTIM = 5,
ieIBSSParamSet = 6, ieCountry = 7,
ieHoppingPatternParams = 8, ieHoppingPatternTable = 9,
ieRequest = 10, ieBSSLoad = 11,
ieEDCAParamSet = 12, ieTSPEC = 13,
ieTCLAS = 14, ieSchedule = 15,
ieChallengeText = 16, /* 17-31 reserved */
iePowerConstraint = 32, iePowerCapability = 33,
ieTPCRequest = 34, ieTPCReport = 35,
ieSupportedChannels = 36, ieChannelSwitchAnnounce = 37,
ieMeasurementRequest = 38, ieMeasurementReport = 39,
ieQuiet = 40, ieIBSSDFS = 41,
ieERPInformation = 42, ieTSDelay = 43,
ieTCLASProcessing = 44, /* 45 reserved */
ieQoSCapability = 46, /* 47 reserved */
ieRSN = 48, /* 49 reserved */
ieExtendedSupportedRates= 50, /* 51-125 reserved */
/* 126 reserved */ ieExtendedCapabilities = 127,
/* 128-220 reserved */ ieVendorSpecific = 221,
/* 222-255 reserved */
};
uint8_t id; // type codes specified in enum ID
uint8_t length; // length in bytes of data that follows
uint8_t data[0]; // variable length up to 255 bytes
} __packed;
union Capability {
struct {
/* § 7.3.1.4 */
bool ESS :1;
bool IBSS :1; // indicates Ad-hoc mode
bool CFPollable :1;
bool CFPollRequest :1;
bool Privacy :1; // indicates WEP on/off
bool ShortPreamble :1;
bool PBCC :1;
bool ChannelAgility :1;
bool SpectrumMgmt :1;
bool QoS :1;
bool ShortSlotTime :1;
bool APSD :1;
bool Reserved :1;
bool DSSSOFDM :1; // indicates 11g mode on/off
bool DelayedBlockAck :1;
bool ImmediateBlockAck:1;
} bits __packed;
uint16_t value;
} __packed;
/* Following is the structure of a MAC header present in ALL frames. The remaining
* contents of the frame depend on the type/subtype etc. § 7.2 onwards
*/
struct WiFiFrameHeader
{
enum FrameType {
ManagementFrame = 0,
ControlFrame = 1,
DataFrame = 2,
ReservedFrame = 3
};
enum FrameSubtype {
/* Subtype for Management frames: */
AssocRequest = 0, AssocResponse = 1,
ReassocRequest = 2, ReassocResponse = 3,
ProbeRequest = 4, ProbeResponse = 5,
/* 6-7 are reserved */
Beacon = 8, ATIM = 9,
Disassoc = 10, Authentication = 11,
DeAuthentication= 12, Action = 13,
/* 14-15 are reserved */
/* Subtypes for Control frames: */
/* 0-7 are reserved */
BlockAckReq = 8, BlockAck = 9,
PSPoll = 10, RTS = 11,
CTS = 12, ACK = 13,
CFEnd = 14, CFEndPoll = 15,
/* Subtypes for Data frames: */
Data = 0, DataCFAck = 1,
DataCFPoll = 2, DataCFAckPoll = 3,
Null = 4, CFAck = 5,
CFPoll = 6, CFAckPoll = 7,
QoSData = 8, QoSDataCFAck = 9,
QoSDataCFPoll = 10, QoSDataCFAckPoll = 11,
QoSNull = 12, /* 13 is reserved */
QoSCFPoll = 14, QoSCFAckCFPoll = 15
};
uint8_t protocolVersion :2;
FrameType type :2;
FrameSubtype subtype :4;
bool toDS :1;
bool fromDS :1;
bool moreFrag :1;
bool retry :1;
bool powerSaveMode :1; // Called PwrMgt in spec
bool moreData :1;
bool protectedFrame :1;
bool order :1;
uint16_t durationID :16;
/* The following is also present in all MAC headers, but we won't
* put in here because its meaning depends on the particular frame type
IOEthernetAddress addr1;
*/
} __packed;
struct SequenceControl {
uint8_t fragmentNumber :4;
uint16_t sequenceNumber :12;
} __packed;
struct ManagementFrameHeader
{
WiFiFrameHeader hdr;
uint8_t da[6];
uint8_t sa[6];
uint8_t bssid[6];
SequenceControl sequenceControl;
} __packed;
struct ProbeResponseFrameHeader {
ManagementFrameHeader mgmt;
uint64_t timestamp;
uint16_t beaconInterval;
uint16_t capability;
/* Then follows a variable number of information elements */
uint8_t ieData[0];
} __packed;
struct TxDataFrameHeader {
WiFiFrameHeader hdr;
uint8_t bssid[6];
uint8_t sa[6]; // source MAC addr
uint8_t da[6]; // dest MAC addr
uint16_t seq;
uint8_t data[0]; // variable length
} __packed;
struct TxQoSDataFrameHeader {
WiFiFrameHeader hdr;
uint8_t bssid[6];
uint8_t sa[6]; // source MAC addr
uint8_t da[6]; // dest MAC addr
uint16_t seq;
uint16_t qos;
uint8_t data[0]; // variable length
} __packed;
struct EthernetFrameHeader {
uint8_t da[6];
uint8_t sa[6];
uint8_t frameType[2]; // always = 0x80 0x00
uint8_t data[0]; // variable length
} __packed;
}
}
#endif