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

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