Lines Matching defs:privptr
209 static struct sk_buff *claw_pack_skb(struct claw_privbk *privptr);
330 struct claw_privbk *privptr=NULL;
335 privptr = kzalloc(sizeof(struct claw_privbk), GFP_KERNEL);
336 dev_set_drvdata(&cgdev->dev, privptr);
337 if (privptr == NULL) {
343 privptr->p_mtc_envelope= kzalloc( MAX_ENVELOPE_SIZE, GFP_KERNEL);
344 privptr->p_env = kzalloc(sizeof(struct claw_env), GFP_KERNEL);
345 if ((privptr->p_mtc_envelope==NULL) || (privptr->p_env==NULL)) {
351 memcpy(privptr->p_env->adapter_name,WS_NAME_NOT_DEF,8);
352 memcpy(privptr->p_env->host_name,WS_NAME_NOT_DEF,8);
353 memcpy(privptr->p_env->api_type,WS_NAME_NOT_DEF,8);
354 privptr->p_env->packing = 0;
355 privptr->p_env->write_buffers = 5;
356 privptr->p_env->read_buffers = 5;
357 privptr->p_env->read_size = CLAW_FRAME_SIZE;
358 privptr->p_env->write_size = CLAW_FRAME_SIZE;
368 privptr->p_env->p_priv = privptr;
384 struct claw_privbk *privptr = dev->ml_priv;
389 p_ch = &privptr->channel[WRITE_CHANNEL];
407 claw_pack_skb(struct claw_privbk *privptr)
410 struct chbk *p_ch = &privptr->channel[WRITE_CHANNEL];
411 struct claw_env *p_env = privptr->p_env;
441 privptr->stats.tx_packets++;
467 struct claw_privbk *privptr = dev->ml_priv;
470 buff_size = privptr->p_env->write_size;
491 struct claw_privbk *privptr;
497 privptr = (struct claw_privbk *)dev->ml_priv;
499 if (privptr->buffs_alloc == 0) {
506 privptr->system_validate_comp=0;
507 privptr->release_pend=0;
508 if(strncmp(privptr->p_env->api_type,WS_APPL_NAME_PACKED,6) == 0) {
509 privptr->p_env->read_size=DEF_PACK_BUFSIZE;
510 privptr->p_env->write_size=DEF_PACK_BUFSIZE;
511 privptr->p_env->packing=PACKING_ASK;
513 privptr->p_env->packing=0;
514 privptr->p_env->read_size=CLAW_FRAME_SIZE;
515 privptr->p_env->write_size=CLAW_FRAME_SIZE;
518 tasklet_init(&privptr->channel[READ_CHANNEL].tasklet, claw_irq_tasklet,
519 (unsigned long) &privptr->channel[READ_CHANNEL]);
522 init_waitqueue_head(&privptr->channel[i].wait);
526 &privptr->channel[WRITE_CHANNEL].collect_queue);
527 privptr->channel[i].flag_a = 0;
528 privptr->channel[i].IO_active = 0;
529 privptr->channel[i].flag &= ~CLAW_TIMER;
532 timer.data = (unsigned long)(&privptr->channel[i]);
536 privptr->channel[i].cdev), saveflags);
537 parm = (unsigned long) &privptr->channel[i];
538 privptr->channel[i].claw_state = CLAW_START_HALT_IO;
540 add_wait_queue(&privptr->channel[i].wait, &wait);
542 (struct ccw_device *)privptr->channel[i].cdev,parm);
545 get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
548 remove_wait_queue(&privptr->channel[i].wait, &wait);
550 ccw_check_return_code(privptr->channel[i].cdev, rc);
551 if((privptr->channel[i].flag & CLAW_TIMER) == 0x00)
554 if ((((privptr->channel[READ_CHANNEL].last_dstat |
555 privptr->channel[WRITE_CHANNEL].last_dstat) &
557 (((privptr->channel[READ_CHANNEL].flag |
558 privptr->channel[WRITE_CHANNEL].flag) & CLAW_TIMER) != 0x00)) {
559 dev_info(&privptr->channel[READ_CHANNEL].cdev->dev,
565 get_ccwdev_lock(privptr->channel[i].cdev),
567 parm = (unsigned long) &privptr->channel[i];
568 privptr->channel[i].claw_state = CLAW_STOP;
570 (struct ccw_device *)&privptr->channel[i].cdev,
573 get_ccwdev_lock(privptr->channel[i].cdev),
577 privptr->channel[i].cdev, rc);
580 free_pages((unsigned long)privptr->p_buff_ccw,
581 (int)pages_to_order_of_mag(privptr->p_buff_ccw_num));
582 if (privptr->p_env->read_size < PAGE_SIZE) {
583 free_pages((unsigned long)privptr->p_buff_read,
585 privptr->p_buff_read_num));
588 p_buf=privptr->p_read_active_first;
592 privptr->p_buff_pages_perread ));
596 if (privptr->p_env->write_size < PAGE_SIZE ) {
597 free_pages((unsigned long)privptr->p_buff_write,
599 privptr->p_buff_write_num));
602 p_buf=privptr->p_write_active_first;
606 privptr->p_buff_pages_perwrite ));
610 privptr->buffs_alloc = 0;
611 privptr->channel[READ_CHANNEL].flag = 0x00;
612 privptr->channel[WRITE_CHANNEL].flag = 0x00;
613 privptr->p_buff_ccw=NULL;
614 privptr->p_buff_read=NULL;
615 privptr->p_buff_write=NULL;
638 struct claw_privbk *privptr = NULL;
645 privptr = dev_get_drvdata(&cdev->dev);
646 if (!privptr) {
655 if (privptr->channel[READ_CHANNEL].cdev == cdev)
656 p_ch = &privptr->channel[READ_CHANNEL];
657 else if (privptr->channel[WRITE_CHANNEL].cdev == cdev)
658 p_ch = &privptr->channel[WRITE_CHANNEL];
667 p_env=privptr->p_env;
738 privptr->stats.rx_errors++;
816 p_ch_r = (struct chbk *)&privptr->channel[READ_CHANNEL];
842 struct claw_privbk * privptr;
847 privptr = (struct claw_privbk *)dev->ml_priv;
865 struct claw_privbk *privptr;
872 privptr = (struct claw_privbk *)dev->ml_priv;
873 if (!privptr)
876 privptr->release_pend=1;
880 get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
881 /* del_timer(&privptr->channel[READ_CHANNEL].timer); */
882 privptr->channel[i].claw_state = CLAW_STOP;
883 privptr->channel[i].IO_active = 0;
884 parm = (unsigned long) &privptr->channel[i];
887 &privptr->channel[WRITE_CHANNEL].collect_queue);
888 rc = ccw_device_halt (privptr->channel[i].cdev, parm);
889 if (privptr->system_validate_comp==0x00) /* never opened? */
890 init_waitqueue_head(&privptr->channel[i].wait);
891 add_wait_queue(&privptr->channel[i].wait, &wait);
894 get_ccwdev_lock(privptr->channel[i].cdev), saveflags);
897 remove_wait_queue(&privptr->channel[i].wait, &wait);
899 ccw_check_return_code(privptr->channel[i].cdev, rc);
902 if (privptr->pk_skb != NULL) {
903 dev_kfree_skb_any(privptr->pk_skb);
904 privptr->pk_skb = NULL;
906 if(privptr->buffs_alloc != 1) {
911 if (privptr->p_buff_ccw != NULL) {
912 free_pages((unsigned long)privptr->p_buff_ccw,
913 (int)pages_to_order_of_mag(privptr->p_buff_ccw_num));
916 if (privptr->p_env->read_size < PAGE_SIZE) {
917 if (privptr->p_buff_read != NULL) {
918 free_pages((unsigned long)privptr->p_buff_read,
919 (int)pages_to_order_of_mag(privptr->p_buff_read_num));
923 p_buf=privptr->p_read_active_first;
927 privptr->p_buff_pages_perread ));
932 if (privptr->p_env->write_size < PAGE_SIZE ) {
933 free_pages((unsigned long)privptr->p_buff_write,
934 (int)pages_to_order_of_mag(privptr->p_buff_write_num));
937 p_buf=privptr->p_write_active_first;
941 privptr->p_buff_pages_perwrite ));
946 privptr->buffs_alloc = 0;
947 privptr->p_buff_ccw=NULL;
948 privptr->p_buff_read=NULL;
949 privptr->p_buff_write=NULL;
950 privptr->system_validate_comp=0;
951 privptr->release_pend=0;
953 p_this_ccw=privptr->p_read_active_first;
961 while (privptr->p_write_active_first!=NULL) {
962 p_this_ccw=privptr->p_write_active_first;
964 privptr->p_write_active_first=p_this_ccw->next;
965 p_this_ccw->next=privptr->p_write_free_chain;
966 privptr->p_write_free_chain=p_this_ccw;
967 ++privptr->write_free_count;
969 privptr->p_write_active_last=NULL;
970 privptr->mtc_logical_link = -1;
971 privptr->mtc_skipping = 1;
972 privptr->mtc_offset=0;
974 if (((privptr->channel[READ_CHANNEL].last_dstat |
975 privptr->channel[WRITE_CHANNEL].last_dstat) &
977 dev_warn(&privptr->channel[READ_CHANNEL].cdev->dev,
982 privptr->channel[READ_CHANNEL].last_dstat,
983 privptr->channel[WRITE_CHANNEL].last_dstat);
1021 struct claw_privbk *privptr=NULL;
1029 privptr = (struct claw_privbk *) dev->ml_priv;
1031 if ((privptr->write_free_count > 0) &&
1033 pk_skb = claw_pack_skb(privptr);
1036 if (privptr->write_free_count > 0) {
1037 pk_skb = claw_pack_skb(privptr);
1042 if (privptr->p_write_active_first!=NULL) {
1107 struct claw_privbk *privptr;
1111 privptr = dev->ml_priv;
1112 p_end = privptr->p_end_ccw;
1144 if ( privptr-> p_read_active_first ==NULL ) {
1145 privptr->p_read_active_first = p_first; /* set new first */
1146 privptr->p_read_active_last = p_last; /* set new last */
1167 privptr->p_read_active_last->r_TIC_1.cda=
1169 privptr->p_read_active_last->r_TIC_2.cda=
1177 privptr->p_read_active_last->r_TIC_1.cda=
1179 privptr->p_read_active_last->r_TIC_2.cda=
1183 privptr->p_read_active_last->next = p_first;
1184 privptr->p_read_active_last=p_last;
1185 } /* end of if ( privptr-> p_read_active_first ==NULL) */
1269 struct claw_privbk *privptr;
1274 privptr = dev->ml_priv;
1275 p_env=privptr->p_env;
1309 struct claw_privbk *privptr;
1326 privptr = (struct claw_privbk *)(dev->ml_priv);
1327 p_ch = (struct chbk *)&privptr->channel[WRITE_CHANNEL];
1328 p_env =privptr->p_env;
1353 if (privptr->write_free_count!=0) {
1359 if (privptr->write_free_count==0) {
1360 ch = &privptr->channel[WRITE_CHANNEL];
1372 ch = &privptr->channel[WRITE_CHANNEL];
1381 numBuffers = DIV_ROUND_UP(skb->len, privptr->p_env->write_size);
1384 if (privptr->write_free_count < numBuffers ||
1385 privptr->p_write_free_chain == NULL ) {
1388 ch = &privptr->channel[WRITE_CHANNEL];
1398 p_this_ccw=privptr->p_write_free_chain; /* get a block */
1400 ch = &privptr->channel[WRITE_CHANNEL];
1405 privptr->p_write_free_chain=p_this_ccw->next;
1407 --privptr->write_free_count; /* -1 */
1408 if (len_of_data >= privptr->p_env->write_size)
1409 bytesInThisBuffer = privptr->p_env->write_size;
1440 pEnd=privptr->p_end_ccw;
1464 if (privptr->p_write_active_first==NULL ) {
1465 privptr->p_write_active_first=p_first_ccw;
1466 privptr->p_write_active_last=p_last_ccw;
1487 privptr->p_write_active_last->w_TIC_1.cda=
1497 privptr->p_write_active_last->w_TIC_1.cda=
1502 privptr->p_write_active_last->next=p_first_ccw;
1503 privptr->p_write_active_last=p_last_ccw;
1516 if (privptr->write_free_count==0) {
1549 struct claw_privbk *privptr = dev->ml_priv;
1556 privptr->active_link_ID=0;
1558 privptr->p_write_free_chain=NULL; /* pointer to free ccw chain*/
1559 privptr->p_write_active_first=NULL; /* pointer to the first write ccw*/
1560 privptr->p_write_active_last=NULL; /* pointer to the last write ccw*/
1561 privptr->p_read_active_first=NULL; /* pointer to the first read ccw*/
1562 privptr->p_read_active_last=NULL; /* pointer to the last read ccw */
1563 privptr->p_end_ccw=NULL; /* pointer to ending ccw */
1564 privptr->p_claw_signal_blk=NULL; /* pointer to signal block */
1565 privptr->buffs_alloc = 0;
1566 memset(&privptr->end_ccw, 0x00, sizeof(struct endccw));
1567 memset(&privptr->ctl_bk, 0x00, sizeof(struct clawctl));
1569 privptr->write_free_count=0; /* number of free bufs on write chain */
1577 privptr->p_env->read_buffers+privptr->p_env->write_buffers+1;
1591 if (privptr->p_env->read_size < PAGE_SIZE) {
1592 claw_reads_perpage = PAGE_SIZE / privptr->p_env->read_size;
1593 claw_read_pages = DIV_ROUND_UP(privptr->p_env->read_buffers,
1597 privptr->p_buff_pages_perread =
1598 DIV_ROUND_UP(privptr->p_env->read_size, PAGE_SIZE);
1599 claw_read_pages = privptr->p_env->read_buffers *
1600 privptr->p_buff_pages_perread;
1602 if (privptr->p_env->write_size < PAGE_SIZE) {
1604 PAGE_SIZE / privptr->p_env->write_size;
1605 claw_write_pages = DIV_ROUND_UP(privptr->p_env->write_buffers,
1610 privptr->p_buff_pages_perwrite =
1611 DIV_ROUND_UP(privptr->p_env->read_size, PAGE_SIZE);
1612 claw_write_pages = privptr->p_env->write_buffers *
1613 privptr->p_buff_pages_perwrite;
1618 if (privptr->p_buff_ccw==NULL) {
1619 privptr->p_buff_ccw=
1622 if (privptr->p_buff_ccw==NULL) {
1625 privptr->p_buff_ccw_num=ccw_pages_required;
1627 memset(privptr->p_buff_ccw, 0x00,
1628 privptr->p_buff_ccw_num * PAGE_SIZE);
1634 privptr->p_end_ccw = (struct endccw *)&privptr->end_ccw;
1635 real_address = (__u32)__pa(privptr->p_end_ccw);
1637 p_endccw=privptr->p_end_ccw;
1694 p_buff=privptr->p_buff_ccw;
1712 if (privptr->p_claw_signal_blk==NULL) {
1713 privptr->p_claw_signal_blk=p_free_chain;
1715 pClawH=(struct clawh *)privptr->p_claw_signal_blk;
1724 if (privptr->p_buff_write==NULL) {
1725 if (privptr->p_env->write_size < PAGE_SIZE) {
1726 privptr->p_buff_write=
1729 if (privptr->p_buff_write==NULL) {
1730 privptr->p_buff_ccw=NULL;
1738 memset(privptr->p_buff_write, 0x00,
1740 privptr->p_write_free_chain=NULL;
1742 p_buff=privptr->p_buff_write;
1744 for (i=0 ; i< privptr->p_env->write_buffers ; i++) {
1747 p_buf->next =privptr->p_write_free_chain;
1748 privptr->p_write_free_chain = p_buf;
1762 privptr->p_env->write_size) >=
1764 (privptr->p_env->write_size) - 1) & PAGE_MASK)) {
1765 p_buff = p_buff+privptr->p_env->write_size;
1771 privptr->p_write_free_chain=NULL;
1772 for (i = 0; i< privptr->p_env->write_buffers ; i++) {
1775 privptr->p_buff_pages_perwrite) );
1777 free_pages((unsigned long)privptr->p_buff_ccw,
1779 privptr->p_buff_ccw_num));
1780 privptr->p_buff_ccw=NULL;
1781 p_buf=privptr->p_buff_write;
1786 privptr->p_buff_pages_perwrite));
1791 memset(p_buff, 0x00, privptr->p_env->write_size );
1794 p_buf->next = privptr->p_write_free_chain;
1795 privptr->p_write_free_chain = p_buf;
1796 privptr->p_buff_write = p_buf;
1813 privptr->p_buff_write_num=claw_write_pages;
1814 privptr->write_free_count=privptr->p_env->write_buffers;
1820 if (privptr->p_buff_read==NULL) {
1821 if (privptr->p_env->read_size < PAGE_SIZE) {
1822 privptr->p_buff_read=
1825 if (privptr->p_buff_read==NULL) {
1826 free_pages((unsigned long)privptr->p_buff_ccw,
1828 privptr->p_buff_ccw_num));
1830 free_pages((unsigned long)privptr->p_buff_write,
1832 privptr->p_buff_write_num));
1833 privptr->p_buff_ccw=NULL;
1834 privptr->p_buff_write=NULL;
1837 memset(privptr->p_buff_read, 0x00, claw_read_pages * PAGE_SIZE);
1838 privptr->p_buff_read_num=claw_read_pages;
1843 p_buff=privptr->p_buff_read;
1844 for (i=0 ; i< privptr->p_env->read_buffers ; i++) {
1866 p_buf-> read.count = privptr->p_env->read_size;
1905 if (((unsigned long)p_buff+privptr->p_env->read_size) >=
1906 ((unsigned long)(p_buff+2*(privptr->p_env->read_size)
1909 p_buff= p_buff+privptr->p_env->read_size;
1914 (p_buff+2*(privptr->p_env->read_size)-1)
1920 for (i=0 ; i< privptr->p_env->read_buffers ; i++) {
1923 privptr->p_buff_pages_perread));
1925 free_pages((unsigned long)privptr->p_buff_ccw,
1926 (int)pages_to_order_of_mag(privptr->
1929 p_buf=privptr->p_buff_write;
1934 privptr->p_buff_pages_perwrite));
1938 p_buf=privptr->p_buff_read;
1943 privptr->p_buff_pages_perread));
1946 privptr->p_buff_ccw=NULL;
1947 privptr->p_buff_write=NULL;
1950 memset(p_buff, 0x00, privptr->p_env->read_size);
1952 privptr->p_buff_read = p_buf;
1974 p_buf-> read.count = privptr->p_env->read_size;
2017 privptr->buffs_alloc = 1;
2031 struct claw_privbk *privptr;
2034 privptr = dev_get_drvdata(&cgdev->dev);
2035 if (privptr != NULL) {
2037 kfree(privptr->p_env);
2038 kfree(privptr->p_mtc_envelope);
2039 kfree(privptr);
2058 struct claw_privbk *privptr;
2068 privptr = dev->ml_priv;
2069 p_env=privptr->p_env;
2070 tdev = &privptr->channel[READ_CHANNEL].cdev->dev;
2076 if (privptr->release_pend==1) {
2156 privptr->system_validate_comp = 1;
2178 if (privptr->system_validate_comp == 0)
2180 privptr->system_validate_comp = 1;
2215 if (privptr->active_link_ID != 0) {
2247 privptr->active_link_ID = p_ctlbk->linkid;
2248 p_ch = &privptr->channel[WRITE_CHANNEL];
2279 privptr->active_link_ID = -(p_ctlbk->linkid);
2292 if (p_ctlbk->linkid == -(privptr->active_link_ID)) {
2293 privptr->active_link_ID = p_ctlbk->linkid;
2299 p_ch = &privptr->channel[WRITE_CHANNEL];
2315 privptr->active_link_ID = 1;
2318 privptr->active_link_ID = 0;
2344 struct claw_privbk *privptr;
2351 privptr = dev->ml_priv;
2352 p_ctl=(struct clawctl *)&privptr->ctl_bk;
2368 if (privptr->p_env->packing > 0) {
2374 privptr->p_env->read_size;
2376 privptr->p_env->write_size;
2386 if (privptr->p_env->packing > 0) {
2408 if (privptr->p_env->packing >= PACK_SEND)
2423 struct claw_privbk *privptr = dev->ml_priv;
2428 p_ctl=(struct clawctl *)&privptr->ctl_bk;
2430 if ( privptr->system_validate_comp==0x00 ) {
2433 if (privptr->p_env->packing == PACKING_ASK )
2436 if (privptr->p_env->packing == PACK_SEND) {
2440 if (privptr->p_env->packing == 0)
2442 HOST_APPL_NAME, privptr->p_env->api_type);
2479 struct claw_privbk *privptr;
2483 privptr = dev->ml_priv;
2484 p_env=privptr->p_env;
2518 struct claw_privbk *privptr;
2521 privptr = dev->ml_priv;
2522 return &privptr->stats;
2534 struct claw_privbk *privptr;
2557 privptr = dev->ml_priv;
2559 p_dev = &privptr->channel[READ_CHANNEL].cdev->dev;
2560 p_env = privptr->p_env;
2561 p_this_ccw=privptr->p_read_active_first;
2566 privptr->p_read_active_first=p_this_ccw->next;
2586 privptr->p_env->read_size ) {
2595 if (privptr->mtc_skipping) {
2605 privptr->mtc_skipping=0; /* Ok, the end */
2606 privptr->mtc_logical_link=-1;
2631 if (privptr->mtc_logical_link<0) {
2639 privptr->mtc_offset=0;
2640 privptr->mtc_logical_link=link_num;
2643 if (bytes_to_mov > (MAX_ENVELOPE_SIZE- privptr->mtc_offset) ) {
2645 privptr->stats.rx_frame_errors++;
2649 memcpy( privptr->p_mtc_envelope+ privptr->mtc_offset,
2653 memcpy( privptr->p_mtc_envelope+ privptr->mtc_offset,
2657 len_of_data=privptr->mtc_offset+bytes_to_mov;
2661 privptr->p_mtc_envelope,
2667 privptr->stats.rx_packets++;
2668 privptr->stats.rx_bytes+=len_of_data;
2674 privptr->stats.rx_dropped++;
2676 privptr->mtc_offset=0;
2677 privptr->mtc_logical_link=-1;
2680 privptr->mtc_offset+=bytes_to_mov;
2705 p_this_ccw = privptr->p_read_active_first;
2727 struct claw_privbk *privptr = dev->ml_priv;
2731 p_ch = &privptr->channel[READ_CHANNEL];
2734 p_clawh=(struct clawh *)privptr->p_claw_signal_blk;
2737 if ((privptr->p_write_active_first!=NULL &&
2738 privptr->p_write_active_first->header.flag!=CLAW_PENDING) ||
2739 (privptr->p_read_active_first!=NULL &&
2740 privptr->p_read_active_first->header.flag!=CLAW_PENDING )) {
2748 p_ccwbk=privptr->p_read_active_first;
2777 struct claw_privbk *privptr;
2784 privptr = (struct claw_privbk *)dev->ml_priv;
2785 p_ch = &privptr->channel[WRITE_CHANNEL];
2788 p_first_ccw=privptr->p_write_active_first;
2817 struct claw_privbk *privptr = (struct claw_privbk *)dev->ml_priv;
2827 p_this_ccw=privptr->p_write_active_first;
2833 ((p_this_ccw == privptr->p_write_active_last) &&
2837 privptr->p_write_active_first=p_this_ccw->next;
2839 p_this_ccw->next=privptr->p_write_free_chain;
2840 privptr->p_write_free_chain=p_this_ccw;
2841 ++privptr->write_free_count;
2842 privptr->stats.tx_bytes+= p_this_ccw->write.count;
2843 p_this_ccw=privptr->p_write_active_first;
2844 privptr->stats.tx_packets++;
2850 if (privptr->write_free_count!=0) {
2854 if (privptr->p_write_active_first==NULL) {
2855 privptr->p_write_active_last=NULL;
2857 CLAW_DBF_TEXT_(4, trace, "FWC=%d", privptr->write_free_count);
2868 struct claw_privbk *privptr;
2874 privptr = dev->ml_priv;
2877 if (privptr) {
2878 privptr->channel[READ_CHANNEL].ndev = NULL; /* say it's free */
2919 * Init a new channel in the privptr->channel[i].
2926 add_channel(struct ccw_device *cdev,int i,struct claw_privbk *privptr)
2932 privptr->channel[i].flag = i+1; /* Read is 1 Write is 2 */
2933 p_ch = &privptr->channel[i];
2956 struct claw_privbk *privptr;
2965 privptr = dev_get_drvdata(&cgdev->dev);
2966 dev_set_drvdata(&cgdev->cdev[READ_CHANNEL]->dev, privptr);
2967 dev_set_drvdata(&cgdev->cdev[WRITE_CHANNEL]->dev, privptr);
2968 if (!privptr)
2970 p_env = privptr->p_env;
2975 ret = add_channel(cgdev->cdev[0],0,privptr);
2977 ret = add_channel(cgdev->cdev[1],1,privptr);
3003 dev->ml_priv = privptr;
3004 dev_set_drvdata(&cgdev->dev, privptr);
3005 dev_set_drvdata(&cgdev->cdev[READ_CHANNEL]->dev, privptr);
3006 dev_set_drvdata(&cgdev->cdev[WRITE_CHANNEL]->dev, privptr);
3015 if (privptr->buffs_alloc == 0) {
3024 privptr->channel[READ_CHANNEL].ndev = dev;
3025 privptr->channel[WRITE_CHANNEL].ndev = dev;
3026 privptr->p_env->ndev = dev;