asn1/camel/CAP-gprsSSF-gsmSCF-ops-args.asn

   1 -- 3GPP TS 29.078 11.0.0 (2011-09)
   2 -- 8    GPRS Control
   3 -- 8.1  gsmSCF/gprsSSF operations and arguments
   4
   5 CAP-gprsSSF-gsmSCF-ops-args {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
   6 umts-network(1) modules(3) cap-GPRS-ops-args(107) version8(7)}
   7 -- Module CAP-gprsSSF-gsmSCF-ops-args is updated to version8(7) for Rel-6. The OPERATION
   8 -- definitions in this module are not modified, compared to Rel-5.
   9
  10 DEFINITIONS IMPLICIT TAGS ::= BEGIN
  11
  12 -- This module contains the operations and operation arguments used for the
  13 -- gprsSSF ? gsmSCF interface, for the control of GPRS.
  14
  15 -- The table in subclause 2.1 lists the specifications that contain the modules
  16 -- that are used by CAP.
  17
  18 IMPORTS
  19
  20         errortypes,
  21         datatypes,
  22         operationcodes,
  23         classes,
  24         ros-InformationObjects
  25 FROM CAP-object-identifiers {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
  26 umts-network(1) modules(3) cap-object-identifiers(100) version8(7)}
  27
  28         OPERATION
  29 FROM Remote-Operations-Information-Objects ros-InformationObjects
  30
  31         ServiceKey
  32 FROM CS1-DataTypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
  33 modules(0) cs1-datatypes(2) version1(0)}
  34
  35         MiscCallInfo
  36 FROM CS2-datatypes {itu-t(0) identified-organization(4) etsi(0) inDomain(1) in-network(1)
  37 cs2(20) modules(0) in-cs2-datatypes (0) version1(0)}
  38
  39         IMEI,
  40         IMSI,
  41         GSN-Address, -- WS moved to common datatypes in rel 9.0.0
  42         RAIdentity,  -- WS moved to common datatypes in rel 10.4.0
  43         ISDN-AddressString
  44 FROM MAP-CommonDataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
  45 gsm-Network(1) modules(3) map-CommonDataTypes(18) version12(12)}
  46
  47         GPRSChargingID,
  48         GPRSMSClass
  49 --      GSN-Address,  WS moved to common datatypes in rel 9.0.0
  50 --      RAIdentity  WS moved to common datatypes in rel 10.4.0
  51 FROM MAP-MS-DataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
  52 gsm-Network(1) modules(3) map-MS-DataTypes(11) version12(12)}
  53
  54         PARAMETERS-BOUND
  55 FROM CAP-classes classes
  56
  57         opcode-activityTestGPRS,
  58         opcode-applyChargingGPRS,
  59         opcode-applyChargingReportGPRS,
  60         opcode-cancelGPRS,
  61         opcode-connectGPRS,
  62         opcode-continueGPRS,
  63         opcode-entityReleasedGPRS,
  64         opcode-eventReportGPRS,
  65         opcode-furnishChargingInformationGPRS,
  66         opcode-initialDPGPRS,
  67         opcode-releaseGPRS,
  68         opcode-requestReportGPRSEvent,
  69         opcode-resetTimerGPRS,
  70         opcode-sendChargingInformationGPRS
  71 FROM CAP-operationcodes operationcodes
  72 -- The CAP Operation identifiers for CAP V3 for GPRS in Rel-6 are the same as the CAP Operation
  73 -- identifiers for CAP V3 for GPRS in Rel-5.
  74
  75         AccessPointName {},
  76         GPRSCause {},
  77         ChargingCharacteristics,
  78         ChargingResult,
  79         ChargingRollOver,
  80         EndUserAddress,
  81         Extensions,
  82         FCIGPRSBillingChargingCharacteristics,
  83         GPRSEventSpecificInformation {},
  84         GPRSEvent,
  85         GPRSEventType,
  86         LocationInformationGPRS,
  87         PDPID,
  88         PDPInitiationType,
  89         QualityOfService,
  90         SCIGPRSBillingChargingCharacteristics {},
  91         SGSNCapabilities,
  92         TimeAndTimezone {},
  93         TimerID,
  94         TimerValue
  95 FROM CAP-datatypes datatypes
  96 -- For Rel-6, the CAP-datatypes module is updated to version8(7); Object Identifier 'datatypes'
  97 -- is also updated to version8(7). As a result, the present module uses Rel-6 data type definitions.
  98
  99         missingCustomerRecord,
 100         missingParameter,
 101         parameterOutOfRange,
 102         systemFailure,
 103         taskRefused,
 104         unexpectedComponentSequence,
 105         unexpectedDataValue,
 106         unexpectedParameter,
 107         unknownPDPID
 108 FROM CAP-errortypes errortypes
 109 -- For Rel-6, the CAP-errortypes module is updated to version8(7); Object Identifier
 110 -- 'errortypes' is also updated to version8(7). As a result, the present module uses Rel-6
 111 -- error type definitions.
 112
 113 ;
 114
 115 activityTestGPRS OPERATION ::= {
 116         RETURN RESULT   TRUE
 117         CODE                    opcode-activityTestGPRS}
 118 -- Direction: gsmSCF -> gprsSSF, Timer: Tatg
 119 -- This operation is used to check for the continued existence of a relationship between the gsmSCF
 120 -- and gprsSSF. If the relationship is still in existence, then the gprsSSF will respond. If no
 121 -- reply is received, then the gsmSCF will assume that the gprsSSF has failed in some way
 122 -- and will take the appropriate action.
 123
 124 applyChargingGPRS OPERATION ::= {
 125         ARGUMENT                ApplyChargingGPRSArg
 126         RETURN RESULT   FALSE
 127         ERRORS                  {missingParameter |
 128                                         unexpectedComponentSequence |
 129                                         unexpectedParameter |
 130                                         unexpectedDataValue |
 131                                         parameterOutOfRange |
 132                                         systemFailure |
 133                                         taskRefused |
 134                                         unknownPDPID}
 135         CODE                    opcode-applyChargingGPRS}
 136 -- Direction gsmSCF -> gprsSSF, Timer Tacg
 137 -- This operation is used for interacting from the gsmSCF with the gprsSSF CSE-controlled
 138 -- GPRS session or PDP Context charging mechanism.
 139
 140 ApplyChargingGPRSArg ::= SEQUENCE {
 141         chargingCharacteristics                         [0] ChargingCharacteristics,
 142         tariffSwitchInterval                            [1] INTEGER (1..86400)                                          OPTIONAL,
 143         pDPID                                                           [2] PDPID                                                                       OPTIONAL,
 144         ...
 145         }
 146 -- tariffSwitchInterval is measured in 1 second units.
 147
 148 applyChargingReportGPRS OPERATION ::= {
 149         ARGUMENT                ApplyChargingReportGPRSArg
 150         RETURN RESULT   TRUE
 151         ERRORS                  {missingParameter |
 152                                         unexpectedComponentSequence |
 153                                         unexpectedParameter |
 154                                         unexpectedDataValue |
 155                                         parameterOutOfRange |
 156                                         systemFailure |
 157                                         taskRefused |
 158                                         unknownPDPID}
 159         CODE                    opcode-applyChargingReportGPRS}
 160 --      Direction gprsSSF -> gsmSCF,Timer Tacrg
 161 --      The ApplyChargingReportGPRS operation provides the feedback from the gprsSCF to the gsmSCF
 162 --      CSE-controlled GPRS session charging mechanism.
 163
 164 ApplyChargingReportGPRSArg ::= SEQUENCE {
 165         chargingResult                                          [0] ChargingResult,
 166         qualityOfService                                        [1] QualityOfService                                            OPTIONAL,
 167         active                                                          [2] BOOLEAN DEFAULT TRUE,
 168         pDPID                                                           [3] PDPID                                                                       OPTIONAL,
 169         ...,
 170         chargingRollOver                                        [4]     ChargingRollOver                                                OPTIONAL
 171         }
 172
 173 cancelGPRS OPERATION ::= {
 174         ARGUMENT                CancelGPRSArg
 175         RETURN RESULT   FALSE
 176         ERRORS                  {missingParameter |
 177                                         taskRefused |
 178                                         unknownPDPID}
 179         CODE                    opcode-cancelGPRS}
 180 --  Direction: gsmSCF ?? gprsSSF, Timer: Tcag
 181 --  This generic operation cancels all previous requests,
 182 --      i.e. all EDPs and reports can be cancelled by the gsmSCF.
 183
 184 CancelGPRSArg ::= SEQUENCE {
 185         pDPID                                                           [0] PDPID                                                                       OPTIONAL,
 186         ...
 187         }
 188
 189 connectGPRS {PARAMETERS-BOUND: bound} OPERATION::= {
 190         ARGUMENT                ConnectGPRSArg {bound}
 191         RETURN RESULT   FALSE
 192         ERRORS                  {missingParameter |
 193                                         parameterOutOfRange |
 194                                         unknownPDPID |
 195                                         systemFailure |
 196                                         taskRefused |
 197                                         unexpectedComponentSequence |
 198                                         unexpectedDataValue |
 199                                         unexpectedParameter}
 200         CODE                    opcode-connectGPRS}
 201 -- Direction: gsmSCF -> gprsSSF, Timer: Tcong
 202 -- This operation is used to modify the Access Point Name used when establishing a PDP Context.
 203
 204 ConnectGPRSArg {PARAMETERS-BOUND: bound}::= SEQUENCE {
 205         accessPointName         [0] AccessPointName {bound},
 206         pdpID           [1] PDPID                       OPTIONAL,
 207         ...
 208         }
 209
 210 continueGPRS OPERATION ::= {
 211         ARGUMENT                ContinueGPRSArg
 212         RETURN RESULT   FALSE
 213         ERRORS                  {missingParameter |
 214                                         unknownPDPID |
 215                                         unexpectedDataValue}
 216         CODE                    opcode-continueGPRS}
 217 --  Direction: gsmSCF -> gprsSSF, Timer: Tcueg
 218 --  This operation is used to request the gprsSSF to proceed with processing at the DP at
 219 --  which it previously suspended processing to await gsmSCF instructions (i.e., proceed to
 220 --  the next point in processing in the Attach/Detach state model or PDP Context
 221 --      state model) substituting new data from the gsmSCF.
 222
 223 ContinueGPRSArg ::= SEQUENCE {
 224         pDPID                                                           [0] PDPID                                                                       OPTIONAL,
 225         ...
 226 }
 227
 228 entityReleasedGPRS {PARAMETERS-BOUND : bound} OPERATION ::= {
 229         ARGUMENT                EntityReleasedGPRSArg {bound}
 230         RETURN RESULT   TRUE
 231         ERRORS                  {missingParameter |
 232                                         taskRefused |
 233                                         unknownPDPID}
 234         CODE                    opcode-entityReleasedGPRS}
 235 --  Direction: gprsSSF -> gsmSCF, Timer: Terg
 236 --  This operation is used when the GPRS Session is detached or a PDP Context is diconnected and
 237 --  the associated event is not armed for reporting.
 238 --  The usage of this operation is independent of the functional entity that initiates the Detach
 239 --  or PDP Context Disconnection and is independent of the cause of the Detach or PDP Context
 240 --  Disconnect.
 241
 242 EntityReleasedGPRSArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 243         gPRSCause                                                       [0] GPRSCause {bound},
 244         pDPID                                                           [1] PDPID                                                                       OPTIONAL,
 245         ...
 246         }
 247
 248 eventReportGPRS {PARAMETERS-BOUND : bound} OPERATION ::= {
 249         ARGUMENT                EventReportGPRSArg {bound}
 250         RETURN RESULT   TRUE
 251         ERRORS                  {unknownPDPID}
 252         CODE                    opcode-eventReportGPRS}
 253 --      Direction gprsSSF -> gsmSCF,Timer Tereg
 254 --              This operation is used to notify the gsmSCF of a GPRS session or PDP context related
 255 --              events (e.g. PDP context activation) previously requested by the gsmSCF in a
 256 --              RequestReportGPRSEventoperation.
 257
 258 EventReportGPRSArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
 259         gPRSEventType                                           [0] GPRSEventType,
 260         miscGPRSInfo                                            [1] MiscCallInfo DEFAULT {messageType request},
 261         gPRSEventSpecificInformation            [2]     GPRSEventSpecificInformation {bound}    OPTIONAL,
 262         pDPID                                                           [3]     PDPID OPTIONAL,
 263         ...
 264         }
 265
 266 furnishChargingInformationGPRS {PARAMETERS-BOUND : bound} OPERATION ::= {
 267         ARGUMENT                FurnishChargingInformationGPRSArg {bound}
 268         RETURN RESULT   FALSE
 269         ERRORS                  {missingParameter |
 270                                         taskRefused |
 271                                         unexpectedComponentSequence |
 272                                         unexpectedDataValue |
 273                                         unexpectedParameter |
 274                                         unknownPDPID}
 275         CODE                    opcode-furnishChargingInformationGPRS}
 276 -- Direction: gsmSCF -> gprsSSF, Timer: Tfcig
 277 -- This operation is used to request the gprsSSF to generate, register a logical record or to
 278 -- include some information in the default logical GPRS record.
 279 -- The registered logical record is intended for off line charging of the GPRS session
 280 -- or PDP Context.
 281
 282 FurnishChargingInformationGPRSArg {PARAMETERS-BOUND : bound} ::=
 283         FCIGPRSBillingChargingCharacteristics{bound}
 284
 285 initialDPGPRS {PARAMETERS-BOUND : bound} OPERATION ::= {
 286         ARGUMENT                InitialDPGPRSArg {bound}
 287         RETURN RESULT   FALSE
 288         ERRORS                  {missingCustomerRecord |
 289                                         missingParameter |
 290                                         parameterOutOfRange |
 291                                         systemFailure |
 292                                         taskRefused |
 293                                         unexpectedComponentSequence |
 294                                         unexpectedDataValue |
 295                                         unexpectedParameter}
 296         CODE                    opcode-initialDPGPRS}
 297 --      Direction gprsSSF -> gsmSCF,Timer Tidpg
 298 --      This operation is used by the gprsSSF when a trigger is detected at a DP in the GPRS state
 299 --      machines to request instructions from the gsmSCF
 300
 301 InitialDPGPRSArg {PARAMETERS-BOUND : bound}::= SEQUENCE {
 302         serviceKey                                                      [0] ServiceKey,
 303         gPRSEventType                                           [1] GPRSEventType,
 304         mSISDN                                                          [2] ISDN-AddressString,
 305         iMSI                                                            [3] IMSI,
 306         timeAndTimeZone                                         [4] TimeAndTimezone {bound},
 307         gPRSMSClass                                                     [5] GPRSMSClass                                                         OPTIONAL,
 308         endUserAddress                                          [6] EndUserAddress {bound}                                      OPTIONAL,
 309         qualityOfService                                        [7] QualityOfService                                            OPTIONAL,
 310         accessPointName                                         [8] AccessPointName{bound}                                      OPTIONAL,
 311         routeingAreaIdentity                            [9] RAIdentity                                                          OPTIONAL,
 312         chargingID                                                      [10] GPRSChargingID                                                     OPTIONAL,
 313         sGSNCapabilities                                        [11] SGSNCapabilities                                           OPTIONAL,
 314         locationInformationGPRS                         [12] LocationInformationGPRS                            OPTIONAL,
 315         pDPInitiationType                                       [13] PDPInitiationType                                          OPTIONAL,
 316         extensions                                                      [14] Extensions {bound}                                         OPTIONAL,
 317         ...,
 318         gGSNAddress                                                     [15] GSN-Address                                                        OPTIONAL,
 319         secondaryPDP-context                            [16] NULL                                                                       OPTIONAL,
 320         iMEI                                                            [17] IMEI                                                                       OPTIONAL
 321         }
 322 --      The RouteingAreaIdentity parameter is not used.
 323 --      The receiving entity shall ignore RouteingAreaIdentity if received.
 324 --  The RouteingAreaIdentity is conveyed in the LocationInformationGPRS parameter.
 325 --  The CSGInformation is conveyed in the LocationInformationGPRS parameter. The encoding of the
 326 --  parameter is as defined in 3GPP TS 29.002 [11].
 327
 328 releaseGPRS {PARAMETERS-BOUND : bound} OPERATION ::= {
 329         ARGUMENT                ReleaseGPRSArg {bound}
 330         RETURN RESULT   FALSE
 331         ERRORS                  {missingParameter |
 332                                         taskRefused |
 333                                         unknownPDPID}
 334         CODE                    opcode-releaseGPRS}
 335 --  Direction: gsmSCF -> gprsSSF, Timer: Trg
 336 --  This operation is used to tear down an existing GPRS session or PDP Context at any phase.
 337
 338 ReleaseGPRSArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 339         gprsCause                                                       [0] GPRSCause {bound},
 340         pDPID                                                           [1]     PDPID                                                                   OPTIONAL,
 341         ...
 342         }
 343
 344 requestReportGPRSEvent {PARAMETERS-BOUND : bound} OPERATION ::= {
 345         ARGUMENT                RequestReportGPRSEventArg {bound}
 346         RETURN RESULT   FALSE
 347         ERRORS                  {missingParameter |
 348                                         parameterOutOfRange |
 349                                         systemFailure |
 350                                         taskRefused |
 351                                         unexpectedComponentSequence |
 352                                         unexpectedDataValue |
 353                                         unexpectedParameter |
 354                                         unknownPDPID}
 355         CODE                    opcode-requestReportGPRSEvent}
 356 -- Direction: gsmSCF -> gprsSSF, Timer: Trrqe
 357 -- This operation is used to request the gprsSSF to monitor for an event (e.g., GPRS events
 358 -- such as attach or PDP Context activiation), then send a notification back to the
 359 -- gsmSCF when the event is detected.
 360
 361 RequestReportGPRSEventArg {PARAMETERS-BOUND : bound} ::= SEQUENCE {
 362         gPRSEvent                                                       [0] SEQUENCE SIZE (1..bound.&numOfGPRSEvents) OF GPRSEvent,
 363         pDPID                                                           [1]     PDPID                                                                   OPTIONAL,
 364         ...
 365         }
 366 -- Indicates the GPRS related events for notification.
 367
 368 resetTimerGPRS OPERATION ::= {
 369         ARGUMENT                ResetTimerGPRSArg
 370         RETURN RESULT   FALSE
 371         ERRORS                  {missingParameter |
 372                                         parameterOutOfRange |
 373                                         taskRefused |
 374                                         unexpectedComponentSequence |
 375                                         unexpectedDataValue |
 376                                         unexpectedParameter |
 377                                         unknownPDPID}
 378         CODE                    opcode-resetTimerGPRS}
 379 --  Direction: gsmSCF ? gprsSSF, Timer: Trtg
 380 --  This operation is used to request the gprsSSF to refresh an application timer in the gprsSSF.
 381
 382 ResetTimerGPRSArg ::= SEQUENCE {
 383         timerID                                                         [0] TimerID                                     DEFAULT tssf,
 384         timervalue                                                      [1] TimerValue,
 385         ...
 386         }
 387
 388 sendChargingInformationGPRS {PARAMETERS-BOUND: bound} OPERATION ::= {
 389         ARGUMENT                SendChargingInformationGPRSArg { bound}
 390         RETURN RESULT   FALSE
 391         ERRORS                  {missingParameter |
 392                                         unexpectedComponentSequence |
 393                                         unexpectedParameter |
 394                                         parameterOutOfRange |
 395                                         systemFailure |
 396                                         taskRefused |
 397                                         unexpectedDataValue |
 398                                         unknownPDPID}
 399         CODE                    opcode-sendChargingInformationGPRS}
 400 -- Direction: gsmSCF -> gprsSSF, Timer: Tscig
 401 -- This operation is used to instruct the gprsSSF on the charging information which the
 402 -- gprsSSF shall send to the Mobile Station by means of GSM access signalling.
 403
 404 SendChargingInformationGPRSArg {PARAMETERS-BOUND: bound}::= SEQUENCE {
 405         sCIGPRSBillingChargingCharacteristics [0] SCIGPRSBillingChargingCharacteristics {bound},
 406         ...
 407         }
 408
 409 END