static void *
repl_krealloc(const void *p, size_t size, gfp_t flags)
{
void *ret_val;
if (size == 0 || !ZERO_OR_NULL_PTR(p)) {
/* kfree */
if (!ZERO_OR_NULL_PTR(p) && !klc_find_and_remove_alloc(p))
klc_add_bad_free(p, stack_depth);
/* [NB] If size != 0 and p != NULL and later the allocation fails, we will
* need to add a fake allocation event for 'p' to the storage because 'p'
* is not actually freed by krealloc() in this case.
*/
}
ret_val = krealloc(p, size, flags);
if (size != 0) {
if (p == NULL) {
/* kmalloc */
if (ret_val != NULL)
klc_add_alloc(ret_val, size, stack_depth);
} else {
/* kfree + kmalloc if everything succeeds */
klc_add_alloc(((ret_val != NULL) ? ret_val : p), size, stack_depth);
/* If the allocation failed, we return information about 'p'
* to the storage. A minor issue is that stack trace will
* now point to this call to krealloc rather than to the call
* when 'p' was allocated. Should not be much of a problem.
*/
}
}
return ret_val;
}
static u64 *get_th_params(struct platform_device *pdev,
const struct device_node *node, const char *prop,
int *nports)
{
int size = 0, ret;
u64 *ret_arr = NULL;
int *arr = NULL;
int i;
if (of_get_property(node, prop, &size)) {
*nports = size / sizeof(int);
} else {
pr_debug("Property %s not available\n", prop);
*nports = 0;
return NULL;
}
ret_arr = devm_kzalloc(&pdev->dev, (*nports * sizeof(u64)),
GFP_KERNEL);
arr = kzalloc(size, GFP_KERNEL);
if ((size > 0) && (ZERO_OR_NULL_PTR(arr)
|| ZERO_OR_NULL_PTR(ret_arr))) {
if (arr)
kfree(arr);
else if (ret_arr)
devm_kfree(&pdev->dev, ret_arr);
pr_err("Error: Failed to alloc mem for %s\n", prop);
return NULL;
}
ret = of_property_read_u32_array(node, prop, (u32 *)arr, *nports);
if (ret) {
pr_err("Error in reading property: %s\n", prop);
goto err;
}
for (i = 0; i < *nports; i++)
ret_arr[i] = (uint64_t)KBTOB(arr[i]);
MSM_BUS_DBG("%s: num entries %d prop %s", __func__, *nports, prop);
for (i = 0; i < *nports; i++)
MSM_BUS_DBG("Th %d val %llu", i, ret_arr[i]);
kfree(arr);
return ret_arr;
err:
kfree(arr);
devm_kfree(&pdev->dev, ret_arr);
return NULL;
}
static int *get_arr(struct platform_device *pdev,
struct device_node *node, const char *prop,
int *nports)
{
int size = 0, ret;
int *arr = NULL;
if (of_get_property(node, prop, &size)) {
*nports = size / sizeof(int);
} else {
dev_dbg(&pdev->dev, "Property %s not available\n", prop);
*nports = 0;
return NULL;
}
arr = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
if ((size > 0) && ZERO_OR_NULL_PTR(arr)) {
dev_err(&pdev->dev, "Error: Failed to alloc mem for %s\n",
prop);
return NULL;
}
ret = of_property_read_u32_array(node, prop, (u32 *)arr, *nports);
if (ret) {
dev_err(&pdev->dev, "Error in reading property: %s\n", prop);
goto arr_err;
}
return arr;
arr_err:
devm_kfree(&pdev->dev, arr);
return NULL;
}
static ssize_t diag_dbgfs_read_mempool(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
char *buf = NULL;
int ret = 0;
buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(buf)) {
pr_err("diag: %s, Error allocating memory\n", __func__);
return -ENOMEM;
}
ret = scnprintf(buf, DEBUG_BUF_SIZE,
"POOL_TYPE_COPY: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_HDLC: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_USER: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_WRITE_STRUCT: [0x%p : 0x%p] count = %d\n",
driver->diagpool,
diag_pools_array[POOL_COPY_IDX],
driver->count,
driver->diag_hdlc_pool,
diag_pools_array[POOL_HDLC_IDX],
driver->count_hdlc_pool,
driver->diag_user_pool,
diag_pools_array[POOL_USER_IDX],
driver->count_user_pool,
driver->diag_write_struct_pool,
diag_pools_array[POOL_WRITE_STRUCT_IDX],
driver->count_write_struct_pool);
ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret);
kfree(buf);
return ret;
}
static int add_dirty_node(int **dirty_nodes, int id, int *num_dirty)
{
int i;
int found = 0;
int ret = 0;
int *dnode = NULL;
for (i = 0; i < *num_dirty; i++) {
if ((*dirty_nodes)[i] == id) {
found = 1;
break;
}
}
if (!found) {
(*num_dirty)++;
dnode =
krealloc(*dirty_nodes, sizeof(int) * (*num_dirty),
GFP_KERNEL);
if (ZERO_OR_NULL_PTR(dnode)) {
MSM_BUS_ERR("%s: Failure allocating dirty nodes array",
__func__);
ret = -ENOMEM;
} else {
*dirty_nodes = dnode;
(*dirty_nodes)[(*num_dirty) - 1] = id;
}
}
return ret;
}
/**
* add_path_node: Adds the path information to the current node
* @info: Internal node info structure
* @next: Combination of the id and index of the next node
* Function returns: Number of pnodes (path_nodes) on success,
* error on failure.
*
* Every node maintains the list of path nodes. A path node is
* reached by finding the node-id and index stored at the current
* node. This makes updating the paths with requested bw and clock
* values efficient, as it avoids lookup for each update-path request.
*/
static int add_path_node(struct msm_bus_inode_info *info, int next)
{
struct path_node *pnode;
int i;
if (ZERO_OR_NULL_PTR(info)) {
MSM_BUS_ERR("Cannot find node info!: id :%d\n",
info->node_info->priv_id);
return -ENXIO;
}
for (i = 0; i <= info->num_pnodes; i++) {
if (info->pnode[i].next == -2) {
MSM_BUS_DBG("Reusing pnode for info: %d at index: %d\n",
info->node_info->priv_id, i);
info->pnode[i].clk[DUAL_CTX] = 0;
info->pnode[i].clk[ACTIVE_CTX] = 0;
info->pnode[i].bw[DUAL_CTX] = 0;
info->pnode[i].bw[ACTIVE_CTX] = 0;
info->pnode[i].next = next;
MSM_BUS_DBG("%d[%d] : (%d, %d)\n",
info->node_info->priv_id, i, GET_NODE(next),
GET_INDEX(next));
return i;
}
}
info->num_pnodes++;
pnode = krealloc(info->pnode,
((info->num_pnodes + 1) * sizeof(struct path_node))
, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(pnode)) {
MSM_BUS_ERR("Error creating path node!\n");
info->num_pnodes--;
return -ENOMEM;
}
info->pnode = pnode;
info->pnode[info->num_pnodes].clk[DUAL_CTX] = 0;
info->pnode[info->num_pnodes].clk[ACTIVE_CTX] = 0;
info->pnode[info->num_pnodes].bw[DUAL_CTX] = 0;
info->pnode[info->num_pnodes].bw[ACTIVE_CTX] = 0;
info->pnode[info->num_pnodes].next = next;
MSM_BUS_DBG("%d[%d] : (%d, %d)\n", info->node_info->priv_id,
info->num_pnodes, GET_NODE(next), GET_INDEX(next));
return info->num_pnodes;
}
static void
repl_kzfree(void *p)
{
if (!ZERO_OR_NULL_PTR(p) && !klc_find_and_remove_alloc(p))
klc_add_bad_free(p, stack_depth);
kzfree(p);
return;
}
static void
repl_vfree(const void *addr)
{
if (!ZERO_OR_NULL_PTR(addr) && !klc_find_and_remove_alloc(addr))
klc_add_bad_free(addr, stack_depth);
vfree(addr);
return;
}
static void
repl_free_pages_exact(void *virt, size_t size)
{
if (!ZERO_OR_NULL_PTR(virt) && !klc_find_and_remove_alloc(virt))
klc_add_bad_free(virt, stack_depth);
free_pages_exact(virt, size);
return;
}
static void
repl_kmem_cache_free(struct kmem_cache *mc, void *p)
{
if (!ZERO_OR_NULL_PTR(p) && !klc_find_and_remove_alloc(p))
klc_add_bad_free(p, stack_depth);
kmem_cache_free(mc, p);
return;
}
/**
* Create a file in the debugfs, also create parent directories if needed and
* remove the old file if it exists.
*
* @param path Path to a file to be created.
* The path is always treated relative to the Tempesta root
* directory in the debugfs (see tfw_debugfs_root).
* @param data A pointer to some data which is saved in 'file' and 'inode'
* structures. It may be retrieved by any function in @fops as
* file->private_data or file->f_inode->i_private (it is copied
* into both places).
* @param fops A set of functions that handle system calls on the created file.
*
*
* The function creates a file in the debugfs, but does it in a robust way:
* - the file is replaced if it already exists
* - all parent directories are created if they don't exist
*
* Returns: An ERR_PTR if the file is not created.
*/
static struct dentry *
create_with_parents(const char *path, void *data,
const struct file_operations *fops)
{
size_t name_size;
char *buf, *pos, *component;
struct dentry *parent, *child;
/* Copy the path to a temporary buffer where it can be modified. */
name_size = strlen(path) + 1;
buf = kmalloc(name_size, GFP_KERNEL);
BUG_ON(ZERO_OR_NULL_PTR(buf));
strlcpy(buf, path, name_size);
/* Eat the leading slash to allow specify either /foo/bar or foo/bar */
pos = buf;
if (*pos == '/')
++pos;
/* Walk over the path and create non-existing directories. */
parent = tfw_debugfs_root;
component = pos;
do {
if (*pos != '/')
continue;
*pos = '\0';
child = lookup_file(component, parent);
if (!child) {
child = debugfs_create_dir(component, parent);
BUG_ON(!parent);
}
parent = child;
component = pos + 1;
} while (*(++pos));
/* Remove the file if it already exists. */
child = lookup_file(component, parent);
if (child) {
TFW_DBG("Removing already existing debugfs file: %s\n", path);
debugfs_remove(child);
}
/* Create the actual file. */
child = debugfs_create_file(component, S_IRWXU, parent, data, fops);
if (IS_ERR_OR_NULL(child)) {
int err = PTR_ERR(child);
TFW_WARN("Can't create debugfs file: %s (%d)\n", path, err);
} else {
TFW_DBG("Created debugfs file: %s\n", path);
}
kfree(buf);
return child;
}
static void
repl_free_pages(unsigned long addr, unsigned int order)
{
void *p = (void *)addr;
if (!ZERO_OR_NULL_PTR(p) && !klc_find_and_remove_alloc(p))
klc_add_bad_free(p, stack_depth);
free_pages(addr, order);
return;
}
static void *
repl_alloc_pages_exact(size_t size, gfp_t gfp_mask)
{
void *ret_val;
ret_val = alloc_pages_exact(size, gfp_mask);
if (!ZERO_OR_NULL_PTR(ret_val))
klc_add_alloc(ret_val, size, stack_depth);
return ret_val;
}
/*********************************************************************
* "kmalloc" group
*********************************************************************/
static void *
repl___kmalloc(size_t size, gfp_t flags)
{
void *ret_val;
ret_val = __kmalloc(size, flags);
if (!ZERO_OR_NULL_PTR(ret_val))
klc_add_alloc(ret_val, size, stack_depth);
return ret_val;
}
void kzfree(const void *p)
{
size_t ks;
void *mem = (void *)p;
if (unlikely(ZERO_OR_NULL_PTR(mem)))
return;
ks = ksize(mem);
memset(mem, 0, ks);
kfree(mem);
}
static void
repl_kfree(void *p)
{
/* This is done before actually calling kfree(), because once the
* memory block pointed to by 'p' is freed, some other CPU might
* call an allocation function, get this address as a result and
* add it to the storage before klc_find_and_remove_alloc() is called
* below, which would make a mess.
*/
if (!ZERO_OR_NULL_PTR(p) && !klc_find_and_remove_alloc(p))
klc_add_bad_free(p, stack_depth);
kfree(p);
return;
}
void kfree(const void *block)
{
struct page *sp;
trace_kfree(_RET_IP_, block);
if (unlikely(ZERO_OR_NULL_PTR(block)))
return;
kmemleak_free(block);
sp = virt_to_page(block);
if (PageSlab(sp)) {
int align = max_t(size_t, ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
unsigned int *m = (unsigned int *)(block - align);
slob_free(m, *m + align);
} else
__free_pages(sp, compound_order(sp));
}
void diag_debugfs_init(void)
{
diag_dbgfs_dent = debugfs_create_dir("diag", 0);
if (IS_ERR(diag_dbgfs_dent))
return;
debugfs_create_file("status", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_status_ops);
debugfs_create_file("table", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_table_ops);
debugfs_create_file("work_pending", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_workpending_ops);
debugfs_create_file("mempool", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_mempool_ops);
debugfs_create_file("dci_stats", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_dcistats_ops);
#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
debugfs_create_file("bridge", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_bridge_ops);
#endif
debugfs_create_file("mask_check", 0664, diag_dbgfs_dent, 0,
&diag_dbgfs_mask_check_ops);
diag_dbgfs_table_index = 0;
diag_dbgfs_finished = 0;
diag_dbgfs_dci_data_index = 0;
diag_dbgfs_dci_finished = 0;
/* DCI related structures */
dci_data_smd = kzalloc(sizeof(struct diag_dci_data_info) *
DIAG_DCI_DEBUG_CNT, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(dci_data_smd))
pr_warn("diag: could not allocate memory for dci debug info\n");
mutex_init(&dci_stat_mutex);
}
static void
pscnv_chunk_list_add_unlocked(struct pscnv_chunk_list *list,
struct pscnv_chunk *cnk)
{
struct pscnv_bo *bo = cnk->bo;
struct drm_device *dev = bo->dev;
if (list->max <= list->size) {
list->max = max(2*list->max, PSCNV_INITIAL_CHUNK_LIST_SIZE);
list->chunks = krealloc(list->chunks,
sizeof(struct pscnv_chunk*) * list->max, GFP_KERNEL);
/* krealloc may return ZERO_SIZE_PTR=16 */
if (ZERO_OR_NULL_PTR(list->chunks)) {
NV_ERROR(dev, "pscnv_swapping_option_list_add: out of "
"memory. chunks=%p\n", list->chunks);
return;
}
}
list->chunks[list->size++] = cnk;
}
static ssize_t diag_dbgfs_read_table(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
char *buf;
int ret = 0;
int i;
int bytes_remaining;
int bytes_in_buffer = 0;
int bytes_written;
int buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count;
if (diag_dbgfs_table_index >= diag_max_reg) {
/* Done. Reset to prepare for future requests */
diag_dbgfs_table_index = 0;
return 0;
}
buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(buf)) {
pr_err("diag: %s, Error allocating memory\n", __func__);
return -ENOMEM;
}
bytes_remaining = buf_size;
if (diag_dbgfs_table_index == 0) {
bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining,
"Client ids: Modem: %d, LPASS: %d, "
"WCNSS: %d, APPS: %d\n",
MODEM_DATA, LPASS_DATA, WCNSS_DATA, APPS_DATA);
bytes_in_buffer += bytes_written;
}
for (i = diag_dbgfs_table_index; i < diag_max_reg; i++) {
/* Do not process empty entries in the table */
if (driver->table[i].process_id == 0)
continue;
bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining,
"i: %3d, cmd_code: %4x, subsys_id: %4x, "
"client: %2d, cmd_code_lo: %4x, "
"cmd_code_hi: %4x, process_id: %5d\n",
i,
driver->table[i].cmd_code,
driver->table[i].subsys_id,
driver->table[i].client_id,
driver->table[i].cmd_code_lo,
driver->table[i].cmd_code_hi,
driver->table[i].process_id);
bytes_in_buffer += bytes_written;
/* Check if there is room to add another table entry */
bytes_remaining = buf_size - bytes_in_buffer;
if (bytes_remaining < bytes_written)
break;
}
diag_dbgfs_table_index = i+1;
*ppos = 0;
ret = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buffer);
kfree(buf);
return ret;
}
void jbd2_journal_free_transaction(transaction_t *transaction)
{
if (unlikely(ZERO_OR_NULL_PTR(transaction)))
return;
kmem_cache_free(transaction_cache, transaction);
}
/* Process the data read from the smd control channel */
int diag_process_smd_cntl_read_data(struct diag_smd_info *smd_info, void *buf,
int total_recd)
{
int data_len = 0, type = -1, count_bytes = 0, j, flag = 0;
int feature_mask_len;
struct bindpkt_params_per_process *pkt_params =
kzalloc(sizeof(struct bindpkt_params_per_process), GFP_KERNEL);
struct diag_ctrl_msg *msg;
struct cmd_code_range *range;
struct bindpkt_params *temp;
if (pkt_params == NULL) {
pr_alert("diag: In %s, Memory allocation failure\n",
__func__);
return 0;
}
if (!smd_info) {
pr_err("diag: In %s, No smd info. Not able to read.\n",
__func__);
kfree(pkt_params);
return 0;
}
while (count_bytes + HDR_SIZ <= total_recd) {
type = *(uint32_t *)(buf);
data_len = *(uint32_t *)(buf + 4);
if (type < DIAG_CTRL_MSG_REG ||
type > DIAG_CTRL_MSG_LAST) {
pr_alert("diag: In %s, Invalid Msg type %d proc %d",
__func__, type, smd_info->peripheral);
break;
}
if (data_len < 0 || data_len > total_recd) {
pr_alert("diag: In %s, Invalid data len %d, total_recd: %d, proc %d",
__func__, data_len, total_recd,
smd_info->peripheral);
break;
}
count_bytes = count_bytes+HDR_SIZ+data_len;
if (type == DIAG_CTRL_MSG_REG && total_recd >= count_bytes) {
msg = buf+HDR_SIZ;
range = buf+HDR_SIZ+
sizeof(struct diag_ctrl_msg);
pkt_params->count = msg->count_entries;
pkt_params->params = kzalloc(pkt_params->count *
sizeof(struct bindpkt_params), GFP_KERNEL);
if (ZERO_OR_NULL_PTR(pkt_params->params)) {
pr_alert("diag: In %s, Memory alloc fail\n",
__func__);
kfree(pkt_params);
return flag;
}
temp = pkt_params->params;
for (j = 0; j < pkt_params->count; j++) {
temp->cmd_code = msg->cmd_code;
temp->subsys_id = msg->subsysid;
temp->client_id = smd_info->peripheral;
temp->proc_id = NON_APPS_PROC;
temp->cmd_code_lo = range->cmd_code_lo;
temp->cmd_code_hi = range->cmd_code_hi;
range++;
temp++;
}
flag = 1;
/* peripheral undergoing SSR should not
* record new registration
*/
if (!(reg_dirty & smd_info->peripheral_mask))
diagchar_ioctl(NULL, DIAG_IOCTL_COMMAND_REG,
(unsigned long)pkt_params);
else
pr_err("diag: drop reg proc %d\n",
smd_info->peripheral);
kfree(pkt_params->params);
} else if ((type == DIAG_CTRL_MSG_FEATURE) &&
(smd_info->peripheral == MODEM_DATA)) {
feature_mask_len = *(int *)(buf + 8);
driver->log_on_demand_support = (*(uint8_t *)
(buf + 12)) & 0x04;
} else if (type != DIAG_CTRL_MSG_REG) {
flag = 1;
}
buf = buf + HDR_SIZ + data_len;
}
kfree(pkt_params);
return flag;
}
/**
* msm_bus_scale_register_client() - Register the clients with the msm bus
* driver
* @pdata: Platform data of the client, containing src, dest, ab, ib
*
* Client data contains the vectors specifying arbitrated bandwidth (ab)
* and instantaneous bandwidth (ib) requested between a particular
* src and dest.
*/
uint32_t msm_bus_scale_register_client(struct msm_bus_scale_pdata *pdata)
{
struct msm_bus_client *client = NULL;
int i;
int src, dest, nfab;
struct msm_bus_fabric_device *deffab;
deffab = msm_bus_get_fabric_device(MSM_BUS_FAB_DEFAULT);
if (!deffab) {
MSM_BUS_ERR("Error finding default fabric\n");
return -ENXIO;
}
nfab = msm_bus_get_num_fab();
if (nfab < deffab->board_algo->board_nfab) {
MSM_BUS_ERR("Can't register client!\n"
"Num of fabrics up: %d\n",
nfab);
return 0;
}
if ((!pdata) || (pdata->usecase->num_paths == 0) || IS_ERR(pdata)) {
MSM_BUS_ERR("Cannot register client with null data\n");
return 0;
}
client = kzalloc(sizeof(struct msm_bus_client), GFP_KERNEL);
if (!client) {
MSM_BUS_ERR("Error allocating client\n");
return 0;
}
mutex_lock(&msm_bus_lock);
client->pdata = pdata;
client->curr = -1;
for (i = 0; i < pdata->usecase->num_paths; i++) {
int *pnode;
struct msm_bus_fabric_device *srcfab;
pnode = krealloc(client->src_pnode, ((i + 1) * sizeof(int)),
GFP_KERNEL);
if (ZERO_OR_NULL_PTR(pnode)) {
MSM_BUS_ERR("Invalid Pnode ptr!\n");
continue;
} else
client->src_pnode = pnode;
if (!IS_MASTER_VALID(pdata->usecase->vectors[i].src)) {
MSM_BUS_ERR("Invalid Master ID %d in request!\n",
pdata->usecase->vectors[i].src);
goto err;
}
if (!IS_SLAVE_VALID(pdata->usecase->vectors[i].dst)) {
MSM_BUS_ERR("Invalid Slave ID %d in request!\n",
pdata->usecase->vectors[i].dst);
goto err;
}
src = msm_bus_board_get_iid(pdata->usecase->vectors[i].src);
if (src == -ENXIO) {
MSM_BUS_ERR("Master %d not supported. Client cannot be"
" registered\n",
pdata->usecase->vectors[i].src);
goto err;
}
dest = msm_bus_board_get_iid(pdata->usecase->vectors[i].dst);
if (dest == -ENXIO) {
MSM_BUS_ERR("Slave %d not supported. Client cannot be"
" registered\n",
pdata->usecase->vectors[i].dst);
goto err;
}
srcfab = msm_bus_get_fabric_device(GET_FABID(src));
srcfab->visited = true;
pnode[i] = getpath(src, dest);
bus_for_each_dev(&msm_bus_type, NULL, NULL, clearvisitedflag);
if (pnode[i] == -ENXIO) {
MSM_BUS_ERR("Cannot register client now! Try again!\n");
goto err;
}
}
msm_bus_dbg_client_data(client->pdata, MSM_BUS_DBG_REGISTER,
(uint32_t)client);
mutex_unlock(&msm_bus_lock);
MSM_BUS_DBG("ret: %u num_paths: %d\n", (uint32_t)client,
pdata->usecase->num_paths);
return (uint32_t)(client);
err:
kfree(client->src_pnode);
kfree(client);
mutex_unlock(&msm_bus_lock);
return 0;
}
static ssize_t diag_dbgfs_read_bridge(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
char *buf;
int ret;
int i;
int bytes_remaining;
int bytes_in_buffer = 0;
int bytes_written;
int buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count;
int bytes_hsic_inited = 45;
int bytes_hsic_not_inited = 410;
if (diag_dbgfs_finished) {
diag_dbgfs_finished = 0;
return 0;
}
buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(buf)) {
pr_err("diag: %s, Error allocating memory\n", __func__);
return -ENOMEM;
}
bytes_remaining = buf_size;
/* Only one smux for now */
bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining,
"Values for SMUX instance: 0\n"
"smux ch: %d\n"
"smux enabled %d\n"
"smux in busy %d\n"
"smux connected %d\n\n",
driver->lcid,
driver->diag_smux_enabled,
driver->in_busy_smux,
driver->smux_connected);
bytes_in_buffer += bytes_written;
bytes_remaining = buf_size - bytes_in_buffer;
bytes_written = scnprintf(buf+bytes_in_buffer, bytes_remaining,
"HSIC diag_disconnect_work: %d\n",
work_pending(&(driver->diag_disconnect_work)));
bytes_in_buffer += bytes_written;
bytes_remaining = buf_size - bytes_in_buffer;
for (i = 0; i < MAX_HSIC_CH; i++) {
if (diag_hsic[i].hsic_inited) {
/* Check if there is room to add another HSIC entry */
if (bytes_remaining < bytes_hsic_inited)
break;
bytes_written = scnprintf(buf+bytes_in_buffer,
bytes_remaining,
"Values for HSIC Instance: %d\n"
"hsic ch: %d\n"
"hsic_inited: %d\n"
"hsic enabled: %d\n"
"hsic_opened: %d\n"
"hsic_suspend: %d\n"
"in_busy_hsic_read_on_device: %d\n"
"in_busy_hsic_write: %d\n"
"count_hsic_pool: %d\n"
"count_hsic_write_pool: %d\n"
"diag_hsic_pool: %x\n"
"diag_hsic_write_pool: %x\n"
"HSIC write_len: %d\n"
"num_hsic_buf_tbl_entries: %d\n"
"HSIC usb_connected: %d\n"
"HSIC diag_read_work: %d\n"
"diag_read_hsic_work: %d\n"
"diag_usb_read_complete_work: %d\n\n",
i,
diag_hsic[i].hsic_ch,
diag_hsic[i].hsic_inited,
diag_hsic[i].hsic_device_enabled,
diag_hsic[i].hsic_device_opened,
diag_hsic[i].hsic_suspend,
diag_hsic[i].in_busy_hsic_read_on_device,
diag_hsic[i].in_busy_hsic_write,
diag_hsic[i].count_hsic_pool,
diag_hsic[i].count_hsic_write_pool,
(unsigned int)diag_hsic[i].diag_hsic_pool,
(unsigned int)diag_hsic[i].diag_hsic_write_pool,
diag_bridge[i].write_len,
diag_hsic[i].num_hsic_buf_tbl_entries,
diag_bridge[i].usb_connected,
work_pending(&(diag_bridge[i].diag_read_work)),
work_pending(&(diag_hsic[i].diag_read_hsic_work)),
work_pending(&(diag_bridge[i].usb_read_complete_work)));
if (bytes_written > bytes_hsic_inited)
bytes_hsic_inited = bytes_written;
} else {
/* Check if there is room to add another HSIC entry */
if (bytes_remaining < bytes_hsic_not_inited)
break;
bytes_written = scnprintf(buf+bytes_in_buffer,
bytes_remaining,
"HSIC Instance: %d has not been initialized\n\n",
i);
if (bytes_written > bytes_hsic_not_inited)
bytes_hsic_not_inited = bytes_written;
}
bytes_in_buffer += bytes_written;
bytes_remaining = buf_size - bytes_in_buffer;
}
*ppos = 0;
ret = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buffer);
diag_dbgfs_finished = 1;
kfree(buf);
return ret;
}
/* Process the data read from the smd control channel */
int diag_process_smd_cntl_read_data(struct diag_smd_info *smd_info, void *buf,
int total_recd)
{
int data_len = 0, type = -1, count_bytes = 0, j, flag = 0;
struct bindpkt_params_per_process *pkt_params =
kzalloc(sizeof(struct bindpkt_params_per_process), GFP_KERNEL);
struct diag_ctrl_msg *msg;
struct cmd_code_range *range;
struct bindpkt_params *temp;
if (pkt_params == NULL) {
pr_alert("diag: In %s, Memory allocation failure\n",
__func__);
return 0;
}
if (!smd_info) {
pr_err("diag: In %s, No smd info. Not able to read.\n",
__func__);
kfree(pkt_params);
return 0;
}
while (count_bytes + HDR_SIZ <= total_recd) {
type = *(uint32_t *)(buf);
data_len = *(uint32_t *)(buf + 4);
if (type < DIAG_CTRL_MSG_REG ||
type > DIAG_CTRL_MSG_LAST) {
pr_alert("diag: In %s, Invalid Msg type %d proc %d",
__func__, type, smd_info->peripheral);
break;
}
if (data_len < 0 || data_len > total_recd) {
pr_alert("diag: In %s, Invalid data len %d, total_recd: %d, proc %d",
__func__, data_len, total_recd,
smd_info->peripheral);
break;
}
count_bytes = count_bytes+HDR_SIZ+data_len;
if (type == DIAG_CTRL_MSG_REG && total_recd >= count_bytes) {
msg = buf+HDR_SIZ;
range = buf+HDR_SIZ+
sizeof(struct diag_ctrl_msg);
pkt_params->count = msg->count_entries;
pkt_params->params = kzalloc(pkt_params->count *
sizeof(struct bindpkt_params), GFP_KERNEL);
if (ZERO_OR_NULL_PTR(pkt_params->params)) {
pr_alert("diag: In %s, Memory alloc fail\n",
__func__);
kfree(pkt_params);
return flag;
}
temp = pkt_params->params;
for (j = 0; j < pkt_params->count; j++) {
temp->cmd_code = msg->cmd_code;
temp->subsys_id = msg->subsysid;
temp->client_id = smd_info->peripheral;
temp->proc_id = NON_APPS_PROC;
temp->cmd_code_lo = range->cmd_code_lo;
temp->cmd_code_hi = range->cmd_code_hi;
range++;
temp++;
}
flag = 1;
/* peripheral undergoing SSR should not
* record new registration
*/
if (!(reg_dirty & smd_info->peripheral_mask))
diagchar_ioctl(NULL, DIAG_IOCTL_COMMAND_REG,
(unsigned long)pkt_params);
else
pr_err("diag: drop reg proc %d\n",
smd_info->peripheral);
kfree(pkt_params->params);
} else if (type == DIAG_CTRL_MSG_FEATURE &&
total_recd >= count_bytes) {
uint8_t feature_mask = 0;
int feature_mask_len = *(int *)(buf+8);
if (feature_mask_len > 0) {
int periph = smd_info->peripheral;
feature_mask = *(uint8_t *)(buf+12);
if (periph == MODEM_DATA)
driver->log_on_demand_support =
feature_mask &
F_DIAG_LOG_ON_DEMAND_RSP_ON_MASTER;
/*
* If apps supports separate cmd/rsp channels
* and the peripheral supports separate cmd/rsp
* channels
*/
if (driver->supports_separate_cmdrsp &&
(feature_mask & F_DIAG_REQ_RSP_CHANNEL))
driver->separate_cmdrsp[periph] =
ENABLE_SEPARATE_CMDRSP;
else
driver->separate_cmdrsp[periph] =
DISABLE_SEPARATE_CMDRSP;
/*
* Check if apps supports hdlc encoding and the
* peripheral supports apps hdlc encoding
*/
process_hdlc_encoding_feature(smd_info,
feature_mask);
if (feature_mask_len > 1) {
feature_mask = *(uint8_t *)(buf+13);
process_stm_feature(smd_info,
feature_mask);
}
}
flag = 1;
} else if (type != DIAG_CTRL_MSG_REG) {
flag = 1;
}
buf = buf + HDR_SIZ + data_len;
}
kfree(pkt_params);
return flag;
}
int diag_debugfs_init(void)
{
struct dentry *entry = NULL;
diag_dbgfs_dent = debugfs_create_dir("diag", 0);
if (IS_ERR(diag_dbgfs_dent))
return -ENOMEM;
entry = debugfs_create_file("status", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_status_ops);
if (!entry)
goto err;
entry = debugfs_create_file("table", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_table_ops);
if (!entry)
goto err;
entry = debugfs_create_file("work_pending", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_workpending_ops);
if (!entry)
goto err;
entry = debugfs_create_file("mempool", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_mempool_ops);
if (!entry)
goto err;
entry = debugfs_create_file("usbinfo", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_usbinfo_ops);
if (!entry)
goto err;
entry = debugfs_create_file("dci_stats", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_dcistats_ops);
if (!entry)
goto err;
entry = debugfs_create_file("power", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_power_ops);
if (!entry)
goto err;
#ifdef CONFIG_DIAGFWD_BRIDGE_CODE
entry = debugfs_create_file("bridge", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_bridge_ops);
if (!entry)
goto err;
entry = debugfs_create_file("bridge_dci", 0444, diag_dbgfs_dent, 0,
&diag_dbgfs_bridge_dci_ops);
if (!entry)
goto err;
#endif
diag_dbgfs_table_index = 0;
diag_dbgfs_mempool_index = 0;
diag_dbgfs_usbinfo_index = 0;
diag_dbgfs_finished = 0;
diag_dbgfs_dci_data_index = 0;
diag_dbgfs_dci_finished = 0;
/* DCI related structures */
dci_traffic = kzalloc(sizeof(struct diag_dci_data_info) *
DIAG_DCI_DEBUG_CNT, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(dci_traffic))
pr_warn("diag: could not allocate memory for dci debug info\n");
mutex_init(&dci_stat_mutex);
return 0;
err:
kfree(dci_traffic);
debugfs_remove_recursive(diag_dbgfs_dent);
return -ENOMEM;
}
/**
* getpath() - Finds the path from the topology between src and dest
* @src: Source. This is the master from which the request originates
* @dest: Destination. This is the slave to which we're trying to reach
*
* Function returns: next_pnode_id. The higher 16 bits of the next_pnode_id
* represent the src id of the next node on path. The lower 16 bits of the
* next_pnode_id represent the "index", which is the next entry in the array
* of pnodes for that node to fill in clk and bw values. This is created using
* CREATE_PNODE_ID. The return value is stored in ret_pnode, and this is added
* to the list of path nodes.
*
* This function recursively finds the path by updating the src to the
* closest possible node to dest.
*/
static int getpath(int src, int dest)
{
int pnode_num = -1, i;
struct msm_bus_fabnodeinfo *fabnodeinfo;
struct msm_bus_fabric_device *fabdev;
int next_pnode_id = -1;
struct msm_bus_inode_info *info = NULL;
int _src = src/FABRIC_ID_KEY;
int _dst = dest/FABRIC_ID_KEY;
int ret_pnode = -1;
int fabid = GET_FABID(src);
/* Find the location of fabric for the src */
MSM_BUS_DBG("%d --> %d\n", src, dest);
fabdev = msm_bus_get_fabric_device(fabid);
if (!fabdev) {
MSM_BUS_WARN("Fabric Not yet registered. Try again\n");
return -ENXIO;
}
/* Are we there yet? */
if (src == dest) {
info = fabdev->algo->find_node(fabdev, src);
if (ZERO_OR_NULL_PTR(info)) {
MSM_BUS_ERR("Node %d not found\n", dest);
return -ENXIO;
}
for (i = 0; i <= info->num_pnodes; i++) {
if (info->pnode[i].next == -2) {
MSM_BUS_DBG("src = dst Reusing pnode for"
" info: %d at index: %d\n",
info->node_info->priv_id, i);
next_pnode_id = CREATE_PNODE_ID(src, i);
info->pnode[i].clk[DUAL_CTX] = 0;
info->pnode[i].bw[DUAL_CTX] = 0;
info->pnode[i].next = next_pnode_id;
MSM_BUS_DBG("returning: %d, %d\n", GET_NODE
(next_pnode_id), GET_INDEX(next_pnode_id));
return next_pnode_id;
}
}
next_pnode_id = CREATE_PNODE_ID(src, (info->num_pnodes + 1));
pnode_num = add_path_node(info, next_pnode_id);
if (pnode_num < 0) {
MSM_BUS_ERR("Error adding path node\n");
return -ENXIO;
}
MSM_BUS_DBG("returning: %d, %d\n", GET_NODE(next_pnode_id),
GET_INDEX(next_pnode_id));
return next_pnode_id;
} else if (_src == _dst) {
/*
* src and dest belong to same fabric, find the destination
* from the radix tree
*/
info = fabdev->algo->find_node(fabdev, dest);
if (ZERO_OR_NULL_PTR(info)) {
MSM_BUS_ERR("Node %d not found\n", dest);
return -ENXIO;
}
ret_pnode = getpath(info->node_info->priv_id, dest);
next_pnode_id = ret_pnode;
} else {
/* find the dest fabric */
int trynextgw = true;
struct list_head *gateways = fabdev->algo->get_gw_list(fabdev);
list_for_each_entry(fabnodeinfo, gateways, list) {
/* see if the destination is at a connected fabric */
if (_dst == (fabnodeinfo->info->node_info->priv_id /
FABRIC_ID_KEY)) {
/* Found the fab on which the device exists */
info = fabnodeinfo->info;
trynextgw = false;
ret_pnode = getpath(info->node_info->priv_id,
dest);
pnode_num = add_path_node(info, ret_pnode);
if (pnode_num < 0) {
MSM_BUS_ERR("Error adding path node\n");
return -ENXIO;
}
next_pnode_id = CREATE_PNODE_ID(
info->node_info->priv_id, pnode_num);
break;
}
}
/* find the gateway */
if (trynextgw) {
gateways = fabdev->algo->get_gw_list(fabdev);
list_for_each_entry(fabnodeinfo, gateways, list) {
struct msm_bus_fabric_device *gwfab =
msm_bus_get_fabric_device(fabnodeinfo->
info->node_info->priv_id);
if (!gwfab->visited) {
MSM_BUS_DBG("VISITED ID: %d\n",
gwfab->id);
gwfab->visited = true;
info = fabnodeinfo->info;
ret_pnode = getpath(info->
node_info->priv_id, dest);
pnode_num = add_path_node(info,
ret_pnode);
if (pnode_num < 0) {
MSM_BUS_ERR("Malloc failure in"
" adding path node\n");
return -ENXIO;
}
next_pnode_id = CREATE_PNODE_ID(
info->node_info->priv_id, pnode_num);
break;
}
}
if (next_pnode_id < 0)
return -ENXIO;
}
}
if (!IS_NODE(src)) {
MSM_BUS_DBG("Returning next_pnode_id:%d[%d]\n", GET_NODE(
next_pnode_id), GET_INDEX(next_pnode_id));
return next_pnode_id;
}
info = fabdev->algo->find_node(fabdev, src);
if (!info) {
MSM_BUS_ERR("Node info not found.\n");
return -ENXIO;
}
pnode_num = add_path_node(info, next_pnode_id);
MSM_BUS_DBG(" Last: %d[%d] = (%d, %d)\n",
src, info->num_pnodes, GET_NODE(next_pnode_id),
GET_INDEX(next_pnode_id));
MSM_BUS_DBG("returning: %d, %d\n", src, pnode_num);
return CREATE_PNODE_ID(src, pnode_num);
}
static ssize_t diag_dbgfs_read_dcistats(struct file *file,
char __user *ubuf, size_t count, loff_t *ppos)
{
char *buf = NULL;
int bytes_remaining, bytes_written = 0, bytes_in_buf = 0, i = 0;
struct diag_dci_data_info *temp_data = dci_data_smd;
int buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count;
if (diag_dbgfs_dci_finished) {
diag_dbgfs_dci_finished = 0;
return 0;
}
buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(buf)) {
pr_err("diag: %s, Error allocating memory\n", __func__);
return -ENOMEM;
}
bytes_remaining = buf_size;
if (diag_dbgfs_dci_data_index == 0) {
bytes_written =
scnprintf(buf, buf_size,
"number of clients: %d\n"
"dci proc active: %d\n"
"dci real time vote: %d\n",
driver->num_dci_client,
(driver->proc_active_mask & DIAG_PROC_DCI) ? 1 : 0,
(driver->proc_rt_vote_mask & DIAG_PROC_DCI) ? 1 : 0);
bytes_in_buf += bytes_written;
bytes_remaining -= bytes_written;
#ifdef CONFIG_DIAG_OVER_USB
bytes_written = scnprintf(buf+bytes_in_buf, bytes_remaining,
"usb_connected: %d\n",
driver->usb_connected);
bytes_in_buf += bytes_written;
bytes_remaining -= bytes_written;
#endif
if (driver->dci_device) {
bytes_written = scnprintf(buf+bytes_in_buf,
bytes_remaining,
"dci power active, relax: %lu, %lu\n",
driver->dci_device->power.wakeup->active_count,
driver->dci_device->power.wakeup->relax_count);
bytes_in_buf += bytes_written;
bytes_remaining -= bytes_written;
}
if (driver->dci_cmd_device) {
bytes_written = scnprintf(buf+bytes_in_buf,
bytes_remaining,
"dci cmd power active, relax: %lu, %lu\n",
driver->dci_cmd_device->power.wakeup->
active_count,
driver->dci_cmd_device->power.wakeup->
relax_count);
bytes_in_buf += bytes_written;
bytes_remaining -= bytes_written;
}
}
temp_data += diag_dbgfs_dci_data_index;
for (i = diag_dbgfs_dci_data_index; i < DIAG_DCI_DEBUG_CNT; i++) {
if (temp_data->iteration != 0) {
bytes_written = scnprintf(
buf + bytes_in_buf, bytes_remaining,
"i %-10ld\t"
"s %-10d\t"
"c %-10d\t"
"t %-15s\n",
temp_data->iteration,
temp_data->data_size,
temp_data->ch_type,
temp_data->time_stamp);
bytes_in_buf += bytes_written;
bytes_remaining -= bytes_written;
/* Check if there is room for another entry */
if (bytes_remaining < bytes_written)
break;
}
temp_data++;
}
diag_dbgfs_dci_data_index = (i >= DIAG_DCI_DEBUG_CNT) ? 0 : i + 1;
bytes_written = simple_read_from_buffer(ubuf, count, ppos, buf,
bytes_in_buf);
kfree(buf);
diag_dbgfs_dci_finished = 1;
return bytes_written;
}
static ssize_t diag_dbgfs_read_bridge_dci(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
char *buf;
int ret;
int i;
unsigned int bytes_remaining;
unsigned int bytes_in_buffer = 0;
unsigned int bytes_written;
unsigned int buf_size;
int bytes_hsic_inited = 45;
int bytes_hsic_not_inited = 410;
buf_size = (DEBUG_BUF_SIZE < count) ? DEBUG_BUF_SIZE : count;
if (diag_dbgfs_finished) {
diag_dbgfs_finished = 0;
return 0;
}
buf = kzalloc(sizeof(char) * buf_size, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(buf)) {
pr_err("diag: %s, Error allocating memory\n", __func__);
return -ENOMEM;
}
buf_size = ksize(buf);
bytes_remaining = buf_size;
for (i = 0; i < MAX_HSIC_DCI_CH; i++) {
if (diag_hsic_dci[i].hsic_inited) {
/* Check if there is room to add another HSIC entry */
if (bytes_remaining < bytes_hsic_inited)
break;
bytes_written = scnprintf(buf+bytes_in_buffer,
bytes_remaining,
"Values for HSIC DCI Instance: %d\n"
"hsic ch: %d\n"
"hsic_inited: %d\n"
"hsic enabled: %d\n"
"hsic_opened: %d\n"
"hsic_suspend: %d\n"
"in_busy_hsic_write: %d\n"
"data: %p\n"
"data_buf: %p\n"
"data_len: %d\n"
"diag_read_hsic_work: %d\n"
"diag_process_hsic_work: %d\n\n",
i,
diag_hsic_dci[i].hsic_ch,
diag_hsic_dci[i].hsic_inited,
diag_hsic_dci[i].hsic_device_enabled,
diag_hsic_dci[i].hsic_device_opened,
diag_hsic_dci[i].hsic_suspend,
diag_hsic_dci[i].in_busy_hsic_write,
diag_hsic_dci[i].data,
diag_hsic_dci[i].data_buf,
diag_hsic_dci[i].data_len,
work_pending(&(diag_hsic_dci[i].diag_read_hsic_work)),
work_pending(&(diag_hsic_dci[i].
diag_process_hsic_work)));
if (bytes_written > bytes_hsic_inited)
bytes_hsic_inited = bytes_written;
} else {
/* Check if there is room to add another HSIC entry */
if (bytes_remaining < bytes_hsic_not_inited)
break;
bytes_written = scnprintf(buf+bytes_in_buffer,
bytes_remaining,
"HSIC DCI Instance: %d has not been initialized\n\n",
i);
if (bytes_written > bytes_hsic_not_inited)
bytes_hsic_not_inited = bytes_written;
}
bytes_in_buffer += bytes_written;
bytes_remaining = buf_size - bytes_in_buffer;
}
*ppos = 0;
ret = simple_read_from_buffer(ubuf, count, ppos, buf, bytes_in_buffer);
diag_dbgfs_finished = 1;
kfree(buf);
return ret;
}
static ssize_t diag_dbgfs_read_mempool(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
char *buf = NULL;
int ret = 0, i = 0;
buf = kzalloc(sizeof(char) * DEBUG_BUF_SIZE, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(buf)) {
pr_err("diag: %s, Error allocating memory\n", __func__);
return -ENOMEM;
}
ret = scnprintf(buf, DEBUG_BUF_SIZE,
"POOL_TYPE_COPY: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_HDLC: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_USER: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_WRITE_STRUCT: [0x%p : 0x%p] count = %d\n"
"POOL_TYPE_DCI: [0x%p : 0x%p] count = %d\n",
driver->diagpool,
diag_pools_array[POOL_COPY_IDX],
driver->count,
driver->diag_hdlc_pool,
diag_pools_array[POOL_HDLC_IDX],
driver->count_hdlc_pool,
driver->diag_user_pool,
diag_pools_array[POOL_USER_IDX],
driver->count_user_pool,
driver->diag_write_struct_pool,
diag_pools_array[POOL_WRITE_STRUCT_IDX],
driver->count_write_struct_pool,
driver->diag_dci_pool,
diag_pools_array[POOL_DCI_IDX],
driver->count_dci_pool);
for (i = 0; i < MAX_HSIC_CH; i++) {
if (!diag_hsic[i].hsic_inited)
continue;
ret += scnprintf(buf+ret, DEBUG_BUF_SIZE-ret,
"POOL_TYPE_HSIC_%d: [0x%p : 0x%p] count = %d\n",
i+1,
diag_hsic[i].diag_hsic_pool,
diag_pools_array[POOL_HSIC_IDX + i],
diag_hsic[i].count_hsic_pool);
}
for (i = 0; i < MAX_HSIC_CH; i++) {
if (!diag_hsic[i].hsic_inited)
continue;
ret += scnprintf(buf+ret, DEBUG_BUF_SIZE-ret,
"POOL_TYPE_HSIC_%d_WRITE: [0x%p : 0x%p] count = %d\n",
i+1,
diag_hsic[i].diag_hsic_write_pool,
diag_pools_array[POOL_HSIC_WRITE_IDX + i],
diag_hsic[i].count_hsic_write_pool);
}
ret = simple_read_from_buffer(ubuf, count, ppos, buf, ret);
kfree(buf);
return ret;
}
