static int pdp_demux(void)
{
int ret;
u8 ch;
size_t len;
struct pdp_info *dev = NULL;
struct pdp_hdr hdr;
/* read header */
ret = dpram_read(dpram_filp, &hdr, sizeof(hdr));
if (ret < 0) {
return ret;
}
len = hdr.len - sizeof(struct pdp_hdr);
/* check header */
down(&pdp_lock);
dev = pdp_get_dev(hdr.id);
if (dev == NULL) {
printk("invalid id: %u, there is no existing device.\n", hdr.id);
ret = -ENODEV;
goto err;
}
/* read data */
switch (dev->type) {
case DEV_TYPE_NET:
ret = vnet_recv(dev, len);
break;
case DEV_TYPE_SERIAL:
ret = vs_read(dev, len);
break;
default:
ret = -1;
}
if (ret < 0) {
goto err;
}
up(&pdp_lock);
/* check stop byte */
ret = dpram_read(dpram_filp, &ch, sizeof(ch));
if (ret < 0 || ch != 0x7e) {
return ret;
}
return 0;
err:
up(&pdp_lock);
/* flush the remaining data including stop byte. */
dpram_flush_rx(dpram_filp, len + 1);
return ret;
}
static int vnet_recv(struct pdp_info *dev, size_t len,int net_id)
{
struct sk_buff *skb;
int ret;
DPRINTK(2, "BEGIN\n");
/* @LDK@ for multiple pdp.. , ex) email & streaming.. by hobac. */
if (!dev) {
return 0;
}
if (!netif_running(dev->vn_dev.net)) {
EPRINTK("%s(id: %u) is not running\n",
dev->vn_dev.net->name, dev->id);
return -ENODEV;
}
skb = alloc_skb(len, GFP_KERNEL);
if (skb == NULL) {
EPRINTK("alloc_skb() failed\n");
return -ENOMEM;
}
ret = dpram_read(dpram_filp, skb->data, len);
if (ret < 0) {
EPRINTK("dpram_read() failed: %d\n", ret);
dev_kfree_skb_any(skb);
return ret;
}
skb_put(skb, ret);
skb->dev = dev->vn_dev.net;
skb->protocol = __constant_htons(ETH_P_IP);
netif_rx(skb);
dev->vn_dev.stats.rx_packets++;
dev->vn_dev.stats.rx_bytes += skb->len;
DPRINTK(2, "END\n");
return 0;
}
static int dpram_thread(void *data)
{
int ret = 0;
int i;
struct file *filp;
struct sched_param schedpar;
dpram_task = current;
daemonize("dpram_thread");
strcpy(current->comm, "multipdp");
schedpar.sched_priority = 1;
sched_setscheduler(current, SCHED_FIFO, &schedpar);
/* set signals to accept */
siginitsetinv(¤t->blocked, sigmask(SIGUSR1));
recalc_sigpending();
for (i = 0; i < 10; i++) {
filp = dpram_open();
if (filp == NULL) {
EPRINTK("dpram_open failed! retry\n");
msleep(1000);
} else
break;
}
if (filp == NULL) {
EPRINTK("dpram_open failed!\n");
goto out;
}
dpram_filp = filp;
/* send start signal */
complete(&dpram_complete);
while (1) {
ret = dpram_poll(filp);
if (ret == -ERESTARTSYS) {
if (sigismember(¤t->pending.signal, SIGUSR1)) {
sigdelset(¤t->pending.signal, SIGUSR1);
recalc_sigpending();
ret = 0;
break;
}
}
else if (ret < 0) {
EPRINTK("dpram_poll() failed\n");
break;
}
else {
char ch;
ret = dpram_read(dpram_filp, &ch, sizeof(ch));
if(ret < 0) {
return ret;
}
if (ch == 0x7f) {
pdp_demux();
}
}
}
dpram_close(filp);
dpram_filp = NULL;
out:
dpram_task = NULL;
/* send finish signal and exit */
complete_and_exit(&dpram_complete, ret);
}
static int multipdp_vs_read(struct pdp_info *dev, char *buf, size_t len)
{
int ret = 0;
if (!dev) {
return 0;
}
#ifndef NO_TTY_RX_BUFF
if(len > 1500) {
#else
if(len > MAX_RX_BUFF_LEN) {
#endif
unsigned char *prx_buf = kzalloc(len, GFP_ATOMIC);
if(prx_buf == NULL)
return 0;
memcpy(prx_buf, buf, len);
ret = len;
if(ret != len)
return ret;
if(dev->vs_dev.tty == NULL)
printk(">>>>> TTY is NULL : (1)~ !!!! \n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
ret = multipdp_tty_insert_data(dev->vs_dev.tty, prx_buf, ret);
if( ret > 0 )
tty_flip_buffer_push(dev->vs_dev.tty);
}
printk("RF cal data read.(1) len: %d ret: %d\n", len, ret);
kfree(prx_buf);
}
else {
/* pdp data length.. */
memcpy(pdp_rx_buf, buf, len);
ret = len;
if (ret != len) {
return ret;
}
#ifdef LOOP_BACK_TEST
if (dev->id == LOOP_BACK_CHANNEL) {
// compare and resend , update stastic data
//printk("receive loopback packet[%d]\n",loopback_res.nTransfered);
//printk("read data : %x %x %x %x %x %x\n",pdp_rx_buf[0],pdp_rx_buf[1],pdp_rx_buf[2],pdp_rx_buf[3],pdp_rx_buf[4],pdp_rx_buf[5]);
//printk("write data : %x %x %x %x %x %x\n",loopback_data[0],loopback_data[1],loopback_data[2],loopback_data[3],loopback_data[4],loopback_data[5]);
if (loopback_ongoing) {
if (strncmp(pdp_rx_buf, loopback_data, loopback_res.nPacketDataSize)){
//printk("receive packet is not identical to that sent\n");
}
else {
send_loop_back_packet(loopback_data, loopback_res.nPacketDataSize);
}
}
else {
//do nothing
//printk("loopback channel has gotten data, but test is no ongoing\n");
}
}
else if (ret > 0 && dev->vs_dev.tty != NULL) {
tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
tty_flip_buffer_push(dev->vs_dev.tty);
}
#else
if(dev->vs_dev.tty == NULL)
printk(">>>>> TTY is NULL : (2)~ !!!! \n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
#if 1
ret = multipdp_tty_insert_data(dev->vs_dev.tty, pdp_rx_buf, ret);
#else
ret = tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
#endif
if( ret > 0 )
tty_flip_buffer_push(dev->vs_dev.tty);
}
//printk("RF cal data read.(2) len: %d ret: %d\n", len, ret);
#endif
}
//printk("multipdp_vs_read : len = %d\n", ret);
return ret;
}
////////////
#endif
static int vs_read(struct pdp_info *dev, size_t len)
{
int retval = 0;
u32 size;
u32 copied_size;
int insert_size = 0;
if (dev) {
/* pdp data length. */
if (len > MAX_PDP_DATA_LEN) { // RF cal data?
DPRINTK(1, "CAL DATA\n");
size = dpram_read(dpram_filp, prx_buf, len);
DPRINTK(1, "multipdp_thread request read size : %d readed size %d, count : %d\n",len ,size,count);
if ((dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)){
EPRINTK("vs_read : %s, discard data.\n", dev->vs_dev.tty->name);
}
else {
while (size) {
copied_size = (size > MAX_PDP_DATA_LEN) ? MAX_PDP_DATA_LEN : size;
if (size > 0 && dev->vs_dev.tty != NULL)
insert_size = tty_insert_flip_string(dev->vs_dev.tty, prx_buf+retval, copied_size);
if (insert_size != copied_size) {
EPRINTK("flip buffer full : %s, insert size : %d, real size : %d\n",dev->vs_dev.tty->name,copied_size,insert_size);
return -1;
}
size = size - copied_size;
retval += copied_size;
}
DPRINTK(1, "retval : %d\n",retval);
tty_flip_buffer_push(dev->vs_dev.tty);
count++;
}
}
else {
retval = dpram_read(dpram_filp, pdp_rx_buf, len);
if (retval != len)
return retval;
if(retval > 0){
if((dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)) {
EPRINTK("vs_read : %s, discard data.\n", dev->vs_dev.tty->name);
}
else {
insert_size = tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, retval);
if (insert_size != retval) {
EPRINTK("flip buffer full : %s, insert size : %d, real size : %d\n",dev->vs_dev.tty->name,retval,insert_size);
return -1;
}
tty_flip_buffer_push(dev->vs_dev.tty);
}
}
}
}
return 0;
}
static int multipdp_vs_read(struct pdp_info *dev, char *buf, size_t len)
{
int ret = 0;
if (!dev) {
return 0;
}
#ifndef NO_TTY_RX_BUFF
if(len > 1500) {
#else
if(len > MAX_RX_BUFF_LEN) {
#endif
unsigned char *prx_buf = kzalloc(len, GFP_ATOMIC);
if(prx_buf == NULL)
return 0;
memcpy(prx_buf, buf, len);
ret = len;
if(ret != len)
return ret;
if(dev->vs_dev.tty == NULL)
printk(">>>>> TTY is NULL : (1)~ !!!! \n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
ret = multipdp_tty_insert_data(dev->vs_dev.tty, prx_buf, ret);
if( ret > 0 )
tty_flip_buffer_push(dev->vs_dev.tty);
}
printk("RF cal data read.(1) len: %d ret: %d\n", len, ret);
kfree(prx_buf);
}
else {
/* pdp data length.. */
memcpy(pdp_rx_buf, buf, len);
ret = len;
if (ret != len) {
return ret;
}
#ifdef LOOP_BACK_TEST
if (dev->id == LOOP_BACK_CHANNEL) {
// compare and resend , update stastic data
//printk("receive loopback packet[%d]\n",loopback_res.nTransfered);
//printk("read data : %x %x %x %x %x %x\n",pdp_rx_buf[0],pdp_rx_buf[1],pdp_rx_buf[2],pdp_rx_buf[3],pdp_rx_buf[4],pdp_rx_buf[5]);
//printk("write data : %x %x %x %x %x %x\n",loopback_data[0],loopback_data[1],loopback_data[2],loopback_data[3],loopback_data[4],loopback_data[5]);
if (loopback_ongoing) {
if (strncmp(pdp_rx_buf, loopback_data, loopback_res.nPacketDataSize)){
//printk("receive packet is not identical to that sent\n");
}
else {
send_loop_back_packet(loopback_data, loopback_res.nPacketDataSize);
}
}
else {
//do nothing
//printk("loopback channel has gotten data, but test is no ongoing\n");
}
}
else if (ret > 0 && dev->vs_dev.tty != NULL) {
tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
tty_flip_buffer_push(dev->vs_dev.tty);
}
#else
if(dev->vs_dev.tty == NULL)
printk(">>>>> TTY is NULL : (2)~ !!!! \n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
#if 1
ret = multipdp_tty_insert_data(dev->vs_dev.tty, pdp_rx_buf, ret);
#else
ret = tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
#endif
if( ret > 0 )
tty_flip_buffer_push(dev->vs_dev.tty);
}
//printk("RF cal data read.(2) len: %d ret: %d\n", len, ret);
#endif
}
//printk("multipdp_vs_read : len = %d\n", ret);
return ret;
}
////////////
#endif
static int vs_read(struct pdp_info *dev, size_t len)
{
int retval = 0;
u32 size;
u32 copied_size;
int insert_size = 0;
if (dev) {
/* pdp data length. */
if (len > MAX_PDP_DATA_LEN) { // RF cal data?
DPRINTK(1, "CAL DATA\n");
size = dpram_read(dpram_filp, prx_buf, len);
DPRINTK(1, "multipdp_thread request read size : %d readed size %d, count : %d\n",len ,size,count);
#ifdef CONFIG_ENABLE_TTY_CIQ
if ((dev->id == 26 && !fp_vsCIQ0) ||(dev->id == 9 && !fp_vsCIQ1)||(dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)){
#else
if ((dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)){
#endif
EPRINTK("vs_read : %s, discard data.\n", dev->vs_dev.tty->name);
}
else {
while (size) {
copied_size = (size > MAX_PDP_DATA_LEN) ? MAX_PDP_DATA_LEN : size;
if (size > 0 && dev->vs_dev.tty != NULL)
insert_size = tty_insert_flip_string(dev->vs_dev.tty, prx_buf+retval, copied_size);
if (insert_size != copied_size) {
EPRINTK("flip buffer full : %s, insert size : %d, real size : %d\n",dev->vs_dev.tty->name,copied_size,insert_size);
return -1;
}
size = size - copied_size;
retval += copied_size;
}
DPRINTK(1, "retval : %d\n",retval);
tty_flip_buffer_push(dev->vs_dev.tty);
count++;
}
}
else {
retval = dpram_read(dpram_filp, pdp_rx_buf, len);
if (retval != len)
return retval;
if(retval > 0){
#ifdef CONFIG_ENABLE_TTY_CIQ
if((dev->id == 26 && !fp_vsCIQ0) ||(dev->id == 9 && !fp_vsCIQ1) ||( dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)) {
#else
if((dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)) {
#endif
EPRINTK("vs_read : %s, discard data.\n", dev->vs_dev.tty->name);
}
else {
insert_size = tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, retval);
if (insert_size != retval) {
EPRINTK("flip buffer full : %s, insert size : %d, real size : %d\n",dev->vs_dev.tty->name,retval,insert_size);
return -1;
}
tty_flip_buffer_push(dev->vs_dev.tty);
}
}
}
}
return 0;
}
static int vs_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg)
{
return -ENOIOCTLCMD;
}
#if 0
static void vs_break_ctl(struct tty_struct *tty, int break_state)
{
}
#endif
static struct tty_operations multipdp_tty_ops = {
.open = vs_open,
.close = vs_close,
.write = vs_write,
.write_room = vs_write_room,
.ioctl = vs_ioctl,
.chars_in_buffer = vs_chars_in_buffer,
/* TODO: add more operations */
};
static int vs_add_dev(struct pdp_info *dev)
{
struct tty_driver *tty_driver;
tty_driver = get_tty_driver_by_id(dev);
kref_init(&tty_driver->kref);
tty_driver->magic = TTY_DRIVER_MAGIC;
tty_driver->driver_name = "multipdp";
tty_driver->name = dev->vs_dev.tty_name;
tty_driver->major = CSD_MAJOR_NUM;
tty_driver->minor_start = get_minor_start_index(dev->id);
tty_driver->num = 1;
tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
tty_driver->subtype = SERIAL_TYPE_NORMAL;
tty_driver->flags = TTY_DRIVER_REAL_RAW;
// tty_driver->refcount = dev->vs_dev.refcount;
tty_driver->ttys = dev->vs_dev.tty_table; // 2.6 kernel porting
tty_driver->termios = dev->vs_dev.termios;
tty_driver->termios_locked = dev->vs_dev.termios_locked;
tty_set_operations(tty_driver, &multipdp_tty_ops);
return tty_register_driver(tty_driver);
}
static void vs_del_dev(struct pdp_info *dev)
{
struct tty_driver *tty_driver = NULL;
tty_driver = get_tty_driver_by_id(dev);
tty_unregister_driver(tty_driver);
return;
}
/*
* PDP context and mux/demux functions
*/
static inline struct pdp_info * pdp_get_dev(u8 id)
{
int slot;
for (slot = 0; slot < MAX_PDP_CONTEXT; slot++) {
if (pdp_table[slot] && pdp_table[slot]->id == id) {
return pdp_table[slot];
}
}
return NULL;
}
static inline struct pdp_info * pdp_get_serdev(const char *name)
{
int slot;
struct pdp_info *dev;
for (slot = 0; slot < MAX_PDP_CONTEXT; slot++) {
dev = pdp_table[slot];
if (dev && dev->type == DEV_TYPE_SERIAL &&
strcmp(name, dev->vs_dev.tty_name) == 0) {
return dev;
}
}
return NULL;
}
static int dpram_thread(void *data)
{
int ret = 0;
//unsigned long flags;
struct file *filp;
dpram_task = current;
daemonize("dpram_thread");
//reparent_to_init(); // for 2.6 kernel porting : this seems not to be used in driver
// current->tty = NULL; // for 2.6 kernel porting
strcpy(current->comm, "multipdp");
/* set signals to accept */
//spin_lock_irqsave(¤t->sigmask_lock, flags); // for 2.6 kernel proting
siginitsetinv(¤t->blocked, sigmask(SIGUSR1));
//recalc_sigpending(current);
recalc_sigpending();
//spin_unlock_irqrestore(¤t->sigmask_lock, flags); // for 2.6 kernel proting
filp = dpram_open();
if (filp == NULL) {
goto out;
}
dpram_filp = filp;
/* send start signal */
complete(&dpram_complete);
while (1) {
ret = dpram_poll(filp);
if (ret == -ERESTARTSYS) {
if (sigismember(¤t->pending.signal, SIGUSR1)) {
sigdelset(¤t->pending.signal, SIGUSR1);
recalc_sigpending();
ret = 0;
break;
}
}
else if (ret < 0) {
EPRINTK("dpram_poll() failed\n");
break;
}
else {
char ch;
dpram_read(dpram_filp, &ch, sizeof(ch));
if (ch == 0x7f) {
pdp_demux();
}
}
try_to_freeze();
}
dpram_close(filp);
dpram_filp = NULL;
out:
dpram_task = NULL;
/* send finish signal and exit */
complete_and_exit(&dpram_complete, ret);
}
static int multipdp_vs_read(struct pdp_info *dev, char *buf, size_t len)
{
int ret = 0;
if (!dev) {
return 0;
}
#ifndef NO_TTY_RX_BUFF
if(len > 1500) {
#else
if(len > MAX_RX_BUFF_LEN) {
#endif
unsigned char *prx_buf = kzalloc(len, GFP_ATOMIC);
//unsigned char *prx_buf = kzalloc(len, GFP_NOIO);
if(prx_buf == NULL)
return 0;
memcpy(prx_buf, buf, len);
ret = len;
if(ret != len)
return ret;
if(dev->vs_dev.tty == NULL)
printk(">>>>> TTY is NULL : (1)~ !!!! \n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
ret = multipdp_tty_insert_data(dev->vs_dev.tty, prx_buf, ret);
if( ret > 0 )
tty_flip_buffer_push(dev->vs_dev.tty);
}
printk("RF cal data read.(1) len: %d ret: %d\n", len, ret);
kfree(prx_buf);
}
else {
/* pdp data length.. */
memcpy(pdp_rx_buf, buf, len);
ret = len;
if (ret != len) {
return ret;
}
#ifdef LOOP_BACK_TEST
if (dev->id == LOOP_BACK_CHANNEL) {
// compare and resend , update stastic data
//printk("receive loopback packet[%d]\n",loopback_res.nTransfered);
//printk("read data : %x %x %x %x %x %x\n",pdp_rx_buf[0],pdp_rx_buf[1],pdp_rx_buf[2],pdp_rx_buf[3],pdp_rx_buf[4],pdp_rx_buf[5]);
//printk("write data : %x %x %x %x %x %x\n",loopback_data[0],loopback_data[1],loopback_data[2],loopback_data[3],loopback_data[4],loopback_data[5]);
if (loopback_ongoing) {
if (strncmp(pdp_rx_buf, loopback_data, loopback_res.nPacketDataSize)){
//printk("receive packet is not identical to that sent\n");
}
else {
send_loop_back_packet(loopback_data, loopback_res.nPacketDataSize);
}
}
else {
//do nothing
//printk("loopback channel has gotten data, but test is no ongoing\n");
}
}
else if (ret > 0 && dev->vs_dev.tty != NULL) {
tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
tty_flip_buffer_push(dev->vs_dev.tty);
}
#else
if(dev->vs_dev.tty == NULL)
printk(">>>>> TTY is NULL : (2)~ !!!! \n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
#if 1
ret = multipdp_tty_insert_data(dev->vs_dev.tty, pdp_rx_buf, ret);
#else
ret = tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
#endif
if( ret > 0 )
tty_flip_buffer_push(dev->vs_dev.tty);
}
//printk("RF cal data read.(2) len: %d ret: %d\n", len, ret);
#endif
}
//printk("multipdp_vs_read : len = %d\n", ret);
return ret;
}
////////////
#endif
static int vs_read(struct pdp_info *dev, size_t len)
{
int ret = 0;
if (!dev) {
return 0;
}
if(len > 1500) {
unsigned char *prx_buf = kzalloc(len, GFP_ATOMIC);
if(prx_buf == NULL)
return 0;
ret = dpram_read(dpram_filp, prx_buf, len);
if(ret != len){
kfree(prx_buf);
return ret;
}
if (dev->vs_dev.tty == NULL)
printk("vs_read : #1 vs_dev.tty is NULL =====\n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
ret = tty_insert_flip_string(dev->vs_dev.tty, prx_buf, ret);
tty_flip_buffer_push(dev->vs_dev.tty);
}
printk("RF cal data read. len: %d ret: %d\n", len, ret);
kfree(prx_buf);
}
else {
/* pdp data length.. */
ret = dpram_read(dpram_filp, pdp_rx_buf, len);
if (ret != len) {
return ret;
}
#ifdef LOOP_BACK_TEST
if (dev->id == LOOP_BACK_CHANNEL) {
// compare and resend , update stastic data
//printk("receive loopback packet[%d]\n",loopback_res.nTransfered);
//printk("read data : %x %x %x %x %x %x\n",pdp_rx_buf[0],pdp_rx_buf[1],pdp_rx_buf[2],pdp_rx_buf[3],pdp_rx_buf[4],pdp_rx_buf[5]);
//printk("write data : %x %x %x %x %x %x\n",loopback_data[0],loopback_data[1],loopback_data[2],loopback_data[3],loopback_data[4],loopback_data[5]);
if (loopback_ongoing) {
if (strncmp(pdp_rx_buf, loopback_data, loopback_res.nPacketDataSize)){
//printk("receive packet is not identical to that sent\n");
}
else {
send_loop_back_packet(loopback_data, loopback_res.nPacketDataSize);
}
}
else {
//do nothing
//printk("loopback channel has gotten data, but test is no ongoing\n");
}
}
else if (ret > 0 && dev->vs_dev.tty != NULL) { //hobac.
tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
tty_flip_buffer_push(dev->vs_dev.tty);
}
#else
if (dev->vs_dev.tty == NULL)
printk("vs_read : #2 vs_dev.tty is NULL =====\n");
if (ret > 0 && dev->vs_dev.tty != NULL) { //hobac.
tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, ret);
tty_flip_buffer_push(dev->vs_dev.tty);
}
#endif
}
return 0;
}
static int multipdp_vs_read(struct pdp_info *dev, char *buf, size_t len)
{
int ret = -1;
struct sk_buff *skb;
if (!dev) {
pr_err("[MULTIPDP] dev is null!\n");
return 0;
}
#ifndef NO_TTY_RX_BUFF
if (len > 1500) {
#else
if (len > MAX_RX_BUFF_LEN) {
#endif
unsigned char *prx_buf = kzalloc(len, GFP_ATOMIC);
if (prx_buf == NULL) {
pr_err("[MULTIPDP] prx_buf is null!\n");
return 0;
}
memcpy(prx_buf, buf, len);
ret = len;
if (ret != len) {
pr_err("[MULTIPDP] ret != len!\n");
return ret;
}
if (dev->vs_dev.tty == NULL || (dev->id == 1 && !fp_vsCSD)
|| (dev->id == 5 && !fp_vsGPS) || (dev->id == 8
&& !fp_vsEFS)
|| (dev->id == 25 && !fp_vsSMD)
|| (dev->id == 6 && !fp_vsEXGPS) || (dev->id == 29
&& !fp_vsCPLOG)
|| (dev->id == 31 && !fp_vsLOOPBACK)) {
pr_err("[MULTIPDP] TTY is NULL : (1)~ !!!!\n");
return 0;
}
if (ret > 0 && dev->vs_dev.tty != NULL) {
if (dev->id == 29) {
skb = alloc_skb(len, GFP_ATOMIC);
if (unlikely(!skb))
pr_err("[MULTIPDP] sk_buff alloc failed!\n");
memcpy(skb_put(skb, len), prx_buf, len);
skb_queue_tail(&cplog_sk_buf_rx_q, skb);
queue_work(cplog_rx_wq, &cplog_work);
} else {
ret = multipdp_tty_insert_data(
dev->vs_dev.tty, prx_buf, ret);
if (ret > 0) {
dev->vs_dev.tty->low_latency = 0;
tty_flip_buffer_push(dev->vs_dev.tty);
}
}
}
kfree(prx_buf);
} else {
/* pdp data length.. */
memcpy(pdp_rx_buf, buf, len);
ret = len;
if (ret != len) {
pr_err("[MULTIPDP] ret != len!\n");
return ret;
}
#ifdef LOOP_BACK_TEST
if (dev->id == LOOP_BACK_CHANNEL) {
if (loopback_ongoing) {
if (strncmp(pdp_rx_buf,
loopback_data,
loopback_res.
nPacketDataSize)) {
/* DO SOMETHING */
} else {
send_loop_back_packet(
loopback_data,
loopback_res.
nPacketDataSize);
}
} else {
/* DO SOMETHING */
}
} else if (ret > 0 && dev->vs_dev.tty != NULL) {
tty_insert_flip_string(
dev->vs_dev.tty,
pdp_rx_buf, ret);
dev->vs_dev.tty->low_latency = 0;
tty_flip_buffer_push(dev->vs_dev.tty);
}
#else
if (dev->vs_dev.tty == NULL)
pr_err("[MULTIPDP] TTY is NULL : (2)~ !!!!\n");
if (ret > 0 && dev->vs_dev.tty != NULL) {
if (dev->id == 29) {
skb = alloc_skb(len, GFP_ATOMIC);
if (unlikely(!skb))
pr_err("[MULTIPDP] Allocation sk_buff error!\n");
memcpy(skb_put(skb, len), pdp_rx_buf, len);
skb_queue_tail(&cplog_sk_buf_rx_q, skb);
queue_work(cplog_rx_wq, &cplog_work);
} else {
ret = multipdp_tty_insert_data(
dev->vs_dev.tty,
pdp_rx_buf, ret);
if (ret > 0) {
dev->vs_dev.tty->low_latency = 0;
tty_flip_buffer_push(dev->vs_dev.tty);
}
}
}
#endif
}
return ret;
}
#endif
static int vs_read(struct pdp_info *dev, size_t len)
{
int retval = 0;
u32 size;
u32 copied_size;
int insert_size = 0;
if (dev) {
/* pdp data length. */
if (len > MAX_PDP_DATA_LEN) {
DPRINTK(2, "CAL DATA\n");
size = dpram_read(dpram_filp, prx_buf, len);
DPRINTK(2,
"multipdp_thread request read size : %d readed size %d, count : %d\n",
len, size, count);
if ((dev->id == 1 && !fp_vsCSD)
|| (dev->id == 5 && !fp_vsGPS) || (dev->id == 8
&& !fp_vsEFS)
|| (dev->id == 25 && !fp_vsSMD)
|| (dev->id == 6 && !fp_vsEXGPS) || (dev->id == 29
&& !fp_vsCPLOG)
|| (dev->id == 31 && !fp_vsLOOPBACK)) {
pr_err("[MULTIPDP] %s, discard data.\n",
dev->vs_dev.tty->name);
} else {
while (size) {
copied_size = (size >
MAX_PDP_DATA_LEN) ?
MAX_PDP_DATA_LEN : size;
if (size > 0
&& dev->vs_dev.tty != NULL) {
insert_size =
tty_insert_flip_string
(dev->vs_dev.tty,
prx_buf + retval,
copied_size);
}
if (insert_size != copied_size) {
pr_err("[MULTIPDP] flip buffer full : %s,"
"insert size : %d,"
"real size : %d\n",
dev->vs_dev.
tty->name,
copied_size,
insert_size);
return -ERANGE;
}
size = size - copied_size;
retval += copied_size;
}
DPRINTK(2, "retval : %d\n", retval);
tty_flip_buffer_push(dev->vs_dev.tty);
count++;
}
} else {
retval = dpram_read(dpram_filp, pdp_rx_buf, len);
if (retval != len)
return retval;
if (retval > 0) {
if ((dev->id == 1 && !fp_vsCSD)
|| (dev->id == 5 && !fp_vsGPS)
|| (dev->id == 8 && !fp_vsEFS)
|| (dev->id == 25 && !fp_vsSMD)
|| (dev->id == 6 && !fp_vsEXGPS)
|| (dev->id == 29 && !fp_vsCPLOG)
|| (dev->id == 31 && !fp_vsLOOPBACK)) {
pr_err("[MULTIPDP] %s, discard data.\n",
dev->vs_dev.tty->name);
} else {
insert_size =
tty_insert_flip_string(dev->
vs_dev.tty,
pdp_rx_buf,
retval);
if (insert_size != retval) {
pr_err("[MULTIPDP] flip buffer full : %s,"
"insert size : %d,"
"real size : %d\n",
dev->vs_dev.
tty->name,
retval,
insert_size);
return -ERANGE;
}
tty_flip_buffer_push(dev->vs_dev.tty);
}
}
}
}
return 0;
}
static int vs_read(struct pdp_info *dev, size_t len, int vs_id)
{
int retval = 0;
u32 size;
u32 copied_size;
int insert_size = 0;
DPRINTK(2, "BEGIN\n");
if (dev) {
/* pdp data length. */
if (len > MAX_PDP_DATA_LEN) { // RF cal data?
DPRINTK(1, "CAL DATA\n");
size = dpram_read(dpram_filp, prx_buf, len);
DPRINTK(1, "multipdp_thread request read size : %d readed size %d, count : %d\n",len ,size,count);
if ((dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)){
EPRINTK("vs_read : %s, discard data.\n", dev->vs_dev.tty->name);
}
else {
while (size) {
copied_size = (size > MAX_PDP_DATA_LEN) ? MAX_PDP_DATA_LEN : size;
if (size > 0 && dev->vs_dev.tty != NULL)
insert_size = tty_insert_flip_string(dev->vs_dev.tty, prx_buf+retval, copied_size);
if (insert_size != copied_size) {
EPRINTK("flip buffer full : %s, insert size : %d, real size : %d\n",dev->vs_dev.tty->name,copied_size,insert_size);
return -1;
}
size = size - copied_size;
retval += copied_size;
}
DPRINTK(1, "retval : %d\n",retval);
tty_flip_buffer_push(dev->vs_dev.tty);
count++;
}
}
else {
retval = dpram_read(dpram_filp, pdp_rx_buf, len);
if (retval != len)
return retval;
if(retval > 0){
if((dev->id == 1 && !fp_vsCSD) || (dev->id == 5 && !fp_vsGPS) || (dev->id == 8 && !fp_vsEFS)|| (dev->id == 25 && !fp_vsSMD)) {
EPRINTK("vs_read : %s, discard data.\n", dev->vs_dev.tty->name);
}
else {
insert_size = tty_insert_flip_string(dev->vs_dev.tty, pdp_rx_buf, retval);
if (insert_size != retval) {
EPRINTK("flip buffer full : %s, insert size : %d, real size : %d\n",dev->vs_dev.tty->name,retval,insert_size);
return -1;
}
tty_flip_buffer_push(dev->vs_dev.tty);
}
}
}
}
DPRINTK(2, "END\n");
return 0;
}
