Radio interface layer in a cell phone with a set of APIs having a hardware-independent proxy layer and a hardware-specific driver layer

Abstract

A Radio Interface Layer (RIL) is disclosed. The RIL comprises an API set which provides a level of abstraction between the radio on a cell phone and the software of the cell phone. The API set of RIL is roughly based on the GSM AT interface as defined in GSM specifications 07.05 and 07.07. The API set provides access to functionality contained within a cellular telephone, such as a GSM or CDMA compatible telephone. These APIs allow applications running on an operating system in the cellular telephone to issue commands without knowledge of the underlying radio structure of the cellular telephone and specific knowledge of the GSM-type commands. For example, these APIs allow the applications to access to phonebook entries, restrict access to data and functionality using passwords, access file and message storage, and perform many other functions. The RIL is divided into a hardware-independent proxy layer, called by various software components, and a driver layer that is hardware-specific.

Claims

We claim:

1. An abstraction layer for interfacing a computer to a telephony radio, comprising:

a set of application programming interfaces (APIs) for abstracting out multiple radio technologies without knowledge of the telephony radio or cellular network, wherein the set of APIs correspond to call control functions, wherein the abstraction layer comprises a proxy layer and a driver layer, wherein when the proxy layer receives a call at a first interface to one of the set of APIs, the proxy layer transforms the API call to a command understood by the driver layer and sends the command to the driver layer at a second interface, and wherein the driver layer receives the command at the second interface and determines at least one standard telephony radio command corresponding to the called API and sends the telephony radio command to the telephony radio at a third interface, and wherein the proxy layer is hardware independent and the driver is hardware specific.

2. The abstraction layer of claim 1 wherein the telephony radio is one of a plurality of telephony radios which operates based on the standard telephony radio commands.

3. The abstraction layer of claim 1 wherein the set of APIs further correspond to short messaging system functions.

4. The abstraction layer of claim 3 wherein the set of APIs further correspond to network service functions.

5. The abstraction layer of claim 4 wherein the set of APIs further correspond to data connection functions.

6. The abstraction layer of claim 5 wherein the set of APIs further correspond to interface functions.

7. A radio interface layer of a telephone for facilitating communications between an application program module and a radio, comprising:

a proxy layer for communicating with the application program module at a first interface and a driver layer at a second interface, wherein the proxy layer provides an API on the first interface for receiving application program calls to perform a particular function and wherein the proxy layer transforms the API calls to an input/output control (IOCTL) code and sends the IOCTL code to the driver layer at the second interface;

wherein the driver layer communicates with the proxy layer at the second interface and the radio at a third interface, the driver layer receiving an IOCTL code at the second interface and transforming the IOCTL code into a command understood by the radio to perform the particular function and sending the radio command at the third interfaces; and

wherein the proxy layer is hardware independent and the driver layer is hardware specific.

8. The radio interface layer of claim 7 wherein the driver layer further receives communications from the radio indicating that the particular function has been performed and wherein the driver layer sends a success code to the proxy layer indicating that the particular function has been performed.

9. A method for processing commands in a telephone comprising a proxy layer, a driver layer, an application and a radio, the method comprising the steps of:

causing the application to call a radio interface layer (RIL) API in the proxy layer at a first interface, wherein the RIL API is associated with an action to be performed by the radio;

causing the proxy layer to translate the RIL API into IOCTL codes;

sending the IOCTL codes to the driver layer at a second interface;

translating the IOCTL codes to a command corresponding to the action, wherein the command will be understood by the radio;

sending the command to the radio at a third interface; and

wherein the proxy layer is hardware independent and the driver layer is hardware specific.

10. The method of claim 9 wherein the command is an AT command.

11. The method of claim 9 wherein the command is one of a private API set defined by the radio manufacturer.

12. The method of claim 9 further comprising the step of generating in the RIL driver layer a unique ID associated with the RIL API.

13. The method of claim 12 further comprising the step of waiting for a response from the radio, and when received, calling back the calling application with the response and the unique ID returned from the call.

14. The method of claim 13 wherein the RIL driver matches the response from the radio with the unique ID and the RIL driver sends the response to the calling process via a callback function.

15. A method of communicating between a module and a radio comprising:

(a) generating a radio interface layer (RIL) API call at one of a plurality of modules to perform a specific action;

(b) sending the RIL API call to a proxy at a first interface;

(c) at the proxy, converting the RIL API call to a command understood by a radio driver;

(d) transmitting the radio driver command from the proxy to the radio driver at a second interface;

(e) transmitting a radio command from the radio driver to the radio at a third interface;

(f) performing the specific action at the radio; and

wherein the proxy is hardware indepentent and the driver is hardware specific.

16. The method of claim further 15 comprising:

(g) in response to successfully performing the specific action, sending a success code from the driver to the proxy and from the proxy to the one of the plurality of modules that generated the RIL API.

17. The method of claim 16 wherein the RIL API, command and success code are associated with an identifier linking them together and linking them to the one of the plurality of modules that generated the RIL API call and wherein the radio driver receives the success code, and, using the identifier, matches the success code with the one of the plurality of modules that generated the RIL API call and sends the success code to the one of the plurality of modules that generated the RIL API call.

18. The method of claim 17 further comprising the step of:

(h) generating a notification at the radio in response to detecting data that needs to be reported to one of the plurality of modules;

(i) sending the notification to the radio driver.

19. The method of claim 18 further comprising the step of:

(j) sending the notification from the radio driver to the proxy.

20. The method of claim 19 further comprising the step of:

(k) sending the notification from the proxy to at least one of the plurality of modules.

21. The method of claim 18 wherein the data that needs to be reported comprises an incoming phone call to the radio.

22. The method of claim 18 wherein the data that needs to be reported comprises a signal strength change in the radio.

23. The method of claim 18 wherein the one of a plurality of modules is a TSP.

24. The method of claim 18 wherein the one of a plurality of modules is a SIM manager.

25. The method of claim 18 wherein the one of a plurality of modules is an emergency application for generating emergency calls.

26. The method of claim 18 wherein the one of a plurality of modules is a WAP layer.

27. The method of claim 18 wherein the one of a plurality of modules is a TAPI interface.

28. The method of claim 18 wherein the one of a plurality of modules is an ExTAPI interface.

29. The method of claim 18 wherein the one of a plurality of modules is connected to an application program module and receives instructions from the application program module to generate the RIL API call.

30. The method of claim 29 wherein the instructions provided by the application program module comprise instructions defined by the one of a plurality of modules and wherein the instructions are converted to the Rib API calls by the one of a plurality of modules.

Description

TECHNICAL FIELD

The invention generally relates to application programming interfaces (APIs) and, even more particularly, relates to a Radio Interface Layer comprising a set of APIs.

BACKGROUND

Cellular telephones are becoming commonplace in today's world. As users become more accustomed to using cellular telephones, they are requesting more sophisticated uses of telephones. Ideally, users would like their cellular telephones to perform the same functions as their personal computers or hand-held PDAs. Implementing such uses in a cellular telephone environment requires application developers to develop or adapt their software for use on a cellular telephone. However, adapting or developing software for use on one OEM's cellular telephone does not necessarily guarantee that the software application will function on another OEM's cellular telephone due to the different radio implementations of different OEMs and due to the differences in different cellular environments.

In order to create a software solution adaptable to multiple different cellular systems and radios, there is a need for some kind of a hardware adaptation layer, i.e. a layer that isolates the specifics of a particular cellular system/hardware from the bulk of the software system. There is a further need to expose a predefined interface used by the software components. There is still a further need that the layer should allow hardware manufacturers to replace/modify the implementation of the hardware interface to conform to their specific hardware.

Such a layer (TAPI) already exists for use in development of general telephony systems. However, TAPI has two disadvantages making it difficult to use in a cellular environment: a significant amount of cellular-specific functionality isn't exposed by the TAPI interface and TAPI Service Providers (TSPs) are quite difficult to implement, thus making it harder to adapt the software system to different types of hardware. Hence, there is a need for a new hardware adaptation layer which is more specifically suited to the cellular environment and which simplifies the task of adapting it to different types of hardware.

SUMMARY OF THE INVENTION

The present invention meets the above-described needs by providing a Radio Interface Layer (RIL), which is an API set providing a level of abstraction between the radio on a cell phone and the software of the cell phone. The API set of RIL is roughly based on the GSM AT interface as defined in GSM specifications 07.05 and 07.07. The API set provides access to functionality contained within a cellular telephone, such as a GSM or CDMA compatible telephone. The present invention allows applications running on an operating system in the cellular telephone to issue commands without knowledge of the underlying radio structure of the cellular telephone and without specific knowledge of the GSM-type commands. For example, the present invention allows the applications to access phonebook entries, restrict access to data and functionality using passwords, access file and message storage, and perform many other functions. The RIL is divided into a hardware-independent proxy layer, called by various software components, and a driver layer that is hardware-specific. It should be understood that an OEM may replace the driver layer with their own layer containing implementation specific to their hardware.

That the invention improves over the drawbacks of the prior art and accomplishes the advantages described above will become apparent from the following detailed description of the exemplary embodiments and the appended drawings and claims.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 is a block diagram of an exemplary personal computer system.

FIG. 2 is a block diagram illustrating an exemplary embodiment of an RIL in a phone in accordance with an embodiment of the present invention.

FIG. 3 is a flow diagram illustrating a method for processing of commands using the radio interface layer (RIL) in accordance with an embodiment of the present invention.

FIG. 4 is a block diagram illustrating a method for an application to establish a voice call using RIL in accordance with an embodiment of the present invention.

DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

An embodiment of the present invention will be incorporated into a cellular telephone marketed by Microsoft Corporation of Redmond, Wash. The cellular telephone may be a "smart phone" that, in addition to providing telephony services, also runs different software applications and performs different functions normally reserved for personal computers or PDAs. For example, in one embodiment, the telephone may be used as a personal information manager (PIM) for storing appointments, contacts, tasks, etc.

Other embodiments of the present invention may be incorporated into PDAs, personal computers and hand-held computers. FIG. 1 and the following discussion are intended to provide a brief, general description of an exemplary personal computer system for use with the above-described embodiments of the present invention. Those skilled in the art will recognize that software products may include routines, programs, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Moreover, those skilled in the art will appreciate that the invention may be practiced with other computer system configurations, including hand-held devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframe computers, and the like. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, software products may be located in both local and remote memory storage devices.

With reference to FIG. 1, an exemplary system for implementing the invention includes a conventional personal computer 20, including a processing unit 21, a system memory 22, and a system bus 23 that couples the system memory to the processing unit 21. The system memory 22 includes read only memory (ROM) 24 and random access memory (RAM) 25. A basic input/output system 26 (BIOS), containing the basic routines that help to transfer information between elements within the personal computer 20, such as during start-up, is stored in ROM 24. A video BIOS 60 may also be stored in ROM 24. The personal computer 20 further includes a hard disk drive 27, a magnetic disk drive 28, e.g., to read from or write to a removable disk 29, and an optical disk drive 30, e.g., for reading a CD-ROM disk 31 or to read from or write to other optical media. The hard disk drive 27, magnetic disk drive 28, and optical disk drive 30 are connected to the system bus 23 by a hard disk drive interface 32, a magnetic disk drive interface 33, and an optical drive interface 34, respectively. The drives and their associated computer-readable media provide nonvolatile storage for the personal computer 20. Although the description of computer-readable media above refers to a hard disk, a removable magnetic disk and a CD-ROM disk, it should be appreciated by those skilled in the art that other types of media which are readable by a computer, such as magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, and the like, may also be used in the exemplary operating environment.

A number of software products may be stored in the drives and RAM 25, including an operating system 35, a software product 36, such as Microsoft's "OFFICE XP" suite of application program modules, other software products 37, and program data 38. A user may enter commands and information into the personal computer 20 through a keyboard 40 and pointing device, such as a mouse 42. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit 21 through a serial port interface 46 that is coupled to the system bus, but may be connected by other interfaces, such as a game port or a universal serial bus (USB). A monitor 47 or other type of display device is also connected to the system bus 23 via an interface, such as a video adapter 48. In addition to the monitor, personal computers typically include other peripheral output devices (not shown), such as speakers or printers.

The personal computer 20 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 49. The remote computer 49 may be a server, a router, a peer device or other common network node, and typically includes many or all of the elements described relative to the personal computer 20, although only a memory storage device 50 has been illustrated in FIG. 1. The logical connections depicted in FIG. 1 include a local area network (LAN) 51 and a wide area network (WAN) 52. Such networking environments are commonplace in offices, enterprise-wide computer networks, Intranets and the Internet.

When used in a LAN networking environment, the personal computer 20 is connected to the LAN 51 through a network interface 53. When used in a WAN networking environment, the personal computer 20 typically includes a modem 54 or other means for establishing communications over the WAN 52, such as the Internet. The modem 54, which may be internal or external, is connected to the system bus 23 via the serial port interface 46. In a networked environment, program modules depicted relative to the personal computer 20, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used.

Radio Interface Layer

In one embodiment, the present invention, known as the Radio Interface Layer (RIL) comprises an API set which provides a level of abstraction between the radio on a cell phone and the software of the cell phone. The API set of RIL is based on the GSM AT interface as defined in GSM specifications 07.05 and 07.07. The API set provides access to functionality contained within a cellular telephone, such as a GSM or CDMA compatible telephone. The present invention allows applications running on an operating system in the cellular telephone to issue commands without knowledge of the underlying radio structure of the cellular telephone and specific knowledge of the GSM-type commands. For example, the present invention allows the applications to access phonebook entries, restrict access to data and functionality using passwords, access file and message storage, and perform many other functions.

The RIL is divided into a hardware-independent proxy layer, called by various software components, and a driver layer that is hardware-specific. It should be understood that an original equipment manufacturer (OEM) may replace the driver layer with their own layer containing implementation specific to their hardware. In a preferred embodiment, the RIL is a core component of a cellular telephone marketed by Microsoft Corporation of Redmond, Wash.

RIL Driver Layer

In a preferred embodiment, the Radio Interface Layer (RIL) driver layer is used to implement and roughly correspond to the commands, such as AT commands, specified by ETS 300 585, Digital cellular telecommunications system (Phase 2); Use of Data Terminal Equipment-Data Circuit terminating Equipment (DTE-DCE) interface for Short Messaging Service (SMS) and Cell Broadcast Service (CBS) (GSM 07.05), Fifth Edition, April 1997, and ETS 300 642, Digital cellular telecommunications system (Phase 2); AT command set for GSM Mobile Equipment (ME) (GSM 07.07 version 4.4.1), Fourth Edition, March 1999. The GSM specifications 07.05 and 07.07 are hereby incorporated by reference. Of course, the RIL driver may be used to implement and correspond to other command sets, such as CDMA commands, or a combination of several command sets.

OEMs may use the RIL driver of the preferred embodiment or tweak it if they would rather talk with their radio over private APIs instead of via AT commands (most likely for performance reasons).

Generally described, the RIL driver layer receives an RIL API call and causes the radio (i.e. the receiver/transmitter of the cellphone, PDA, etc.) to perform the function defined by the RIL API. In a preferred embodiment, the RIL driver will receive the RIL API call from a RIL proxy layer (described below). The RIL driver layer also processes notifications received from the radio and transmits them to the RIL proxy layer. In a preferred embodiment, the RIL driver layer is a dynamic link library (DLL) that is running as a device driver inside the process space of a device manager (the standard module that manages device drivers on the "WINDOWS CE" operating system). A Device Manager (device.exe) may be responsible for managing all the system drivers, including the RIL driver.

RIL Proxy Layer

In one embodiment, the RIL proxy layer comprises a layer that is called by various other layers of the core architecture, such as a TSP layer, an ExTAPI layer, and a SIM Manager using the platform specific commands of these core architectures. In a preferred embodiment, the proxy layer is a "WINDOWS CE" dynamic link library (DLL) that manages callback notifications and inter-process function calls into the RIL driver layer. Modules that want to use the RIL simply link with this proxy DLL. The RIL proxy layer converts the core architecture specific commands into RIL API calls that will be understood by the RIL driver layer.

There are some important distinctions between the proxy and driver layers. In a preferred embodiment of the invention, a separate proxy instance is created for each module using the RIL proxy DLL. On the other hand, in a preferred embodiment of the invention, the RIL device driver is loaded only once and is shared amongst all proxy layer instances. In other words, a module using the RIL must be aware that only one radio module exists, even though it links to its own proxy DLL. In addition, the Device Manager's control of the RIL driver implies that the proxy and driver live in separate processes (i.e. different address spaces). However, the "WINDOWS CE" operating system exposes mechanisms allowing the proxy and driver layers to communicate without being concerned with the process boundaries.

Another important architectural property of the RIL is that almost all of the functions are asynchronous. When a module first registers with the RIL, it passes in two callback functions. One is used for unsolicited notifications, and the other is used for responses to function calls. For instance, when the phone receives a new incoming call, RIL will use the unsolicited notification callback to let each module know about the incoming call. Alternately, when a module calls RIL to obtain the signal strength, the function call immediately returns a response identifier. Shortly thereafter, RIL uses the function response callback to convey signal strength information to the module. To ensure that function response callbacks are correctly matched up with function calls, this callback structure also contains the same response identifier value returned by the original function call. This asynchronous architecture simplifies RIL implementation. If a module needs to call RIL functions in a synchronous manner, it will need to make the function call and block until it receives the function response callback.

Another architectural feature of the RIL is a virtual serial port (VSP). When an application makes a data connection, it retrieves a handle to a virtual serial port (not the real data stream between the RIL and the radio). This allows RIL to buffer and flow control the data stream so that control commands can be interjected. For example, suppose an application has set up a data connection and is browsing on the Internet. The virtual serial port allows RIL to interject control commands to check for things like signal strength, new SMS messages, etc. However, further suppose an application is receiving a facsimile. Due to strict timing issues in the case of a facsimile transmission, the RIL will enter a dedicated data mode where the application has full control of the virtual serial port. That is, RIL will not attempt to interject any commands in the data stream. It should be understood that the VSP is similar to other communication ports and typically only one application can have the handle to the VSP at one time.

Referring now to FIG. 2, a block diagram illustrating an exemplary embodiment of an RIL in a cellphone 200 in accordance with an embodiment of the present invention will be described. The cellphone 200 comprises a SIM manager 205, an emergency application 210, a TAPI Service Provider (TSP) 215, a WAP layer 220, a SMS manager 225, a data stack 230 and a VSP 250.

The cellphone 200 further comprises a plurality of instances of the RIL proxy layer 235. The RIL proxy layer 235 provides communications between applications (such as the SIM manager 205, emergency application 210, TSP 215, WAP layer 220, SMS manager 225, and ExTAPI, among others) and a RIL driver layer 240. The RIL driver layer 240 provides communications between the RIL proxy layer and the radio hardware 245.

Scenarios

In terms of "using" the RIL (from the point of view of both an application designer and an OEM), the proxy and driver layers each expose a set of functions. For a program module to use the RIL, it only needs to use functions specified in the proxy header file and then link with the proxy DLL. The proxy DLL is implemented by calling functions specified in the driver header file. The driver header file is provided to OEMs and defines the functions that an OEM must implement. In one embodiment, the implementation will be hardware specific, so each OEM will be responsible for its own driver implementation. However, one or more reference implementations of the driver (source code included) may be provided to OEMs to help them with this step. If an OEM uses radio hardware that is supported by one of these reference implementations, it may not need to revise the RIL code.

Method for Processing Commands Using RIL

FIG. 3 is a flow diagram illustrating a method 300 for processing of commands using the radio interface layer (RIL) in accordance with an embodiment of the present invention. The method 300 begins at step 305 when a user calls a RIL API in the proxy layer.

At decision step 310, it is determined whether the callee, i.e. the called process, is in the device.exe process space. If it is, then the method proceeds to step 315 where the driver APIs are called directly. If it is determined at decision step 310 that the callee is not in the device.exe process space then the method proceeds to step 320.

At step 320, input/output control (IOCTL) codes are used to send the appropriate information for the RIL API to the RIL driver running in a separate process space. At step 325, the RIL driver informs the radio to take the action specified by the command of the RIL API. In a preferred embodiment, the RIL driver informs the radio to take action using an AT command interface, as defined in GSM specs (most prominently 07.05 and 07.07). However, sending AT commands may not be ideal for a given radio--perhaps an OEM has a separate private API set that they can use to perform the same functionality as a given AT command. If this is the case, the OEM may change the RIL driver to suit their needs. However, in a preferred embodiment, because the core architecture of the phone has been built on top of a set of RIL APIs that may be implemented via AT commands, it is not necessary for the OEM to substantially modify the RIL driver so long as the radio understands AT commands. However, due to different implementations of the AT interface, some minor modifications may be necessary.

The method then proceeds to step 330 where the RIL API returns with a unique ID generated by the RIL. It should be understood that after sending an AT command, a response from the radio unit is awaited. RIL APIs are designed to be asynchronous, so these APIs will return immediately, with a unique ID assigned to the call.

The method then proceeds to step 335 where a separate thread waits for responses from the radio unit.

The method then proceeds to step 340 where the RIL driver matches the response from the radio unit with the unique ID generated earlier and the RIL driver sends the response to the appropriate calling process via a callback function.

It should also be understood that radio units can also send unsolicited notifications (for example, when the phone switches cellular towers). In this case, the RIL driver receives a notification from the radio and will broadcast a message to all users of the RIL layer who are interested in this class of notification.

For an example illustrating an implementation of method 300, consider the following: the API RIL_ChangeLockingPassword is a RIL API that allows changing the password of a phone for various lock facilities. This API is modeled after the+CPWD AT command, defined in section 7.5 of GSM 07.07. The AT command to change a password requires a lock facility, the old password, and the new password. Accordingly, the API for RIL_ChangeLockingPassword appears as:

HRESULT RIL_ChangeLockingPassword(

HRIL hRil,

DWORD dwFacility,

LPCSTR lpszOldPassword,

LPCSTR lpszNewPassword

);

When the user application wants to change the locking password, it calls this API, typically indirectly via a TAPI layer or another layer. For example, the application may understand the TAPI command for changing a password and send this command to the TAPI layer. The TAPI layer will then make the appropriate RIL API call to the proxy layer. As part of the RIL API, a RIL handle must be provided (which is obtained from initializing RIL), a locking facility must be provided, the old password must be provided and the new password must be provided. For example, suppose a user application wishes to change the password used to lock the SIM card from "1234" to "5678". The user application (or an intermediate layer such as the TAPI layer) would make the following API call:

RIL_ChangeLockingPassword(hRIL, RIL_LOCKFACILITY_SIM, "1234", "5678");

If the calling process is not in the device.exe, these parameters will get bundled into a structure and passed via an IOCTL call, RIL_IOCTL_CHANGELOCKINGPASSWORD:

            typedef struct changelockingpassword_params_tag {
                DWORD dwfacility;
                char szOldPassword[MAXLENGTH_PASSWORD];
                char szNewPassword[MAXLENGTH_PASSWORD];
        }

    Name                 Description
    Network Services     Operator selection, signal status,
                         available operators, etc.
    Call Control         Dial, Hangup, Hold, Transfer, etc.
    Supplemental Services Call waiting, call forwarding,
                         call meter, etc.
    SMS                  Send, receive, SMSC selection, etc.
    Data Connection      Virtual serial port, bearer service types,
                         transparent data/online mode change
    Security Functions   Locking, unlocking, passwords, etc.
    Interface Functions  Initialization, notification registration, etc.
    Phonebook Functions  Accessing the SIM phonebooks
    SIM SMS Functions    Accessing SMS messages from the SIM
    GPRS Functions       Selecting profiles, attaching, activating, etc.
    HSCSD Functions      Managing channel allocations
    SIM Record Access    Access individual files on the SIM
    SIM Toolkit 2.0 Support Engaging in a SIM toolkit session

    Structure                      Comments
                    Network Service Structures
    RILSUBSCRIBERINFO              Defines an assigned phone
                                   number and parameter
                                   associated with it
    RILOPERATORNAMES               Defines the long, short,
                                   and numeric format of
                                   a single operator
    RILOPERATORINFO                Defines a network operator
                     Call Control Structures
    RILCALLINFO                    Defines each call
                                   instance (active, on
                                   hold, in conference, etc.)
    RILRINGINFO                    Indicates the type
                                   of incoming call
                 Supplemental Service Structures
    RILCALLFORWARDSETTINGS         Defines call
                                   forwarding
    RILCALLWAITINGINFO             Information about
                                   an incoming call
    RILCALLERIDSETTINGS            Defines caller ID
    RILHIDEIDSETTINGS              Defines how to hide
                                   your phone number when
                                   calling someone else
    RILDIALEDIDSETTINGS            Defines the true
                                   number that was dialed
    RILCLOSEDGROUPSETTINGS         Defines closed user
                                   group settings
    RILREMOTEPARTYINFO             Structure used for
                                   CallerID and
                                   DialedID notifications
                         Voice Structures
    RILGAININFO                    Defines audio gain
                                   for the transmit and
                                   receive channels
    RILAUDIODEVICEINFO             Defines transmit and
                                   receive audio devices
                       Messaging Structures
    RILMSGSERVICEINFO              Messaging settings
                                   such as storage
                                   locations and usage info
    RILMSGDCS                      Data coding scheme
    RILMSGCONFIG                   Messaging configuration
    RILMESSAGE                     An actual message
    RILMESSAGEINFO                 Contains an
                                   RILMESSAGE along
                                   with additional info
    RILMSGSTORAGEINFO              Information about a
                                   message storage location
                     Data Service Structures
    RILCALLHSCSDINFO               Defines HSCSD parameters
                                   for the current call
    RILHSCSDINFO                   Defines HSCSD parameters
    RILDATACOMPINFO                Defines parameters for
                                   data compression
    RILERRORCORRECTIONINFO         Defines parameters for
                                   error correction
    RILBEARERSVCINFO               Defines the current data
                                   communication settings
    RILRLPINFO                     Defines Radio Link
                                   Protocol (RLP)
                                   parameters for non-
                                   transparent data calls
    RILCONNECTINFO                 Defines connect
                                   information on
                                   a data call
    RILSERIALPORTSTATS             Defines statistics
                                   of the virtual serial port
    RILSERVICEINFO                 Defines parameters
                                   of the data connection
    RILSUPSERVICEDATA              Defines elements
                                   of a USSD message
                      Capability Structures
    RILCAPSBEARERSVC               Bearer service
                                   capabilities
    RILCAPSDIALSVC                 Dial capabilities
    RILCAPSHSCSD                   HSCSD capabilities
    RILCAPSLOCKINGPWD              Locking password
    LENGTH                         length capabilities
    RILCAPSMSGMEMORY               Message storage
    LOCATIONS                      location capabilities
    RILCAPSRLP                     RLP capabilities
                      SIM Toolkit Structures
    RILSIMCMDPARAMETERS            Elements of a
                                   SIM command
    RILSIMRESPONSE                 Elements of a SIM
                                   command response
                     Miscellaneous Structures
    RILEQUIPMENTINFO               Defines miscellaneous
                                   (generally static)
                                   properties of radio
                                   module
    RILPHONEBOOKINFO               Defines the state
                                   of the phonebook
    RILPHONEBOOKENTRY              Defines an entry
                                   in the phonebook
    RILCOSTINFO                    Defines cost
                                   information for the
                                   current operator's rate
    RILSIGNALQUALITY               Defines the current
                                   signal quality
    RILADDRESS                     A phone number
    RILSUBADDRESS                  More detailed information
                                   about a phone number
    RILCELLTOWERINFO               Information about the currently
                                   registered cell tower
    RILRANGE                       Defines a min/max range

    DwCode                       IpData                     Comments
    RIL_NOTIFY_REGSTATUS         ( RIL_REGSTAT_ * )         Sent with change
    CHANGED                      Constant                   in registration
                                                            status
    RIL_NOTIFY_CALLMETER         dwNewCallMeter             Call meter
                                                            has changed
    RIL_NOTIFY_CALLMETER         <NULL>               Maximum call
    MAXREACHED                                              meter has been
                                                            reached
                          Call Control Notifications
    RIL_NOTIFY_RING              RILRINGINFO Structure      Incoming call
    RIL_NOTIFY_CONNECT           RILCONNECTINFO             Call connected
                                 Structure
    RIL_NOTIFY_DISCONNECT        RIL_DISCINIT_* Constant    Call disconnected
    RIL_NOTIFY_DATASVC           RILSERVICEINFO             Data call
    NEGOTIATED                   Structure                  service has
                                                            been negotiated
    RIL_NOTIFY_CALLSTATE         <NULL>               Call state of
    CHANGED                                                 one or more calls
                                                            may have changed
    RIL_NOTIFY_EMERGENCY         <NULL>               RIL has entered
    MODEENTERED                                             emergency mode
    RIL_NOTIFY_EMERGENCY         <NULL>               RIL has exited
    MODEEXITED                                              emergency mode
    RIL_NOTIFY_EMERGENCY         <NULL>               Existing calls
    HANGUP                                                  (if any) were
                                                            hung up for
                                                            emergency mode
    RIL_NOTIFY_HSCSDPARAMS       RILCALLHSCSDINFO           HSCSD parameters
    NEGOTIATED                   Structure                  for a call
                                                            have been
                                                            negotiated
                      Supplemental Service Notifications
    RIL_NOTIFY_CALLERID          ( RILREMOTEPARTYINFO * )   The remote
                                                            address of the
                                                            incoming call
    RIL_NOTIFY_DIALEDID          ( RILREMOTEPARTYINFO * )   The destination
                                                            address of the
                                                            outgoing call
    RIL_NOTIFY_CALLWAITING       ( RILCALLWAITINGINFO * )   Call waiting
                                                            notification
    RIL_NOTIFY_SUPSERVICE        ( RILSUPSERVICEDATA* )     Incoming USSD
    DATA                                                    message
                            Messaging Notifications
    RIL_NOTIFY_MESSAGE           ( RILMESSAGE * )           Indicates a
                                                            new message
    RIL_NOTIFY_BCMESSAGE         ( RILMESSAGE * )           Indicates a
                                                            new broadcast
                                                            message
    RIL_NOTIFY_STATUS            ( RILMESSAGE * )           Indicates a
    MESSAGE                                                 new status
                                                            message
    RIL_NOTIFY_MSGSTORED         ( dwIndex )                Indicates a
                                                            message has
                                                            been stored
    RIL_NOTIFY_MSGDELETED        ( dwIndex )                Indicates a
                                                            message has
                                                            been deleted
    RIL_NOTIFY_MSGSTORAGE        RILMSGSTORAGEINFO          One of the
    CHANGED                      Structure                  message storage
                                                            locations has
                                                            been changed
                            Phonebook Notifications
    RIL_NOTIFY_PHONEBOOK         dwIndex                    Phonebook entry
    ENTRYSTORED                                             has been added
    RIL_NOTIFY_PHONEBOOK         dwIndex                    Phonebook entry
    ENTRYDELETED                                            has been deleted
    RIL_NOTIFY_PHONEBOOK         (RIL_PBLOC *)              Phonebook storage
    STORAGECHANGED               Constant                   location has
                                                            been changed
                           SIM Toolkit Notifications
    RIL_NOTIFY_SIMTOOLKIT        dwByteCount                Proactive SIM
    CMD                                                     command received
    RIL_NOTIFY_SIMTOOLKIT        dwRedialTimeout            Proactive SIM
    CALLSETUP                                               command to setup
                                                            a call
    RIL_NOTIFY_SIMTOOLKIT        dwByteCount                Toolkit command
    EVENT                                                   was handled by
                                                            the radio or radio
                                                            sent a toolkit
                                                            response to the SIM
                          Miscellaneous Notifications
    RIL_NOTIFY_SMSNOT            <NULL>               Sim has been
    ACCESSIBLE                                              removed or has
                                                            failed to respond
    RIL_NOTIFY_DTMFSIGNAL        ( char* )                  A DTMF signal has
                                                            been detected

    Function                       GSM                Comments
                             Network Service Functions
    RIL_GetSubscriberNumbers       +CNUM              Gets list
                                                      of assigned
                                                      phone numbers
    RIL_GetOperatorList            +COPS              Gets a list
                                                      of available
                                                      operators
    RIL_GetPreferredOperatorList   +CPOL              Gets a list
                                                      of preferred
                                                      operators
    RIL_AddPreferredOperator       +CPOL              Adds to the list
                                                      of preferred
                                                      operators
    RIL_RemovePreferredOperator    +CPOL              Removes from
                                                      the list of
                                                      preferred
                                                      operators
    RIL_GetCurrentOperator         +COPS              Gets the operator
                                                      currently registered
    RIL_RegisterOnNetwork          +COPS              Register with a
                                                      particular operator
    RIL_UnregisterFromNetwork      +COPS              Unregister current
                                                      operator
    RIL_GetRegistrationStatus      +CREG              Gets registration
                                                      status
                              Call Control Functions
    RIL_Dial                       D +FCLASS          Dials a number
    RIL_Answer                     A                  Answers an incoming
                                                      call
    RIL_Hangup                     H                  Sets operator
                                                      information
    RIL_SendDTMF                   +VTS               Sends DTMF tones
                                                      (e.g. during
                                                      a call)
    RIL_GetDTMFDuration            +VTD               Gets tone
                                                      duration options
    RIL_SetDTMFDuration            +VTD               Sets tone
                                                      duration options
    RIL_SetDTMFMonitoring                             Turns on/off
                                                      DTMF monitoring
    RIL_GetCallList                +CLCC              Retrieves list
                                                      of active calls
                                                      and their status
    RIL_ManageCalls                +CHLD              Changes call status
                                                      (hold, conference, etc)
    RIL_TransferCall               +CTFR              Explicitly transfers
                                                      a call
    RIL_GetLineStatus              +CPAS              Gets line status
                          Supplemental Service Functions
    RIL_SetCallerIDSettings        +CLIP              CallerID settings
    RIL_GetHideIDSettings          +CLIR              Hides own number
                                                      from recipient
    RIL_SetHideIDStatus            +CLIR              Hides own number
                                                      from recipient
    RIL_GetDialedIDSettings        +COLP              Dialed number on
                                                      an outgoing call
    RIL_SetDialedIDSettings        +COLP              Dialed number on
                                                      an outgoing call
    RIL_GetClosedGroupSettings     +CCUG              Closed user group
                                                      settings
    RIL_SetClosedGroupSettings     +CCUG              Closed user group
                                                      settings
    RIL_GetCallForwardSettings     +CCFC              Call forward
                                                      settings
    RIL_AddCallForwarding          +CCFC              Add a number
                                                      to the call
                                                      forwarding list
    RIL_RemoveCallForwarding       +CCFC              Remove a number
                                                      from the call
                                                      forwarding list
    RIL_SetCallForwardStatus       +CCFC              Enable/disable
                                                      call forwarding
    RIL_GetCallWaitingSettings     +CCWA              Call waiting
                                                      settings
    RIL_SetCallWaitingStatus       +CCWA              Call waiting
                                                      settings
                                  Voice Functions
    RIL_GetAudioGain               +VGR               Gets receive
                                   +VGT               gain of the
                                                      audio device
    RIL_SetAudioGain               +VGR               Sets receive
                                   +VGT               gain of the
                                                      audio device
    RIL_GetAudioDevices            +VGS               List connected
                                                      audio devices
                                                      (mic, speaker, etc)
    RIL_SetAudioDevices            +VGS               Sets connected
                                                      audio devices
                                                      (mic, speaker, etc)
    RIL_GetAudioMuting             +CMUT              Gets muting state
    RIL_SetAudioMuting             +CMUT              Sets muting state
                                Messaging Functions
    RIL_GetMsgServiceOptions       +CSMS +CPMS        Gets messaging
                                   +CMGF +CESP        service options
    RIL_SetMsgServiceOptions       +CSMS +CPMS        Sets messaging
                                   +CMGF +CESP        service options
    RIL_GetMsgConfig               +CSCA +CSMP        Gets message
                                   +CSDH +CSCB        configuration
                                                      options
    RIL_SetMsgConfig               +CSCA +CSMP        Sets message
                                   +CSDH +CSCB        configuration
                                                      options
    RIL_RestoreMsgConifg           +CRES              Restores messaging
                                                      settings
    RIL_SaveMsgConfig              +CSAS              Saves messaging
                                                      settings
    RIL_GetMsgList                 +CMGL              Lists all messages
    RIL_ReadMsg                    +CMGR +CMGD        Read (optionally
                                                      delete)
                                                      a message
    RIL_DeleteMsg                  +CMGD              Delete a message
    RIL_WriteMsg                   +CMGW +CMGS        Writes (optionally
                                   +CMMS              send)
                                                      a message
    RIL_SendMsg                    +CMGS +CMSS        Send a message
                                   +CMMS
    RIL_SendStoredMsg              +CMGS +CMSS        Send a message
                                   +CMMS              from a storage
                                                      location
    RIL_SendMsgAcknowledgement     +CMGS +CMSS        Send a message
                                   +CMMS              ACK when requested
                                                      by an incoming
                                                      message
                              Data Service Functions
    RIL_GetSerialPortHandle                           Gets a virtual
                                                      serial port
                                                      handle
    RIL_GetSerialPortStatistics                       Gets statistics
                                                      on the virtual
                                                      serial port
                                                      handle
    RIL_GetHSCSDOptions            +CHSD +CHDT        Get settings
                                   +CHSN +CHSC        for circuit
                                   +CHSR              switched data
                                                      calls
    RIL_SetHSCSDOptions            +CHSD +CHDT        Set settings
                                   +CHSN +CHSC        for circuit
                                   +CHSR              switched data
                                                      calls
    RIL_GetDataCompression         +DS                Gets data
                                                      compression
                                                      options
    RIL_SetDataCompression         +DS                Sets data
                                                      compression
                                                      options
    RIL_GetErrorCorrection         +EX                Gets error
                                                      correction
                                                      options
    RIL_SetErrorCorrection         +EX                Sets error
                                                      correction
                                                      options
    RIL_GetBearerServiceOptions
    RIL_SetBearerServiceOptions
    RIL_GetRLPOptions                                 Gets radio link protocol
     options
    RIL_SetRLPOptions                                 Sets radio link protocol
     options
    RIL_CancelSupServiceDataSession +CUSD              Cancel a USSD session
    RIL_SendSupServiceData         +CUSD              Send a USSD message
                                Security Functions
    RIL_GetUserIdentity            +CIMI              Retrieve the
                                                      customer's
                                                      mobile
                                                      identity
    RIL_UnlockPhone                +CPIN              Sends a
                                                      pending
                                                      password
    RIL_ChangeCallBarringPassword  +CPIN              Changes the
                                   +CPWD              call barring
                                                      password
    RIL_ChangeLockingPassword      +CPIN              Changes the
                                   +CPWD              locking password
    RIL_GetPhoneLockedState        +CPIN              Gets phone
                                                      lock status
    RIL_GetCallBarringStatus       +CLCK              Gets call
                                                      barring status
    RIL_SetCallBarringStatus       +CLCK              Sets call
                                                      barring status
    RIL_GetLockingStatus           +CLCK              Gets locking
                                                      status
    RIL_SetLockingStatus           +CLCK              Sets locking
                                                      status
                                Interface Functions
    RIL_Initialize                                    Registers RIL
                                                      proxy with RIL
                                                      driver
    RIL_Deinitialize                                  Unregisters
                                                      RIL proxy
                                                      from RIL driver
    RIL_InitializeEmergency                           Registers an
                                                      emergency
                                                      application
    RIL_DeinitializeEmergency                         Unregisters an
                                                      emergency
                                                      application
    RIL_EnableNotifications                           Sets which
                                                      notification
                                                      classes to receive
    RIL_DisableNotifications                          Disables
                                                      notification
                                                      classes from
                                                      being sent
                                Phonebook Functions
    RIL_GetPhonebookOptions        +CPBS              Gets the
                                                      phonebook
                                                      options
    RIL_SetPhonebookOptions        +CPBS              Sets the
                                                      phonebook
                                                      location
    RIL_DeletePhonebookEntry       +CPBW              Deletes a
                                                      phonebook
                                                      entry
    RIL_ReadPhonebookEntries       +CPBR              Get
                                                      phonebook
                                                      entry
    RIL_WritePhonebookEntry        +CPBW              Writes a
                                                      phonebook
                                                      entry
                               SIM Toolkit Functions
    RIL_FetchSimToolkitCmd         +CSIM              Retrieves a
                                                      proactive
                                                      toolkit command
    RIL_GetSimToolkitProfile                          Retrieves a
                                                      current profile
                                                      for a profile
                                                      download
    RIL_SetSimToolkitProfile                          Sets current
                                                      profile for a
                                                      profile download
    RIL_SendSimToolkitCmd          +CSIM              Sends a response
    Response                                          to a proactive
                                                      toolkit command
    RIL_SendSimToolkitEnvelope     +CSIM              Sends an envelope
    Cmd                                               command to the SIM
    RIL_TerminateSimToolkit        +CSIM              Terminates a
    Session                                           toolkit session
                              Miscellaneous Functions
    RIL_GetEquipmentInfo           +CGMI GMI +CGMM    Retrieves
                                   GMM +CGMR GMR      information
                                   +CGSN GSN          about the phone
                                                      equipment
    RIL_GetEquipmentState          +CFUN              Manages phone
                                                      state (power
                                                      management)
    RIL_SetEquipmentState          +CFUN              Manages phone
                                                      state (power
                                                      management)
    RIL_SendSimCmd                 +CSIM              Sends unrestricted



                                                      commands directly
                                                      to a SIM
    RIL_SendRestrictedSimCmd       +CRSM              Sends a restricted
                                                      set of commands
                                                      directly to a SIM
    RIL_ResetTerminal              Z & F              Resets all
                                                      terminal
                                                      parameters
                                                      to defaults
    RIL_GetCostInfo                +CAOC +CPUC        Retrieves advice
                                                      of charge
                                                      information
    RIL_SetCostInfo                +CAOC +CPUC        Sets advice
                                                      of charge
                                                      information
    RIL_GetSignalQuality           +CSQ               Gets signal
                                                      quality
    RIL_GetDevCaps                                    Retrieves the
                                                      capabilities of
                                                      the radio device
    RIL_DevSpecific                                   Developer specific
                                                      command
    RIL_GetCellTowerInfo           +CREG              Gets info about
                                                      the currently
                                                      used cell tower

• Inventors
  Shell, Scott R.; Sherman, Roman; Shen, Alan W.;
• Assignee
  Microsoft Corporation (Redmond, WA)
• Published
  Nov-30-2004
• Current US Classes:
  719/311
  719/313
  719/321
  719/322
  719/327
  719/328
  719/329
• Application #
  788317
• International Classes
  G06F 001/12
• Field of Search
  719/311 719/313 719/321 719/322 719/327 719/328 719/329 709/310
• Examiner
  El-Hady; Nabil
• Agent
  Merchant & Gould
• US Patent References:
  6018571
  6141564
  6269254
  6584185