Lines Matching refs:ch
188 * ch : The channel, the error belongs to.
191 void ctcm_ccw_check_rc(struct channel *ch, int rc, char *msg)
195 CTCM_FUNTAIL, ch->id, msg, rc);
199 ch->id);
200 fsm_event(ch->fsm, CTC_EVENT_IO_EBUSY, ch);
204 ch->id);
205 fsm_event(ch->fsm, CTC_EVENT_IO_ENODEV, ch);
210 fsm_event(ch->fsm, CTC_EVENT_IO_UNKNOWN, ch);
248 struct channel *ch = arg;
249 struct net_device *dev = ch->netdev;
257 CTCM_PR_DEBUG("%s(%s): %s\n", __func__, ch->id, dev->name);
259 duration = done_stamp - ch->prof.send_stamp;
260 if (duration > ch->prof.tx_time)
261 ch->prof.tx_time = duration;
263 if (ch->irb->scsw.cmd.count != 0)
266 CTCM_FUNTAIL, dev->name, ch->irb->scsw.cmd.count);
267 fsm_deltimer(&ch->timer);
268 while ((skb = skb_dequeue(&ch->io_queue))) {
278 spin_lock(&ch->collect_lock);
279 clear_normalized_cda(&ch->ccw[4]);
280 if (ch->collect_len > 0) {
283 if (ctcm_checkalloc_buffer(ch)) {
284 spin_unlock(&ch->collect_lock);
287 ch->trans_skb->data = ch->trans_skb_data;
288 skb_reset_tail_pointer(ch->trans_skb);
289 ch->trans_skb->len = 0;
290 if (ch->prof.maxmulti < (ch->collect_len + 2))
291 ch->prof.maxmulti = ch->collect_len + 2;
292 if (ch->prof.maxcqueue < skb_queue_len(&ch->collect_queue))
293 ch->prof.maxcqueue = skb_queue_len(&ch->collect_queue);
294 *((__u16 *)skb_put(ch->trans_skb, 2)) = ch->collect_len + 2;
296 while ((skb = skb_dequeue(&ch->collect_queue))) {
298 skb_put(ch->trans_skb, skb->len), skb->len);
305 ch->collect_len = 0;
306 spin_unlock(&ch->collect_lock);
307 ch->ccw[1].count = ch->trans_skb->len;
308 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
309 ch->prof.send_stamp = jiffies;
310 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
311 ch->prof.doios_multi++;
315 fsm_deltimer(&ch->timer);
316 ctcm_ccw_check_rc(ch, rc, "chained TX");
319 spin_unlock(&ch->collect_lock);
336 struct channel *ch = arg;
337 struct net_device *dev = ch->netdev;
340 CTCM_PR_DEBUG("%s(%s): %s\n", __func__, ch->id, dev->name);
342 fsm_deltimer(&ch->timer);
344 fsm_event(priv->fsm, DEV_EVENT_TXUP, ch->netdev);
357 struct channel *ch = arg;
358 struct net_device *dev = ch->netdev;
360 int len = ch->max_bufsize - ch->irb->scsw.cmd.count;
361 struct sk_buff *skb = ch->trans_skb;
366 fsm_deltimer(&ch->timer);
375 if (len > ch->max_bufsize) {
378 CTCM_FUNTAIL, dev->name, len, ch->max_bufsize);
387 switch (ch->protocol) {
410 ctcm_unpack_skb(ch, skb);
413 skb->data = ch->trans_skb_data;
416 if (ctcm_checkalloc_buffer(ch))
418 ch->ccw[1].count = ch->max_bufsize;
419 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
421 ctcm_ccw_check_rc(ch, rc, "normal RX");
434 struct channel *ch = arg;
439 CTCM_FUNTAIL, ch->id, fsmstate);
441 ch->sense_rc = 0; /* reset unit check report control */
445 CTCM_FUNTAIL, ch->id);
446 fsm_deltimer(&ch->timer);
447 if (ctcm_checkalloc_buffer(ch))
450 (ch->protocol == CTCM_PROTO_OS390)) {
452 if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
453 *((__u16 *)ch->trans_skb->data) = CTCM_INITIAL_BLOCKLEN;
454 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC,
455 CTC_EVENT_TIMER, ch);
458 struct net_device *dev = ch->netdev;
470 if ((CHANNEL_DIRECTION(ch->flags) == CTCM_WRITE) ||
471 (ch->protocol != CTCM_PROTO_S390))
472 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
474 *((__u16 *)ch->trans_skb->data) = CTCM_INITIAL_BLOCKLEN;
475 ch->ccw[1].count = 2; /* Transfer only length */
477 fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == CTCM_READ)
479 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
481 fsm_deltimer(&ch->timer);
483 ctcm_ccw_check_rc(ch, rc, "init IO");
492 if ((CHANNEL_DIRECTION(ch->flags) == CTCM_READ) &&
493 (ch->protocol == CTCM_PROTO_S390)) {
494 struct net_device *dev = ch->netdev;
511 struct channel *ch = arg;
512 struct net_device *dev = ch->netdev;
517 fsm_deltimer(&ch->timer);
518 buflen = *((__u16 *)ch->trans_skb->data);
523 if (ctcm_checkalloc_buffer(ch))
525 ch->ccw[1].count = ch->max_bufsize;
527 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
530 ctcm_ccw_check_rc(ch, rc, "initial RX");
550 struct channel *ch = arg;
555 fsm_deltimer(&ch->timer);
556 if (IS_MPC(ch)) {
558 CTCM_PR_DEBUG("enter %s: cp=%i ch=0x%p id=%s\n",
559 __func__, smp_processor_id(), ch, ch->id);
561 fsm_addtimer(&ch->timer, timeout, CTC_EVENT_TIMER, ch);
563 CTCM_CCW_DUMP((char *)&ch->ccw[6], sizeof(struct ccw1) * 2);
566 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
570 rc = ccw_device_start(ch->cdev, &ch->ccw[6], 0, 0xff, 0);
572 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
574 fsm_deltimer(&ch->timer);
576 ctcm_ccw_check_rc(ch, rc, "set Mode");
578 ch->retry = 0;
590 struct channel *ch = arg;
595 CTCM_FUNTAIL, ch->id,
596 (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ? "RX" : "TX");
598 if (ch->trans_skb != NULL) {
599 clear_normalized_cda(&ch->ccw[1]);
600 dev_kfree_skb(ch->trans_skb);
601 ch->trans_skb = NULL;
603 if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
604 ch->ccw[1].cmd_code = CCW_CMD_READ;
605 ch->ccw[1].flags = CCW_FLAG_SLI;
606 ch->ccw[1].count = 0;
608 ch->ccw[1].cmd_code = CCW_CMD_WRITE;
609 ch->ccw[1].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
610 ch->ccw[1].count = 0;
612 if (ctcm_checkalloc_buffer(ch)) {
616 CTCM_FUNTAIL, ch->id,
617 (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ?
620 ch->ccw[0].cmd_code = CCW_CMD_PREPARE;
621 ch->ccw[0].flags = CCW_FLAG_SLI | CCW_FLAG_CC;
622 ch->ccw[0].count = 0;
623 ch->ccw[0].cda = 0;
624 ch->ccw[2].cmd_code = CCW_CMD_NOOP; /* jointed CE + DE */
625 ch->ccw[2].flags = CCW_FLAG_SLI;
626 ch->ccw[2].count = 0;
627 ch->ccw[2].cda = 0;
628 memcpy(&ch->ccw[3], &ch->ccw[0], sizeof(struct ccw1) * 3);
629 ch->ccw[4].cda = 0;
630 ch->ccw[4].flags &= ~CCW_FLAG_IDA;
633 fsm_addtimer(&ch->timer, 1000, CTC_EVENT_TIMER, ch);
634 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
635 rc = ccw_device_halt(ch->cdev, 0);
636 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
639 fsm_deltimer(&ch->timer);
640 ctcm_ccw_check_rc(ch, rc, "initial HaltIO");
653 struct channel *ch = arg;
658 fsm_deltimer(&ch->timer);
659 if (IS_MPC(ch))
660 fsm_deltimer(&ch->sweep_timer);
662 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
665 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
670 rc = ccw_device_halt(ch->cdev, 0);
673 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
677 fsm_deltimer(&ch->timer);
680 ctcm_ccw_check_rc(ch, rc, (char *)__func__);
691 * ch The channel to operate on.
694 struct channel *ch)
696 struct net_device *dev = ch->netdev;
701 CTCM_FUNTAIL, dev->name, ch->id, state);
703 fsm_deltimer(&ch->timer);
704 if (IS_MPC(ch))
705 fsm_deltimer(&ch->sweep_timer);
708 if (state == CTC_STATE_STOPPED && ch->trans_skb != NULL) {
709 clear_normalized_cda(&ch->ccw[1]);
710 dev_kfree_skb_any(ch->trans_skb);
711 ch->trans_skb = NULL;
714 ch->th_seg = 0x00;
715 ch->th_seq_num = 0x00;
716 if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
717 skb_queue_purge(&ch->io_queue);
720 ctcm_purge_skb_queue(&ch->io_queue);
721 if (IS_MPC(ch))
722 ctcm_purge_skb_queue(&ch->sweep_queue);
723 spin_lock(&ch->collect_lock);
724 ctcm_purge_skb_queue(&ch->collect_queue);
725 ch->collect_len = 0;
726 spin_unlock(&ch->collect_lock);
780 struct channel *ch = arg;
781 struct net_device *dev = ch->netdev;
793 fsm_deltimer(&ch->timer);
794 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
795 if (!IS_MPC(ch) &&
796 (CHANNEL_DIRECTION(ch->flags) == CTCM_READ)) {
797 int rc = ccw_device_halt(ch->cdev, 0);
799 ctcm_ccw_check_rc(ch, rc,
808 (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) ? "RX" : "TX",
811 if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
829 struct channel *ch = arg;
830 struct net_device *dev = ch->netdev;
837 CTCM_FUNTAIL, ch->id, event, dev->name);
839 fsm_deltimer(&ch->timer);
841 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
845 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
849 rc = ccw_device_halt(ch->cdev, 0);
851 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev), saveflags);
854 fsm_deltimer(&ch->timer);
857 ctcm_ccw_check_rc(ch, rc, "HaltIO in ctcm_chx_restart");
871 struct channel *ch = arg;
872 struct net_device *dev = ch->netdev;
878 fsm_deltimer(&ch->timer);
879 if (ch->retry++ < 3)
887 "%s(%s): %s in %s", CTCM_FUNTAIL, ch->id,
906 struct channel *ch = arg;
907 struct net_device *dev = ch->netdev;
912 CTCM_FUNTAIL, dev->name, ch->id);
926 struct channel *ch = arg;
928 struct net_device *dev = ch->netdev;
934 fsm_deltimer(&ch->timer);
945 ccw_device_halt(ch->cdev, 0);
958 struct channel *ch = arg;
959 struct net_device *dev = ch->netdev;
963 fsm_deltimer(&ch->timer);
964 if (ch->retry++ < 3)
972 "%s(%s): %s in %s", CTCM_FUNTAIL, ch->id,
990 struct channel *ch = arg;
991 struct net_device *dev = ch->netdev;
995 CTCM_PR_DEBUG("Enter: %s: cp=%i ch=0x%p id=%s\n",
996 __func__, smp_processor_id(), ch, ch->id);
998 fsm_deltimer(&ch->timer);
999 if (ch->retry++ > 3) {
1003 CTCM_FUNTAIL, ch->id);
1014 CTCM_FUNTAIL, ch->id, ch->retry);
1015 skb = skb_peek(&ch->io_queue);
1019 clear_normalized_cda(&ch->ccw[4]);
1020 ch->ccw[4].count = skb->len;
1021 if (set_normalized_cda(&ch->ccw[4], skb->data)) {
1024 CTCM_FUNTAIL, ch->id);
1029 fsm_addtimer(&ch->timer, 1000, CTC_EVENT_TIMER, ch);
1031 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1036 ctcmpc_dumpit((char *)&ch->ccw[3],
1039 rc = ccw_device_start(ch->cdev, &ch->ccw[3], 0, 0xff, 0);
1041 spin_unlock_irqrestore(get_ccwdev_lock(ch->cdev),
1044 fsm_deltimer(&ch->timer);
1045 ctcm_ccw_check_rc(ch, rc, "TX in chx_txretry");
1046 ctcm_purge_skb_queue(&ch->io_queue);
1062 struct channel *ch = arg;
1063 struct net_device *dev = ch->netdev;
1065 int rd = CHANNEL_DIRECTION(ch->flags);
1067 fsm_deltimer(&ch->timer);
1070 CTCM_FUNTAIL, ch->id, rd == CTCM_READ ? "RX" : "TX");
1072 if (IS_MPC(ch)) {
1212 struct channel *ch = arg;
1213 struct net_device *dev = ch->netdev;
1230 duration = done_stamp - ch->prof.send_stamp;
1231 if (duration > ch->prof.tx_time)
1232 ch->prof.tx_time = duration;
1234 if (ch->irb->scsw.cmd.count != 0)
1237 CTCM_FUNTAIL, dev->name, ch->irb->scsw.cmd.count);
1238 fsm_deltimer(&ch->timer);
1239 while ((skb = skb_dequeue(&ch->io_queue))) {
1249 spin_lock(&ch->collect_lock);
1250 clear_normalized_cda(&ch->ccw[4]);
1251 if ((ch->collect_len <= 0) || (grp->in_sweep != 0)) {
1252 spin_unlock(&ch->collect_lock);
1257 if (ctcm_checkalloc_buffer(ch)) {
1258 spin_unlock(&ch->collect_lock);
1261 ch->trans_skb->data = ch->trans_skb_data;
1262 skb_reset_tail_pointer(ch->trans_skb);
1263 ch->trans_skb->len = 0;
1264 if (ch->prof.maxmulti < (ch->collect_len + TH_HEADER_LENGTH))
1265 ch->prof.maxmulti = ch->collect_len + TH_HEADER_LENGTH;
1266 if (ch->prof.maxcqueue < skb_queue_len(&ch->collect_queue))
1267 ch->prof.maxcqueue = skb_queue_len(&ch->collect_queue);
1276 while ((skb = skb_dequeue(&ch->collect_queue))) {
1277 skb_put_data(ch->trans_skb, skb->data, skb->len);
1279 (skb_tail_pointer(ch->trans_skb) - skb->len);
1287 __func__, ch->trans_skb->len);
1292 ch->collect_len -= skb->len;
1298 peekskb = skb_peek(&ch->collect_queue);
1308 spin_unlock(&ch->collect_lock);
1313 ch->th_seq_num++;
1314 header->th_seq_num = ch->th_seq_num;
1317 __func__, ch->th_seq_num);
1319 memcpy(skb_push(ch->trans_skb, TH_HEADER_LENGTH), header,
1325 __func__, ch->trans_skb->len);
1328 CTCM_D3_DUMP((char *)ch->trans_skb->data,
1329 min_t(int, ch->trans_skb->len, 50));
1331 spin_unlock(&ch->collect_lock);
1332 clear_normalized_cda(&ch->ccw[1]);
1335 (void *)(unsigned long)ch->ccw[1].cda,
1336 ch->trans_skb->data);
1337 ch->ccw[1].count = ch->max_bufsize;
1339 if (set_normalized_cda(&ch->ccw[1], ch->trans_skb->data)) {
1340 dev_kfree_skb_any(ch->trans_skb);
1341 ch->trans_skb = NULL;
1344 CTCM_FUNTAIL, ch->id);
1350 (void *)(unsigned long)ch->ccw[1].cda,
1351 ch->trans_skb->data);
1353 ch->ccw[1].count = ch->trans_skb->len;
1354 fsm_addtimer(&ch->timer, CTCM_TIME_5_SEC, CTC_EVENT_TIMER, ch);
1355 ch->prof.send_stamp = jiffies;
1357 ctcmpc_dumpit((char *)&ch->ccw[0], sizeof(struct ccw1) * 3);
1358 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
1359 ch->prof.doios_multi++;
1363 fsm_deltimer(&ch->timer);
1364 ctcm_ccw_check_rc(ch, rc, "chained TX");
1381 struct channel *ch = arg;
1382 struct net_device *dev = ch->netdev;
1385 struct sk_buff *skb = ch->trans_skb;
1388 int len = ch->max_bufsize - ch->irb->scsw.cmd.count;
1392 ch->id, ch->max_bufsize, len);
1393 fsm_deltimer(&ch->timer);
1412 new_skb = __dev_alloc_skb(ch->max_bufsize, GFP_ATOMIC);
1429 skb_queue_tail(&ch->io_queue, new_skb);
1430 tasklet_schedule(&ch->ch_tasklet);
1434 skb_queue_tail(&ch->io_queue, new_skb);
1435 tasklet_hi_schedule(&ch->ch_tasklet);
1445 if (ctcm_checkalloc_buffer(ch))
1447 ch->trans_skb->data = ch->trans_skb_data;
1448 skb_reset_tail_pointer(ch->trans_skb);
1449 ch->trans_skb->len = 0;
1450 ch->ccw[1].count = ch->max_bufsize;
1452 ctcmpc_dumpit((char *)&ch->ccw[0],
1457 get_ccwdev_lock(ch->cdev), saveflags);
1458 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
1461 get_ccwdev_lock(ch->cdev), saveflags);
1463 ctcm_ccw_check_rc(ch, rc, "normal RX");
1468 CTCM_PR_DEBUG("Exit %s: %s, ch=0x%p, id=%s\n",
1469 __func__, dev->name, ch, ch->id);
1482 struct channel *ch = arg;
1483 struct net_device *dev = ch->netdev;
1487 CTCM_PR_DEBUG("Enter %s: id=%s, ch=0x%p\n",
1488 __func__, ch->id, ch);
1492 CTCM_FUNTAIL, ch->id, fsm_getstate(fi),
1493 fsm_getstate(gptr->fsm), ch->protocol);
1498 fsm_deltimer(&ch->timer);
1499 if (ctcm_checkalloc_buffer(ch))
1505 if (CHANNEL_DIRECTION(ch->flags) == CTCM_READ) {
1516 fsm_newstate(fi, (CHANNEL_DIRECTION(ch->flags) == CTCM_READ)
1520 CTCM_PR_DEBUG("Exit %s: id=%s, ch=0x%p\n",
1521 __func__, ch->id, ch);
1536 struct channel *ch = arg;
1537 struct net_device *dev = ch->netdev;
1543 fsm_deltimer(&ch->timer);
1545 __func__, ch->id, dev->name, smp_processor_id(),
1554 if (ctcm_checkalloc_buffer(ch))
1556 ch->trans_skb->data = ch->trans_skb_data;
1557 skb_reset_tail_pointer(ch->trans_skb);
1558 ch->trans_skb->len = 0;
1559 ch->ccw[1].count = ch->max_bufsize;
1560 CTCM_CCW_DUMP((char *)&ch->ccw[0], sizeof(struct ccw1) * 3);
1563 spin_lock_irqsave(get_ccwdev_lock(ch->cdev), saveflags);
1564 rc = ccw_device_start(ch->cdev, &ch->ccw[0], 0, 0xff, 0);
1567 get_ccwdev_lock(ch->cdev), saveflags);
1570 ctcm_ccw_check_rc(ch, rc, "initial RX");
1590 struct channel *ch = arg;
1591 struct net_device *dev = ch->netdev;
1595 CTCM_PR_DEBUG("%s(%s): %s(ch=0x%p), cp=%i, ChStat:%s, GrpStat:%s\n",
1596 __func__, dev->name, ch->id, ch, smp_processor_id(),
1597 fsm_getstate_str(ch->fsm), fsm_getstate_str(grp->fsm));
1602 if (!ch->in_mpcgroup)
1604 if (fsm_getstate(ch->fsm) == CH_XID0_PENDING) {
1609 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, ch);
1611 } else if (fsm_getstate(ch->fsm) < CH_XID7_PENDING1)
1613 fsm_newstate(ch->fsm, CH_XID7_PENDING1);
1618 /* attn rcvd before xid0 processed on ch
1620 if (fsm_getstate(ch->fsm) < CH_XID7_PENDING1)
1621 fsm_newstate(ch->fsm, CH_XID7_PENDING1);
1627 switch (fsm_getstate(ch->fsm)) {
1629 fsm_newstate(ch->fsm, CH_XID7_PENDING1);
1632 fsm_newstate(ch->fsm, CH_XID7_PENDING3);
1649 struct channel *ch = arg;
1650 struct net_device *dev = ch->netdev;
1655 __func__, dev->name, ch->id,
1656 fsm_getstate_str(ch->fsm), fsm_getstate_str(grp->fsm));
1658 fsm_deltimer(&ch->timer);
1683 if (fsm_getstate(ch->fsm) == CH_XID0_INPROGRESS) {
1684 fsm_newstate(ch->fsm, CH_XID0_PENDING) ;
1717 if (ch->in_mpcgroup)
1718 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, ch);
1722 CTCM_FUNTAIL, dev->name, ch->id);
1735 struct channel *ch = arg;
1736 struct net_device *dev = ch->netdev;
1740 fsm_event(grp->fsm, MPCG_EVENT_XID0DO, ch);
1762 CTCM_PR_DEBUG("ctcmpc enter: %s(): cp=%i ch=0x%p id=%s\n",
2072 struct channel *ch = priv->channel[direction];
2073 fsm_event(ch->fsm, CTC_EVENT_START, ch);
2094 struct channel *ch = priv->channel[direction];
2095 fsm_event(ch->fsm, CTC_EVENT_STOP, ch);
2096 ch->th_seq_num = 0x00;
2098 __func__, ch->th_seq_num);