背景
本章的内容是适用于AP侧AT指令开发调试的有关人员。
主要是介绍高通实现的ATFWD框架。在这需要说明一下的是，或许你对AT Command很了解了，但是却貌似都不知道ATFWD，这很正常，严格来说，ATFWD都不算属于AT Command框架的一部分，只是高通对扩展的at命令做的一个扩展实现。
我们之前说到，ATCommands以处理方式可以分有两类，一类是直接在modem下进行处理的，还有一部分是在AP侧进行处理更加方便有效的。
而对于APSide的AT命令，高通也提供了一套框架进行实现，在这我们就这一块做详细的学习。
同样的，AT命令通过ATCoP从串口传来并被解析，而对于APSide的AT命令我们会通过allow_list[]数组注册，这个时候modem会判断传来的命令是不是AP相关的，如果是，通过qmi通讯将AT命令传到AP侧进行处理，而在AP侧的流程便是通过ATFWD框架实现的。
因此，只要有ATCoP，那么有关的指令就需要注册到ATCoP中
在某个新基线上移植AT指令，发现有问题，因此收集了这个系列的 文章 作为 这方面的知识补充。
原文作者：laozhuxinlu，本文有删改。
AT指令在产线中是一类比较重要的问题， 一天没来得及解决，则会拖延生产的有关进度。
ATFWD 主要是与 含有 modem 的有关异构处理器有关的。
如果 对应的高通平台 没有 modem 处理器（例如 SDM845），则使用 port-bridge 的方式进行 AT 实现，后续我们会讲到。
代码解析
在vendor下，一般是在vendor/qcom/proprietary/telephony-apps/ATFWD-daemon目录下，我们能看到ATFWD的具体实现：
有时候也可能存在于
vendor/qcom/proprietary/data/ATFWD-daemon下
- Android.mk：编译一个主进程（ATFWD-daemon）到system/bin下面做实时监听从modem下传来的AT命令。
- atfwd_daemon.c：主进程的main函数定义，做AT命令的注册已经QMI（Qualcom Message Interface 高通信息接口 ）初始化，并循环监听传来的AT命令并处理返回。
- sendcmd.cpp：初始化获取binder服务，以此实现将AT命令传到实际处理的地方。
- IAtCmdFwd.cpp：对binder服务的定义。
main
ATFWD-daemon进程的入口是main()函数
/*=========================================================================
FUNCTION: main
===========================================================================*/
/*!
@brief
Initialize the QMI connection and register the ATFWD event listener.
argv[1] if provided, gives the name of the qmi port to open.
Default is "rmnet_sdio0".
*/
/*=========================================================================*/
int main (int argc, char **argv)
{
AtCmdResponse *response;
int i, connectionResult, initType;
userHandle = userHandleSMD = -1;
i = connectionResult = 0;
printf("*** Starting ATFWD-daemon ***
");
(void) getTargetFromSysProperty();
if ( !is_supported_qcci() )
{
if (!strncmp(ATFWD_DATA_TARGET_APQ, target,
strlen(target))) {
printf("APQ baseband : Explicitly stopping ATFWD service....
");
stopSelf();
return -1;
}
if (argc >= 2) {
qmiPort = argv[1];
} else {
qmiPort = getDefaultPort();
if( NULL == qmiPort ) {
qmiPort = DEFAULT_QMI_PORT;
}
}
if (argc >= 3) {
secondaryPort = argv[2];
} else if (!strncmp(ATFWD_DATA_TARGET_SVLTE2A, target, strlen(target))) {
/* For SVLTE type II targets, Modem currently exposes two ATCOP ports.
* One bridged from USB to SDIO, directly talking to 9k modem
* Another bridged from USB to SMD, directly talking to 8k
* Therefore given this modem architecture, ATFWD-daemon needs to
* listen to both the modems( 8k & 9K).
* Register with 8k modem
*/
secondaryPort = DEFAULT_SMD_PORT;
} else if (!strncmp(ATFWD_DATA_TARGET_SGLTE, target, strlen(target))) {
// For SGLTE targets, Register with the SMUX port.
secondaryPort = QMI_PORT_RMNET_SMUX_0;
}
}
printf("init all signals
");
signalInit();
pthread_mutexattr_t attr;
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&ctrMutex, &attr);
pthread_cond_init(&ctrCond, NULL);
printf("Explicitly disbling qmux
");
qmi_cci_qmux_xport_unregister(QMI_CLIENT_QMUX_RMNET_INSTANCE_0);
qmi_cci_qmux_xport_unregister(QMI_CLIENT_QMUX_RMNET_USB_INSTANCE_0);
qmi_cci_qmux_xport_unregister(QMI_CLIENT_QMUX_RMNET_SMUX_INSTANCE_0);
qmi_cci_qmux_xport_unregister(QMI_CLIENT_QMUX_RMNET_MHI_INSTANCE_0);
printf("Disabling QMUX complete...
");
//Get QMI service object
printf("getting at svc obj for access terminal QMI svc
");
qmi_at_svc_obj = at_get_service_object_v01();
for (initType = INIT_QMI; initType != INIT_MAX; initType++) {
connectionResult = 0;
tryInit (initType, &connectionResult);
printf(" tryinit complete with connectresult: %d
", connectionResult);
if (connectionResult < 0)
{
if ( !is_supported_qcci() )
{
if (qmiHandle >= 0) {
qmi_release(qmiHandle);
}
}
else
{
printf("Release qmi_client...
");
qmi_client_release(qmi_at_svc_client);
qmi_at_svc_client = NULL;
}
stopSelf();
return -1;
}
}
else
{
if (!registerATCommands())
{
stopSelf();
return -1;
}
}
while (1) {
pthread_mutex_lock(&ctrMutex);
while (!isNewCommandAvailable()) {
printf("Waiting for ctrCond");
pthread_cond_wait(&ctrCond, &ctrMutex);
printf("Recieved ctrCond: p: %d, S:%d, nr: %d",regForPrimaryPort, regForSecondaryPort, newRequest );
}
if ( !is_supported_qcci() )
{
if (regForPrimaryPort == 1) {
if (qmiPort) {
printf("Rcvd pthread notification for primary QMI port registration");
initAtcopServiceAndRegisterCommands(qmiPort, &userHandle);
} else {
printf("Notification for primary QMI port registration when NOT valid, ignore...");
}
regForPrimaryPort = 0;
}
if (regForSecondaryPort == 1) {
if (secondaryPort) {
printf("Rcvd pthread notification for secondary QMI port registration");
initAtcopServiceAndRegisterCommands(secondaryPort, &userHandleSMD);
} else {
printf("Notification for secondary QMI port registration when NOT valid, ignore...");
}
regForSecondaryPort = 0;
}
if(userHandle < 0 && userHandleSMD < 0)
{
printf("userhandle(s) for both 8k and 9k modems NOT valid -- bail out");
if (qmiHandle >= 0)
{
qmi_release(qmiHandle);
}
stopSelf();
return -1;
}
}
else
{
if ( regForPrimaryPort == 1)
{
printf("Registering for primary port (QCCI).");
connectionResult = 0;
tryInit (INIT_QMI_SRVC, &connectionResult);
printf(" init result: %d
", connectionResult);
if (connectionResult < 0)
{
printf("Release qmi_client...
");
qmi_client_release(qmi_at_svc_client);
qmi_at_svc_client = NULL;
stopSelf();
return -1;
}
if (!registerATCommands())
{
printf("Register for primary port (QCCI) failed.");
stopSelf();
return -1;
}
regForPrimaryPort=0;
}
if ( regForServiceUp == 1 )
{
regForServiceUpEvent();
}
}
if (newRequest == 1) {
printf("pthread notified for new request; sending response.");
response = sendit(&fwdcmd);
if (response == NULL) {
printf("Response processing complete、Invalid cmd resp.");
sendInvalidCommandResponse();
printf("Invalid response sending complete.");
} else {
printf("Response processing complete、Sending response.");
sendResponse(response);
printf("Send response complete.");
}
if (fwdcmd.name) free(fwdcmd.name);
if (fwdcmd.tokens) {
for (i = 0; i < fwdcmd.ntokens; i++) {
free(fwdcmd.tokens[i]);
}
free(fwdcmd.tokens);
}
freeAtCmdResponse(response);
newRequest = 0;
printf("New request processing complete.");
}
pthread_mutex_unlock(&ctrMutex);
}
return 0;
}
tryInit
在main中会调用tryInit()：实现三块的初始化：
- 首先是QMI的初始化；其次是进行QMI连接的初始化：这两块主要是实现能接受到从modem下传上来的At命令。
- 最后是对binder服务的获取初始化：以便能把相应的命令通过binder通讯方式传到相应的地方进行处理。
void tryInit (atfwd_init_type_t type, int *result) {
LOGI("ATFWD :Going to tryInit ATFWD daemon
");
int retryCnt = 1;
for (; retryCnt <= ATFWD_MAX_RETRY_ATTEMPTS; retryCnt++) {
LOGI("ATFWD :retryCnt <= ATFWD_MAX_RETRY_ATTEMPTS
");
qmiErrorCode = 0;
switch (type) {
// 初始化QMI
case INIT_QMI:
LOGI("ATFWD :Going to qmi_init(atfwdSysEventHandler)
");
qmiHandle = qmi_init(atfwdSysEventHandler, NULL);
*result = qmiHandle;
break;
// 连接QMI(实现能接受到从modem下传上来的At命令)
case INIT_QMI_SRVC:
LOGI("ATFWD :Going to qmi_connection_init(qmiPort, &qmiErrorCode)
");
*result = qmi_connection_init(qmiPort, &qmiErrorCode);
break;
// 获取binder服务，以便能把相应的命令通过binder通讯方式传到相应的地方进行处理
case INIT_ATFWD_SRVC:
LOGI("ATFWD :Going to initializeAtFwdService(case INIT_ATFWD_SRVC)
");
*result = initializeAtFwdService();
break;
default:
LOGI("Invalid type %d", type);
return;
}
LOGI("ATFWD :result : %d ,Init step :%d ,qmiErrorCode: %d", *result, type, qmiErrorCode);
if (*result >= 0 && qmiErrorCode == 0) {
break;
}
sleep(retryCnt * ATFWD_RETRY_DELAY);
}
return;
}
initAtcopServiceAndRegisterCommands
初始化并注册所有其添加的At命令；
// 对应的命令
qmi_atcop_at_cmd_fwd_req_type atCmdFwdReqType[] = {
{ //AT command fwd type
1, // Number of commands
{
{ QMI_ATCOP_AT_CMD_NOT_ABORTABLE, "+CKPD"},
}
},
{ //AT command fwd type
1, // Number of commands
{
{ QMI_ATCOP_AT_CMD_NOT_ABORTABLE, "+CTSA"},
}
},
{ //AT command fwd type
1, // Number of commands
{
{ QMI_ATCOP_AT_CMD_NOT_ABORTABLE, "+CFUN"},
}
},
// ...
};
void initAtcopServiceAndRegisterCommands(const char *port, int *handle) {
int i, nErrorCnt, nCommands;
i = nErrorCnt = 0;
initAtCopServiceByPort(port, handle);
if (*handle > 0) {
nCommands = sizeof(atCmdFwdReqType) / sizeof(atCmdFwdReqType[0]);
printf("Trying to register %d commands:
", nCommands);
for (i = 0; i < nCommands ; i++) {
printf("cmd%d: %s
", i, atCmdFwdReqType[i].qmi_atcop_at_cmd_fwd_req_type[0].at_cmd_name);
qmiErrorCode = 0;
int registrationStatus = qmi_atcop_reg_at_command_fwd_req(*handle,
&atCmdFwdReqType[i], &qmiErrorCode);
printf("qmi_atcop_reg_at_command_fwd_req: %d", qmiErrorCode);
if (registrationStatus < 0 || qmiErrorCode != 0) {
printf("Could not register AT command : %s with the QMI Interface - Err code:%d
",
atCmdFwdReqType[i].qmi_atcop_at_cmd_fwd_req_type[0].at_cmd_name, qmiErrorCode);
nErrorCnt++;
qmiErrorCode = 0;
}
}
if(nErrorCnt == nCommands) {
printf("AT commands registration failure..、Release client handle: %d
", *handle);
qmi_atcop_srvc_release_client(*handle, &qmiErrorCode);
*handle = -1;
return;
}
} else {
printf("ATcop Service Init failed
");
return;
}
printf("Registered AT Commands event handler
");
return;
}
等待新命令
此后，函数会循环在while(1)中，当modem下有传来需要处理的命令的时候，newRequest会置为1，走if(newRequest == 1){……}
if (newRequest == 1) {
LOGI("pthread notified for new request
");
response = sendit(&fwdcmd);
if (response == NULL) {
sendInvalidCommandResponse();
} else {
sendResponse(response);
}
if (fwdcmd.name) free(fwdcmd.name);
if (fwdcmd.tokens) {
for (i = 0; i < fwdcmd.ntokens; i++) {
free(fwdcmd.tokens[i]);
}
free(fwdcmd.tokens);
}
freeAtCmdResponse(response);
newRequest = 0;
}
main()函数下调用sendit(&fwdcmd)函数将命令传递出去，并将返回的结果给response数据结构；
Sendit
typedef struct {
int opcode;
char *name; // 指令名称， AT+abc --> abc
int ntokens; // 有多少个参数
char **tokens; // 参数数组
} AtCmd;
typedef struct {
int result;
char *response;
} AtCmdResponse;
extern "C" AtCmdResponse *sendit(const AtCmd *cmd)
{
AtCmdResponse *result = NULL;
result = new AtCmdResponse;
result->response = NULL;
LOGI("sendit");
LOGE("%s:%d peeta", __func__, __LINE__);
if(strcasecmp(cmd->name, "+QFCT")==0){
LOGI("ATFWD AtCmdFwd QFCT");
if(NULL != cmd->tokens) {
LOGI("ATFWD AtCmdFwd Tokens Not NULL ntokens=%d",cmd->ntokens);
if(cmd->ntokens == 0 || cmd->tokens[0] == NULL){
LOGI("ATFWD AtCmdFwd Tokens[0] is NULL");
quec_qfct_handle(result);
}else if(0 == strncmp("wifi-kill",cmd->tokens[0],strlen("wifi-kill"))){
// char *args[5] = { PTT_SOCKET_BIN, "-f", "-d", "-v", NULL };
LOGI("ATFWD AtCmdFwd:%s",cmd->tokens[0]);
property_set("wifi.ptt_socket_app", "false");
property_set("wifi.p_socket_app", "true");
//...
}else{
LOGI("ATFWD AtCmdFwd Tokens is NULL");
quec_qfct_handle(result);
}
}else if(strcasecmp(cmd->name, "+QGMR")==0)
{
quec_qgmr_handle(cmd,result);
}
return result;
}
如果使用到了binder，还可以这样：sendit()函数调用processCommand()函数，processCommand是继承于BpInterface类实现的，我们通过Parcel数据将数据写入data下，然后通过调用唤起RPC进行binder数据通讯：remote()->transact(processAtCmd,data, &reply);
extern "C" AtCmdResponse *sendit(const AtCmd *cmd)
{
AtCmdResponse *result;
if (!cmd) return NULL;
result = gAtCmdFwdService->processCommand(*cmd);
return result;
}
以上主要就是一个ATCommand在ATFWD下的大致流程了。
总结
简单的说，那就是一个进程，进行数据中转的进程：数据从modem下传上来先通过venderril，再从venderril下传到framework（或者别的什么地方）下进行处理，ATFWD便是venderril下的一个中转站。其中与modem的通讯方式采用QMI，与framework采用bingerserver方式通讯。
ATFWD调试技巧
如果在AT指令的实现中遇到了某些问题，可以按照下面的流程进行分析。
0、确保ATFWD进程正常执行，如果没有，则根据log确定 是 中途退出（没走完流程）还是 Android系统的权限问题。
AT Command流程分析之具体实现
主要是介绍作为一个AT Command的开发者，具体如何参与到代码的开发。当然，这里主要是介绍一些基本的开发工作……
想必从前面的学习，你已经了解到AT命令执行的大致流程，基于这个流程，AT Command的功能开发也主要是包括在两个方面：
- BP Side类型的AT命令开发
- AP Side类型的AT命令开发
BP侧
首先是BP Side类型的AT命令开发，或者说如何在ATCoP上去扩展实现实现一个AT命令。
我们知道AT命令分有以下几种类型，在这我们以最常见的扩展AT命令为例，命名：”+CLAY”。
- 基本 AT 命令（basic_table）
- 寄存器 AT 命令（sreg_table）
- 扩展 AT 命令（extended_table）
- 厂商 AT 命令（vendor_table）
定义指针变量
在dsati.h下的dsatetsi_ext_action_index_enum_type枚举数组中添加一个指针变量如下：
DSATETSI_EXT_ACT_CLAY_ETSI_IDX = 14084
建立AT命令和处理函数的映射
在dsatetsictab.c下的dsatetsi_ext_action_table_ex []数据下添加映射：
//...
{DSATETSI_EXT_ACT_CLAY_ETSI_IDX, dsatetsime_exec_clay_cmd }
// ...
定义AT命令
如果想要定义一个at命令，需要首先确定它的命令表项，也就是name、属性、参数情况、处理函数指针等……
下面我们增加的是一个最简单的命令，name是”+CLAY”，属性是无参数。
在dsatetsictab_ex.c下的dsatetsi_ext_action_table []数组中添加：
{ "+CLAY", READ_ONLY | COMMON_CMD,
SPECIAL_NONE, 0,DSATETSI_EXT_ACT_CLAY_ETSI_IDX
}
具体的含义请参见 AT Command流程分析之AtCop解析模块。
声明处理函数
上面完成以后就能定义其实际的处理函数了，在定义之前，我们先要声明一下，在dsatetsime.h下添加：
dsat_result_enum_type dsatetsime_exec_clay_cmd (
dsat_mode_enum_typemode, /*AT command mode: */
constdsati_cmd_type *parse_table, /*Ptr to cmd in parse table */
consttokens_struct_type *tok_ptr, /*Command tokens from parser */
dsm_item_type*res_buff_ptr /* Place to put response */
);
定义处理函数
dsat_result_enum_type dsatetsime_exec_clay_cmd (
dsat_mode_enum_typemode, /*AT command mode: */
constdsati_cmd_type *parse_table, /*Ptr to cmd in parse table */
consttokens_struct_type *tok_ptr, /*Command tokens from parser */
dsm_item_type*res_buff_ptr /* Place to put response */
){
dsat_result_enum_type result= DSAT_OK;
if(tok_ptr->op == NA){
res_buff_ptr->used =(word) snprintf ((char*)res_buff_ptr->data_ptr,
res_buff_ptr->size,
"%s: %s,%s",
"+CLAY",
"hello",
"world");
}
else if(tok_ptr->op ==(NA|EQ|QU)){} //针对其他的语法格式进行处理
else if(tok_ptr->op ==(NA|QU)){} //针对其他的语法格式进行处理
else if(tok_ptr->op ==(NA|EQ|AR)){} //针对其他的语法格式进行处理
else{ result= DSAT_ERROR;} //针对错误的语法格式进行处理
return result;
}
至此，一个BP Site的自定义AT 命令便开发完成了，这里需要注意的是，这边只是举例实现，而且对AT+CLAY的命令类型作为扩展命令开发的，就所以流程仅供参考……
AP侧
那么，要想扩展添加一个AP Site的AT命令又该如何呢？
首先要确认ATFWD在设备中已添加注册并正常运行（可在system/bin下去查看）
同样的，这里就AT+CLAY举例实现……
1、在Modem侧添加自定义的AT Command的注册。
在*/amss_8909/modem_proc/datamodem/interface/atcop/src/dsatclient_ex.c下的LOCAL byte allowed_list[][MAX_CMD_SIZE]数组中添加定义：
LOCAL byte allowed_list[][MAX_CMD_SIZE]={……,"+CLAY",""};
2、 AP侧的Vendor下添加AT Command的注册。
在*/vendor/qcom/proprietary/data/ATFWD-daemon/atfwd_daemon.c下的qmi_atcop_at_cmd_fwd_req_type atCmdFwdReqType[]数组中添加定义：
{ //AT command fwd type
1, // Number of commands
{
{ QMI_ATCOP_AT_CMD_NOT_ABORTABLE, "+CLAY"},
}
},
3、 添加在framework侧的实际处理并返回处理结果。之前我们说过，AP Site的AT命令在串口经过modem通过QMI通讯方式将命令传到Vendor Ril下，但是实际上是需要将该命令传到framework下去处理的，这个时候需要用到binder通讯方式将命令传到framework下去实际处理。
在Vendor下的binder通讯发送在/vendor/qcom/proprietary/data/ATFWD-daemon/IAtCmdFwd.cpp下去实现的：
virtual AtCmdResponse *processCommand(const AtCmd &cmd)
{
// ...
data.writeInterfaceToken(IAtCmdFwdService::getInterfaceDescriptor());
data.writeInt32(1); //specify there is an input parameter
data.writeInt32(cmd.opcode); //opcode
String16 cmdname(cmd.name);
s16 = strdup8to16(cmd.name, &len);
data.writeString16(s16, len); //command name
free(s16);
data.writeInt32(cmd.ntokens);
for (int i=0; i < cmd.ntokens; i++) {
s16 = strdup8to16(cmd.tokens[i], &len);
data.writeString16(s16,len);
free(s16);
}
status_t status = remote()->transact(processAtCmd, data, &reply);//RPC call
LOGI("Status: %d",status);
if (status != NO_ERROR) {
LOGE("Error in RPC Call to AtCdmFwd Service (Exception occurred?)");
return NULL;
}
// ...
}
实际就是通过
status_t status = remote()->transact(processAtCmd, data, &reply);//RPC call
实现了发送，最后返回的处理结果在status下。
4、在framework侧的处理实现：
status_t BnAtCmdFwdService::onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags) {
case processAtCmd: {
// ...…… //接受到binder通讯传来的数据
}
}
最后就是针对接收到的具体的值进行处理。