static void diag_update_msg_mask(int start, int end , uint8_t *buf)
{
int found = 0;
int first;
int last;
uint8_t *ptr = driver->msg_masks;
uint8_t *ptr_buffer_start = &(*(driver->msg_masks));
uint8_t *ptr_buffer_end = &(*(driver->msg_masks)) + MSG_MASK_SIZE;
unsigned long flags;
/*mutex_lock(&driver->diagchar_mutex);*/
spin_lock_irqsave(&driver->diagchar_lock, flags);
/* First SSID can be zero : So check that last is non-zero */
while (*(uint32_t *)(ptr + 4)) {
first = *(uint32_t *)ptr;
ptr += 4;
last = *(uint32_t *)ptr;
ptr += 4;
if (start >= first && start <= last) {
ptr += (start - first)*4;
if (end <= last)
if (CHK_OVERFLOW(ptr_buffer_start, ptr,
ptr_buffer_end,
(((end - start)+1)*4)))
memcpy(ptr, buf , ((end - start)+1)*4);
else
DIAGFWD_ERR("Not enough"
" buffer space for"
" MSG_MASK\n");
else
printk(KERN_INFO "Unable to copy"
" mask change\n");
found = 1;
break;
} else {
ptr += ((last - first) + 1)*4;
}
}
/* Entry was not found - add new table */
if (!found) {
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
8 + ((end - start) + 1)*4)) {
memcpy(ptr, &(start) , 4);
ptr += 4;
memcpy(ptr, &(end), 4);
ptr += 4;
memcpy(ptr, buf , ((end - start) + 1)*4);
} else
DIAGFWD_ERR(" Not enough buffer"
" space for MSG_MASK\n");
}
/*mutex_unlock(&driver->diagchar_mutex);*/
spin_unlock_irqrestore(&driver->diagchar_lock, flags);
diag_print_mask_table();
}
static void diag_update_msg_mask(int start, int end , uint8_t *buf)
{
int found = 0, first, last, actual_last;
uint8_t *actual_last_ptr;
uint8_t *ptr = driver->msg_masks;
uint8_t *ptr_buffer_start = &(*(driver->msg_masks));
uint8_t *ptr_buffer_end = &(*(driver->msg_masks)) + MSG_MASK_SIZE;
mutex_lock(&driver->diagchar_mutex);
/* First SSID can be zero : So check that last is non-zero */
while (*(uint32_t *)(ptr + 4)) {
first = *(uint32_t *)ptr;
ptr += 4;
last = *(uint32_t *)ptr;
ptr += 4;
actual_last = *(uint32_t *)ptr;
actual_last_ptr = ptr;
ptr += 4;
if (start >= first && start <= actual_last) {
ptr += (start - first)*4;
if (end > actual_last) {
pr_info("diag: ssid range mismatch\n");
actual_last = end;
*(uint32_t *)(actual_last_ptr) = end;
}
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
(((end - start)+1)*4))) {
pr_debug("diag: update ssid start %d, end %d\n",
start, end);
memcpy(ptr, buf , ((end - start)+1)*4);
} else
pr_alert("diag: Not enough space MSG_MASK\n");
found = 1;
break;
} else {
ptr += MAX_SSID_PER_RANGE*4;
}
}
/* Entry was not found - add new table */
if (!found) {
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
8 + ((end - start) + 1)*4)) {
memcpy(ptr, &(start) , 4);
ptr += 4;
memcpy(ptr, &(end), 4);
ptr += 4;
memcpy(ptr, &(end), 4); /* create actual_last entry */
ptr += 4;
pr_debug("diag: adding NEW ssid start %d, end %d\n",
start, end);
memcpy(ptr, buf , ((end - start) + 1)*4);
} else
pr_alert("diag: Not enough buffer space for MSG_MASK\n");
}
mutex_unlock(&driver->diagchar_mutex);
diag_print_mask_table();
}
static void diag_update_msg_mask(int start, int end , uint8_t *buf)
{
int found = 0;
int first;
int last;
uint8_t *ptr = driver->msg_masks;
uint8_t *ptr_buffer_start = &(*(driver->msg_masks));
uint8_t *ptr_buffer_end = &(*(driver->msg_masks)) + MSG_MASK_SIZE;
mutex_lock(&driver->diagchar_mutex);
while (*(uint32_t *)(ptr + 4)) {
first = *(uint32_t *)ptr;
ptr += 4;
last = *(uint32_t *)ptr;
ptr += 4;
if (start >= first && start <= last) {
ptr += (start - first)*4;
if (end <= last)
if (CHK_OVERFLOW(ptr_buffer_start, ptr,
ptr_buffer_end,
(((end - start)+1)*4)))
memcpy(ptr, buf , ((end - start)+1)*4);
else
printk(KERN_CRIT "Not enough"
" buffer space for"
" MSG_MASK\n");
else
printk(KERN_INFO "Unable to copy"
" mask change\n");
found = 1;
break;
} else {
ptr += ((last - first) + 1)*4;
}
}
if (!found) {
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
8 + ((end - start) + 1)*4)) {
memcpy(ptr, &(start) , 4);
ptr += 4;
memcpy(ptr, &(end), 4);
ptr += 4;
memcpy(ptr, buf , ((end - start) + 1)*4);
} else
printk(KERN_CRIT " Not enough buffer"
" space for MSG_MASK\n");
}
mutex_unlock(&driver->diagchar_mutex);
diag_print_mask_table();
}
static void diag_update_log_mask(int equip_id, uint8_t *buf, int num_items)
{
uint8_t *temp = buf;
int i = 0;
unsigned char *ptr_data;
int offset = (sizeof(struct mask_info))*MAX_EQUIP_ID;
struct mask_info *ptr = (struct mask_info *)(driver->log_masks);
pr_debug("diag: received equip id = %d\n", equip_id);
mutex_lock(&driver->diagchar_mutex);
/* Check if we already know index of this equipment ID */
for (i = 0; i < MAX_EQUIP_ID; i++) {
if ((ptr->equip_id == equip_id) && (ptr->index != 0)) {
offset = ptr->index;
break;
}
if ((ptr->equip_id == 0) && (ptr->index == 0)) {
/* Reached a null entry */
ptr->equip_id = equip_id;
ptr->num_items = num_items;
ptr->index = driver->log_masks_length;
offset = driver->log_masks_length;
driver->log_masks_length += ((num_items+7)/8);
break;
}
ptr++;
}
ptr_data = driver->log_masks + offset;
if (CHK_OVERFLOW(driver->log_masks, ptr_data, driver->log_masks
+ LOG_MASK_SIZE, (num_items+7)/8))
memcpy(ptr_data, temp , (num_items+7)/8);
else
pr_err("diag: Not enough buffer space for LOG_MASK\n");
mutex_unlock(&driver->diagchar_mutex);
}
static void diag_update_pkt_buffer(unsigned char *buf)
{
unsigned char *ptr = driver->pkt_buf;
unsigned char *temp = buf;
mutex_lock(&driver->diagchar_mutex);
if (CHK_OVERFLOW(ptr, ptr, ptr + PKT_SIZE, driver->pkt_length))
memcpy(ptr, temp , driver->pkt_length);
else
DIAGFWD_ERR(" Not enough buffer space for PKT_RESP\n");
mutex_unlock(&driver->diagchar_mutex);
}
static void diag_update_log_mask(uint8_t *buf, int num_items)
{
uint8_t *ptr = driver->log_masks;
uint8_t *temp = buf;
mutex_lock(&driver->diagchar_mutex);
if (CHK_OVERFLOW(ptr, ptr, ptr + LOG_MASK_SIZE,
(num_items+7)/8))
memcpy(ptr, temp , (num_items+7)/8);
else
printk(KERN_CRIT " Not enough buffer space for LOG_MASK\n");
mutex_unlock(&driver->diagchar_mutex);
}
static void diag_update_event_mask(uint8_t *buf, int num_bytes)
{
uint8_t *ptr = driver->event_masks;
uint8_t *temp = buf + 2;
mutex_lock(&driver->diagchar_mutex);
if (CHK_OVERFLOW(ptr, ptr, ptr+EVENT_MASK_SIZE, num_bytes)) {
memcpy(ptr, temp, num_bytes);
driver->event_status = DIAG_CTRL_MASK_VALID;
} else {
pr_err("diag: In %s, not enough buffer space\n", __func__);
}
mutex_unlock(&driver->diagchar_mutex);
}
static void diag_update_event_mask(uint8_t *buf, int toggle, int num_bytes)
{
uint8_t *ptr = driver->event_masks;
uint8_t *temp = buf + 2;
mutex_lock(&driver->diagchar_mutex);
if (!toggle)
memset(ptr, 0 , EVENT_MASK_SIZE);
else
if (CHK_OVERFLOW(ptr, ptr,
ptr+EVENT_MASK_SIZE, num_bytes))
memcpy(ptr, temp , num_bytes);
else
printk(KERN_CRIT "Not enough buffer space for EVENT_MASK\n");
mutex_unlock(&driver->diagchar_mutex);
}
static void diag_update_log_mask(int equip_id, uint8_t *buf, int num_items)
{
uint8_t *temp = buf;
struct mask_info {
int equip_id;
int index;
};
int i = 0;
unsigned char *ptr_data;
int offset = 8*MAX_EQUIP_ID;
struct mask_info *ptr = (struct mask_info *)driver->log_masks;
mutex_lock(&driver->diagchar_mutex);
/* Check if we already know index of this equipment ID */
for (i = 0; i < MAX_EQUIP_ID; i++) {
if ((ptr->equip_id == equip_id) && (ptr->index != 0)) {
offset = ptr->index;
break;
}
if ((ptr->equip_id == 0) && (ptr->index == 0)) {
/*Reached a null entry */
ptr->equip_id = equip_id;
ptr->index = driver->log_masks_length;
offset = driver->log_masks_length;
driver->log_masks_length += ((num_items+7)/8);
break;
}
ptr++;
}
ptr_data = driver->log_masks + offset;
if (CHK_OVERFLOW(ptr_data, ptr_data, ptr_data + LOG_MASK_SIZE,
(num_items+7)/8))
memcpy(ptr_data, temp , (num_items+7)/8);
else
DIAGFWD_ERR(" Not enough buffer space for LOG_MASK\n");
mutex_unlock(&driver->diagchar_mutex);
}
static void diag_update_msg_mask(int start, int end , uint8_t *buf)
{
int found = 0, first, last, actual_last;
uint8_t *actual_last_ptr;
uint8_t *ptr = driver->msg_masks;
uint8_t *ptr_buffer_start = &(*(driver->msg_masks));
uint8_t *ptr_buffer_end = &(*(driver->msg_masks)) + MSG_MASK_SIZE;
uint32_t copy_len = (end - start + 1) * sizeof(int);
mutex_lock(&driver->diagchar_mutex);
while (*(uint32_t *)(ptr + 4)) {
first = *(uint32_t *)ptr;
ptr += 4;
last = *(uint32_t *)ptr;
ptr += 4;
actual_last = *(uint32_t *)ptr;
actual_last_ptr = ptr;
ptr += 4;
if (start >= first && start <= actual_last) {
ptr += (start - first)*4;
if (end > actual_last) {
pr_info("diag: ssid range mismatch\n");
actual_last = end;
*(uint32_t *)(actual_last_ptr) = end;
}
if (actual_last-first >= MAX_SSID_PER_RANGE) {
pr_err("diag: In %s, truncating ssid range, %d-%d to max allowed: %d",
__func__, first, actual_last,
MAX_SSID_PER_RANGE);
copy_len = MAX_SSID_PER_RANGE;
actual_last = first + MAX_SSID_PER_RANGE;
*(uint32_t *)actual_last_ptr = actual_last;
}
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
(((end - start)+1)*4))) {
pr_debug("diag: update ssid start %d, end %d\n",
start, end);
memcpy(ptr, buf , copy_len);
} else
pr_alert("diag: Not enough space MSG_MASK\n");
found = 1;
break;
} else {
ptr += MAX_SSID_PER_RANGE*4;
}
}
if (!found) {
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
8 + ((end - start) + 1)*4)) {
memcpy(ptr, &(start) , 4);
ptr += 4;
memcpy(ptr, &(end), 4);
ptr += 4;
memcpy(ptr, &(end), 4);
ptr += 4;
pr_debug("diag: adding NEW ssid start %d, end %d\n",
start, end);
memcpy(ptr, buf , ((end - start) + 1)*4);
} else
pr_alert("diag: Not enough buffer space for MSG_MASK\n");
}
driver->msg_status = DIAG_CTRL_MASK_VALID;
mutex_unlock(&driver->diagchar_mutex);
diag_print_mask_table();
}
static void diag_update_msg_mask(int start, int end , uint8_t *buf)
{
int found = 0;
int first;
int last;
uint8_t *ptr = driver->msg_masks;
uint8_t *ptr_buffer_start = &(*(driver->msg_masks));
uint8_t *ptr_buffer_end = &(*(driver->msg_masks)) + MSG_MASK_SIZE;
mutex_lock(&driver->diagchar_mutex);
/* First SSID can be zero : So check that last is non-zero */
while (*(uint32_t *)(ptr + 4)) {
first = *(uint32_t *)ptr;
ptr += 4;
last = *(uint32_t *)ptr;
ptr += 4;
if (start >= first && start <= last) {
ptr += (start - first)*4;
if (end <= last)
if (CHK_OVERFLOW(ptr_buffer_start, ptr,
ptr_buffer_end,
(((end - start)+1)*4)))
memcpy(ptr, buf , ((end - start)+1)*4);
else
printk(KERN_CRIT "Not enough"
" buffer space for"
" MSG_MASK\n");
else
printk(KERN_INFO "Unable to copy"
" mask change\n");
found = 1;
break;
} else {
ptr += ((last - first) + 1)*4;
}
}
/* Entry was not found - add new table */
if (!found) {
if (CHK_OVERFLOW(ptr_buffer_start, ptr, ptr_buffer_end,
8 + ((end - start) + 1)*4)) {
memcpy(ptr, &(start) , 4);
ptr += 4;
memcpy(ptr, &(end), 4);
ptr += 4;
memcpy(ptr, buf , ((end - start) + 1)*4);
} else
printk(KERN_CRIT " Not enough buffer"
" space for MSG_MASK\n");
}
mutex_unlock(&driver->diagchar_mutex);
diag_print_mask_table();
#ifdef CONFIG_LGE_DIAG
if(ptr[(LGE_DIAG_ICD_LOGGING_SSID-start)*4] == LGE_DIAG_ICD_LOGGING_SSID_MASK)
{
if(key_touch_logging_status == 0)
{
printk(KERN_INFO "[SLATE] %s : enable hard key press & pan tap event logging\n",__func__);
key_touch_logging_status = 1;
}
}
else
{
if(key_touch_logging_status == 1)
{
printk(KERN_INFO "[SLATE] %s : disable hard key press & pan tap event logging\n",__func__);
key_touch_logging_status = 0;
}
}
#endif /*CONFIG_LGE_DIAG*/
}
