static void wp_smd_diag_notify(void *priv, unsigned event)
{
struct wp_diag_context *ctxt = priv;
struct diag_packet *dp;
unsigned long flags;
unsigned char *discard_buf;
//printk(KERN_INFO "wp_diag: %s, event %d\n", __FUNCTION__, event);
if (ctxt->ch && event == SMD_EVENT_DATA)
{
int r = smd_read_avail(ctxt->ch);
//printk(KERN_INFO "wp_diag: smd_read_avail num bytes = %d\n", r);
if (r > RX_MAX || r <= 0) {
printk(KERN_ERR "wp_diag: diag dropped num bytes = %d or invaild num to read\n", r);
return;
}
spin_lock_irqsave(&ctxt->read_q_lock, flags);
if (_wp_context.read_q_count < READQ_MAX) {
dp = kmalloc(sizeof(struct diag_packet), GFP_ATOMIC);
if (!dp) {
printk(KERN_ERR "wp_diag: kmalloc dp failed\n");
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
return;
}
dp->content = kmalloc(r, GFP_ATOMIC);
if (!dp->content) {
printk(KERN_ERR "wp_diag: kmalloc dp->content failed\n");
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
return;
}
dp->len = smd_read_from_cb(ctxt->ch, dp->content, r);
//printk(KERN_INFO "wp_diag: smd_read_from_cb %d\n", dp->len);
list_add_tail(&dp->list, &ctxt->read_q);
_wp_context.read_q_count++;
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
TRACE("A9>", dp->content, dp->len, 0);
//printk(KERN_ERR "wp_diag: put readq count %d\n", _wp_context.read_q_count);
} else {
printk(KERN_ERR "wp_diag: execeed max num in read q: %d\n", _wp_context.read_q_count);
discard_buf = kmalloc(r, GFP_ATOMIC);
smd_read_from_cb(ctxt->ch, discard_buf, r);
kfree(discard_buf);
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
}
wake_up_interruptible(&ctxt->wait_q);
}
}
void __diag_smd_qdsp_send_req(int context)
{
void *buf;
if (driver->chqdsp && (!driver->in_busy_qdsp)) {
int r = smd_read_avail(driver->chqdsp);
if (r > USB_MAX_IN_BUF) {
printk(KERN_INFO "diag dropped num bytes = %d\n", r);
return;
}
if (r > 0) {
buf = driver->usb_buf_in_qdsp;
if (!buf) {
printk(KERN_INFO "Out of diagmem for q6\n");
} else {
APPEND_DEBUG('l');
if (context == SMD_CONTEXT)
smd_read_from_cb(
driver->chqdsp, buf, r);
else
smd_read(driver->chqdsp, buf, r);
APPEND_DEBUG('m');
driver->usb_write_ptr_qdsp->length = r;
driver->in_busy_qdsp = 1;
diag_device_write(buf, QDSP_DATA);
}
}
}
}
static void apr_tal_notify(void *priv, unsigned event)
{
struct apr_svc_ch_dev *apr_ch = priv;
int len, r_len, sz;
int pkt_cnt = 0;
unsigned long flags;
pr_debug("event = %d\n", event);
switch (event) {
case SMD_EVENT_DATA:
pkt_cnt = 0;
spin_lock_irqsave(&apr_ch->lock, flags);
check_pending:
len = smd_read_avail(apr_ch->ch);
if (len < 0) {
pr_err("apr_tal: Invalid Read Event :%d\n", len);
spin_unlock_irqrestore(&apr_ch->lock, flags);
return;
}
sz = smd_cur_packet_size(apr_ch->ch);
if (sz < 0) {
pr_debug("pkt size is zero\n");
spin_unlock_irqrestore(&apr_ch->lock, flags);
return;
}
if (!len && !sz && !pkt_cnt)
goto check_write_avail;
if (!len) {
pr_debug("len = %d pkt_cnt = %d\n", len, pkt_cnt);
spin_unlock_irqrestore(&apr_ch->lock, flags);
return;
}
r_len = smd_read_from_cb(apr_ch->ch, apr_ch->data, len);
if (len != r_len) {
pr_err("apr_tal: Invalid Read\n");
spin_unlock_irqrestore(&apr_ch->lock, flags);
return;
}
pkt_cnt++;
pr_debug("%d %d %d\n", len, sz, pkt_cnt);
if (apr_ch->func)
apr_ch->func(apr_ch->data, r_len, apr_ch->priv);
goto check_pending;
check_write_avail:
if (smd_write_avail(apr_ch->ch))
wake_up(&apr_ch->wait);
spin_unlock_irqrestore(&apr_ch->lock, flags);
break;
case SMD_EVENT_OPEN:
pr_debug("apr_tal: SMD_EVENT_OPEN\n");
apr_ch->smd_state = 1;
wake_up(&apr_ch->wait);
break;
case SMD_EVENT_CLOSE:
pr_debug("apr_tal: SMD_EVENT_CLOSE\n");
break;
}
}
void __diag_smd_send_req(int context)
{
void *buf;
if (driver->ch && (!driver->in_busy)) {
int r = smd_read_avail(driver->ch);
if (r > USB_MAX_IN_BUF) {
if (r < MAX_BUF_SIZE) {
printk(KERN_ALERT "\n diag: SMD sending in "
"packets upto %d bytes", r);
driver->usb_buf_in = krealloc(
driver->usb_buf_in, r, GFP_KERNEL);
} else {
printk(KERN_ALERT "\n diag: SMD sending in "
"packets more than %d bytes", MAX_BUF_SIZE);
return;
}
}
if (r > 0) {
buf = driver->usb_buf_in;
if (!buf) {
printk(KERN_INFO "Out of diagmem for a9\n");
} else {
APPEND_DEBUG('i');
if (context == SMD_CONTEXT)
smd_read_from_cb(driver->ch, buf, r);
else
smd_read(driver->ch, buf, r);
APPEND_DEBUG('j');
driver->usb_write_ptr->length = r;
driver->in_busy = 1;
diag_device_write(buf, MODEM_DATA);
}
}
}
}
static void radio_hci_smd_recv_event(unsigned long temp)
{
int len;
int rc;
struct sk_buff *skb;
unsigned char *buf;
struct radio_data *hsmd = &hs;
len = smd_read_avail(hsmd->fm_channel);
while (len) {
skb = alloc_skb(len, GFP_KERNEL);
if (!skb) {
FMDERR("Memory not allocated for the socket");
return;
}
buf = kmalloc(len, GFP_KERNEL);
if (!buf) {
kfree_skb(skb);
FMDERR("Error in allocating buffer memory");
return;
}
rc = smd_read_from_cb(hsmd->fm_channel, (void *)buf, len);
memcpy(skb_put(skb, len), buf, len);
skb_orphan(skb);
skb->dev = (struct net_device *)hs.hdev;
rc = radio_hci_recv_frame(skb);
kfree(buf);
len = smd_read_avail(hsmd->fm_channel);
}
}
static void wp_smd_diag_notify(void *priv, unsigned event)
{
struct wp_diag_context *ctxt = priv;
struct diag_packet *dp;
unsigned long flags;
#ifdef DYNAMIC_ALLOC
unsigned char *discard_buf;
#endif
//printk(KERN_INFO "wp_diag: %s, event %d\n", __FUNCTION__, event);
if (ctxt->ch && event == SMD_EVENT_DATA)
{
int r = smd_read_avail(ctxt->ch);
//printk(KERN_INFO "wp_diag: smd_read_avail num bytes = %d\n", r);
if (r > RX_MAX || r <= 0) {
printk(KERN_ERR "wp_diag: diag dropped num bytes = %d or invaild num to read\n", r);
return;
}
spin_lock_irqsave(&ctxt->read_q_lock, flags);
#ifdef DYNAMIC_ALLOC
if (_wp_context.read_q_count < READQ_MAX) {
dp = kmalloc(sizeof(struct diag_packet), GFP_ATOMIC);
if (!dp) {
printk(KERN_ERR "wp_diag: kmalloc dp failed\n");
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
return;
}
dp->content = kmalloc(r, GFP_ATOMIC);
if (!dp->content) {
kfree(dp);
printk(KERN_ERR "wp_diag: kmalloc dp->content failed\n");
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
return;
}
dp->len = smd_read_from_cb(ctxt->ch, dp->content, r);
//printk(KERN_INFO "wp_diag: smd_read_from_cb %d\n", dp->len);
list_add_tail(&dp->list, &ctxt->read_q);
_wp_context.read_q_count++;
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
TRACE("A9>", dp->content, dp->len, 0);
//printk(KERN_ERR "wp_diag: put readq count %d\n", _wp_context.read_q_count);
} else {
printk(KERN_ERR "wp_diag: exceed max num in read q: %d\n", _wp_context.read_q_count);
discard_buf = kmalloc(r, GFP_ATOMIC);
smd_read_from_cb(ctxt->ch, discard_buf, r);
kfree(discard_buf);
spin_unlock_irqrestore(&ctxt->read_q_lock, flags);
return;
}
#else
// note if small buffer run out, we can use larger buffer
if (r <= RX_SMALL_MAX && ctxt->s_free_q_count > 0) {
dp = list_first_entry(&ctxt->s_free_q, struct diag_packet, list);
list_del(&dp->list);
ctxt->s_free_q_count--;
} else if (r <= RX_MEDIUM_MAX && ctxt->m_free_q_count > 0) {
