43bef51f5f42b8a99912c5e3ec0c0646de2e1ac8
[obnox/wireshark/wip.git] / 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         GSN-Address, -- WS moved to common datatypes in rel 9.0.0
42         ISDN-AddressString
43 FROM MAP-CommonDataTypes {itu-t(0) identified-organization(4) etsi(0) mobileDomain(0)
44 gsm-Network(1) modules(3) map-CommonDataTypes(18) version9(9)}
45
46         GPRSChargingID,
47         GPRSMSClass,
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