at.h

   1 /*
   2  * This file is part of hayes-ril.
   3  *
   4  * Copyright (C) 2012 Paul Kocialkowski <contact@paulk.fr>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <telephony/ril.h>
  20
  21 #ifndef _HAYES_RIL_AT_H_
  22 #define _HAYES_RIL_AT_H_
  23
  24 /*
  25  * Defines
  26  */
  27
  28 #define AT_SYNC_LOCK() pthread_mutex_lock(&(at_responses_handling.sync_mutex));
  29 #define AT_SYNC_UNLOCK() pthread_mutex_unlock(&(at_responses_handling.sync_mutex));
  30 #define AT_ASYNC_LOCK() pthread_mutex_lock(&(at_responses_handling.async_mutex));
  31 #define AT_ASYNC_UNLOCK() pthread_mutex_unlock(&(at_responses_handling.async_mutex));
  32 #define AT_RESPONSES_LOCK() pthread_mutex_lock(&(at_responses_handling.responses_mutex));
  33 #define AT_RESPONSES_UNLOCK() pthread_mutex_unlock(&(at_responses_handling.responses_mutex));
  34 #define AT_RESPONSES_QUEUE_LOCK() pthread_mutex_lock(&(at_responses_handling.responses_queue_mutex));
  35 #define AT_RESPONSES_QUEUE_UNLOCK() pthread_mutex_unlock(&(at_responses_handling.responses_queue_mutex));
  36
  37 #define AT_PARSE_SINGLE_QUOTE   (1 << 0)
  38 #define AT_PARSE_DOUBLE_QUOTE   (1 << 1)
  39
  40 /*
  41  * Variables structures
  42  */
  43
  44 struct at_response {
  45         char *command;
  46
  47         char **data;
  48         int data_count;
  49
  50         int status;
  51         char *error;
  52 };
  53
  54 struct at_request {
  55         char *command;
  56         char *data;
  57
  58         int status;
  59         char *error;
  60 };
  61
  62 enum {
  63         AT_STATUS_UNDEF,
  64         AT_STATUS_OK,
  65         AT_STATUS_CONNECT,
  66         AT_STATUS_ERROR,
  67         AT_STATUS_CME_ERROR,
  68         AT_STATUS_INTERNAL_ERROR,
  69 };
  70
  71 enum {
  72         AT_RESPONSE_UNHANDELD,
  73         AT_RESPONSE_HANDLED_OK,
  74         AT_RESPONSE_HANDLED_ERROR,
  75 };
  76
  77 struct at_responses_queue {
  78         struct at_response **responses;
  79         int responses_count;
  80 };
  81
  82 typedef int (*at_async_request_cb)(struct at_response *response, void *data, RIL_Token t);
  83
  84 struct at_async_request {
  85         char *command;
  86         void *data;
  87         RIL_Token token;
  88
  89         at_async_request_cb func;
  90 };
  91
  92 struct at_async_queue {
  93         struct at_async_request **requests;
  94         int requests_count;
  95 };
  96
  97 struct at_responses_handling {
  98         pthread_mutex_t responses_queue_mutex;
  99         struct at_responses_queue responses_queue;
 100         pthread_mutex_t responses_mutex;
 101
 102         struct at_async_queue async_queue;
 103         pthread_mutex_t async_mutex;
 104
 105         struct at_request *sync_request;
 106         struct at_response *sync_response;
 107         pthread_mutex_t sync_mutex;
 108 };
 109
 110 /*
 111  * Functions
 112  */
 113
 114 // Utilities
 115 int at_strings_compare(char *major, char *minor);
 116 int at_commands_compare(char *major, char *minor);
 117 void at_string_clean(char *string, int length);
 118 int at_status_error(int status);
 119
 120 // Responses structures processing
 121 int at_responses_process(struct at_response ***responses_p, char *data, int length);
 122 void at_response_free(struct at_response *response);
 123 void at_responses_free(struct at_response **responses, int responses_count);
 124
 125 // Responses handling
 126 void at_responses_handling_init(void);
 127
 128 // Responses queue
 129 int at_response_queue(struct at_response *response);
 130 struct at_response *at_response_dequeue(void);
 131
 132 // Expect to func
 133 int at_request_expect_to_func(char *command, void *data, RIL_Token t, at_async_request_cb func);
 134 int at_response_expect_to_func(struct at_response *response);
 135
 136 // Expect status
 137 int at_request_expect_status(struct at_request *request);
 138 int at_response_expect_status(struct at_response *response);
 139 int at_expect_status(struct at_request *request);
 140
 141 // Request
 142 int at_request_send(struct at_request *request);
 143 struct at_request *at_request_create(char *command, char *data);
 144 void at_request_free(struct at_request *request);
 145
 146 // Send
 147 int at_send(char *command, char *data);
 148 int at_send_command(char *command);
 149 int at_send_expect_status(char *command, char *data);
 150 int at_send_expect_to_func(char *command, char *data, void *pdata, RIL_Token t, at_async_request_cb func);
 151
 152 #endif