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; }