Lines Matching defs:ssi
148 /* List of ssi protocol instances */
201 static struct hsi_msg *ssip_alloc_data(struct ssi_protocol *ssi,
211 msg->channel = ssi->channel_id_data;
219 struct ssi_protocol *ssi = hsi_client_drvdata(msg->cl);
222 spin_lock_bh(&ssi->lock);
223 list_add_tail(&msg->link, &ssi->cmdqueue);
224 spin_unlock_bh(&ssi->lock);
227 static struct hsi_msg *ssip_claim_cmd(struct ssi_protocol *ssi)
231 BUG_ON(list_empty(&ssi->cmdqueue));
233 spin_lock_bh(&ssi->lock);
234 msg = list_first_entry(&ssi->cmdqueue, struct hsi_msg, link);
236 spin_unlock_bh(&ssi->lock);
242 static void ssip_free_cmds(struct ssi_protocol *ssi)
246 list_for_each_entry_safe(msg, tmp, &ssi->cmdqueue, link) {
254 static int ssip_alloc_cmds(struct ssi_protocol *ssi)
270 msg->channel = ssi->channel_id_cmd;
271 list_add_tail(&msg->link, &ssi->cmdqueue);
276 ssip_free_cmds(ssi);
281 static void ssip_set_rxstate(struct ssi_protocol *ssi, unsigned int state)
283 ssi->recv_state = state;
286 del_timer(&ssi->rx_wd);
287 if (ssi->send_state == SEND_IDLE)
288 del_timer(&ssi->keep_alive);
292 if (atomic_read(&ssi->tx_usecnt))
296 mod_timer(&ssi->keep_alive, jiffies +
298 mod_timer(&ssi->rx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
305 static void ssip_set_txstate(struct ssi_protocol *ssi, unsigned int state)
307 ssi->send_state = state;
311 del_timer(&ssi->tx_wd);
312 if (ssi->recv_state == RECV_IDLE)
313 del_timer(&ssi->keep_alive);
318 mod_timer(&ssi->keep_alive,
320 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
330 struct ssi_protocol *ssi;
332 list_for_each_entry(ssi, &ssip_list, link)
333 if (slave->device.parent == ssi->cl->device.parent) {
334 master = ssi->cl;
344 struct ssi_protocol *ssi = hsi_client_drvdata(master);
346 dev_dbg(&master->device, "start TX %d\n", atomic_read(&ssi->tx_usecnt));
347 spin_lock_bh(&ssi->lock);
348 if (ssi->send_state == SEND_IDLE) {
349 ssip_set_txstate(ssi, WAIT4READY);
352 spin_unlock_bh(&ssi->lock);
353 atomic_inc(&ssi->tx_usecnt);
361 struct ssi_protocol *ssi = hsi_client_drvdata(master);
363 WARN_ON_ONCE(atomic_read(&ssi->tx_usecnt) == 0);
365 if (atomic_dec_and_test(&ssi->tx_usecnt)) {
366 spin_lock_bh(&ssi->lock);
367 if ((ssi->send_state == SEND_READY) ||
368 (ssi->send_state == WAIT4READY)) {
369 ssip_set_txstate(ssi, SEND_IDLE);
372 spin_unlock_bh(&ssi->lock);
374 dev_dbg(&master->device, "stop TX %d\n", atomic_read(&ssi->tx_usecnt));
382 struct ssi_protocol *ssi = hsi_client_drvdata(master);
383 return netif_running(ssi->netdev);
389 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
393 if (netif_running(ssi->netdev))
394 netif_carrier_off(ssi->netdev);
396 spin_lock_bh(&ssi->lock);
397 if (ssi->send_state != SEND_IDLE)
399 spin_unlock_bh(&ssi->lock);
400 if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
402 spin_lock_bh(&ssi->lock);
403 del_timer(&ssi->rx_wd);
404 del_timer(&ssi->tx_wd);
405 del_timer(&ssi->keep_alive);
406 ssi->main_state = 0;
407 ssi->send_state = 0;
408 ssi->recv_state = 0;
409 ssi->flags = 0;
410 ssi->rxid = 0;
411 ssi->txid = 0;
412 list_for_each_safe(head, tmp, &ssi->txqueue) {
418 ssi->txqueue_len = 0;
419 spin_unlock_bh(&ssi->lock);
424 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
427 spin_lock_bh(&ssi->lock);
428 dev_err(&cl->device, "Main state: %d\n", ssi->main_state);
429 dev_err(&cl->device, "Recv state: %d\n", ssi->recv_state);
430 dev_err(&cl->device, "Send state: %d\n", ssi->send_state);
431 dev_err(&cl->device, "CMT %s\n", (ssi->main_state == ACTIVE) ?
434 test_bit(SSIP_WAKETEST_FLAG, &ssi->flags));
435 dev_err(&cl->device, "Data RX id: %d\n", ssi->rxid);
436 dev_err(&cl->device, "Data TX id: %d\n", ssi->txid);
438 list_for_each_entry(msg, &ssi->txqueue, link)
440 spin_unlock_bh(&ssi->lock);
445 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
450 msg = ssip_claim_cmd(ssi);
457 struct ssi_protocol *ssi = from_timer(ssi, t, keep_alive);
458 struct hsi_client *cl = ssi->cl;
461 ssi->main_state, ssi->recv_state, ssi->send_state);
463 spin_lock(&ssi->lock);
464 if (ssi->recv_state == RECV_IDLE)
465 switch (ssi->send_state) {
467 if (atomic_read(&ssi->tx_usecnt) == 0)
475 spin_unlock(&ssi->lock);
478 mod_timer(&ssi->keep_alive, jiffies + msecs_to_jiffies(SSIP_KATOUT));
479 spin_unlock(&ssi->lock);
484 struct ssi_protocol *ssi = from_timer(ssi, t, rx_wd);
485 struct hsi_client *cl = ssi->cl;
493 struct ssi_protocol *ssi = from_timer(ssi, t, tx_wd);
494 struct hsi_client *cl = ssi->cl;
502 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
506 msg = ssip_claim_cmd(ssi);
511 msg = ssip_claim_cmd(ssi);
518 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
521 dev_dbg(&cl->device, "RX start M(%d) R(%d)\n", ssi->main_state,
522 ssi->recv_state);
523 spin_lock_bh(&ssi->lock);
528 if ((ssi->main_state != ACTIVE) || (ssi->recv_state == RECV_READY)) {
529 spin_unlock_bh(&ssi->lock);
532 ssip_set_rxstate(ssi, RECV_READY);
533 spin_unlock_bh(&ssi->lock);
535 msg = ssip_claim_cmd(ssi);
544 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
546 dev_dbg(&cl->device, "RX stop M(%d)\n", ssi->main_state);
547 spin_lock_bh(&ssi->lock);
548 if (likely(ssi->main_state == ACTIVE))
549 ssip_set_rxstate(ssi, RECV_IDLE);
550 spin_unlock_bh(&ssi->lock);
562 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
567 spin_lock_bh(&ssi->lock);
568 ssip_set_txstate(ssi, SENDING);
569 spin_unlock_bh(&ssi->lock);
575 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
579 spin_lock_bh(&ssi->lock);
580 if (list_empty(&ssi->txqueue)) {
581 spin_unlock_bh(&ssi->lock);
584 dmsg = list_first_entry(&ssi->txqueue, struct hsi_msg, link);
586 ssi->txqueue_len--;
587 spin_unlock_bh(&ssi->lock);
589 msg = ssip_claim_cmd(ssi);
595 spin_lock_bh(&ssi->lock);
597 ssi->txid));
598 ssi->txid++;
599 ssip_set_txstate(ssi, SENDING);
600 spin_unlock_bh(&ssi->lock);
643 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
652 del_timer(&ssi->rx_wd); /* FIXME: Revisit */
660 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
667 switch (ssi->main_state) {
674 spin_lock_bh(&ssi->lock);
675 ssi->main_state = HANDSHAKE;
676 spin_unlock_bh(&ssi->lock);
678 if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
681 spin_lock_bh(&ssi->lock);
683 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
684 spin_unlock_bh(&ssi->lock);
688 msg = ssip_claim_cmd(ssi);
694 dev_dbg(&cl->device, "Wrong state M(%d)\n", ssi->main_state);
701 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
706 spin_lock_bh(&ssi->lock);
707 if (ssi->main_state != ACTIVE)
709 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
712 ssi->main_state);
713 spin_unlock_bh(&ssi->lock);
718 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
721 spin_lock_bh(&ssi->lock);
722 if (ssi->main_state != HANDSHAKE) {
724 ssi->main_state);
725 spin_unlock_bh(&ssi->lock);
728 spin_unlock_bh(&ssi->lock);
730 if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
733 spin_lock_bh(&ssi->lock);
734 ssi->main_state = ACTIVE;
735 del_timer(&ssi->tx_wd); /* Stop boot handshake timer */
736 spin_unlock_bh(&ssi->lock);
745 netif_wake_queue(ssi->netdev);
746 netif_carrier_on(ssi->netdev);
751 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
753 spin_lock_bh(&ssi->lock);
754 if (unlikely(ssi->main_state != ACTIVE)) {
756 ssi->send_state, ssi->main_state);
757 spin_unlock_bh(&ssi->lock);
760 if (ssi->send_state != WAIT4READY) {
762 spin_unlock_bh(&ssi->lock);
765 ssip_set_txstate(ssi, SEND_READY);
766 spin_unlock_bh(&ssi->lock);
772 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
778 spin_lock_bh(&ssi->lock);
779 if (unlikely(ssi->main_state != ACTIVE)) {
781 ssi->send_state, ssi->main_state);
782 spin_unlock_bh(&ssi->lock);
785 ssip_set_rxstate(ssi, RECEIVING);
786 if (unlikely(SSIP_MSG_ID(cmd) != ssi->rxid)) {
788 SSIP_MSG_ID(cmd), ssi->rxid);
789 spin_unlock_bh(&ssi->lock);
792 ssi->rxid++;
793 spin_unlock_bh(&ssi->lock);
794 skb = netdev_alloc_skb(ssi->netdev, len * 4);
799 skb->dev = ssi->netdev;
801 msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC);
858 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
861 spin_lock_bh(&ssi->lock);
862 if (list_empty(&ssi->txqueue)) {
863 if (atomic_read(&ssi->tx_usecnt)) {
864 ssip_set_txstate(ssi, SEND_READY);
866 ssip_set_txstate(ssi, SEND_IDLE);
869 spin_unlock_bh(&ssi->lock);
871 spin_unlock_bh(&ssi->lock);
874 netif_wake_queue(ssi->netdev);
880 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
888 spin_lock_bh(&ssi->lock);
889 if (list_empty(&ssi->txqueue)) {
890 ssip_set_txstate(ssi, SENDING_SWBREAK);
891 spin_unlock_bh(&ssi->lock);
892 cmsg = ssip_claim_cmd(ssi);
898 spin_unlock_bh(&ssi->lock);
922 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
939 if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
942 spin_lock_bh(&ssi->lock);
943 ssi->main_state = HANDSHAKE;
944 spin_unlock_bh(&ssi->lock);
964 struct ssi_protocol *ssi =
966 struct hsi_client *cl = ssi->cl;
974 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
994 msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC);
1001 spin_lock_bh(&ssi->lock);
1002 if (unlikely(ssi->main_state != ACTIVE)) {
1003 spin_unlock_bh(&ssi->lock);
1007 list_add_tail(&msg->link, &ssi->txqueue);
1008 ssi->txqueue_len++;
1009 if (dev->tx_queue_len < ssi->txqueue_len) {
1010 dev_info(&cl->device, "TX queue full %d\n", ssi->txqueue_len);
1013 if (ssi->send_state == SEND_IDLE) {
1014 ssip_set_txstate(ssi, WAIT4READY);
1015 spin_unlock_bh(&ssi->lock);
1016 dev_dbg(&cl->device, "Start TX qlen %d\n", ssi->txqueue_len);
1018 } else if (ssi->send_state == SEND_READY) {
1021 ssi->txqueue_len);
1022 spin_unlock_bh(&ssi->lock);
1023 schedule_work(&ssi->work);
1025 spin_unlock_bh(&ssi->lock);
1044 struct ssi_protocol *ssi = hsi_client_drvdata(master);
1045 dev_err(&ssi->cl->device, "CMT reset detected!\n");
1046 ssip_error(ssi->cl);
1076 struct ssi_protocol *ssi;
1079 ssi = kzalloc(sizeof(*ssi), GFP_KERNEL);
1080 if (!ssi)
1083 spin_lock_init(&ssi->lock);
1084 timer_setup(&ssi->rx_wd, ssip_rx_wd, TIMER_DEFERRABLE);
1085 timer_setup(&ssi->tx_wd, ssip_tx_wd, TIMER_DEFERRABLE);
1086 timer_setup(&ssi->keep_alive, ssip_keep_alive, 0);
1087 INIT_LIST_HEAD(&ssi->txqueue);
1088 INIT_LIST_HEAD(&ssi->cmdqueue);
1089 atomic_set(&ssi->tx_usecnt, 0);
1090 hsi_client_set_drvdata(cl, ssi);
1091 ssi->cl = cl;
1092 INIT_WORK(&ssi->work, ssip_xmit_work);
1094 ssi->channel_id_cmd = hsi_get_channel_id_by_name(cl, "mcsaab-control");
1095 if (ssi->channel_id_cmd < 0) {
1096 err = ssi->channel_id_cmd;
1101 ssi->channel_id_data = hsi_get_channel_id_by_name(cl, "mcsaab-data");
1102 if (ssi->channel_id_data < 0) {
1103 err = ssi->channel_id_data;
1108 err = ssip_alloc_cmds(ssi);
1114 ssi->netdev = alloc_netdev(0, ifname, NET_NAME_UNKNOWN, ssip_pn_setup);
1115 if (!ssi->netdev) {
1122 ssi->netdev->min_mtu = PHONET_MIN_MTU;
1123 ssi->netdev->max_mtu = SSIP_MAX_MTU;
1125 SET_NETDEV_DEV(ssi->netdev, dev);
1126 netif_carrier_off(ssi->netdev);
1127 err = register_netdev(ssi->netdev);
1133 list_add(&ssi->link, &ssip_list);
1136 ssi->channel_id_cmd, ssi->channel_id_data);
1140 free_netdev(ssi->netdev);
1142 ssip_free_cmds(ssi);
1144 kfree(ssi);
1152 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
1154 list_del(&ssi->link);
1155 unregister_netdev(ssi->netdev);
1156 ssip_free_cmds(ssi);
1158 kfree(ssi);
1165 .name = "ssi-protocol",
1187 MODULE_ALIAS("hsi:ssi-protocol");