Add files using upload-large-folder tool

marked/Rel-16/23_series/23090/raw.md

@@ -0,0 +1,1214 @@
+
+
+
+
+
+
+# Contents
+
+|                                                                  |    |
+|------------------------------------------------------------------|----|
+| Foreword .....                                                   | 4  |
+| 1 Scope.....                                                     | 5  |
+| 2 References.....                                                | 5  |
+| 3 Abbreviations .....                                            | 6  |
+| 4 Cross phase compatibility .....                                | 6  |
+| 5 Network initiated unstructured supplementary service.....      | 6  |
+| 5.1 Handling of network initiated USSD .....                     | 6  |
+| 5.2 Functions and information flows.....                         | 6  |
+| 5.2.1 Invoking unstructured SS operation from the HLR .....      | 6  |
+| 5.2.2 Invoking unstructured SS operation from the VLR .....      | 7  |
+| 5.2.3 Invoking unstructured SS operation from the MSC .....      | 7  |
+| 5.2.4 Forwarding USSD operations.....                            | 7  |
+| 5.2.5 Handling of unstructured SS operation at the MS.....       | 8  |
+| 5.3 Information stored in the HLR.....                           | 15 |
+| 5.4 Information stored in the VLR.....                           | 15 |
+| 5.5 Handover .....                                               | 15 |
+| 5.6 Cross-phase compatibility .....                              | 16 |
+| 6 Mobile initiated unstructured supplementary service data ..... | 16 |
+| 6.1 Handling of mobile initiated USSD .....                      | 16 |
+| 6.2 Functions and information flows.....                         | 16 |
+| 6.2.1 Handling of USSD request at MS .....                       | 16 |
+| 6.2.2 Handling of USSD request at MSC.....                       | 17 |
+| 6.2.3 Handling of USSD request at VLR .....                      | 17 |
+| 6.2.4 Handling of USSD request at HLR .....                      | 17 |
+| 6.2.5 Processing the USSD request .....                          | 17 |
+| 6.3 Information stored in the HLR.....                           | 30 |
+| 6.4 Information stored in the VLR.....                           | 31 |
+| 6.5 Handover .....                                               | 31 |
+| 6.6 Cross-phase compatibility .....                              | 31 |
+| Annex A (informative): Change history.....                       | 32 |
+
+# --- Foreword
+
+This Technical Specification has been produced by the 3<sup>rd</sup> Generation Partnership Project (3GPP).
+
+The contents of the present document are subject to continuing work within the TSG and may change following formal TSG approval. Should the TSG modify the contents of the present document, it will be re-released by the TSG with an identifying change of release date and an increase in version number as follows:
+
+Version x.y.z
+
+where:
+
+- x the first digit:
+  - 1 presented to TSG for information;
+  - 2 presented to TSG for approval;
+  - 3 or greater indicates TSG approved document under change control.
+- y the second digit is incremented for all changes of substance, i.e. technical enhancements, corrections, updates, etc.
+- z the third digit is incremented when editorial only changes have been incorporated in the document.
+
+# 1 Scope
+
+The present document gives the stage 2 description of Unstructured Supplementary Service Data (USSD).
+
+The unstructured supplementary service data (USSD) mechanism allows the Mobile Station (MS) user and a PLMN operator defined application to communicate in a way which is transparent to the MS and to intermediate network entities. The mechanism allows development of PLMN specific supplementary services. The following diagram shows how handling of USSD is carried out, independently of the applications.
+
+![Diagram illustrating the handling of USSD across network entities: USER, MS, MSC, VLR, and HLR. The USER is connected to the MS. The MS contains an MMI and a USSD Handler. The MSC, VLR, and HLR each contain Applications and a USSD Handler. A horizontal line connects the USSD Handler in the MS to the USSD Handler in the MSC, which is then connected to the USSD Handler in the VLR, which is finally connected to the USSD Handler in the HLR.](ca5566458a134032dd860e88fdaa0d2b_img.jpg)
+
+```
+graph LR; USER[USER] --- MS[MS]; subgraph MS; MMI[MMI] --- USSD_H[USSD Handler]; end; subgraph MSC; Apps1[Applications] --- USSD_H1[USSD Handler]; end; subgraph VLR; Apps2[Applications] --- USSD_H2[USSD Handler]; end; subgraph HLR; Apps3[Applications] --- USSD_H3[USSD Handler]; end; USSD_H --- USSD_H1 --- USSD_H2 --- USSD_H3;
+```
+
+Diagram illustrating the handling of USSD across network entities: USER, MS, MSC, VLR, and HLR. The USER is connected to the MS. The MS contains an MMI and a USSD Handler. The MSC, VLR, and HLR each contain Applications and a USSD Handler. A horizontal line connects the USSD Handler in the MS to the USSD Handler in the MSC, which is then connected to the USSD Handler in the VLR, which is finally connected to the USSD Handler in the HLR.
+
+**Figure 1.1: Handling of USSD**
+
+The present document defines the requirements for handling USSD at the MS and network entities. It does not include specification of particular applications, nor does it specify how a particular application is selected. Where more than one application exists at a network entity, routing of messages to the correct application is carried out by the USSD handler. The MMI for USSD is specified in TS 22.030 and TS 22.090. The alphabet indicator and the data coding scheme are defined in TS 23.038.
+
+USSD may be initiated by the MS user, or by the network in the following ways:
+
+- Network initiated USSD (clause 1);
+- Mobile initiated USSD (clause 2).
+
+# 2 References
+
+The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
+
+- References are either specific (identified by date of publication, edition number, version number, etc.) or non-specific.
+- For a specific reference, subsequent revisions do not apply.
+- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document *in the same Release as the present document*.
+
+- [1] 3GPP TR 21.905: "3G Vocabulary".
+- [2] 3GPP TS 22.030: "Man-Machine Interface (MMI) of the User Equipment (UE)".
+- [3] 3GPP TS 22.090: "Unstructured Supplementary Service Data (USSD) - Stage 1".
+- [4] 3GPP TS 23.038: "Alphabets and language-specific information".
+
+# --- 3 Abbreviations
+
+In addition to those below, abbreviations used in the present document are listed in TR 21.905 [1].
+
+|      |                                         |
+|------|-----------------------------------------|
+| AI   | Application Initiated                   |
+| MI   | Mobile Initiated                        |
+| USSD | Unstructured Supplementary Service Data |
+
+# --- 4 Cross phase compatibility
+
+The Phase 1 series of GSM specifications defined the signalling protocol which may be used, but they did not specify the operation of USSD as a service.
+
+The main body of the present document assumes that the MS and all network entities comply with this phase of USSD. In order to minimize any possible problems between a Phase 1 implementation of USSD and this phase, subclauses 5.6 and 6.6 define the additional requirements for when one or more entity complies with the Phase 1 USSD specification for network initiated and mobile initiated USSD respectively.
+
+# --- 5 Network initiated unstructured supplementary service
+
+## 5.1 Handling of network initiated USSD
+
+The network (MSC, VLR or HLR) can at any time send a USSD operation towards an MS. This operation may be either a request (asking the MS to provide information) or a notification (requiring no information in the response from the MS). No prior provision of USSD is required, although provision of services which make use of USSD may be required. All USSD requests, notifications and responses (except responses to notifications) contain the USSD string, an alphabet indicator and language indicator.
+
+## 5.2 Functions and information flows
+
+The following text describes the handling of network initiated USSD. Diagrammatic representations are as follows:
+
+|            |                                                           |
+|------------|-----------------------------------------------------------|
+| Figure 5.1 | SDL for USSD invocation (HLR, VLR, MSC);                  |
+| Figure 5.2 | SDL for forwarding of USSD operations (VLR, MSC);         |
+| Figure 5.3 | SDL for MS;                                               |
+| Figure 5.4 | Information flow for successful single USSD request;      |
+| Figure 5.5 | Information flow for successful single USSD notification; |
+| Figure 5.6 | Information flow for successful multiple USSD requests;   |
+| Figure 5.7 | Information flow for failed USSD request.                 |
+
+### 5.2.1 Invoking unstructured SS operation from the HLR
+
+When an application in the HLR is to send a USSD request or notification to an MS, it shall set up a transaction to the VLR where the subscriber is currently registered and send the operation to the VLR. It shall then await a response. The HLR is responsible for controlling the transaction, and shall therefore normally release the transaction when it receives a response from the VLR. The HLR may also release the transaction before receiving a response if necessary (e.g. if an application timer expires).
+
+If an application in the HLR needs to send further operations to the same MS as part of the same application, it may continue to use the same transaction until all operations are completed (see figure 5.6). If a different transaction is to be used for a subsequent operation, the HLR shall release the first transaction before starting the next.
+
+If the VLR releases the transaction at any time (e.g. due to user clearing), the HLR shall inform the application and terminate the USSD operation.
+
+See subclause 5.2.4 for forwarding of an HLR invoked operation by the VLR and MSC.
+
+### 5.2.2 Invoking unstructured SS operation from the VLR
+
+When an application in the VLR is to send a USSD request or notification to an MS, it shall set up a transaction to the MSC where the subscriber is currently registered and send the operation to the MSC. It shall then await a response. The VLR is responsible for controlling the transaction, and shall therefore normally release the transaction when it receives a response from the MSC. The VLR may also release the transaction before receiving a response if necessary (e.g. if an application timer expires).
+
+If an application in the VLR needs to send further operations to the same MS as part of the same application, it may continue to use the same transaction until all operations are completed. If a different transaction is to be used for a subsequent operation, the VLR shall release the first transaction before starting the next.
+
+See subclause 5.2.4 for forwarding of a VLR invoked operation by the MSC.
+
+If the MSC releases the transaction at any time (e.g. due to the user clearing), the VLR shall inform the application and terminate the USSD operation.
+
+### 5.2.3 Invoking unstructured SS operation from the MSC
+
+When an application in the MSC is to send a USSD request or notification to an MS, it shall set up a transaction to the MS where the subscriber is currently registered and send the operation to the MS. It shall then await a response. The MSC is responsible for controlling the transaction, and shall therefore normally release the transaction when it receives a response from the MS. The MSC may also release the transaction before receiving a response if necessary (e.g. if an application timer expires).
+
+If an application in the MSC needs to send further operations to the same MS as part of the same application, it may continue to use the same transaction until all operations are completed. If a different transaction is to be used for a subsequent operation, the VLR shall release the first transaction before starting the next.
+
+If the MS releases the transaction at any time (e.g. due to the user clearing), the MSC shall inform the application and terminate the USSD operation.
+
+NOTE: MSC invoked USSD is only likely to be used for call related operations, where the application is controlling a call to or from the MS.
+
+### 5.2.4 Forwarding USSD operations
+
+The VLR may any time receive a USSD operation from the HLR. If the subscriber can be contacted, the VLR shall set up a transaction to the MSC and forward the operation unchanged. Any further information exchange between the HLR and MSC shall be transparent to the VLR. When one transaction is released, the VLR shall release the other.
+
+The MSC may at any time receive an USSD operation from the VLR. If the subscriber can be contacted, the MSC shall set up a transaction to the MS and forward the operation unchanged. Any further information exchange between the VLR and MS shall be transparent to the MSC. When one transaction is released, the MSC shall release the other.
+
+### 5.2.5 Handling of unstructured SS operation at the MS
+
+The MS may at any time receive a USSD operation (request or notification) from the MSC.
+
+If the MS receives a USSD transaction while another USSD transaction (network or mobile initiated) or a non-call related supplementary service transaction is in progress, the MS shall reject the new transaction.
+
+If the MS receives a USSD operation when it is in a state where the MMI required is not possible (e.g. during dialling) it shall reject the operation.
+
+If the MS does not support the alphabet indicated in the USSD operation, it shall inform the network.
+
+If the MS is in a state where it can handle the operation, it shall process the operation as follows:
+
+- The MS shall analyse the data coding scheme and decides whether the USSD operation is MMI mode or application mode. See 3GPP TS 22. 030 [2] for details of codes.
+
+If the data coding scheme corresponds to the MMI mode :
+
+- For a USSD request, the MS shall display the text provided and await user input. If the user enters a response, the MS shall return the response to the MSC, maintaining the transaction. If the user requests release of the transaction, the MS shall release the transaction.
+- For a USSD notification, the MS shall display the text provided and send back a response.
+
+If the data coding schemes corresponds to the application mode :
+
+- For a USSD request, the MS shall pass the message to the application addressed in the ME, SIM or TE, and await application response . If the application responds, the MS shall pass the response to the MSC, maintaining the transaction. If the application releases the transaction, the MS shall release the transaction.
+- For a USSD notification, the MS shall pass the message to the application addressed in the ME, SIM or TE, and send back a response.
+
+After sending the response to a USSD operation, the MS shall wait for the network to release the transaction. If, while awaiting this release, the MS receives any further USSD operations, it shall process them in the normal way.
+
+![State transition diagram for Process USSD_NI1. It shows two main entry points: 'USSD notify' and 'USSD request'. Both lead to 'MS reachable' decision diamonds. If 'no', they lead to 'RELEASE (error)' and then 'idle'. If 'yes', they lead to 'USSD notify' and 'USSD request' respectively, which then merge into 'NW wait user response'. From 'NW wait user response', four paths emerge: 'error' (leading to 'error' and then 'wait for application'), 'USSD response' (leading to 'USSD response' and then 'wait for application'), 'release' (leading to 'release' and then 'idle'), and 'release' (leading to 'release' and then 'idle'). From 'wait for application', four paths emerge: 'USSD notify' (leading to 'USSD notify' and then 'NW wait user response'), 'USSD request' (leading to 'USSD request' and then 'NW wait user response'), 'release' (leading to 'release' and then 'idle'), and 'release' (leading to 'release' and then 'idle').](b3baf3a29b67c7425d2562ddbc52f0cc_img.jpg)
+
+**Process USSD\_NI1**
+
+390\_51(1)
+
+**INPUTS AND OUTPUTS**
+
+Source/destination of messages shown to/from the right is the application.
+
+Source/destination of messages shown to/from the left depends on the entity being described, as follows:
+
+| Entity | To/From |
+|--------|---------|
+| HLR    | VLR     |
+| VLR    | MSC     |
+| MSC    | MS      |
+
+State transition diagram for Process USSD\_NI1. It shows two main entry points: 'USSD notify' and 'USSD request'. Both lead to 'MS reachable' decision diamonds. If 'no', they lead to 'RELEASE (error)' and then 'idle'. If 'yes', they lead to 'USSD notify' and 'USSD request' respectively, which then merge into 'NW wait user response'. From 'NW wait user response', four paths emerge: 'error' (leading to 'error' and then 'wait for application'), 'USSD response' (leading to 'USSD response' and then 'wait for application'), 'release' (leading to 'release' and then 'idle'), and 'release' (leading to 'release' and then 'idle'). From 'wait for application', four paths emerge: 'USSD notify' (leading to 'USSD notify' and then 'NW wait user response'), 'USSD request' (leading to 'USSD request' and then 'NW wait user response'), 'release' (leading to 'release' and then 'idle'), and 'release' (leading to 'release' and then 'idle').
+
+**Figure 5.1: Network initiated USSD invoked at HLR, VLR or MSC**
+
+![State transition diagram for Process USSD_NI2. The diagram shows the flow of USSD messages between a network entity (VLR or MSC) and a mobile station (MS). It starts in an 'idle' state. From 'idle', a 'USSD notify' or 'USSD request' can be received. Each leads to an 'MS reachable' decision. If 'no', a 'RELEASE (error)' is sent and the state returns to 'idle'. If 'yes', the message is forwarded ('USSD notify' or 'USSD request') to a 'forwarding wait user' state. From 'forwarding wait user', four responses are possible: 'error', 'USSD response', 'release', or 'release'. 'error' leads to an 'error' state and back to 'idle'. 'USSD response' leads to a 'USSD response' state and then to 'forwarding wait application'. 'release' leads to a 'release' state and then to 'idle'. 'forwarding wait application' leads to four states: 'USSD notify', 'USSD request', 'release', or 'release'. 'USSD notify' and 'USSD request' lead to their respective states and then back to 'forwarding wait user'. 'release' leads to a 'release' state and then to 'idle'.](e6df2733626a85205c1db682e6259c46_img.jpg)
+
+**Process USSD\_NI2**
+
+390\_52(1)
+
+**INPUTS AND OUTPUTS**
+
+Source/destination of messages depends on the entity being described, as follows:
+
+| Entity | Left | Right |
+|--------|------|-------|
+| VLR    | MSC  | HLR   |
+| MSC    | MS   | VLR   |
+
+```
+stateDiagram-v2
+    [*] --> idle
+    idle --> USSD_notify_in {USSD notify}
+    idle --> USSD_request_in {USSD request}
+    USSD_notify_in --> MS_reachable_notify {MS reachable}
+    USSD_request_in --> MS_reachable_request {MS reachable}
+    MS_reachable_notify -- no --> RELEASE_error_notify [RELEASE (error)]
+    MS_reachable_notify -- yes --> USSD_notify_out {USSD notify}
+    MS_reachable_request -- no --> RELEASE_error_request [RELEASE (error)]
+    MS_reachable_request -- yes --> USSD_request_out {USSD request}
+    RELEASE_error_notify --> idle
+    RELEASE_error_request --> idle
+    USSD_notify_out --> forwarding_wait_user {forwarding wait user}
+    USSD_request_out --> forwarding_wait_user
+    forwarding_wait_user --> error_in {error}
+    forwarding_wait_user --> USSD_response_out {USSD response}
+    forwarding_wait_user --> release_out1 {release}
+    forwarding_wait_user --> release_out2 {release}
+    error_in --> error_out {error}
+    error_out --> idle
+    USSD_response_out --> USSD_response_in {USSD response}
+    USSD_response_in --> forwarding_wait_application {forwarding wait application}
+    release_out1 --> release_in1 {release}
+    release_out2 --> release_in2 {release}
+    release_in1 --> idle
+    release_in2 --> idle
+    forwarding_wait_application --> USSD_notify_out2 {USSD notify}
+    forwarding_wait_application --> USSD_request_out2 {USSD request}
+    forwarding_wait_application --> release_out3 {release}
+    forwarding_wait_application --> release_out4 {release}
+    USSD_notify_out2 --> USSD_notify_in2 {USSD notify}
+    USSD_request_out2 --> USSD_request_in2 {USSD request}
+    USSD_notify_in2 --> forwarding_wait_user
+    USSD_request_in2 --> forwarding_wait_user
+    release_out3 --> release_in3 {release}
+    release_out4 --> release_in4 {release}
+    release_in3 --> idle
+    release_in4 --> idle
+```
+
+State transition diagram for Process USSD\_NI2. The diagram shows the flow of USSD messages between a network entity (VLR or MSC) and a mobile station (MS). It starts in an 'idle' state. From 'idle', a 'USSD notify' or 'USSD request' can be received. Each leads to an 'MS reachable' decision. If 'no', a 'RELEASE (error)' is sent and the state returns to 'idle'. If 'yes', the message is forwarded ('USSD notify' or 'USSD request') to a 'forwarding wait user' state. From 'forwarding wait user', four responses are possible: 'error', 'USSD response', 'release', or 'release'. 'error' leads to an 'error' state and back to 'idle'. 'USSD response' leads to a 'USSD response' state and then to 'forwarding wait application'. 'release' leads to a 'release' state and then to 'idle'. 'forwarding wait application' leads to four states: 'USSD notify', 'USSD request', 'release', or 'release'. 'USSD notify' and 'USSD request' lead to their respective states and then back to 'forwarding wait user'. 'release' leads to a 'release' state and then to 'idle'.
+
+Figure 5.2: Network initiated USSD forwarding at VLR or MSC
+
+![SDL Flowchart for Process USSD_NI3: Network initiated USSD at MS.](5a4e62bead259c258d069fd3663ea670_img.jpg)
+
+**Process USSD\_NI3** 390\_53(1)
+
+INPUTS AND OUTPUTS
+
+Source/destination of messages shown to/from the left is the MS MMI.
+
+Source/destination of messages shown to/from the right is the network.
+
+**Detailed Diagram Description:**  
+ The flowchart describes the **Process USSD\_NI3** starting from an **idle** state. 
+ Two main branches originate from the network side:
+ 
+
+- Branch 1 (USSD notify):** Leads to checks for 'alphabet supported' (no -> connector 1), 'valid state' (no -> connector 1), and 'Mode = MMI mode'.
+  - If 'Mode = MMI mode' is yes: It sends 'USSD notify' to MS MMI, then 'USSD notify' to the network, and ends at connector 1.
+  - If 'Mode = MMI mode' is no: It checks 'Mode = application mode?'. If yes, it goes to an **error** state and then **wait network action**. If no, it goes to connector 3.
+- Branch 2 (USSD request):** Leads to checks for 'alphabet supported' (no -> connector 2) and 'valid state' (no -> connector 2).
+  - If 'Mode = MMI mode' is yes: It sends 'USSD request' to MS MMI, enters state **MS wait user response**, receives 'USSD response' from MMI, sends 'USSD response' to network, enters **wait network action**, and finally sends/receives 'USSD notify'/'USSD request' before ending at connector 1 or 2.
+  - If 'Mode = MMI mode' is no: It checks 'Mode = application mode?'. If yes, it sends 'USSD request' to the application (note: 'Send to the application in the MS'), enters **MS wait application response**, and handles various 'release' signals before returning to **idle**.
+
+ Connectors 1 and 2 return the process to the **idle** state. Connector 3 leads to a 'USSD notify' output to the MMI.
+
+SDL Flowchart for Process USSD\_NI3: Network initiated USSD at MS.
+
+Figure 5.3: Network initiated USSD at MS
+
+![Sequence diagram showing information flow for USSD request (Single Operation) between MS, MSC, VLR, and HLR.](27b06ec9f42b5d727a2630f61a5f1861_img.jpg)
+
+The diagram illustrates the information flow for a USSD request (Single Operation) across four entities: MS (Mobile Station), MSC (Mobile Switching Center), VLR (Visitor Location Register), and HLR (Home Location Register). The sequence is divided into three initiation scenarios:
+
+- HLR initiated:**
+  - The HLR sends a **USSD request** to the VLR.
+  - The VLR forwards the **USSD request** to the MSC.
+  - The MSC sends a **USSD request** to the MS.
+  - The MS returns a **USSD response** to the MSC.
+  - The MSC forwards the **USSD response** to the VLR.
+  - The VLR sends a **Release** message to the HLR.
+  - The HLR sends a **Release** message to the MSC.
+  - The MSC sends a **Release** message to the MS.
+- VLR initiated:**
+  - The VLR sends a **USSD request** to the MSC.
+  - The MSC sends a **USSD request** to the MS.
+  - The MS returns a **USSD response** to the MSC.
+  - The MSC forwards the **USSD response** to the VLR.
+  - The VLR sends a **Release** message to the MSC.
+  - The MSC sends a **Release** message to the MS.
+- MSC initiated:**
+  - The MSC sends a **USSD request** to the MS.
+  - The MS returns a **USSD response** to the MSC.
+  - The MSC sends a **Release** message to the MS.
+
+Sequence diagram showing information flow for USSD request (Single Operation) between MS, MSC, VLR, and HLR.
+
+Figure 5.4: Information flow for USSD request (Single Operation)
+
+![Sequence diagram showing information flow for USSD notification (Single Operation) between MS, MSC, VLR, and HLR.](ff0952ef692c9d960ce5f6708bcc9711_img.jpg)
+
+```
+sequenceDiagram
+    participant MS
+    participant MSC
+    participant VLR
+    participant HLR
+
+    Note left of MS: HLR initiated
+    HLR->>VLR: USSD notify
+    VLR->>MSC: USSD notify
+    MSC->>MS: USSD notify
+    MS->>MSC: USSD response
+    MSC->>VLR: USSD response
+    VLR->>HLR: USSD response
+    MSC->>VLR: Release
+    VLR->>MS: Release
+
+    Note left of MS: VLR initiated
+    VLR->>MSC: USSD notify
+    MSC->>MS: USSD notify
+    MS->>MSC: USSD response
+    MSC->>VLR: USSD response
+    MSC->>VLR: Release
+    VLR->>MS: Release
+
+    Note left of MS: MSC initiated
+    MSC->>MS: USSD notify
+    MS->>MSC: USSD response
+    MSC->>MS: Release
+```
+
+The diagram illustrates the information flow for a USSD notification (Single Operation) across four entities: MS (Mobile Station), MSC (Mobile Switching Center), VLR (Visitor Location Register), and HLR (Home Location Register). It is divided into three sections based on the initiator: HLR initiated, VLR initiated, and MSC initiated. In the HLR initiated section, the HLR sends a USSD notify to the VLR, which then forwards it to the MSC and then to the MS. The MS sends a USSD response back to the MSC, which is then forwarded by the MSC to the VLR and finally to the HLR. A Release message is sent from the MSC to the VLR, which then forwards it to the MS. In the VLR initiated section, the VLR sends a USSD notify to the MSC, which then forwards it to the MS. The MS sends a USSD response back to the MSC, which is then forwarded by the MSC to the VLR. A Release message is sent from the MSC to the VLR, which then forwards it to the MS. In the MSC initiated section, the MSC sends a USSD notify to the MS. The MS sends a USSD response back to the MSC. A Release message is sent from the MSC to the MS.
+
+Sequence diagram showing information flow for USSD notification (Single Operation) between MS, MSC, VLR, and HLR.
+
+Figure 5.5: Information flow for USSD notification (Single Operation)
+
+![Sequence diagram showing information flow for HLR initiated USSD request between MS, MSC, VLR, and HLR.](a33da0f14e456f92539ce3e9b7d81f9a_img.jpg)
+
+The diagram is a sequence diagram with four lifelines: MS, MSC, VLR, and HLR. The interaction consists of two identical USSD request-response cycles, separated by a vertical ellipsis. In the first cycle, the HLR sends a 'USSD request' to the VLR, which then forwards it to the MSC. The MSC sends a 'USSD request' to the MS. The MS responds with a 'USSD response' to the MSC, which is then forwarded by the MSC to the VLR, and finally by the VLR to the HLR. The HLR sends a 'Release' message to the VLR, which is forwarded by the VLR to the MSC, and finally by the MSC to the MS. The second cycle follows the same pattern. The 'Release' message is the last message in the sequence.
+
+```
+sequenceDiagram
+    participant MS
+    participant MSC
+    participant VLR
+    participant HLR
+    Note right of HLR: First USSD Request
+    HLR->>VLR: USSD request
+    VLR->>MSC: USSD request
+    MSC->>MS: USSD request
+    MS-->>MSC: USSD response
+    MSC-->>VLR: USSD response
+    VLR-->>HLR: USSD response
+    HLR->>VLR: Release
+    VLR-->>MSC: Release
+    MSC-->>MS: Release
+    Note right of HLR: Second USSD Request
+    HLR->>VLR: USSD request
+    VLR->>MSC: USSD request
+    MSC->>MS: USSD request
+    MS-->>MSC: USSD response
+    MSC-->>VLR: USSD response
+    VLR-->>HLR: USSD response
+    HLR->>VLR: Release
+    VLR-->>MSC: Release
+    MSC-->>MS: Release
+```
+
+Sequence diagram showing information flow for HLR initiated USSD request between MS, MSC, VLR, and HLR.
+
+**Figure 5.6: Information flow for HLR initiated USSD request (Multiple Operation On Same Transaction)**
+
+![Sequence diagram showing information flow for a failed USSD request between MS, MSC, VLR, and HLR.](7efae06af3af43ffe5d4b956a679cf54_img.jpg)
+
+```
+
+sequenceDiagram
+    participant MS
+    participant MSC
+    participant VLR
+    participant HLR
+
+    Note left of MS: VLR cannot contact subscriber
+    Note left of MSC: MSC cannot contact subscriber
+    Note left of MS: Error detected at MS
+    Note left of MS: MS clears transaction
+
+    HLR->>VLR: USSD request
+    VLR-->>HLR: Error
+    MSC->>VLR: USSD request
+    VLR-->>HLR: Error
+    MSC-->>VLR: Error
+    MSC->>VLR: USSD request
+    VLR-->>HLR: Error
+    MSC-->>VLR: Error
+    MSC->>VLR: USSD request
+    VLR-->>HLR: Error
+    MSC-->>VLR: Error
+    MSC->>VLR: USSD request
+    VLR-->>HLR: Release
+    MSC-->>VLR: Release
+    MSC->>MS: USSD request
+    MS-->>MSC: Error
+    MSC-->>MS: Release
+  
+```
+
+The sequence diagram illustrates the information flow for a failed USSD request. It involves four lifelines: MS (Mobile Station), MSC (Mobile Switching Center), VLR (Visitor Location Register), and HLR (Home Location Register). The process starts with the HLR sending a USSD request to the VLR, which returns an error. The MSC then sends a USSD request to the VLR, which again returns an error. The MSC receives an error from the VLR and sends another USSD request to the VLR, which returns an error. The MSC receives another error from the VLR and sends a USSD request to the VLR, which returns a release message. The MSC receives the release message from the VLR and sends a USSD request to the MS, which returns an error. The MSC receives the error from the MS and sends a release message to the MS. The diagram also includes notes indicating that the VLR cannot contact the subscriber, the MSC cannot contact the subscriber, an error is detected at the MS, and the MS clears the transaction.
+
+Sequence diagram showing information flow for a failed USSD request between MS, MSC, VLR, and HLR.
+
+Figure 5.7: Information flow for failed USSD request
+
+## 5.3 Information stored in the HLR
+
+The HLR shall not store any information specific to the use of USSD, although information may be stored for services which are offered by USSD applications.
+
+## 5.4 Information stored in the VLR
+
+The VLR shall not store any information specific to the use of USSD, although information may be stored for services which are offered by USSD applications.
+
+## 5.5 Handover
+
+Handover will have no impact on the operation of this service.
+
+## 5.6 Cross-phase compatibility
+
+Network initiated USSD shall not be permitted if the MS or any network entity involved in the operation is of Phase 1. If, when setting up a transaction, a network entity discovers that the other end is of Phase 1, it shall reject the request and release the transaction being set up.
+
+# --- 6 Mobile initiated unstructured supplementary service data
+
+## 6.1 Handling of mobile initiated USSD
+
+A MS can at any time initiate a USSD request to the network. No prior provision of the service is required, although provisioning of services which make use of USSD may be required. All USSD messages (requests and responses), contain the USSD string, an alphabet indicator and language indicator.
+
+## 6.2 Functions and information flows
+
+The following text describes the handling of mobile network initiated USSD. Diagrammatic representations are as follows:
+
+- Figure 6.1 SDL, request from user at MS;
+- Figure 6.2 SDL, request from MS at MSC;
+- Figure 6.3 SDL, request from application at MSC;
+- Figure 6.4 SDL, request from MSC at VLR;
+- Figure 6.5 SDL, request from application at VLR;
+- Figure 6.6 SDL, request from VLR at HLR;
+- Figure 6.7 Information flow, no further information required;
+- Figure 6.8 Information flow, further information required;
+- Figure 6.9 Information flow for failed USSD request.
+
+### 6.2.1 Handling of USSD request at MS
+
+When the user or the application in the MS makes a request which the MS determines is to make use of USSD, the MS shall set up a transaction to the network, send the request to the MSC and await a response. When the MS receives the response, it shall display the information contained to the user or relay the message to the application in the MS.
+
+While awaiting the response, the MS may receive a network initiated USSD request or notification on the same transaction. If this occurs, the MS shall process that operation (see section 1) and continue to await the response to the mobile initiated request.
+
+If, when the MS determines that a user request is to make use of USSD, the MS is already involved in a USSD or a non-call related supplementary service transaction, the MS shall reject the request.
+
+### 6.2.2 Handling of USSD request at MSC
+
+When an MSC receives a USSD request containing an HPLMN service code, it shall set up a transaction to the VLR and forward the request unchanged. If this forwarding fails, an error shall be returned to the MS. The MSC shall be transparent to any further requests or responses (in either direction) for that transaction, passing them between the MS and VLR without taking any action. When one transaction is released (MS-MSC or MSC-VLR), the MSC shall release the other.
+
+If an HPLMN service code is not included, the MSC shall process the request locally (see section 6.2.5).
+
+If the MSC does not support the alphabet used in a USSD request, it shall set up a transaction to the VLR and forward the request unchanged, in the same way as when a HPLMN service code is received.
+
+### 6.2.3 Handling of USSD request at VLR
+
+When a VLR receives a USSD request containing an HPLMN service code and the user is not in the HPLMN, it shall set up a transaction to the HLR and forward the request unchanged. If this forwarding fails, an error shall be returned to the MS. The VLR shall be transparent to any further requests or responses (in either direction) for that transaction, passing them between the MSC and HLR without taking any action. When one transaction is released (MSC-VLR or VLR-HLR), the VLR shall release the other.
+
+If an HPLMN service code is not included, or the user is in the HPLMN, the VLR shall process the request locally (see subclause 6.2.5).
+
+If the VLR does not support the alphabet used in a USSD request, it shall set up a transaction to the HLR and forward the request unchanged, in the same way as when a HPLMN service code is received and the user is not in the HPLMN.
+
+### 6.2.4 Handling of USSD request at HLR
+
+An HLR shall always process a USSD request locally (see subclause 6.2.5).
+
+If the HLR does not support the alphabet used in a USSD request, it shall inform the MS and release the transaction.
+
+### 6.2.5 Processing the USSD request
+
+When a network entity is to process a USSD request locally, the request shall be handled by an appropriate application. The location, nature and contents of USSD applications is, by definition, service provider and network operator dependent, but may include:
+
+- Setting up or releasing signalling and/or speech channels;
+- Passing the request to another network entity (unchanged or changed);
+- Passing a different USSD request to another network entity;  
+and/or
+- Requesting further information from the MS (one or more times).
+
+Upon completion of handling the request, the network entity shall respond to the request and release the transaction.
+
+![State transition diagram for Mobile Initiated USSD (USSD_MI1). The process starts at 'idle', receives a 'USSD request' from the application/user, enters 'wait network response', then branches into 'USSD response' (idle), 'USSD notify' (wait network response), 'USSD request' (MI wait user response), 'release' (idle), or 'error' (idle). The 'MI wait user response' state further branches into 'USSD response' (wait network response), 'release' (idle), or 'error' (idle).](4356776ca004ecba5d599667a155d7d4_img.jpg)
+
+Process USSD\_MI1 390\_61(1)
+
+```
+stateDiagram-v2
+    [*] --> idle
+    note left of USSD_request: Sent by the application or entered by the user
+    idle --> USSD_request
+    USSD_request --> USSD_request
+    USSD_request --> wait_network_response
+    state "wait network response" as wait_network_response
+    wait_network_response --> USSD_response
+    wait_network_response --> USSD_notify
+    wait_network_response --> USSD_request
+    wait_network_response --> release
+    wait_network_response --> release
+    wait_network_response --> error
+    USSD_response --> USSD_response
+    USSD_response --> idle
+    USSD_notify --> USSD_notify
+    USSD_notify --> USSD_response
+    USSD_notify --> wait_network_response
+    USSD_request --> USSD_request
+    USSD_request --> MI_wait_user_response
+    MI_wait_user_response --> USSD_response
+    MI_wait_user_response --> release
+    MI_wait_user_response --> release
+    MI_wait_user_response --> error
+    USSD_response --> USSD_response
+    USSD_response --> wait_network_response
+    release --> release
+    release --> idle
+    release --> release
+    release --> error
+    error --> error
+    error --> idle
+```
+
+**INPUTS AND OUTPUTS**
+
+Source/destination of messages shown to/from the left is the MS MMI or the application in the MS.
+
+Source/destination of messages shown to/from the right is the MSC.
+
+State transition diagram for Mobile Initiated USSD (USSD\_MI1). The process starts at 'idle', receives a 'USSD request' from the application/user, enters 'wait network response', then branches into 'USSD response' (idle), 'USSD notify' (wait network response), 'USSD request' (MI wait user response), 'release' (idle), or 'error' (idle). The 'MI wait user response' state further branches into 'USSD response' (wait network response), 'release' (idle), or 'error' (idle).
+
+Figure 6.1: Mobile initiated USSD at MS
+
+![Flowchart for Process USSD_MI2. It starts with 'idle', followed by 'USSD request'. A decision 'alphabet supported' has a 'no' path leading to 'MI wait VLR response' and a 'yes' path to 'HPLMN service code'. 'HPLMN service code' has a 'no' path to 'USSD request (appl)' and a 'yes' path to 'USSD request (VLR)'. 'USSD request (VLR)' leads to 'MI wait VLR response' and 'USSD request (appl)' leads to 'MSC application processing'.](8fa679f79a1bb1f527cba9f29e784e89_img.jpg)
+
+Process USSD\_MI2
+
+390\_621(3)
+
+**INPUTS AND OUTPUTS**
+
+Source/destination of messages shown to/from the left is the MS.
+
+Source/destination of messages shown to/from the right is either the VLR or the application (as indicated).
+
+```
+graph TD; idle([idle]) --> UR{USSD request}; UR --> AS{alphabet supported}; AS -- no --> MV[MI wait VLR response]; AS -- yes --> HSC{HPLMN service code}; HSC -- no --> UA{USSD request (appl)}; HSC -- yes --> UV{USSD request (VLR)}; UV --> MV; UA --> MP[MSC application processing];
+```
+
+Flowchart for Process USSD\_MI2. It starts with 'idle', followed by 'USSD request'. A decision 'alphabet supported' has a 'no' path leading to 'MI wait VLR response' and a 'yes' path to 'HPLMN service code'. 'HPLMN service code' has a 'no' path to 'USSD request (appl)' and a 'yes' path to 'USSD request (VLR)'. 'USSD request (VLR)' leads to 'MI wait VLR response' and 'USSD request (appl)' leads to 'MSC application processing'.
+
+Figure 6.2 (sheet 1 of 3): Mobile initiated USSD at MSC
+
+![State transition diagram for Process USSD_MI2. The diagram shows two main state transition paths starting from 'MI wait VLR response'. The first path leads to 'USSD response (VLR)' and then to 'idle'. The second path leads to 'MI wait user response (for VLR)', which then branches into 'USSD response', 'release', 'release (VLR)', and 'error'. 'USSD response' leads to 'USSD response (VLR)' and then to 'MI wait VLR response'. 'release' and 'release (VLR)' both lead to 'idle'. 'error' leads to 'error (VLR)' and then to 'MI wait VLR response'.](81a4cbf0b3c4cbc065efdf8f800dadde_img.jpg)
+
+Process USSD\_MI2
+
+390\_622(3)
+
+```
+stateDiagram-v2
+    [*] --> MI_wait_VLR_response : MI wait VLR response
+    MI_wait_VLR_response --> USSD_response_VLR_1 : USSD response (VLR)
+    MI_wait_VLR_response --> USSD_request_VLR : USSD request (VLR)
+    MI_wait_VLR_response --> USSD_notify_VLR : USSD notify (VLR)
+    MI_wait_VLR_response --> release_1 : release
+    MI_wait_VLR_response --> release_VLR_1 : release (VLR)
+    MI_wait_VLR_response --> error_VLR_1 : error (VLR)
+
+    USSD_response_VLR_1 --> USSD_response : USSD response
+    USSD_response --> idle_1 : idle
+
+    USSD_request_VLR --> USSD_request : USSD request
+    USSD_notify_VLR --> USSD_notify : USSD notify
+    USSD_request --> MI_wait_user_response : MI wait user response (for VLR)
+    USSD_notify --> MI_wait_user_response
+
+    release_1 --> release_VLR : release (VLR)
+    release_VLR_1 --> release_2 : release
+    error_VLR_1 --> error : error
+    release_VLR --> idle_2 : idle
+    release_2 --> idle_2
+    error --> error_VLR : error (VLR)
+    error_VLR --> MI_wait_VLR_response_2 : MI wait VLR response
+
+    MI_wait_user_response --> USSD_response_2 : USSD response
+    MI_wait_user_response --> release_3 : release
+    MI_wait_user_response --> release_VLR_2 : release (VLR)
+    MI_wait_user_response --> error_2 : error
+
+    USSD_response_2 --> USSD_response_VLR_2 : USSD response (VLR)
+    USSD_response_VLR_2 --> MI_wait_VLR_response_2
+
+    release_3 --> release_VLR_3 : release (VLR)
+    release_VLR_3 --> release_4 : release
+    release_4 --> idle_2
+
+    error_2 --> error_VLR_2 : error (VLR)
+    error_VLR_2 --> MI_wait_VLR_response_2
+```
+
+State transition diagram for Process USSD\_MI2. The diagram shows two main state transition paths starting from 'MI wait VLR response'. The first path leads to 'USSD response (VLR)' and then to 'idle'. The second path leads to 'MI wait user response (for VLR)', which then branches into 'USSD response', 'release', 'release (VLR)', and 'error'. 'USSD response' leads to 'USSD response (VLR)' and then to 'MI wait VLR response'. 'release' and 'release (VLR)' both lead to 'idle'. 'error' leads to 'error (VLR)' and then to 'MI wait VLR response'.
+
+Figure 6.2 (sheet 2 of 3): Mobile initiated USSD at MSC
+
+![State transition diagram for Process USSD_MI2. The diagram shows transitions between states: MSC application processing, USSD response, USSD request, USSD notify, release, release (application), error, error (application), idle, and MSC wait user response (for application). Transitions are labeled with messages like 'USSD response (application)', 'USSD request (application)', 'USSD notify (application)', 'release', 'release (application)', and 'error (application)'. The diagram is divided into two main sections by a horizontal line, with the top section showing initial transitions and the bottom section showing transitions from the 'MSC wait user response' state.](79e1709a7317ead45379cbb8ff3ba802_img.jpg)
+
+Process USSD\_MI2 390\_623(3)
+
+```
+stateDiagram-v2
+    [*] --> MSC_application_processing : MSC application processing
+    MSC_application_processing --> USSD_response_application : USSD response (application)
+    MSC_application_processing --> USSD_request_application : USSD request (application)
+    MSC_application_processing --> USSD_notify_application : USSD notify (application)
+    MSC_application_processing --> release : release
+    MSC_application_processing --> release_application : release (application)
+    MSC_application_processing --> error_application : error (application)
+
+    USSD_response_application --> USSD_response : USSD response
+    USSD_response --> idle : idle
+
+    USSD_request_application --> USSD_request : USSD request
+    USSD_notify_application --> USSD_notify : USSD notify
+    release_application --> release_application_state : release (application)
+    release_application_state --> MSC_wait_user_response : MSC wait user response (for application)
+    release --> release_state : release
+    error_application --> error : error
+    error --> idle : idle
+
+    MSC_wait_user_response --> USSD_response_state : USSD response
+    MSC_wait_user_response --> release_state : release
+    MSC_wait_user_response --> release_application_state : release (application)
+    MSC_wait_user_response --> error_state : error
+
+    USSD_response_state --> USSD_response_application : USSD response (application)
+    USSD_response_application --> MSC_application_processing : MSC application processing
+
+    release_state --> release_application_state : release (application)
+    release_application_state --> idle : idle
+
+    error_state --> error_application : error (application)
+    error_application --> MSC_application_processing : MSC application processing
+```
+
+State transition diagram for Process USSD\_MI2. The diagram shows transitions between states: MSC application processing, USSD response, USSD request, USSD notify, release, release (application), error, error (application), idle, and MSC wait user response (for application). Transitions are labeled with messages like 'USSD response (application)', 'USSD request (application)', 'USSD notify (application)', 'release', 'release (application)', and 'error (application)'. The diagram is divided into two main sections by a horizontal line, with the top section showing initial transitions and the bottom section showing transitions from the 'MSC wait user response' state.
+
+Figure 6.2 (sheet 3 of 3): Mobile initiated USSD at MSC
+
+![State transition diagram for Process USSD_AI1. The diagram shows the flow of USSD messages between an application and a VLR. It starts at an 'idle' state, receives a 'USSD request (application)', sends a 'USSD request (VLR)', and enters an 'AI wait VLR response' state. From there, it branches into several possible message exchanges: 1) 'USSD request (VLR)' to 'USSD request (application)' leading to 'AI wait application response (for VLR)'; 2) 'USSD notify (VLR)' to 'USSD notify (application)'; 3) 'USSD response (VLR)' to 'USSD response (application)' leading to 'idle'; 4) 'release (application)' to 'release (VLR)'; 5) 'release (VLR)' to 'release (application)'; 6) 'error (VLR)' to 'error (application)'. From 'AI wait application response (for VLR)', it branches into: 1) 'USSD response (application)' to 'USSD response (VLR)' leading to 'AI wait VLR response'; 2) 'error (application)' to 'error (VLR)'; 3) 'release (application)' to 'release (VLR)' leading to 'idle'; 4) 'release (VLR)' to 'release (application)'. A note on the right explains message directions and the use of 'USSD request'.](e180f2b5fcbe8001554a7c0677cd3f82_img.jpg)
+
+Process USSD\_AI1 390\_63(1)
+
+```
+stateDiagram-v2
+    [*] --> idle
+    idle --> USSD_request_application : USSD request (application)
+    USSD_request_application --> USSD_request_VLR : USSD request (VLR)
+    USSD_request_VLR --> AI_wait_VLR_response : AI wait VLR response
+    AI_wait_VLR_response --> USSD_request_VLR : USSD request (VLR)
+    AI_wait_VLR_response --> USSD_notify_VLR : USSD notify (VLR)
+    AI_wait_VLR_response --> USSD_response_VLR : USSD response (VLR)
+    AI_wait_VLR_response --> release_application : release (application)
+    AI_wait_VLR_response --> release_VLR : release (VLR)
+    AI_wait_VLR_response --> error_VLR : error (VLR)
+    USSD_request_VLR --> USSD_request_application : USSD request (application)
+    USSD_notify_VLR --> USSD_notify_application : USSD notify (application)
+    USSD_response_VLR --> USSD_response_application : USSD response (application)
+    release_application --> release_VLR : release (VLR)
+    release_VLR --> release_application : release (application)
+    error_VLR --> error_application : error (application)
+    USSD_request_application --> AI_wait_application_response : AI wait application response (for VLR)
+    USSD_response_application --> USSD_response_VLR : USSD response (VLR)
+    error_application --> error_VLR : error (VLR)
+    release_application --> release_VLR : release (VLR)
+    release_VLR --> release_application : release (application)
+    AI_wait_application_response --> USSD_response_application : USSD response (application)
+    AI_wait_application_response --> error_application : error (application)
+    AI_wait_application_response --> release_application : release (application)
+    AI_wait_application_response --> release_VLR : release (VLR)
+    USSD_response_VLR --> AI_wait_VLR_response : AI wait VLR response
+    release_VLR --> idle : release (VLR)
+    error_VLR --> idle : error (VLR)
+```
+
+**INPUTS AND OUTPUTS**
+
+For consistency with other SDL diagrams, all messages are shown to/from the right, for either the VLR or the application (as indicated).
+
+USSD request from application is used when an application receives a request from a MS and passes on the request (changed or unchanged) or generates a new request.
+
+State transition diagram for Process USSD\_AI1. The diagram shows the flow of USSD messages between an application and a VLR. It starts at an 'idle' state, receives a 'USSD request (application)', sends a 'USSD request (VLR)', and enters an 'AI wait VLR response' state. From there, it branches into several possible message exchanges: 1) 'USSD request (VLR)' to 'USSD request (application)' leading to 'AI wait application response (for VLR)'; 2) 'USSD notify (VLR)' to 'USSD notify (application)'; 3) 'USSD response (VLR)' to 'USSD response (application)' leading to 'idle'; 4) 'release (application)' to 'release (VLR)'; 5) 'release (VLR)' to 'release (application)'; 6) 'error (VLR)' to 'error (application)'. From 'AI wait application response (for VLR)', it branches into: 1) 'USSD response (application)' to 'USSD response (VLR)' leading to 'AI wait VLR response'; 2) 'error (application)' to 'error (VLR)'; 3) 'release (application)' to 'release (VLR)' leading to 'idle'; 4) 'release (VLR)' to 'release (application)'. A note on the right explains message directions and the use of 'USSD request'.
+
+Figure 6.3: Application initiated USSD at MSC
+
+![Flowchart for Process USSD_MI3. It starts with an 'idle' state, followed by a 'USSD request' from the MSC. A decision 'alphabet supported' follows. If 'no', it goes to 'MI wait HLR response'. If 'yes', it goes to another decision 'HPLMN service code'. If 'no', it goes to 'USSD request (application)' then 'VLR application processing'. If 'yes', it goes to 'USSD request (HLR)' then 'MI wait HLR response'.](eb03559a4d92ea9ebd63ea9be663c50a_img.jpg)
+
+Process USSD\_MI3
+
+390\_641(3)
+
+**INPUTS AND OUTPUTS**
+
+Source/destination of messages shown to/from the left is the MSC.
+
+Source/destination of messages shown to/from the right is either the HLR or the application (as indicated).
+
+```
+graph TD; idle([idle]) --> UR{USSD request}; UR --> AS{alphabet supported}; AS -- no --> MIW[MI wait HLR response]; AS -- yes --> HSC{HPLMN service code}; HSC -- no --> UA{USSD request (application)}; HSC -- yes --> UH{USSD request (HLR)}; UA --> VAP[VLR application processing]; UH --> MIW;
+```
+
+Flowchart for Process USSD\_MI3. It starts with an 'idle' state, followed by a 'USSD request' from the MSC. A decision 'alphabet supported' follows. If 'no', it goes to 'MI wait HLR response'. If 'yes', it goes to another decision 'HPLMN service code'. If 'no', it goes to 'USSD request (application)' then 'VLR application processing'. If 'yes', it goes to 'USSD request (HLR)' then 'MI wait HLR response'.
+
+Figure 6.4 (sheet 1 of 3): Mobile initiated USSD at VLR
+
+![State transition diagram for Process USSD_MI3. The diagram shows various states and transitions for a mobile initiated USSD process at a VLR. States include 'MI wait HLR response', 'USSD response (HLR)', 'USSD request (HLR)', 'USSD notify (HLR)', 'release', 'error (HLR)', 'idle', and 'MI wait user response (for HLR)'. Transitions are labeled with message names like 'USSD response', 'USSD request', 'USSD notify', 'release (HLR)', 'release', and 'error'.](ae53f90bb87d6d09e2d6b5278d7c338f_img.jpg)
+
+Process USSD\_MI3 390\_642(3)
+
+```
+stateDiagram-v2
+    [*] --> MI_wait_HLR_response : MI wait HLR response
+    MI_wait_HLR_response --> USSD_response_HLR : USSD response (HLR)
+    MI_wait_HLR_response --> USSD_request_HLR : USSD request (HLR)
+    MI_wait_HLR_response --> USSD_notify_HLR : USSD notify (HLR)
+    MI_wait_HLR_response --> release : release
+    MI_wait_HLR_response --> release_HLR : release (HLR)
+    MI_wait_HLR_response --> error_HLR : error (HLR)
+
+    USSD_response_HLR --> USSD_response : USSD response
+    USSD_response --> idle : idle
+
+    USSD_request_HLR --> USSD_request : USSD request
+    USSD_notify_HLR --> USSD_notify : USSD notify
+    USSD_request --> MI_wait_user_response : MI wait user response (for HLR)
+    USSD_notify --> MI_wait_user_response
+
+    release --> release_HLR : release (HLR)
+    release_HLR --> idle : idle
+
+    release_HLR --> release : release
+    release --> idle : idle
+
+    error_HLR --> error : error
+    error --> MI_wait_HLR_response : MI wait HLR response
+
+    MI_wait_user_response --> USSD_response : USSD response
+    MI_wait_user_response --> release : release
+    MI_wait_user_response --> release_HLR : release (HLR)
+    MI_wait_user_response --> error : error
+
+    USSD_response --> USSD_response_HLR : USSD response (HLR)
+    USSD_response_HLR --> MI_wait_HLR_response : MI wait HLR response
+
+    release --> release_HLR : release (HLR)
+    release_HLR --> idle : idle
+
+    release_HLR --> release : release
+    release --> idle : idle
+
+    error --> error_HLR : error (HLR)
+    error_HLR --> MI_wait_HLR_response : MI wait HLR response
+```
+
+State transition diagram for Process USSD\_MI3. The diagram shows various states and transitions for a mobile initiated USSD process at a VLR. States include 'MI wait HLR response', 'USSD response (HLR)', 'USSD request (HLR)', 'USSD notify (HLR)', 'release', 'error (HLR)', 'idle', and 'MI wait user response (for HLR)'. Transitions are labeled with message names like 'USSD response', 'USSD request', 'USSD notify', 'release (HLR)', 'release', and 'error'.
+
+Figure 6.4 (sheet 2 of 3): Mobile initiated USSD at VLR
+
+![State transition diagram for Process USSD_MI3. The diagram shows transitions between states like 'VLR application processing', 'idle', and 'VLR wait user response (for application)' based on events like 'USSD response (application)', 'USSD request (application)', 'USSD notify (application)', 'release', 'release (application)', and 'error (application)'.](26d664119ad25250780f554633444e54_img.jpg)
+
+Process USSD\_MI3 390\_643(3)
+
+```
+stateDiagram-v2
+    [*] --> VLR_application_processing : VLR application processing
+    VLR_application_processing --> USSD_response_application : USSD response (application)
+    VLR_application_processing --> USSD_request_application : USSD request (application)
+    VLR_application_processing --> USSD_notify_application : USSD notify (application)
+    VLR_application_processing --> release : release
+    VLR_application_processing --> release_application : release (application)
+    VLR_application_processing --> error_application : error (application)
+
+    USSD_response_application --> USSD_response : USSD response
+    USSD_response --> idle : idle
+
+    USSD_request_application --> USSD_request : USSD request
+    USSD_notify_application --> USSD_notify : USSD notify
+    release --> release_application : release (application)
+    release_application --> release : release
+    error_application --> error : error
+
+    USSD_request --> VLR_wait_user_response : VLR wait user response (for application)
+    USSD_notify --> VLR_wait_user_response
+    release_application --> idle : idle
+    release --> idle
+    error --> idle
+
+    VLR_wait_user_response --> USSD_response : USSD response
+    VLR_wait_user_response --> release : release
+    VLR_wait_user_response --> release_application : release (application)
+    VLR_wait_user_response --> error : error
+
+    USSD_response --> USSD_response_application : USSD response (application)
+    release --> release_application : release (application)
+    release_application --> release : release
+    error --> error_application : error (application)
+
+    USSD_response_application --> VLR_application_processing : VLR application processing
+    release_application --> idle : idle
+    error_application --> VLR_application_processing : VLR application processing
+```
+
+State transition diagram for Process USSD\_MI3. The diagram shows transitions between states like 'VLR application processing', 'idle', and 'VLR wait user response (for application)' based on events like 'USSD response (application)', 'USSD request (application)', 'USSD notify (application)', 'release', 'release (application)', and 'error (application)'.
+
+Figure 6.4 (sheet 3 of 3): Mobile initiated USSD at VLR
+
+![State transition diagram for Process USSD_AI2. It shows states 'idle' and 'AI wait HLR response'. Transitions include 'USSD request (application)', 'USSD request (HLR)', 'USSD notify (HLR)', 'USSD response (HLR)', 'release (application)', and 'error (HLR)'. The diagram is divided into two main sections by a horizontal line. The top section starts with 'idle' -> 'USSD request (application)' -> 'USSD request (HLR)' -> 'AI wait HLR response'. From 'AI wait HLR response', there are six outgoing transitions: 'USSD request (HLR)' -> 'USSD request (application)' -> 'AI wait application response (for HLR)'; 'USSD notify (HLR)' -> 'USSD notify (application)' -> 'idle'; 'USSD response (HLR)' -> 'USSD response (application)' -> 'idle'; 'release (application)' -> 'release (HLR)' -> 'idle'; 'release (HLR)' -> 'release (application)' -> 'idle'; and 'error (HLR)' -> 'error (application)' -> 'idle'. The bottom section starts with 'AI wait application response (for HLR)' -> 'USSD response (application)' -> 'USSD response (HLR)' -> 'AI wait HLR response'; 'error (application)' -> 'error (HLR)' -> 'AI wait HLR response'; 'release (application)' -> 'release (HLR)' -> 'idle'; and 'release (HLR)' -> 'release (application)' -> 'idle'.](90ddb84c323b956e2d50a54d3f870566_img.jpg)
+
+**Process USSD\_AI2** 390\_65(1)
+
+**INPUTS AND OUTPUTS**
+
+For consistency with other SDL diagrams, all messages are shown to/from the right, for either the HLR or the application (as indicated).
+
+USSD request from application is used when an application receives a request from a MS and passes on the request (changed or unchanged) or generates a new request.
+
+```
+stateDiagram-v2
+    [*] --> idle
+    idle --> USSD_request_application : USSD request (application)
+    USSD_request_application --> USSD_request_HLR : USSD request (HLR)
+    USSD_request_HLR --> AI_wait_HLR_response : AI wait HLR response
+
+    state "AI wait HLR response" as AI_wait_HLR_response
+    AI_wait_HLR_response --> USSD_request_HLR_2 : USSD request (HLR)
+    USSD_request_HLR_2 --> USSD_request_application_2 : USSD request (application)
+    USSD_request_application_2 --> AI_wait_application_response : AI wait application response (for HLR)
+
+    AI_wait_HLR_response --> USSD_notify_HLR : USSD notify (HLR)
+    USSD_notify_HLR --> USSD_notify_application : USSD notify (application)
+    USSD_notify_application --> idle_2 : idle
+
+    AI_wait_HLR_response --> USSD_response_HLR : USSD response (HLR)
+    USSD_response_HLR --> USSD_response_application : USSD response (application)
+    USSD_response_application --> idle_3 : idle
+
+    AI_wait_HLR_response --> release_application : release (application)
+    release_application --> release_HLR : release (HLR)
+    release_HLR --> idle_4 : idle
+
+    AI_wait_HLR_response --> release_HLR_2 : release (HLR)
+    release_HLR_2 --> release_application_2 : release (application)
+    release_application_2 --> idle_5 : idle
+
+    AI_wait_HLR_response --> error_HLR : error (HLR)
+    error_HLR --> error_application : error (application)
+    error_application --> idle_6 : idle
+
+    AI_wait_application_response : AI wait application response (for HLR)
+    AI_wait_application_response --> USSD_response_application_3 : USSD response (application)
+    USSD_response_application_3 --> USSD_response_HLR_3 : USSD response (HLR)
+    USSD_response_HLR_3 --> AI_wait_HLR_response_2 : AI wait HLR response
+
+    AI_wait_application_response --> error_application_3 : error (application)
+    error_application_3 --> error_HLR_3 : error (HLR)
+    error_HLR_3 --> AI_wait_HLR_response_2 : AI wait HLR response
+
+    AI_wait_application_response --> release_application_3 : release (application)
+    release_application_3 --> release_HLR_3 : release (HLR)
+    release_HLR_3 --> idle_7 : idle
+
+    AI_wait_application_response --> release_HLR_4 : release (HLR)
+    release_HLR_4 --> release_application_4 : release (application)
+    release_application_4 --> idle_8 : idle
+```
+
+State transition diagram for Process USSD\_AI2. It shows states 'idle' and 'AI wait HLR response'. Transitions include 'USSD request (application)', 'USSD request (HLR)', 'USSD notify (HLR)', 'USSD response (HLR)', 'release (application)', and 'error (HLR)'. The diagram is divided into two main sections by a horizontal line. The top section starts with 'idle' -> 'USSD request (application)' -> 'USSD request (HLR)' -> 'AI wait HLR response'. From 'AI wait HLR response', there are six outgoing transitions: 'USSD request (HLR)' -> 'USSD request (application)' -> 'AI wait application response (for HLR)'; 'USSD notify (HLR)' -> 'USSD notify (application)' -> 'idle'; 'USSD response (HLR)' -> 'USSD response (application)' -> 'idle'; 'release (application)' -> 'release (HLR)' -> 'idle'; 'release (HLR)' -> 'release (application)' -> 'idle'; and 'error (HLR)' -> 'error (application)' -> 'idle'. The bottom section starts with 'AI wait application response (for HLR)' -> 'USSD response (application)' -> 'USSD response (HLR)' -> 'AI wait HLR response'; 'error (application)' -> 'error (HLR)' -> 'AI wait HLR response'; 'release (application)' -> 'release (HLR)' -> 'idle'; and 'release (HLR)' -> 'release (application)' -> 'idle'.
+
+Figure 6.5: Application initiated USSD at VLR
+
+![State transition diagram for Process USSD_MI4. The process starts at 'idle', receives a 'USSD request' from the VLR, checks if the alphabet is supported. If 'no', it sends an 'error' to the application and returns to 'idle'. If 'yes', it sends a 'USSD request' to the application and enters 'HLR application processing'. From there, it branches into two main paths. The first path involves 'USSD request', 'USSD notify', 'USSD response', 'release', and 'error' messages between the VLR and application, leading to 'HLR wait user response' and then back to 'HLR application processing'. The second path involves 'USSD response', 'error', 'release', and 'release' messages between the application and VLR, leading back to 'idle'.](2ae3eae1bd80a90f192f568ae246a9a6_img.jpg)
+
+Process USSD\_MI4
+
+390\_66(1)
+
+```
+stateDiagram-v2
+    [*] --> idle
+    idle --> USSD_request_VLR: USSD request
+    USSD_request_VLR --> alphabet_supported{alphabet supported}
+    alphabet_supported --> error_app: error
+    error_app --> idle
+    alphabet_supported --> USSD_request_app: USSD request
+    USSD_request_app --> HLR_app_processing: HLR application processing
+
+    state "HLR application processing" as HLR_app_processing
+    HLR_app_processing --> USSD_request_VLR
+    HLR_app_processing --> USSD_notify_app
+    HLR_app_processing --> USSD_response_VLR
+    HLR_app_processing --> release_app
+    HLR_app_processing --> release_VLR
+    HLR_app_processing --> error_app
+
+    USSD_request_VLR --> USSD_request_app
+    USSD_notify_app --> USSD_notify_VLR
+    USSD_response_VLR --> USSD_response_app
+    release_app --> release_VLR
+    release_VLR --> release_app
+    error_app --> error_VLR
+
+    USSD_request_app --> HLR_wait_user_response: HLR wait user response
+    USSD_notify_VLR --> idle
+    USSD_response_app --> HLR_app_processing
+    release_VLR --> idle
+    release_app --> release_VLR
+    error_VLR --> idle
+
+    HLR_wait_user_response --> USSD_response_VLR
+    HLR_wait_user_response --> error_app
+    HLR_wait_user_response --> release_app
+    HLR_wait_user_response --> release_VLR
+
+    USSD_response_VLR --> USSD_response_app
+    error_app --> error_VLR
+    release_app --> release_VLR
+    release_VLR --> release_app
+
+    USSD_response_app --> HLR_app_processing
+    error_VLR --> idle
+    release_VLR --> idle
+```
+
+idle
+
+USSD request
+
+alphabet supported
+
+no
+
+yes
+
+error
+
+USSD request
+
+HLR application processing
+
+USSD request
+
+USSD notify
+
+USSD response
+
+release
+
+release
+
+error
+
+USSD request
+
+USSD notify
+
+USSD response
+
+release
+
+release
+
+error
+
+HLR wait user response
+
+idle
+
+USSD response
+
+error
+
+release
+
+release
+
+USSD response
+
+error
+
+release
+
+release
+
+HLR application processing
+
+idle
+
+INPUTS AND OUTPUTS
+
+Source/destination of messages shown to/from the left is the VLR.
+
+Source/destination of messages shown to/from the right is the application.
+
+State transition diagram for Process USSD\_MI4. The process starts at 'idle', receives a 'USSD request' from the VLR, checks if the alphabet is supported. If 'no', it sends an 'error' to the application and returns to 'idle'. If 'yes', it sends a 'USSD request' to the application and enters 'HLR application processing'. From there, it branches into two main paths. The first path involves 'USSD request', 'USSD notify', 'USSD response', 'release', and 'error' messages between the VLR and application, leading to 'HLR wait user response' and then back to 'HLR application processing'. The second path involves 'USSD response', 'error', 'release', and 'release' messages between the application and VLR, leading back to 'idle'.
+
+Figure 6.6: Mobile initiated USSD at HLR
+
+![Sequence diagram showing information flow for mobile initiated USSD Request. Lifelines: MS, MSC, VLR, HLR. The diagram shows three scenarios: 'Request handled by MSC', 'Request handled by VLR', and 'Request handled by HLR'. In each scenario, the MS sends a USSD request to the MSC. The MSC then either responds (OR1:N) or forwards it to the VLR (OR1:Y). The VLR then either responds (OR2:N) or forwards it to the HLR (OR2:Y). The HLR responds to the VLR, which in turn responds to the MSC, which finally responds to the MS.](9c1d3678db4a12d5864cb2a4def1135d_img.jpg)
+
+```
+sequenceDiagram
+    participant MS
+    participant MSC
+    participant VLR
+    participant HLR
+
+    Note left of MS: Request handled by MSC
+    MS->>MSC: USSD request
+    MSC-->>MS: USSD response OR1:N
+
+    Note left of MS: Request handled by VLR
+    MS->>MSC: USSD request
+    MSC-->>MS: USSD response OR1:Y
+    MSC->>VLR: USSD request
+    VLR-->>MSC: USSD response OR2:N
+    VLR-->>MS: USSD response
+
+    Note left of MS: Request handled by HLR
+    MS->>MSC: USSD request
+    MSC-->>MS: USSD response OR1:Y
+    MSC->>VLR: USSD request
+    VLR-->>MSC: USSD response OR2:Y
+    VLR->>HLR: USSD request
+    HLR-->>VLR: USSD response
+    HLR-->>MSC: USSD response
+    HLR-->>MS: USSD response
+```
+
+Sequence diagram showing information flow for mobile initiated USSD Request. Lifelines: MS, MSC, VLR, HLR. The diagram shows three scenarios: 'Request handled by MSC', 'Request handled by VLR', and 'Request handled by HLR'. In each scenario, the MS sends a USSD request to the MSC. The MSC then either responds (OR1:N) or forwards it to the VLR (OR1:Y). The VLR then either responds (OR2:N) or forwards it to the HLR (OR2:Y). The HLR responds to the VLR, which in turn responds to the MSC, which finally responds to the MS.
+
+NOTE: OR1: HPLMN service code Y: Yes  
+OR2: HPLMN service code and user not in HPLMN N: No
+
+Note that the application at the MSC/VLR may pass the request on to another network entity. This is not shown here.
+
+**Figure 6.7: Information flow for mobile initiated USSD Request (No further information requested)**
+
+![Sequence diagram showing information flow for mobile initiated USSD Request Handled by HLR, further information requested. Lifelines: MS, MSC, VLR, HLR. The diagram shows a sequence of USSD requests and responses between the entities.](28d75f39a24203712ee907b32cf0bbe5_img.jpg)
+
+```
+
+sequenceDiagram
+    participant MS
+    participant MSC
+    participant VLR
+    participant HLR
+
+    MS->>MSC: USSD request
+    MSC->>VLR: USSD request
+    VLR->>HLR: USSD request
+    HLR-->>VLR: USSD request
+    VLR-->>MSC: USSD request
+    MSC-->>MS: USSD request
+    MS->>MSC: USSD response
+    MSC->>VLR: USSD response
+    VLR->>HLR: USSD response
+    
+    Note over MS,HLR: ...
+
+    HLR->>VLR: USSD request
+    VLR->>MSC: USSD request
+    MSC->>MS: USSD request
+    MS->>MSC: USSD response
+    MSC->>VLR: USSD response
+    VLR->>HLR: USSD response
+    HLR-->>VLR: USSD response
+    VLR-->>MSC: USSD response
+    MSC-->>MS: USSD response
+    
+```
+
+Sequence diagram showing information flow for mobile initiated USSD Request Handled by HLR, further information requested. Lifelines: MS, MSC, VLR, HLR. The diagram shows a sequence of USSD requests and responses between the entities.
+
+NOTE: Note that this call flow only shows one example to illustrate the possible scenarios. See the SDL diagrams for a complete description.
+
+**Figure 6.8: Information flow for mobile initiated USSD Request Handled by HLR, further information requested**
+
+![Sequence diagram showing information flow for mobile initiated failed USSD Request between MS, MSC, VLR, and HLR.](dd5771673aececa53d42ece89218299d_img.jpg)
+
+```
+sequenceDiagram
+    participant MS
+    participant MSC
+    participant VLR
+    participant HLR
+
+    Note left of MS: Error detected at MSC
+    MS->>MSC: USSD request
+    MSC-->>MS: Error
+
+    Note left of MS: Error detected at VLR
+    MS->>MSC: USSD request
+    MSC->>VLR: USSD request
+    VLR-->>MSC: Error
+    MSC-->>MS: Error
+
+    Note left of MS: Error detected at HLR
+    MS->>MSC: USSD request
+    MSC->>VLR: USSD request
+    VLR->>HLR: USSD request
+    HLR-->>VLR: Error
+    VLR-->>MSC: Error
+    MSC-->>MS: Error
+
+    Note left of MS: MS clears transaction before response received
+    MS->>MSC: USSD request
+    MSC->>VLR: USSD request
+    VLR->>HLR: USSD request
+    MS->>MSC: Release
+    MSC->>VLR: Release
+    VLR->>HLR: Release
+```
+
+The diagram illustrates the interaction between a Mobile Station (MS), Mobile Switching Center (MSC), Visitor Location Register (VLR), and Home Location Register (HLR) for a failed USSD request. It shows four scenarios: 1) Error detected at MSC: MS sends a USSD request to MSC, which immediately responds with an Error. 2) Error detected at VLR: MS sends a USSD request to MSC, which forwards it to VLR; VLR responds with an Error to MSC, which then forwards it to MS. 3) Error detected at HLR: MS sends a USSD request to MSC, which forwards it to VLR, which then forwards it to HLR; HLR responds with an Error to VLR, which forwards it to MSC, which then forwards it to MS. 4) MS clears transaction before response received: MS sends a USSD request to MSC, which forwards it to VLR, which then forwards it to HLR; before any error is received, MS sends a Release message to MSC, which forwards it to VLR, which then forwards it to HLR.
+
+Sequence diagram showing information flow for mobile initiated failed USSD Request between MS, MSC, VLR, and HLR.
+
+NOTE: This call flow only shows a limited number of examples to illustrate the possible scenarios. See the SDL diagrams for a complete description.
+
+**Figure 6.9: Information flow for mobile initiated failed USSD Request**
+
+## 6.3 Information stored in the HLR
+
+The HLR shall not store any information specific to the use of USSD, although information may be stored for services which are offered by USSD applications.
+
+## 6.4 Information stored in the VLR
+
+The VLR shall not store any information specific to the use of USSD, although information may be stored for services which are offered by USSD applications.
+
+## 6.5 Handover
+
+Handover will have no impact on the operation of this service.
+
+## 6.6 Cross-phase compatibility
+
+If, when a Phase 2 MS sends a mobile initiated USSD request, any network entity is of Phase 1, the request will be rejected. If it is possible to encode the content of the USSD request using the Phase 1 protocol, the MS shall repeat the request, using the Phase 1 protocol.
+
+A Mobile initiated USSD request from a Phase 1 MS uses the Phase 1 protocol. On receipt of such a request, the application shall also use the Phase 1 protocol when sending the response.
+
+A Phase 2 network shall not send network initiated requests or notifications during a mobile initiated USSD request if the MS or any network entity involved in the operation is of Phase 1.
+
+# Annex A (informative): Change history
+
+| TSG CN#  | Spec      | CR   | Rev | Phase  | Cat | New Ver | Subject/Comment                |
+|----------|-----------|------|-----|--------|-----|---------|--------------------------------|
+| Apr 1999 | GSM 03.90 |      |     | R97    |     |         | Transferred to 3GPP CN1        |
+| CN#03    | 23.090    |      |     | R99    |     | 3.0.0   | Approved at CN#03              |
+| CN#06    | 23.090    | 001  | 1   | R99    |     | 3.1.0   | USSD enhancement               |
+| CN#09    | 23.090    | 002  | 1   | R99    | F   | 3.2.0   | SDL refresh                    |
+| CN#11    | 23.090    |      |     | Rel-4  |     | 4.0.0   | Release 4 after CN#11          |
+| CN#16    | 23.090    |      |     | Rel-5  |     | 5.0.0   | Release 5 after CN#16          |
+| CN#26    | 23.090    |      |     | Rel-6  |     | 6.0.0   | Release 6 after CN#26          |
+| CT#30    | 23.090    | 0003 | 1   | Rel-6  | F   | 6.1.0   | Incorrect References           |
+| CT#36    | 23.090    |      |     | Rel-7  |     | 7.0.0   | Upgraded unchanged from Rel-6  |
+| CT#42    | 23.090    |      |     | Rel-8  |     | 8.0.0   | Upgraded unchanged from Rel-7  |
+| CT#42    | 23.090    | -    | -   | Rel-9  |     | 9.0.0   | Update to Rel-9 version (MCC)  |
+| 2011-03  | 23.090    | -    | -   | Rel-10 |     | 10.0.0  | Update to Rel-10 version (MCC) |
+| 2012-09  | 23.090    | -    | -   | Rel-11 |     | 11.0.0  | Update to Rel-11 version (MCC) |
+| 2014-09  | 23.090    | -    | -   | Rel-12 |     | 12.0.0  | Update to Rel-12 version (MCC) |
+| 2015-12  | 23.090    | -    | -   | Rel-13 |     | 13.0.0  | Update to Rel-13 version (MCC) |
+| 2017-03  | 23.090    | -    | -   | Rel-14 |     | 14.0.0  | Update to Rel-14 version (MCC) |
+| 2018-06  | 23.090    | -    | -   | Rel-15 | -   | 15.0.0  | Update to Rel-15 version (MCC) |
+| 2020-07  | 23.090    | -    | -   | Rel-16 | -   | 16.0.0  | Update to Rel-16 version (MCC) |