serial_port.h

/* Copyright Statement:
 *
 * (C) 2005-2016 MediaTek Inc. All rights reserved.
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein
 * is confidential and proprietary to MediaTek Inc. ("MediaTek") and/or its licensors.
 * Without the prior written permission of MediaTek and/or its licensors,
 * any reproduction, modification, use or disclosure of MediaTek Software,
 * and information contained herein, in whole or in part, shall be strictly prohibited.
 * You may only use, reproduce, modify, or distribute (as applicable) MediaTek Software
 * if you have agreed to and been bound by the applicable license agreement with
 * MediaTek ("License Agreement") and been granted explicit permission to do so within
 * the License Agreement ("Permitted User"). If you are not a Permitted User,
 * please cease any access or use of MediaTek Software immediately.
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT MEDIATEK SOFTWARE RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES
 * ARE PROVIDED TO RECEIVER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
 * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
 * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
 * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
 * SUPPLIED WITH MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
 * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
 * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
 * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
 * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
 * CUMULATIVE LIABILITY WITH RESPECT TO MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
 * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE MEDIATEK SOFTWARE AT ISSUE,
 * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
 * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
 */

#ifndef __SERIAL_PORT_H__
#define __SERIAL_PORT_H__

#ifdef MTK_PORT_SERVICE_ENABLE

#include <stdint.h>
#include "serial_port_config.h"
#include "hal_uart.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef enum {
    SERIAL_PORT_DEV_UART_TYPE_BEGIN = 0,                        
    SERIAL_PORT_DEV_UART_0 = SERIAL_PORT_DEV_UART_TYPE_BEGIN,   
    SERIAL_PORT_DEV_UART_1,                                     
    SERIAL_PORT_DEV_UART_2,                                     
    SERIAL_PORT_DEV_UART_3,                                     
    SERIAL_PORT_DEV_UART_TYPE_END = SERIAL_PORT_DEV_UART_3,     
    SERIAL_PORT_DEV_USB_TYPE_BEGIN,                             
    SERIAL_PORT_DEV_USB_COM1 = SERIAL_PORT_DEV_USB_TYPE_BEGIN,  
    SERIAL_PORT_DEV_USB_COM2,                                   
    SERIAL_PORT_DEV_USB_TYPE_END = SERIAL_PORT_DEV_USB_COM2,    
    SERIAL_PORT_DEV_MAX,                                        
    SERIAL_PORT_DEV_UNDEFINED = 255,                            
} serial_port_dev_t;

typedef enum {
    SERIAL_PORT_TYPE_BEGIN = 0,                                 
    SERIAL_PORT_TYPE_UART = SERIAL_PORT_TYPE_BEGIN,             
    SERIAL_PORT_TYPE_USB,                                       
    SERIAL_PORT_TYPE_MAX,                                       
} serial_port_type_t;

typedef enum {
    SERIAL_PORT_CMD_WRITE_DATA = 0,             
    SERIAL_PORT_CMD_READ_DATA,                  
    SERIAL_PORT_CMD_WRITE_DATA_BLOCKING,        
    SERIAL_PORT_CMD_READ_DATA_BLOCKING,         
    SERIAL_PORT_CMD_GET_WRITE_AVAIL,            
    SERIAL_PORT_CMD_GET_READ_AVAIL,             
    SERIAL_PORT_CMD_MAX,                        
} serial_port_ctrl_cmd_t;

typedef enum {
    SERIAL_PORT_EVENT_READY_TO_READ = 0,        
    SERIAL_PORT_EVENT_READY_TO_WRITE,           
    SERIAL_PORT_EVENT_USB_CONNECTION,           
    SERIAL_PORT_EVENT_USB_DISCONNECTION,        
} serial_port_callback_event_t;

typedef enum {
    SERIAL_PORT_STATUS_DEV_NOT_READY = -7,      
    SERIAL_PORT_STATUS_BUSY = -6,               
    SERIAL_PORT_STATUS_UNINITIALIZED = -5,      
    SERIAL_PORT_STATUS_UNSUPPORTED = -4,        
    SERIAL_PORT_STATUS_INVALID_DEVICE = -3,     
    SERIAL_PORT_STATUS_INVALID_PARAMETER = -2,  
    SERIAL_PORT_STATUS_FAIL = -1,               
    SERIAL_PORT_STATUS_OK = 0,                  
} serial_port_status_t;
typedef void (*serial_port_register_callback_t)(serial_port_dev_t device, serial_port_callback_event_t event, void *parameter);

typedef uint32_t serial_port_handle_t;

typedef struct {
    uint8_t *data;                   
    uint32_t size;                   
    uint32_t ret_size;               
} serial_port_write_data_t;

typedef struct {
    uint8_t *buffer;                 
    uint32_t size;                   
    uint32_t ret_size;               
} serial_port_read_data_t;

typedef struct {
    uint32_t ret_size;               
} serial_port_get_write_avail_t;

typedef struct {
    uint32_t ret_size;               
} serial_port_get_read_avail_t;

typedef struct {
    serial_port_register_callback_t callback;  
} serial_port_open_para_t;

typedef struct {
    char name[SERIAL_PORT_USER_NAME_SIZE];     
    serial_port_dev_t device;                  
} serial_port_assign_t;

typedef struct {
    hal_uart_baudrate_t baudrate;              
} serial_port_setting_uart_t;

typedef union {
    serial_port_setting_uart_t port_setting_uart;  
} serial_port_dev_setting_t;

typedef union {
    serial_port_write_data_t serial_port_write_data;                
    serial_port_read_data_t serial_port_read_data;                  
    serial_port_write_data_t serial_port_write_data_blocking;       
    serial_port_read_data_t serial_port_read_data_blocking;         
    serial_port_get_write_avail_t serial_port_get_write_avail;      
    serial_port_get_read_avail_t serial_port_get_read_avail;        
} serial_port_ctrl_para_t;
serial_port_status_t serial_port_open(serial_port_dev_t device,
                                      serial_port_open_para_t *para,
                                      serial_port_handle_t *handle);

serial_port_status_t serial_port_control(serial_port_handle_t handle,
        serial_port_ctrl_cmd_t command,
        serial_port_ctrl_para_t *para);

serial_port_status_t serial_port_close(serial_port_handle_t handle);

serial_port_type_t serial_port_get_device_type(serial_port_dev_t device);

serial_port_status_t serial_port_config_dump_dev_number(uint32_t *user_count, serial_port_assign_t *port_assign);

serial_port_status_t serial_port_config_read_dev_number(const char *user_name, serial_port_dev_t *device);

serial_port_status_t serial_port_config_write_dev_number(const char *user_name, serial_port_dev_t device);

serial_port_status_t serial_port_config_read_dev_setting(serial_port_dev_t device, serial_port_dev_setting_t *dev_setting);

serial_port_status_t serial_port_config_write_dev_setting(serial_port_dev_t device, serial_port_dev_setting_t *dev_setting);

#endif

#ifdef __cplusplus
}
#endif

#endif