Debian Codegraph @

gobi-api/Gobi_2012-06-18-1054/Gobi3000Translation/Gobi3000TranslationPDS.cpp

raw
1 /*===========================================================================
2 FILE:
3 Gobi3000TranslationPDS.cpp
4
5 DESCRIPTION:
6 QUALCOMM Translation for Gobi 3000 (Position Determination Service)
7
8 Copyright (c) 2012, Code Aurora Forum. All rights reserved.
9
10 Redistribution and use in source and binary forms, with or without
11 modification, are permitted provided that the following conditions are met:
12 * Redistributions of source code must retain the above copyright
13 notice, this list of conditions and the following disclaimer.
14 * Redistributions in binary form must reproduce the above copyright
15 notice, this list of conditions and the following disclaimer in the
16 documentation and/or other materials provided with the distribution.
17 * Neither the name of Code Aurora Forum nor
18 the names of its contributors may be used to endorse or promote
19 products derived from this software without specific prior written
20 permission.
21
22
23 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
27 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 POSSIBILITY OF SUCH DAMAGE.
34 ==========================================================================*/
35
36 //---------------------------------------------------------------------------
37 // Include Files
38 //---------------------------------------------------------------------------
39 #include "Gobi3000Translation.h"
40
41 /*===========================================================================
42 METHOD:
43 PackResetPDSData
44
45 DESCRIPTION:
46 This function resets the specified PDS data
47
48 PARAMETERS:
49 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
50 contain, upon output the number of BYTEs copied
51 to pOut
52 pOut [ O ] - Output buffer
53 pGPSDataMask [ I ] - Bitmask of GPS data to clear (optional)
54 pCellDataMask [ I ] - Bitmask of cell data to clear (optional)
55
56 RETURN VALUE:
57 ULONG - Return code
58 ===========================================================================*/
59 ULONG PackResetPDSData(
60 ULONG * pOutLen,
61 BYTE * pOut,
62 ULONG * pGPSDataMask,
63 ULONG * pCellDataMask )
64 {
65 // Validate arguments (at least one mask must be present)
66 if (pOut == 0 || (pGPSDataMask == 0 && pCellDataMask == 0))
67 {
68 return eGOBI_ERR_INVALID_ARG;
69 }
70
71 sQMIRawContentHeader * pHeader;
72 ULONG offset = 0;
73
74 // Optionally add pGPSDataMask
75 if (pGPSDataMask != 0)
76 {
77 // Check size
78 WORD tlvx10Sz = sizeof( sPDSResetPDSDataRequest_GPSData );
79 if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz)
80 {
81 return eGOBI_ERR_BUFFER_SZ;
82 }
83
84 pHeader = (sQMIRawContentHeader*)(pOut + offset);
85 pHeader->mTypeID = 0x10;
86 pHeader->mLength = tlvx10Sz;
87 offset += sizeof( sQMIRawContentHeader );
88
89 sPDSResetPDSDataRequest_GPSData * pTLVx10;
90 pTLVx10 = (sPDSResetPDSDataRequest_GPSData*)(pOut + offset);
91 memset( pTLVx10, 0, tlvx10Sz );
92
93 // Typecast the input over the bitmask
94 *(ULONG *)pTLVx10 = *pGPSDataMask;
95 offset += tlvx10Sz;
96 }
97
98 // Optionally add pCellDataMask
99 if (pCellDataMask != 0)
100 {
101 // Check size
102 WORD tlvx11Sz = sizeof( sPDSResetPDSDataRequest_CellData );
103 if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx11Sz)
104 {
105 return eGOBI_ERR_BUFFER_SZ;
106 }
107
108 pHeader = (sQMIRawContentHeader*)(pOut + offset);
109 pHeader->mTypeID = 0x11;
110 pHeader->mLength = tlvx11Sz;
111 offset += sizeof( sQMIRawContentHeader );
112
113 sPDSResetPDSDataRequest_CellData * pTLVx11;
114 pTLVx11 = (sPDSResetPDSDataRequest_CellData*)(pOut + offset);
115 memset( pTLVx11, 0, tlvx11Sz );
116
117 // Typecast the input over the bitmask
118 *(ULONG *)pTLVx11 = *pCellDataMask;
119 offset += tlvx11Sz;
120 }
121
122 *pOutLen = offset;
123
124 return eGOBI_ERR_NONE;
125 }
126
127 /*===========================================================================
128 METHOD:
129 PackSetPortAutomaticTracking
130
131 DESCRIPTION:
132 This function sets the automatic tracking configuration for the NMEA
133 COM port
134
135 PARAMETERS:
136 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
137 contain, upon output the number of BYTEs copied
138 to pOut
139 pOut [ O ] - Output buffer
140 bAuto [ I ] - Enable automatic tracking for NMEA COM port?
141
142 RETURN VALUE:
143 ULONG - Return code
144 ===========================================================================*/
145 ULONG PackSetPortAutomaticTracking(
146 ULONG * pOutLen,
147 BYTE * pOut,
148 ULONG bAuto )
149 {
150 // Validate arguments
151 if (pOut == 0)
152 {
153 return eGOBI_ERR_INVALID_ARG;
154 }
155
156 // Add bAuto
157
158 // Check size
159 WORD tlvx01Sz = sizeof( sPDSSetCOMPortAutoTrackingConfigRequest_Config );
160 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
161 {
162 return eGOBI_ERR_BUFFER_SZ;
163 }
164
165 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
166 pHeader->mTypeID = 0x01;
167 pHeader->mLength = tlvx01Sz;
168
169 ULONG offset = sizeof( sQMIRawContentHeader );
170
171 sPDSSetCOMPortAutoTrackingConfigRequest_Config * pTLVx01;
172 pTLVx01 = (sPDSSetCOMPortAutoTrackingConfigRequest_Config*)(pOut + offset);
173 memset( pTLVx01, 0, tlvx01Sz );
174
175 // Set the value
176 pTLVx01->mAutoTrackingEnabled = (bAuto == 0 ? 0 : 1);
177
178 offset += tlvx01Sz;
179
180 *pOutLen = offset;
181
182 return eGOBI_ERR_NONE;
183 }
184
185 /*===========================================================================
186 METHOD:
187 ParseGetPortAutomaticTracking
188
189 DESCRIPTION:
190 This function returns the automatic tracking configuration for the NMEA
191 COM port
192
193 PARAMETERS:
194 inLen [ I ] - Length of input buffer
195 pIn [ I ] - Input buffer
196 pbAuto [ O ] - Automatic tracking enabled for NMEA COM port?
197
198 RETURN VALUE:
199 ULONG - Return code
200 ===========================================================================*/
201 ULONG ParseGetPortAutomaticTracking(
202 ULONG inLen,
203 const BYTE * pIn,
204 ULONG * pbAuto )
205 {
206 // Validate arguments
207 if (pIn == 0 || pbAuto == 0)
208 {
209 return eGOBI_ERR_INVALID_ARG;
210 }
211
212 // Find pbAuto
213 const sPDSGetCOMPortAutoTrackingConfigResponse_Config * pTLVx01;
214 ULONG outLenx01;
215 ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 );
216 if (rc != eGOBI_ERR_NONE)
217 {
218 return rc;
219 }
220
221 // Is the TLV large enough?
222 if (outLenx01 < sizeof( sPDSGetCOMPortAutoTrackingConfigResponse_Config ))
223 {
224 return eGOBI_ERR_MALFORMED_RSP;
225 }
226
227 *pbAuto = pTLVx01->mAutoTrackingEnabled;
228
229 return eGOBI_ERR_NONE;
230 }
231
232 /*===========================================================================
233 METHOD:
234 PackSetServiceAutomaticTracking
235
236 DESCRIPTION:
237 This function sets the automatic tracking state for the service
238
239 PARAMETERS:
240 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
241 contain, upon output the number of BYTEs copied
242 to pOut
243 pOut [ O ] - Output buffer
244 pbAuto [ I ] - Start automatic tracking session for service?
245
246 RETURN VALUE:
247 ULONG - Return code
248 ===========================================================================*/
249 ULONG PackSetServiceAutomaticTracking(
250 ULONG * pOutLen,
251 BYTE * pOut,
252 ULONG bAuto )
253 {
254 // Validate arguments
255 if (pOut == 0)
256 {
257 return eGOBI_ERR_INVALID_ARG;
258 }
259
260 // Add bAuto
261
262 // Check size
263 WORD tlvx01Sz = sizeof( sPDSSetServiceAutoTrackingStateRequest_State );
264 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
265 {
266 return eGOBI_ERR_BUFFER_SZ;
267 }
268
269 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
270 pHeader->mTypeID = 0x01;
271 pHeader->mLength = tlvx01Sz;
272
273 ULONG offset = sizeof( sQMIRawContentHeader );
274
275 sPDSSetServiceAutoTrackingStateRequest_State * pTLVx01;
276 pTLVx01 = (sPDSSetServiceAutoTrackingStateRequest_State*)(pOut + offset);
277 memset( pTLVx01, 0, tlvx01Sz );
278
279 // Set the value
280 pTLVx01->mAutoTrackingEnabled = (bAuto == 0 ? 0 : 1);
281
282 offset += tlvx01Sz;
283
284 *pOutLen = offset;
285
286 return eGOBI_ERR_NONE;
287 }
288 /*===========================================================================
289 METHOD:
290 ParseGetServiceAutomaticTracking
291
292 DESCRIPTION:
293 This function returns the automatic tracking state for the service
294
295 PARAMETERS:
296 inLen [ I ] - Length of input buffer
297 pIn [ I ] - Input buffer
298 pbAuto [ O ] - Automatic tracking session started for service?
299
300 RETURN VALUE:
301 ULONG - Return code
302 ===========================================================================*/
303 ULONG ParseGetServiceAutomaticTracking(
304 ULONG inLen,
305 const BYTE * pIn,
306 ULONG * pbAuto )
307 {
308 // Validate arguments
309 if (pIn == 0 || pbAuto == 0)
310 {
311 return eGOBI_ERR_INVALID_ARG;
312 }
313
314 // Find pbAuto
315 const sPDSGetServiceAutoTrackingStateResponse_State * pTLVx01;
316 ULONG outLenx01;
317 ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 );
318 if (rc != eGOBI_ERR_NONE)
319 {
320 return rc;
321 }
322
323 // Is the TLV large enough?
324 if (outLenx01 < sizeof( sPDSGetServiceAutoTrackingStateResponse_State ))
325 {
326 return eGOBI_ERR_MALFORMED_RSP;
327 }
328
329 *pbAuto = pTLVx01->mAutoTrackingEnabled;
330
331 return eGOBI_ERR_NONE;
332 }
333
334 /*===========================================================================
335 METHOD:
336 PackSetAGPSConfig
337
338 DESCRIPTION:
339 This function sets the PDS AGPS configuration
340
341 PARAMETERS:
342 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
343 contain, upon output the number of BYTEs copied
344 to pOut
345 pOut [ O ] - Output buffer
346 serverAddress [ I ] - IPv4 address of AGPS server
347 serverPort [ I ] - Port number of AGPS server
348
349 RETURN VALUE:
350 ULONG - Return code
351 ===========================================================================*/
352 ULONG PackSetAGPSConfig(
353 ULONG * pOutLen,
354 BYTE * pOut,
355 ULONG serverAddress,
356 ULONG serverPort )
357 {
358 // Validate arguments
359 if (pOut == 0)
360 {
361 return eGOBI_ERR_INVALID_ARG;
362 }
363
364 // Add arguments
365
366 // Check size
367 WORD tlvx10Sz = sizeof( sPDSSetAGPSConfigRequest_Server );
368 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx10Sz)
369 {
370 return eGOBI_ERR_BUFFER_SZ;
371 }
372
373 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
374 pHeader->mTypeID = 0x10;
375 pHeader->mLength = tlvx10Sz;
376
377 ULONG offset = sizeof( sQMIRawContentHeader );
378
379 sPDSSetAGPSConfigRequest_Server * pTLVx10;
380 pTLVx10 = (sPDSSetAGPSConfigRequest_Server*)(pOut + offset);
381 memset( pTLVx10, 0, tlvx10Sz );
382
383 ULONG ip0 = (serverAddress & 0x000000FF);
384 ULONG ip1 = (serverAddress & 0x0000FF00) >> 8;
385 ULONG ip2 = (serverAddress & 0x00FF0000) >> 16;
386 ULONG ip3 = (serverAddress & 0xFF000000) >> 24;
387
388 // Set the values
389 pTLVx10->mServerAddress[0] = (INT8)ip0;
390 pTLVx10->mServerAddress[1] = (INT8)ip1;
391 pTLVx10->mServerAddress[2] = (INT8)ip2;
392 pTLVx10->mServerAddress[3] = (INT8)ip3;
393 pTLVx10->mServerPort = serverPort;
394
395 offset += tlvx10Sz;
396
397 *pOutLen = offset;
398
399 return eGOBI_ERR_NONE;
400 }
401
402 /*===========================================================================
403 METHOD:
404 ParseGetAGPSConfig
405
406 DESCRIPTION:
407 This function returns the PDS AGPS configuration
408
409 PARAMETERS:
410 inLen [ I ] - Length of input buffer
411 pIn [ I ] - Input buffer
412 pServerAddress [ O ] - IPv4 address of AGPS server
413 pServerPort [ O ] - Port number of AGPS server
414
415 RETURN VALUE:
416 ULONG - Return code
417 ===========================================================================*/
418 ULONG ParseGetAGPSConfig(
419 ULONG inLen,
420 const BYTE * pIn,
421 ULONG * pServerAddress,
422 ULONG * pServerPort )
423 {
424 // Validate arguments
425 if (pIn == 0 || pServerAddress == 0 || pServerPort == 0)
426 {
427 return eGOBI_ERR_INVALID_ARG;
428 }
429
430 // Find arguments
431 const sPDSGetAGPSConfigResponse_ServerAddress * pTLVx01;
432 ULONG outLenx01;
433 ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 );
434 if (rc != eGOBI_ERR_NONE)
435 {
436 return rc;
437 }
438
439 // Is the TLV large enough?
440 if (outLenx01 < sizeof( sPDSGetAGPSConfigResponse_ServerAddress ))
441 {
442 return eGOBI_ERR_MALFORMED_RSP;
443 }
444
445 *pServerPort = pTLVx01->mServerPort;
446
447 ULONG ip0 = (ULONG)pTLVx01->mServerAddress[0];
448 ULONG ip1 = (ULONG)pTLVx01->mServerAddress[1] << 8;
449 ULONG ip2 = (ULONG)pTLVx01->mServerAddress[2] << 16;
450 ULONG ip3 = (ULONG)pTLVx01->mServerAddress[3] << 24;
451 *pServerAddress = (ip0 | ip1 | ip2 | ip3);
452
453 return eGOBI_ERR_NONE;
454 }
455
456 /*===========================================================================
457 METHOD:
458 PackSetXTRATimeState
459
460 DESCRIPTION:
461 This function sets the XTRA time positioning state
462
463 PARAMETERS:
464 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
465 contain, upon output the number of BYTEs copied
466 to pOut
467 pOut [ O ] - Output buffer
468 state [ I ] - XTRA time positioning state
469
470 RETURN VALUE:
471 ULONG - Return code
472 ===========================================================================*/
473 ULONG PackSetXTRATimeState(
474 ULONG * pOutLen,
475 BYTE * pOut,
476 ULONG state )
477 {
478 // Validate arguments
479 if (pOut == 0)
480 {
481 return eGOBI_ERR_INVALID_ARG;
482 }
483
484 // Add state
485
486 // Check size
487 WORD tlvx10Sz = sizeof( sPDSSetPositionMethodsStateRequest_XTRATime );
488 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx10Sz)
489 {
490 return eGOBI_ERR_BUFFER_SZ;
491 }
492
493 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
494 pHeader->mTypeID = 0x10;
495 pHeader->mLength = tlvx10Sz;
496
497 ULONG offset = sizeof( sQMIRawContentHeader );
498
499 sPDSSetPositionMethodsStateRequest_XTRATime * pTLVx10;
500 pTLVx10 = (sPDSSetPositionMethodsStateRequest_XTRATime*)(pOut + offset);
501 memset( pTLVx10, 0, tlvx10Sz );
502
503 // Set the value
504 pTLVx10->mMethodState = (eQMIPDSMethodStates)state;
505
506 offset += tlvx10Sz;
507 *pOutLen = offset;
508
509 return eGOBI_ERR_NONE;
510 }
511
512 /*===========================================================================
513 METHOD:
514 ParseGetXTRATimeState
515
516 DESCRIPTION:
517 This function returns the XTRA time positioning state
518
519 PARAMETERS:
520 inLen [ I ] - Length of input buffer
521 pIn [ I ] - Input buffer
522 pState [ O ] - XTRA time positioning state
523
524 RETURN VALUE:
525 ULONG - Return code
526 ===========================================================================*/
527 ULONG ParseGetXTRATimeState(
528 ULONG inLen,
529 const BYTE * pIn,
530 ULONG * pState )
531 {
532 // Validate arguments
533 if (pIn == 0 || pState == 0)
534 {
535 return eGOBI_ERR_INVALID_ARG;
536 }
537
538 // Find pState
539 const sPDSGetPositionMethodsStateResponse_XTRATime * pTLVx10;
540 ULONG outLenx10;
541 ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
542 if (rc != eGOBI_ERR_NONE)
543 {
544 return rc;
545 }
546
547 // Is the TLV large enough?
548 if (outLenx10 < sizeof( sPDSGetPositionMethodsStateResponse_XTRATime ))
549 {
550 return eGOBI_ERR_MALFORMED_RSP;
551 }
552
553 *pState = pTLVx10->mMethodState;
554
555 return eGOBI_ERR_NONE;
556 }
557
558 /*===========================================================================
559 METHOD:
560 PackSetXTRADataState
561
562 DESCRIPTION:
563 This function sets the XTRA data positioning state
564
565 PARAMETERS:
566 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
567 contain, upon output the number of BYTEs copied
568 to pOut
569 pOut [ O ] - Output buffer
570 state [ I ] - XTRA data positioning state
571
572 RETURN VALUE:
573 ULONG - Return code
574 ===========================================================================*/
575 ULONG PackSetXTRADataState(
576 ULONG * pOutLen,
577 BYTE * pOut,
578 ULONG state )
579 {
580 // Validate arguments
581 if (pOut == 0)
582 {
583 return eGOBI_ERR_INVALID_ARG;
584 }
585
586 // Add state
587
588 // Check size
589 WORD tlvx10Sz = sizeof( sPDSSetPositionMethodsStateRequest_XTRAData );
590 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx10Sz)
591 {
592 return eGOBI_ERR_BUFFER_SZ;
593 }
594
595 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
596 pHeader->mTypeID = 0x10;
597 pHeader->mLength = tlvx10Sz;
598
599 ULONG offset = sizeof( sQMIRawContentHeader );
600
601 sPDSSetPositionMethodsStateRequest_XTRAData * pTLVx10;
602 pTLVx10 = (sPDSSetPositionMethodsStateRequest_XTRAData*)(pOut + offset);
603 memset( pTLVx10, 0, tlvx10Sz );
604
605 // Set the value
606 pTLVx10->mMethodState = (eQMIPDSMethodStates)state;
607
608 offset += tlvx10Sz;
609 *pOutLen = offset;
610
611 return eGOBI_ERR_NONE;
612 }
613
614 /*===========================================================================
615 METHOD:
616 ParseGetXTRADataState
617
618 DESCRIPTION:
619 This function returns the XTRA data positioning state
620
621 PARAMETERS:
622 inLen [ I ] - Length of input buffer
623 pIn [ I ] - Input buffer
624 pState [ O ] - XTRA data positioning state
625
626 RETURN VALUE:
627 ULONG - Return code
628 ===========================================================================*/
629 ULONG ParseGetXTRADataState(
630 ULONG inLen,
631 const BYTE * pIn,
632 ULONG * pState )
633 {
634 // Validate arguments
635 if (pIn == 0 || pState == 0)
636 {
637 return eGOBI_ERR_INVALID_ARG;
638 }
639
640 // Find pState
641 const sPDSGetPositionMethodsStateResponse_XTRAData * pTLVx10;
642 ULONG outLenx10;
643 ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
644 if (rc != eGOBI_ERR_NONE)
645 {
646 return rc;
647 }
648
649 // Is the TLV large enough?
650 if (outLenx10 < sizeof( sPDSGetPositionMethodsStateResponse_XTRAData ))
651 {
652 return eGOBI_ERR_MALFORMED_RSP;
653 }
654
655 *pState = pTLVx10->mMethodState;
656
657 return eGOBI_ERR_NONE;
658 }
659
660 /*===========================================================================
661 METHOD:
662 ParseGetXTRAValidity
663
664 DESCRIPTION:
665 This function returns the XTRA database validity period
666
667 PARAMETERS:
668 inLen [ I ] - Length of input buffer
669 pIn [ I ] - Input buffer
670 pGPSWeek [ O ] - Starting GPS week of validity period
671 pGPSWeekOffset [ O ] - Starting GPS week offset (minutes) of validity period
672 pDuration [ O ] - Length of validity period (hours)
673
674 RETURN VALUE:
675 ULONG - Return code
676 ===========================================================================*/
677 ULONG ParseGetXTRAValidity(
678 ULONG inLen,
679 const BYTE * pIn,
680 USHORT * pGPSWeek,
681 USHORT * pGPSWeekOffset,
682 USHORT * pDuration )
683 {
684 // Validate arguments
685 if (pIn == 0 || pGPSWeek == 0 || pGPSWeekOffset == 0 || pDuration == 0)
686 {
687 return eGOBI_ERR_INVALID_ARG;
688 }
689
690 // Find arguments
691 const sPDSGetXTRAParametersResponse_Validity * pTLVx13;
692 ULONG outLenx13;
693 ULONG rc = GetTLV( inLen, pIn, 0x13, &outLenx13, (const BYTE **)&pTLVx13 );
694 if (rc != eGOBI_ERR_NONE)
695 {
696 return rc;
697 }
698
699 // Is the TLV large enough?
700 if (outLenx13 < sizeof( sPDSGetXTRAParametersResponse_Validity ))
701 {
702 return eGOBI_ERR_MALFORMED_RSP;
703 }
704
705 *pDuration = pTLVx13->mValidPeriodDurationInHours;
706 *pGPSWeek = pTLVx13->mValidPeriodGPSStartWeek;
707 *pGPSWeekOffset = pTLVx13->mValidPeriodGPSStartWeekOffsetInMinutes;
708
709 return eGOBI_ERR_NONE;
710 }
711
712 /*===========================================================================
713 METHOD:
714 PackSetXTRANetwork
715
716 DESCRIPTION:
717 This function sets the XTRA WWAN network preference
718
719 PARAMETERS:
720 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
721 contain, upon output the number of BYTEs copied
722 to pOut
723 pOut [ O ] - Output buffer
724 preference [ I ] - XTRA WWAN network preference
725
726 RETURN VALUE:
727 ULONG - Return code
728 ===========================================================================*/
729 ULONG PackSetXTRANetwork(
730 ULONG * pOutLen,
731 BYTE * pOut,
732 ULONG preference )
733 {
734 // Validate arguments
735 if (pOut == 0)
736 {
737 return eGOBI_ERR_INVALID_ARG;
738 }
739
740 // Add preference
741
742 // Check size
743 WORD tlvx12Sz = sizeof( sPDSSetXTRAParametersRequest_Network );
744 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx12Sz)
745 {
746 return eGOBI_ERR_BUFFER_SZ;
747 }
748
749 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
750 pHeader->mTypeID = 0x12;
751 pHeader->mLength = tlvx12Sz;
752
753 ULONG offset = sizeof( sQMIRawContentHeader );
754
755 sPDSSetXTRAParametersRequest_Network * pTLVx12;
756 pTLVx12 = (sPDSSetXTRAParametersRequest_Network*)(pOut + offset);
757 memset( pTLVx12, 0, tlvx12Sz );
758
759 // Set the value
760 pTLVx12->mWWANNetworkPreference = (eQMIPDSWWANNetworkPreferences)preference;
761
762 offset += tlvx12Sz;
763 *pOutLen = offset;
764
765 return eGOBI_ERR_NONE;
766 }
767
768 /*===========================================================================
769 METHOD:
770 ParseGetXTRANetwork
771
772 DESCRIPTION:
773 This function returns the XTRA WWAN network preference
774
775 PARAMETERS:
776 inLen [ I ] - Length of input buffer
777 pIn [ I ] - Input buffer
778 pPreference [ O ] - XTRA WWAN network preference
779
780 RETURN VALUE:
781 ULONG - Return code
782 ===========================================================================*/
783 ULONG ParseGetXTRANetwork(
784 ULONG inLen,
785 const BYTE * pIn,
786 ULONG * pPreference )
787 {
788 // Validate arguments
789 if (pIn == 0 || pPreference == 0)
790 {
791 return eGOBI_ERR_INVALID_ARG;
792 }
793
794 // Find pPreference
795 const sPDSGetXTRAParametersResponse_Network * pTLVx12;
796 ULONG outLenx12;
797 ULONG rc = GetTLV( inLen, pIn, 0x12, &outLenx12, (const BYTE **)&pTLVx12 );
798 if (rc != eGOBI_ERR_NONE)
799 {
800 return rc;
801 }
802
803 // Is the TLV large enough?
804 if (outLenx12 < sizeof( sPDSGetXTRAParametersResponse_Network ))
805 {
806 return eGOBI_ERR_MALFORMED_RSP;
807 }
808
809 *pPreference = pTLVx12->mWWANNetworkPreference;
810
811 return eGOBI_ERR_NONE;
812 }
813
814 /*===========================================================================
815 METHOD:
816 PackSetXTRAAutomaticDownload
817
818 DESCRIPTION:
819 This function sets the XTRA automatic download configuration
820
821 PARAMETERS:
822 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
823 contain, upon output the number of BYTEs copied
824 to pOut
825 pOut [ O ] - Output buffer
826 bEnabled [ I ] - Automatic download enabled?
827 interval [ I ] - Interval (hours) between XTRA downloads
828
829 RETURN VALUE:
830 ULONG - Return code
831 ===========================================================================*/
832 ULONG PackSetXTRAAutomaticDownload(
833 ULONG * pOutLen,
834 BYTE * pOut,
835 ULONG bEnabled,
836 USHORT interval )
837 {
838 // Validate arguments
839 if (pOut == 0)
840 {
841 return eGOBI_ERR_INVALID_ARG;
842 }
843
844 // Add arguments
845
846 // Check size
847 WORD tlvx10Sz = sizeof( sPDSSetXTRAParametersRequest_Automatic );
848 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx10Sz)
849 {
850 return eGOBI_ERR_BUFFER_SZ;
851 }
852
853 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
854 pHeader->mTypeID = 0x10;
855 pHeader->mLength = tlvx10Sz;
856
857 ULONG offset = sizeof( sQMIRawContentHeader );
858
859 sPDSSetXTRAParametersRequest_Automatic * pTLVx10;
860 pTLVx10 = (sPDSSetXTRAParametersRequest_Automatic*)(pOut + offset);
861 memset( pTLVx10, 0, tlvx10Sz );
862
863 // Set the value
864 pTLVx10->mAutomaticDownloadEnabled = (bEnabled == 0 ? 0 : 1);
865 pTLVx10->mDownloadIntervalInHours = interval;
866
867 offset += tlvx10Sz;
868 *pOutLen = offset;
869
870 return eGOBI_ERR_NONE;
871 }
872
873 /*===========================================================================
874 METHOD:
875 ParseGetXTRAAutomaticDownload
876
877 DESCRIPTION:
878 This function returns the XTRA automatic download configuration
879
880 PARAMETERS:
881 inLen [ I ] - Length of input buffer
882 pIn [ I ] - Input buffer
883 pbEnabled [ O ] - Automatic download enabled?
884 pInterval [ O ] - Interval (hours) between XTRA downloads
885
886 RETURN VALUE:
887 ULONG - Return code
888 ===========================================================================*/
889 ULONG ParseGetXTRAAutomaticDownload(
890 ULONG inLen,
891 const BYTE * pIn,
892 ULONG * pbEnabled,
893 USHORT * pInterval )
894 {
895 // Validate arguments
896 if (pIn == 0 || pbEnabled == 0 || pInterval == 0)
897 {
898 return eGOBI_ERR_INVALID_ARG;
899 }
900
901 // Find arguments
902 const sPDSGetXTRAParametersResponse_Automatic * pTLVx10;
903 ULONG outLenx10;
904 ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
905 if (rc != eGOBI_ERR_NONE)
906 {
907 return rc;
908 }
909
910 // Is the TLV large enough?
911 if (outLenx10 < sizeof( sPDSGetXTRAParametersResponse_Automatic ))
912 {
913 return eGOBI_ERR_MALFORMED_RSP;
914 }
915
916 *pbEnabled = pTLVx10->mAutomaticDownloadEnabled;
917 *pInterval = pTLVx10->mDownloadIntervalInHours;
918
919 return eGOBI_ERR_NONE;
920 }
921
922 /*===========================================================================
923 METHOD:
924 ParseGetPDSState
925
926 DESCRIPTION:
927 This function returns the current PDS state
928
929 PARAMETERS:
930 inLen [ I ] - Length of input buffer
931 pIn [ I ] - Input buffer
932 pEnabled [ O ] - Current PDS state (0 = disabled)
933 pTracking [ O ] - Current PDS tracking session state
934
935
936 RETURN VALUE:
937 ULONG - Return code
938 ===========================================================================*/
939 ULONG ParseGetPDSState(
940 ULONG inLen,
941 const BYTE * pIn,
942 ULONG * pEnabled,
943 ULONG * pTracking )
944 {
945 // Validate arguments
946 if (pIn == 0 || pEnabled == 0 || pTracking == 0)
947 {
948 return eGOBI_ERR_INVALID_ARG;
949 }
950
951 // Find arguments
952 const sPDSGetServiceStateResponse_State * pTLVx01;
953 ULONG outLenx01;
954 ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 );
955 if (rc != eGOBI_ERR_NONE)
956 {
957 return rc;
958 }
959
960 // Is the TLV large enough?
961 if (outLenx01 < sizeof( sPDSGetServiceStateResponse_State ))
962 {
963 return eGOBI_ERR_MALFORMED_RSP;
964 }
965
966 *pEnabled = pTLVx01->mServiceEnabled;
967 *pTracking = pTLVx01->mTrackingSessionState;
968
969 return eGOBI_ERR_NONE;
970 }
971
972 /*===========================================================================
973 METHOD:
974 PackSetPDSState
975
976 DESCRIPTION:
977 This function sets the PDS state
978
979 PARAMETERS:
980 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
981 contain, upon output the number of BYTEs copied
982 to pOut
983 pOut [ O ] - Output buffer
984 enable [ I ] - Desired PDS state (0 = disable)
985
986 RETURN VALUE:
987 ULONG - Return code
988 ===========================================================================*/
989 ULONG PackSetPDSState(
990 ULONG * pOutLen,
991 BYTE * pOut,
992 ULONG enable )
993 {
994 // Validate arguments
995 if (pOut == 0)
996 {
997 return eGOBI_ERR_INVALID_ARG;
998 }
999
1000 // Add enable
1001
1002 // Check size
1003 WORD tlvx01Sz = sizeof( sPDSSetServiceStateRequest_State );
1004 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
1005 {
1006 return eGOBI_ERR_BUFFER_SZ;
1007 }
1008
1009 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
1010 pHeader->mTypeID = 0x01;
1011 pHeader->mLength = tlvx01Sz;
1012
1013 ULONG offset = sizeof( sQMIRawContentHeader );
1014
1015 sPDSSetServiceStateRequest_State * pTLVx01;
1016 pTLVx01 = (sPDSSetServiceStateRequest_State*)(pOut + offset);
1017 memset( pTLVx01, 0, tlvx01Sz );
1018
1019 // Set the value
1020 pTLVx01->mServiceEnabled = (enable == 0 ? 0 : 1);
1021
1022 offset += tlvx01Sz;
1023 *pOutLen = offset;
1024
1025 return eGOBI_ERR_NONE;
1026 }
1027
1028 /*===========================================================================
1029 METHOD:
1030 PackPDSInjectTimeReference
1031
1032 DESCRIPTION:
1033 This function injects a system time into the PDS engine
1034
1035 PARAMETERS:
1036 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
1037 contain, upon output the number of BYTEs copied
1038 to pOut
1039 pOut [ O ] - Output buffer
1040 sysTime [ I ] - System time
1041 sysDiscontinuities [ I ] - Number of system time discontinuities
1042
1043 RETURN VALUE:
1044 ULONG - Return code
1045 ===========================================================================*/
1046 ULONG PackPDSInjectTimeReference(
1047 ULONG * pOutLen,
1048 BYTE * pOut,
1049 ULONGLONG systemTime,
1050 USHORT systemDiscontinuities )
1051 {
1052 // Validate arguments
1053 if (pOut == 0)
1054 {
1055 return eGOBI_ERR_INVALID_ARG;
1056 }
1057
1058 // Add arguments
1059
1060 // Check size
1061 WORD tlvx01Sz = sizeof( sPDSInjectTimeReferenceRequest_Time );
1062 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
1063 {
1064 return eGOBI_ERR_BUFFER_SZ;
1065 }
1066
1067 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
1068 pHeader->mTypeID = 0x01;
1069 pHeader->mLength = tlvx01Sz;
1070
1071 ULONG offset = sizeof( sQMIRawContentHeader );
1072
1073 sPDSInjectTimeReferenceRequest_Time * pTLVx01;
1074 pTLVx01 = (sPDSInjectTimeReferenceRequest_Time*)(pOut + offset);
1075 memset( pTLVx01, 0, tlvx01Sz );
1076
1077 // Set the values
1078 pTLVx01->mSystemTimeMilliseconds = systemTime;
1079 pTLVx01->mSystemDiscontinuties = systemDiscontinuities;
1080
1081 offset += tlvx01Sz;
1082 *pOutLen = offset;
1083
1084 return eGOBI_ERR_NONE;
1085 }
1086
1087 /*===========================================================================
1088 METHOD:
1089 ParseGetPDSDefaults
1090
1091 DESCRIPTION:
1092 This function returns the default tracking session configuration
1093
1094 PARAMETERS:
1095 inLen [ I ] - Length of input buffer
1096 pIn [ I ] - Input buffer
1097 pOperation [ O ] - Current session operating mode
1098 pTimeout [ O ] - Maximum amount of time (seconds) to work on each fix
1099 pInterval [ O ] - Interval (milliseconds) between fix requests
1100 pAccuracy [ O ] - Current accuracy threshold (meters)
1101
1102 RETURN VALUE:
1103 ULONG - Return code
1104 ===========================================================================*/
1105 ULONG ParseGetPDSDefaults(
1106 ULONG inLen,
1107 const BYTE * pIn,
1108 ULONG * pOperation,
1109 BYTE * pTimeout,
1110 ULONG * pInterval,
1111 ULONG * pAccuracy )
1112 {
1113 // Validate arguments
1114 if (pIn == 0 || pOperation == 0 || pTimeout == 0
1115 || pInterval == 0 || pAccuracy == 0)
1116 {
1117 return eGOBI_ERR_INVALID_ARG;
1118 }
1119
1120 // Find arguments
1121 const sPDSGetDefaultsResponse_Defaults * pTLVx01;
1122 ULONG outLenx01;
1123 ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 );
1124 if (rc != eGOBI_ERR_NONE)
1125 {
1126 return rc;
1127 }
1128
1129 // Is the TLV large enough?
1130 if (outLenx01 < sizeof( sPDSGetDefaultsResponse_Defaults ))
1131 {
1132 return eGOBI_ERR_MALFORMED_RSP;
1133 }
1134
1135 *pOperation = pTLVx01->mSessionOperation;
1136 *pTimeout = pTLVx01->mTimeoutSeconds;
1137 *pInterval = pTLVx01->mFixRequestIntervalSeconds;
1138 *pAccuracy = pTLVx01->mDesiredAccuracyMeters;
1139
1140 return eGOBI_ERR_NONE;
1141 }
1142
1143 /*===========================================================================
1144 METHOD:
1145 PackSetPDSDefaults
1146
1147 DESCRIPTION:
1148 This function sets the default tracking session configuration
1149
1150 PARAMETERS:
1151 pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can
1152 contain, upon output the number of BYTEs copied
1153 to pOut
1154 pOut [ O ] - Output buffer
1155 operation [ I ] - Desired session operating mode
1156 timeout [ I ] - Maximum amount of time (seconds) to work on each fix
1157 interval [ I ] - Interval (milliseconds) between fix requests
1158 accuracy [ I ] - Desired accuracy threshold (meters)
1159
1160 RETURN VALUE:
1161 ULONG - Return code
1162 ===========================================================================*/
1163 ULONG PackSetPDSDefaults(
1164 ULONG * pOutLen,
1165 BYTE * pOut,
1166 ULONG operation,
1167 BYTE timeout,
1168 ULONG interval,
1169 ULONG accuracy )
1170 {
1171 // Validate arguments
1172 if (pOut == 0)
1173 {
1174 return eGOBI_ERR_INVALID_ARG;
1175 }
1176
1177 // Add arguments
1178
1179 // Check size
1180 WORD tlvx01Sz = sizeof( sPDSSetDefaultsRequest_Defaults );
1181 if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
1182 {
1183 return eGOBI_ERR_BUFFER_SZ;
1184 }
1185
1186 sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
1187 pHeader->mTypeID = 0x01;
1188 pHeader->mLength = tlvx01Sz;
1189
1190 ULONG offset = sizeof( sQMIRawContentHeader );
1191
1192 sPDSSetDefaultsRequest_Defaults * pTLVx01;
1193 pTLVx01 = (sPDSSetDefaultsRequest_Defaults*)(pOut + offset);
1194 memset( pTLVx01, 0, tlvx01Sz );
1195
1196 // Set the values
1197 pTLVx01->mDesiredAccuracyMeters = accuracy;
1198 pTLVx01->mFixRequestIntervalSeconds = interval;
1199 pTLVx01->mSessionOperation = (eQMIPDSOperationTypes)operation;
1200 pTLVx01->mTimeoutSeconds = timeout;
1201
1202 offset += tlvx01Sz;
1203
1204 *pOutLen = offset;
1205
1206 return eGOBI_ERR_NONE;
1207 }