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_WAITING,
  73         AT_RESPONSE_UNHANDELD_REASON_DATA,
  74         AT_RESPONSE_UNHANDELD_REASON_STATUS,
  75         AT_RESPONSE_HANDLED_OK,
  76         AT_RESPONSE_HANDLED_ERROR,
  77 };
  78
  79 struct at_responses_queue {
  80         struct at_response **responses;
  81         int responses_count;
  82 };
  83
  84 typedef int (*at_async_request_cb)(struct at_response *response, void *data, RIL_Token t);
  85
  86 struct at_async_request {
  87         int handled;
  88         int status;
  89         char *error;
  90
  91         char *command;
  92         void *data;
  93         RIL_Token token;
  94
  95         at_async_request_cb func;
  96 };
  97
  98 struct at_async_queue {
  99         struct at_async_request **requests;
 100         int requests_count;
 101 };
 102
 103 struct at_responses_handling {
 104         pthread_mutex_t responses_queue_mutex;
 105         struct at_responses_queue responses_queue;
 106         pthread_mutex_t responses_mutex;
 107
 108         struct at_async_queue async_queue;
 109         pthread_mutex_t async_mutex;
 110
 111         struct at_request *sync_request;
 112         struct at_response *sync_response;
 113         pthread_mutex_t sync_mutex;
 114 };
 115
 116 /*
 117  * Functions
 118  */
 119
 120 // Utilities
 121 int at_strings_compare(char *major, char *minor);
 122 int at_commands_compare(char *major, char *minor);
 123 void at_string_clean(char *string, int length);
 124 int at_status_error(int status);
 125
 126 // Responses structures processing
 127 int at_responses_process(struct at_response ***responses_p, char *data, int length);
 128 void at_response_free(struct at_response *response);
 129 void at_responses_free(struct at_response **responses, int responses_count);
 130
 131 // Responses handling
 132 void at_responses_handling_init(void);
 133
 134 // Responses queue
 135 int at_response_queue(struct at_response *response);
 136 struct at_response *at_response_dequeue(void);
 137
 138 // Expect to func
 139 int at_request_expect_to_func(char *command, void *data, RIL_Token t, at_async_request_cb func);
 140 int at_response_expect_to_func(struct at_response *response);
 141
 142 // Expect status
 143 int at_request_expect_status(struct at_request *request);
 144 int at_response_expect_status(struct at_response *response);
 145 int at_expect_status(struct at_request *request);
 146
 147 // Request
 148 int at_request_send(struct at_request *request);
 149 struct at_request *at_request_create(char *command, char *data);
 150 void at_request_free(struct at_request *request);
 151
 152 // Send
 153 int at_send(char *command, char *data);
 154 int at_send_command(char *command);
 155 int at_send_expect_status(char *command, char *data);
 156 int at_send_expect_to_func(char *command, char *data, void *pdata, RIL_Token t, at_async_request_cb func);
 157
 158 #endif