return ret;
}
+EXPORT_SYMBOL(cy_as_misc_get_firmware_version);
+
static cy_as_return_status_t
my_handle_response_read_m_c_u_register(cy_as_device *dev_p,
cy_as_ll_request_response *req_p,
return ret;
}
-
+EXPORT_SYMBOL(cy_as_misc_read_m_c_u_register);
cy_as_return_status_t
cy_as_misc_write_m_c_u_register(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_reset);
static cy_as_return_status_t
get_unallocated_resource(cy_as_device *dev_p, cy_as_resource_type resource)
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_acquire_resource);
+
cy_as_return_status_t
cy_as_misc_release_resource(cy_as_device_handle handle,
cy_as_resource_type resource)
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_misc_release_resource);
cy_as_return_status_t
cy_as_misc_set_trace_level(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_heart_beat_control);
static cy_as_return_status_t
my_set_sd_clock_freq(
return my_set_sd_clock_freq(dev_p, 0, (uint8_t)setting, cb, client);
}
+EXPORT_SYMBOL(cy_as_misc_set_low_speed_sd_freq);
cy_as_return_status_t
cy_as_misc_set_high_speed_sd_freq(
return my_set_sd_clock_freq(dev_p, 1, (uint8_t)setting, cb, client);
}
+EXPORT_SYMBOL(cy_as_misc_set_high_speed_sd_freq);
cy_as_return_status_t
cy_as_misc_get_gpio_value(cy_as_device_handle handle,
return ret;
}
-
+EXPORT_SYMBOL(cy_as_misc_get_gpio_value);
cy_as_return_status_t
cy_as_misc_set_gpio_value(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_set_gpio_value);
static cy_as_return_status_t
my_enter_standby(cy_as_device *dev_p, cy_bool pin)
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_enter_standby);
cy_as_return_status_t
cy_as_misc_enter_standby_e_x_u(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_leave_standby);
cy_as_return_status_t
cy_as_misc_register_callback(
return ret;
}
-
+EXPORT_SYMBOL(cy_as_misc_storage_changed);
cy_as_return_status_t
cy_as_misc_enter_suspend(
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_enter_suspend);
cy_as_return_status_t
cy_as_misc_leave_suspend(
return ret;
}
+EXPORT_SYMBOL(cy_as_misc_leave_suspend);
cy_as_return_status_t
cy_as_misc_reserve_l_n_a_boot_area(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_mtp_start);
static cy_as_return_status_t
my_handle_response_mtp_stop(cy_as_device *dev_p,
client, CY_RQT_INIT_SEND_OBJECT);
}
+EXPORT_SYMBOL(cy_as_mtp_init_send_object);
cy_as_return_status_t
cy_as_mtp_init_get_object(cy_as_device_handle handle,
transaction_id, cb, client, CY_RQT_INIT_GET_OBJECT);
}
+EXPORT_SYMBOL(cy_as_mtp_init_get_object);
static cy_as_return_status_t
my_handle_response_cancel_send_object(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_mtp_cancel_send_object);
static cy_as_return_status_t
my_handle_response_cancel_get_object(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_mtp_cancel_get_object);
cy_as_return_status_t
cy_as_mtp_send_block_table(cy_as_device_handle handle,
dev_p->is_storage_only_mode = cy_true;
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_mtp_storage_only_start);
cy_as_return_status_t
cy_as_mtp_storage_only_stop(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_mtp_storage_only_stop);
+
return ret;
}
-
+EXPORT_SYMBOL(cy_as_storage_start);
static cy_as_return_status_t
my_handle_response_storage_stop(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_storage_stop);
cy_as_return_status_t
cy_as_storage_register_callback(cy_as_device_handle handle,
return CY_AS_ERROR_SUCCESS;
}
-
+EXPORT_SYMBOL(cy_as_storage_register_callback);
static cy_as_return_status_t
return my_storage_claim(dev_p, NULL, bus, device,
CY_AS_REQUEST_RESPONSE_MS, cb, client);
}
+EXPORT_SYMBOL(cy_as_storage_claim);
static cy_as_return_status_t
my_handle_response_storage_release(cy_as_device *dev_p,
return my_storage_release(dev_p, NULL, bus, device,
CY_AS_REQUEST_RESPONSE_MS, cb, client);
}
+EXPORT_SYMBOL(cy_as_storage_release);
static cy_as_return_status_t
my_handle_response_storage_query_bus(cy_as_device *dev_p,
return my_storage_query_bus(dev_p, bus, cy_as_media_max_media_value,
CY_AS_REQUEST_RESPONSE_MS, count, cb, client);
}
+EXPORT_SYMBOL(cy_as_storage_query_bus);
cy_as_return_status_t
cy_as_storage_query_media(cy_as_device_handle handle,
return my_storage_query_bus(dev_p, bus, type, CY_AS_REQUEST_RESPONSE_EX,
count, cb, client);
}
+EXPORT_SYMBOL(cy_as_storage_query_media);
static cy_as_return_status_t
my_handle_response_storage_query_device(cy_as_device *dev_p,
CY_AS_REQUEST_RESPONSE_MS, data_p->bus,
data_p->device, cb, client);
}
+EXPORT_SYMBOL(cy_as_storage_query_device);
static cy_as_return_status_t
my_handle_response_storage_query_unit(cy_as_device *dev_p,
return my_storage_query_unit(dev_p, data_p, CY_AS_REQUEST_RESPONSE_MS,
data_p->bus, data_p->device, data_p->unit, cb, client);
}
-
+EXPORT_SYMBOL(cy_as_storage_query_unit);
static cy_as_return_status_t
cy_as_get_block_size(cy_as_device *dev_p,
return my_storage_device_control(dev_p, bus, device, card_detect_en,
write_prot_en, config_detect, cb, client);
}
+EXPORT_SYMBOL(cy_as_storage_device_control);
static void
cy_as_async_storage_callback(cy_as_device *dev_p,
CY_RQT_READ_BLOCK, bus, device,
unit, block, data_p, num_blocks);
}
+EXPORT_SYMBOL(cy_as_storage_read);
cy_as_return_status_t
cy_as_storage_write(cy_as_device_handle handle,
CY_RQT_WRITE_BLOCK, bus, device,
unit, block, data_p, num_blocks);
}
-
+EXPORT_SYMBOL(cy_as_storage_write);
cy_as_return_status_t
cy_as_storage_read_async(cy_as_device_handle handle,
CY_AS_REQUEST_RESPONSE_MS, bus, device, unit,
block, data_p, num_blocks, NULL, callback);
}
+EXPORT_SYMBOL(cy_as_storage_read_async);
cy_as_return_status_t
cy_as_storage_write_async(cy_as_device_handle handle,
CY_AS_REQUEST_RESPONSE_MS, bus, device, unit, block,
data_p, num_blocks, NULL, callback);
}
-
+EXPORT_SYMBOL(cy_as_storage_write_async);
static void
my_storage_cancel_callback(
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_storage_cancel_async);
/*
* This function does all the API side clean-up associated with
return ret;
}
+EXPORT_SYMBOL(cy_as_storage_sd_register_read);
cy_as_return_status_t
cy_as_storage_create_p_partition(
return ret;
}
+EXPORT_SYMBOL(cy_as_storage_create_p_partition);
cy_as_return_status_t
cy_as_storage_remove_p_partition(
return ret;
}
+EXPORT_SYMBOL(cy_as_storage_remove_p_partition);
static cy_as_return_status_t
my_handle_response_get_transfer_amount(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_storage_get_transfer_amount);
cy_as_return_status_t
cy_as_storage_erase(
return ret;
}
+EXPORT_SYMBOL(cy_as_storage_erase);
static void
cy_as_storage_func_callback(cy_as_device *dev_p,
return cy_as_sdio_direct_io(handle, bus, device, n_function_no,
address, misc_buf, 0x00, cy_false, data_p);
}
+EXPORT_SYMBOL(cy_as_sdio_direct_read);
cy_as_return_status_t
cy_as_sdio_direct_write(
return cy_as_sdio_direct_io(handle, bus, device, n_function_no,
address, misc_buf, argument, cy_true, data_p);
}
+EXPORT_SYMBOL(cy_as_sdio_direct_write);
/*Cmd53 IO*/
cy_as_return_status_t
n_function_no, address, misc_buf, argument, cy_false,
data_p, callback);
}
+EXPORT_SYMBOL(cy_as_sdio_extended_read);
/* CMD53 Extended Write*/
cy_as_return_status_t
n_function_no, address, misc_buf, argument, cy_true,
data_p, callback);
}
-
+EXPORT_SYMBOL(cy_as_sdio_extended_write);
/* Read the CIS info tuples for the given function and Tuple ID*/
cy_as_return_status_t
cy_as_ll_destroy_response(dev_p, reply_p);
return ret;
}
+EXPORT_SYMBOL(cy_as_sdio_query_card);
/*Reset SDIO card. */
cy_as_return_status_t
cy_as_ll_destroy_response(dev_p, reply_p);
return ret;
}
+EXPORT_SYMBOL(cy_as_sdio_init_function);
/*Query individual functions. */
cy_as_return_status_t
bus, n_function_no, blocksize);
return ret;
}
+EXPORT_SYMBOL(cy_as_sdio_set_blocksize);
/* Deinitialize an SDIO function*/
cy_as_return_status_t
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_start);
void
cy_as_usb_reset(cy_as_device *dev_p)
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_stop);
/*
* This function registers a callback to be called when
dev_p->usb_event_cb_ms = callback;
return CY_AS_ERROR_SUCCESS;
}
-
+EXPORT_SYMBOL(cy_as_usb_register_callback);
static cy_as_return_status_t
my_handle_response_no_data(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_connect);
static cy_as_return_status_t
my_handle_response_disconnect(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_disconnect);
static cy_as_return_status_t
my_handle_response_set_enum_config(cy_as_device *dev_p,
client
);
}
-
+EXPORT_SYMBOL(cy_as_usb_set_enum_config);
static cy_as_return_status_t
my_handle_response_get_enum_config(cy_as_device *dev_p,
return my_usb_get_enum_config(handle,
CY_AS_REQUEST_RESPONSE_MS, config_p, cb, client);
}
-
+EXPORT_SYMBOL(cy_as_usb_get_enum_config);
/*
* This method sets the USB descriptor for a given entity.
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_set_descriptor);
/*
* This method clears all descriptors that were previously
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_clear_descriptors);
static cy_as_return_status_t
my_handle_response_get_descriptor(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_get_descriptor);
cy_as_return_status_t
cy_as_usb_set_physical_configuration(cy_as_device_handle handle,
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_usb_set_physical_configuration);
static cy_bool
is_physical_valid(uint8_t config, cy_as_end_point_number_t ep)
return cy_as_dma_enable_end_point(dev_p, ep,
config_p->enabled, (cy_as_dma_direction)config_p->dir);
}
+EXPORT_SYMBOL(cy_as_usb_set_end_point_config);
cy_as_return_status_t
cy_as_usb_get_end_point_config(cy_as_device_handle handle,
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_usb_get_end_point_config);
/*
* Commit the configuration of the various endpoints to the hardware.
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_commit_config);
static void
sync_request_callback(cy_as_device *dev_p,
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_read_data);
cy_as_return_status_t
cy_as_usb_read_data_async(cy_as_device_handle handle,
}
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_read_data_async);
cy_as_return_status_t
cy_as_usb_write_data(cy_as_device_handle handle,
ret = dev_p->usb_error;
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_write_data);
static void
mtp_write_callback(
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_usb_write_data_async);
static void
my_usb_cancel_async_callback(
return CY_AS_ERROR_SUCCESS;
}
+EXPORT_SYMBOL(cy_as_usb_cancel_async);
static void
cy_as_usb_ack_callback(
return cy_as_usb_nak_stall_request(handle, ep,
CY_RQT_ENDPOINT_SET_NAK, cy_true, 0, cb, client);
}
-
+EXPORT_SYMBOL(cy_as_usb_set_nak);
cy_as_return_status_t
cy_as_usb_clear_nak(cy_as_device_handle handle,
return cy_as_usb_nak_stall_request(handle, ep,
CY_RQT_ENDPOINT_SET_NAK, cy_false, 0, cb, client);
}
+EXPORT_SYMBOL(cy_as_usb_clear_nak);
cy_as_return_status_t
cy_as_usb_get_nak(cy_as_device_handle handle,
CY_RQT_GET_ENDPOINT_NAK, CY_RESP_ENDPOINT_NAK,
nak_p, cb, client);
}
-
+EXPORT_SYMBOL(cy_as_usb_get_nak);
cy_as_return_status_t
cy_as_usb_set_stall(cy_as_device_handle handle,
return cy_as_usb_nak_stall_request(handle, ep,
CY_RQT_STALL_ENDPOINT, cy_true, 0, cb, client);
}
+EXPORT_SYMBOL(cy_as_usb_set_stall);
cy_as_return_status_t
cy_as_usb_clear_stall(cy_as_device_handle handle,
return cy_as_usb_nak_stall_request(handle, ep,
CY_RQT_STALL_ENDPOINT, cy_false, 0, cb, client);
}
+EXPORT_SYMBOL(cy_as_usb_clear_stall);
cy_as_return_status_t
cy_as_usb_get_stall(cy_as_device_handle handle,
return cy_as_usb_get_nak_stall(handle, ep,
CY_RQT_GET_STALL, CY_RESP_ENDPOINT_STALL, stall_p, cb, client);
}
+EXPORT_SYMBOL(cy_as_usb_get_stall);
cy_as_return_status_t
cy_as_usb_signal_remote_wakeup(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_signal_remote_wakeup);
cy_as_return_status_t
cy_as_usb_set_m_s_report_threshold(cy_as_device_handle handle,
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_set_m_s_report_threshold);
cy_as_return_status_t
cy_as_usb_select_m_s_partitions(
return ret;
}
+EXPORT_SYMBOL(cy_as_usb_select_m_s_partitions);
static void
cy_as_usb_func_callback(
+++ /dev/null
-/*
-## cyandevice_export.h - Linux Antioch device driver file
-##
-## ===========================
-## Copyright (C) 2010 Cypress Semiconductor
-##
-## This program is free software; you can redistribute it and/or
-## modify it under the terms of the GNU General Public License
-## as published by the Free Software Foundation; either version 2
-## of the License, or (at your option) any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-## GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License
-## along with this program; if not, write to the Free Software
-## Foundation, Inc., 51 Franklin Street
-## Fifth Floor, Boston, MA 02110-1301, USA.
-## ===========================
-*/
-
-/*
- * Export Misc APIs that can be used from the other driver modules.
- * The APIs to create a device handle and download firmware are not exported
- * because they are expected to be used only by this kernel module.
- */
-EXPORT_SYMBOL(cy_as_misc_get_firmware_version);
-EXPORT_SYMBOL(cy_as_misc_read_m_c_u_register);
-EXPORT_SYMBOL(cy_as_misc_reset);
-EXPORT_SYMBOL(cy_as_misc_acquire_resource);
-EXPORT_SYMBOL(cy_as_misc_release_resource);
-EXPORT_SYMBOL(cy_as_misc_enter_standby);
-EXPORT_SYMBOL(cy_as_misc_leave_standby);
-EXPORT_SYMBOL(cy_as_misc_enter_suspend);
-EXPORT_SYMBOL(cy_as_misc_leave_suspend);
-EXPORT_SYMBOL(cy_as_misc_storage_changed);
-EXPORT_SYMBOL(cy_as_misc_heart_beat_control);
-EXPORT_SYMBOL(cy_as_misc_get_gpio_value);
-EXPORT_SYMBOL(cy_as_misc_set_gpio_value);
-EXPORT_SYMBOL(cy_as_misc_set_low_speed_sd_freq);
-EXPORT_SYMBOL(cy_as_misc_set_high_speed_sd_freq);
-
-/*
- * Export the USB APIs that can be used by the dependent kernel modules.
- */
-EXPORT_SYMBOL(cy_as_usb_set_end_point_config);
-EXPORT_SYMBOL(cy_as_usb_read_data_async);
-EXPORT_SYMBOL(cy_as_usb_write_data_async);
-EXPORT_SYMBOL(cy_as_usb_cancel_async);
-EXPORT_SYMBOL(cy_as_usb_set_stall);
-EXPORT_SYMBOL(cy_as_usb_clear_stall);
-EXPORT_SYMBOL(cy_as_usb_connect);
-EXPORT_SYMBOL(cy_as_usb_disconnect);
-EXPORT_SYMBOL(cy_as_usb_start);
-EXPORT_SYMBOL(cy_as_usb_stop);
-EXPORT_SYMBOL(cy_as_usb_set_enum_config);
-EXPORT_SYMBOL(cy_as_usb_get_enum_config);
-EXPORT_SYMBOL(cy_as_usb_set_physical_configuration);
-EXPORT_SYMBOL(cy_as_usb_register_callback);
-EXPORT_SYMBOL(cy_as_usb_commit_config);
-EXPORT_SYMBOL(cy_as_usb_set_descriptor);
-EXPORT_SYMBOL(cy_as_usb_clear_descriptors);
-EXPORT_SYMBOL(cy_as_usb_get_descriptor);
-EXPORT_SYMBOL(cy_as_usb_get_end_point_config);
-EXPORT_SYMBOL(cy_as_usb_read_data);
-EXPORT_SYMBOL(cy_as_usb_write_data);
-EXPORT_SYMBOL(cy_as_usb_get_stall);
-EXPORT_SYMBOL(cy_as_usb_set_nak);
-EXPORT_SYMBOL(cy_as_usb_clear_nak);
-EXPORT_SYMBOL(cy_as_usb_get_nak);
-EXPORT_SYMBOL(cy_as_usb_signal_remote_wakeup);
-EXPORT_SYMBOL(cy_as_usb_set_m_s_report_threshold);
-EXPORT_SYMBOL(cy_as_usb_select_m_s_partitions);
-
-/*
- * Export all Storage APIs that can be used by dependent kernel modules.
- */
-EXPORT_SYMBOL(cy_as_storage_start);
-EXPORT_SYMBOL(cy_as_storage_stop);
-EXPORT_SYMBOL(cy_as_storage_register_callback);
-EXPORT_SYMBOL(cy_as_storage_query_bus);
-EXPORT_SYMBOL(cy_as_storage_query_media);
-EXPORT_SYMBOL(cy_as_storage_query_device);
-EXPORT_SYMBOL(cy_as_storage_query_unit);
-EXPORT_SYMBOL(cy_as_storage_device_control);
-EXPORT_SYMBOL(cy_as_storage_claim);
-EXPORT_SYMBOL(cy_as_storage_release);
-EXPORT_SYMBOL(cy_as_storage_read);
-EXPORT_SYMBOL(cy_as_storage_write);
-EXPORT_SYMBOL(cy_as_storage_read_async);
-EXPORT_SYMBOL(cy_as_storage_write_async);
-EXPORT_SYMBOL(cy_as_storage_cancel_async);
-EXPORT_SYMBOL(cy_as_storage_sd_register_read);
-EXPORT_SYMBOL(cy_as_storage_create_p_partition);
-EXPORT_SYMBOL(cy_as_storage_remove_p_partition);
-EXPORT_SYMBOL(cy_as_storage_get_transfer_amount);
-EXPORT_SYMBOL(cy_as_storage_erase);
-
-EXPORT_SYMBOL(cy_as_sdio_query_card);
-EXPORT_SYMBOL(cy_as_sdio_init_function);
-EXPORT_SYMBOL(cy_as_sdio_set_blocksize);
-EXPORT_SYMBOL(cy_as_sdio_direct_read);
-EXPORT_SYMBOL(cy_as_sdio_direct_write);
-EXPORT_SYMBOL(cy_as_sdio_extended_read);
-EXPORT_SYMBOL(cy_as_sdio_extended_write);
-
-EXPORT_SYMBOL(cy_as_hal_alloc);
-EXPORT_SYMBOL(cy_as_hal_free);
-EXPORT_SYMBOL(cy_as_hal_sleep);
-EXPORT_SYMBOL(cy_as_hal_create_sleep_channel);
-EXPORT_SYMBOL(cy_as_hal_destroy_sleep_channel);
-EXPORT_SYMBOL(cy_as_hal_sleep_on);
-EXPORT_SYMBOL(cy_as_hal_wake);
-EXPORT_SYMBOL(cy_as_hal_mem_set);
-
-EXPORT_SYMBOL(cy_as_mtp_storage_only_start);
-EXPORT_SYMBOL(cy_as_mtp_storage_only_stop);
-EXPORT_SYMBOL(cy_as_mtp_start);
-EXPORT_SYMBOL(cy_as_mtp_init_send_object);
-EXPORT_SYMBOL(cy_as_mtp_init_get_object);
-EXPORT_SYMBOL(cy_as_mtp_cancel_send_object);
-EXPORT_SYMBOL(cy_as_mtp_cancel_get_object);
-
-#ifdef __CY_ASTORIA_SCM_KERNEL_HAL__
-/* Functions in the SCM kernel HAL implementation only. */
-EXPORT_SYMBOL(cy_as_hal_enable_scatter_list);
-EXPORT_SYMBOL(cy_as_hal_disable_scatter_list);
-#endif
-
-/*[]*/
#include "../include/linux/westbridge/cyashal.h"
#include "../include/linux/westbridge/cyasregs.h"
-/* API exports include file */
-#include "cyandevice_export.h"
-
typedef struct cyasdevice {
/* Handle to the Antioch device */
cy_as_device_handle dev_handle;