Lines Matching defs:ssi
146 /* List of ssi protocol instances */
199 static struct hsi_msg *ssip_alloc_data(struct ssi_protocol *ssi,
209 msg->channel = ssi->channel_id_data;
217 struct ssi_protocol *ssi = hsi_client_drvdata(msg->cl);
220 spin_lock_bh(&ssi->lock);
221 list_add_tail(&msg->link, &ssi->cmdqueue);
222 spin_unlock_bh(&ssi->lock);
225 static struct hsi_msg *ssip_claim_cmd(struct ssi_protocol *ssi)
229 BUG_ON(list_empty(&ssi->cmdqueue));
231 spin_lock_bh(&ssi->lock);
232 msg = list_first_entry(&ssi->cmdqueue, struct hsi_msg, link);
234 spin_unlock_bh(&ssi->lock);
240 static void ssip_free_cmds(struct ssi_protocol *ssi)
244 list_for_each_entry_safe(msg, tmp, &ssi->cmdqueue, link) {
252 static int ssip_alloc_cmds(struct ssi_protocol *ssi)
268 msg->channel = ssi->channel_id_cmd;
269 list_add_tail(&msg->link, &ssi->cmdqueue);
274 ssip_free_cmds(ssi);
279 static void ssip_set_rxstate(struct ssi_protocol *ssi, unsigned int state)
281 ssi->recv_state = state;
284 del_timer(&ssi->rx_wd);
285 if (ssi->send_state == SEND_IDLE)
286 del_timer(&ssi->keep_alive);
290 if (atomic_read(&ssi->tx_usecnt))
294 mod_timer(&ssi->keep_alive, jiffies +
296 mod_timer(&ssi->rx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
303 static void ssip_set_txstate(struct ssi_protocol *ssi, unsigned int state)
305 ssi->send_state = state;
309 del_timer(&ssi->tx_wd);
310 if (ssi->recv_state == RECV_IDLE)
311 del_timer(&ssi->keep_alive);
316 mod_timer(&ssi->keep_alive,
318 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
328 struct ssi_protocol *ssi;
330 list_for_each_entry(ssi, &ssip_list, link)
331 if (slave->device.parent == ssi->cl->device.parent) {
332 master = ssi->cl;
342 struct ssi_protocol *ssi = hsi_client_drvdata(master);
344 dev_dbg(&master->device, "start TX %d\n", atomic_read(&ssi->tx_usecnt));
345 spin_lock_bh(&ssi->lock);
346 if (ssi->send_state == SEND_IDLE) {
347 ssip_set_txstate(ssi, WAIT4READY);
350 spin_unlock_bh(&ssi->lock);
351 atomic_inc(&ssi->tx_usecnt);
359 struct ssi_protocol *ssi = hsi_client_drvdata(master);
361 WARN_ON_ONCE(atomic_read(&ssi->tx_usecnt) == 0);
363 if (atomic_dec_and_test(&ssi->tx_usecnt)) {
364 spin_lock_bh(&ssi->lock);
365 if ((ssi->send_state == SEND_READY) ||
366 (ssi->send_state == WAIT4READY)) {
367 ssip_set_txstate(ssi, SEND_IDLE);
370 spin_unlock_bh(&ssi->lock);
372 dev_dbg(&master->device, "stop TX %d\n", atomic_read(&ssi->tx_usecnt));
380 struct ssi_protocol *ssi = hsi_client_drvdata(master);
381 return netif_running(ssi->netdev);
387 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
391 if (netif_running(ssi->netdev))
392 netif_carrier_off(ssi->netdev);
394 spin_lock_bh(&ssi->lock);
395 if (ssi->send_state != SEND_IDLE)
397 spin_unlock_bh(&ssi->lock);
398 if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
400 spin_lock_bh(&ssi->lock);
401 del_timer(&ssi->rx_wd);
402 del_timer(&ssi->tx_wd);
403 del_timer(&ssi->keep_alive);
404 ssi->main_state = 0;
405 ssi->send_state = 0;
406 ssi->recv_state = 0;
407 ssi->flags = 0;
408 ssi->rxid = 0;
409 ssi->txid = 0;
410 list_for_each_safe(head, tmp, &ssi->txqueue) {
416 ssi->txqueue_len = 0;
417 spin_unlock_bh(&ssi->lock);
422 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
425 spin_lock_bh(&ssi->lock);
426 dev_err(&cl->device, "Main state: %d\n", ssi->main_state);
427 dev_err(&cl->device, "Recv state: %d\n", ssi->recv_state);
428 dev_err(&cl->device, "Send state: %d\n", ssi->send_state);
429 dev_err(&cl->device, "CMT %s\n", (ssi->main_state == ACTIVE) ?
432 test_bit(SSIP_WAKETEST_FLAG, &ssi->flags));
433 dev_err(&cl->device, "Data RX id: %d\n", ssi->rxid);
434 dev_err(&cl->device, "Data TX id: %d\n", ssi->txid);
436 list_for_each_entry(msg, &ssi->txqueue, link)
438 spin_unlock_bh(&ssi->lock);
443 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
448 msg = ssip_claim_cmd(ssi);
455 struct ssi_protocol *ssi = from_timer(ssi, t, keep_alive);
456 struct hsi_client *cl = ssi->cl;
459 ssi->main_state, ssi->recv_state, ssi->send_state);
461 spin_lock(&ssi->lock);
462 if (ssi->recv_state == RECV_IDLE)
463 switch (ssi->send_state) {
465 if (atomic_read(&ssi->tx_usecnt) == 0)
473 spin_unlock(&ssi->lock);
476 mod_timer(&ssi->keep_alive, jiffies + msecs_to_jiffies(SSIP_KATOUT));
477 spin_unlock(&ssi->lock);
482 struct ssi_protocol *ssi = from_timer(ssi, t, rx_wd);
483 struct hsi_client *cl = ssi->cl;
491 struct ssi_protocol *ssi = from_timer(ssi, t, tx_wd);
492 struct hsi_client *cl = ssi->cl;
500 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
504 msg = ssip_claim_cmd(ssi);
509 msg = ssip_claim_cmd(ssi);
516 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
519 dev_dbg(&cl->device, "RX start M(%d) R(%d)\n", ssi->main_state,
520 ssi->recv_state);
521 spin_lock_bh(&ssi->lock);
526 if ((ssi->main_state != ACTIVE) || (ssi->recv_state == RECV_READY)) {
527 spin_unlock_bh(&ssi->lock);
530 ssip_set_rxstate(ssi, RECV_READY);
531 spin_unlock_bh(&ssi->lock);
533 msg = ssip_claim_cmd(ssi);
542 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
544 dev_dbg(&cl->device, "RX stop M(%d)\n", ssi->main_state);
545 spin_lock_bh(&ssi->lock);
546 if (likely(ssi->main_state == ACTIVE))
547 ssip_set_rxstate(ssi, RECV_IDLE);
548 spin_unlock_bh(&ssi->lock);
560 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
565 spin_lock_bh(&ssi->lock);
566 ssip_set_txstate(ssi, SENDING);
567 spin_unlock_bh(&ssi->lock);
573 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
577 spin_lock_bh(&ssi->lock);
578 if (list_empty(&ssi->txqueue)) {
579 spin_unlock_bh(&ssi->lock);
582 dmsg = list_first_entry(&ssi->txqueue, struct hsi_msg, link);
584 ssi->txqueue_len--;
585 spin_unlock_bh(&ssi->lock);
587 msg = ssip_claim_cmd(ssi);
593 spin_lock_bh(&ssi->lock);
595 ssi->txid));
596 ssi->txid++;
597 ssip_set_txstate(ssi, SENDING);
598 spin_unlock_bh(&ssi->lock);
641 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
650 del_timer(&ssi->rx_wd); /* FIXME: Revisit */
658 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
665 switch (ssi->main_state) {
672 spin_lock_bh(&ssi->lock);
673 ssi->main_state = HANDSHAKE;
674 spin_unlock_bh(&ssi->lock);
676 if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
679 spin_lock_bh(&ssi->lock);
681 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
682 spin_unlock_bh(&ssi->lock);
686 msg = ssip_claim_cmd(ssi);
692 dev_dbg(&cl->device, "Wrong state M(%d)\n", ssi->main_state);
699 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
704 spin_lock_bh(&ssi->lock);
705 if (ssi->main_state != ACTIVE)
707 mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
710 ssi->main_state);
711 spin_unlock_bh(&ssi->lock);
716 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
719 spin_lock_bh(&ssi->lock);
720 if (ssi->main_state != HANDSHAKE) {
722 ssi->main_state);
723 spin_unlock_bh(&ssi->lock);
726 spin_unlock_bh(&ssi->lock);
728 if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
731 spin_lock_bh(&ssi->lock);
732 ssi->main_state = ACTIVE;
733 del_timer(&ssi->tx_wd); /* Stop boot handshake timer */
734 spin_unlock_bh(&ssi->lock);
743 netif_wake_queue(ssi->netdev);
744 netif_carrier_on(ssi->netdev);
749 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
751 spin_lock_bh(&ssi->lock);
752 if (unlikely(ssi->main_state != ACTIVE)) {
754 ssi->send_state, ssi->main_state);
755 spin_unlock_bh(&ssi->lock);
758 if (ssi->send_state != WAIT4READY) {
760 spin_unlock_bh(&ssi->lock);
763 ssip_set_txstate(ssi, SEND_READY);
764 spin_unlock_bh(&ssi->lock);
770 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
776 spin_lock_bh(&ssi->lock);
777 if (unlikely(ssi->main_state != ACTIVE)) {
779 ssi->send_state, ssi->main_state);
780 spin_unlock_bh(&ssi->lock);
783 ssip_set_rxstate(ssi, RECEIVING);
784 if (unlikely(SSIP_MSG_ID(cmd) != ssi->rxid)) {
786 SSIP_MSG_ID(cmd), ssi->rxid);
787 spin_unlock_bh(&ssi->lock);
790 ssi->rxid++;
791 spin_unlock_bh(&ssi->lock);
792 skb = netdev_alloc_skb(ssi->netdev, len * 4);
798 msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC);
855 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
858 spin_lock_bh(&ssi->lock);
859 if (list_empty(&ssi->txqueue)) {
860 if (atomic_read(&ssi->tx_usecnt)) {
861 ssip_set_txstate(ssi, SEND_READY);
863 ssip_set_txstate(ssi, SEND_IDLE);
866 spin_unlock_bh(&ssi->lock);
868 spin_unlock_bh(&ssi->lock);
871 netif_wake_queue(ssi->netdev);
877 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
885 spin_lock_bh(&ssi->lock);
886 if (list_empty(&ssi->txqueue)) {
887 ssip_set_txstate(ssi, SENDING_SWBREAK);
888 spin_unlock_bh(&ssi->lock);
889 cmsg = ssip_claim_cmd(ssi);
895 spin_unlock_bh(&ssi->lock);
919 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
937 if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
940 spin_lock_bh(&ssi->lock);
941 ssi->main_state = HANDSHAKE;
942 spin_unlock_bh(&ssi->lock);
962 struct ssi_protocol *ssi =
964 struct hsi_client *cl = ssi->cl;
972 struct ssi_protocol *ssi = hsi_client_drvdata(cl);
992 msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC);
999 spin_lock_bh(&ssi->lock);
1000 if (unlikely(ssi->main_state != ACTIVE)) {
1001 spin_unlock_bh(&ssi->lock);
1005 list_add_tail(&msg->link, &ssi->txqueue);
1006 ssi->txqueue_len++;
1007 if (dev->tx_queue_len < ssi->txqueue_len) {
1008 dev_info(&cl->device, "TX queue full %d\n", ssi->txqueue_len);
1011 if (ssi->send_state == SEND_IDLE) {
1012 ssip_set_txstate(ssi, WAIT4READY);
1013 spin_unlock_bh(&ssi->lock);
1014 dev_dbg(&cl->device, "Start TX qlen %d\n", ssi->txqueue_len);
1016 } else if (ssi->send_state == SEND_READY) {
1019 ssi->txqueue_len);
1020 spin_unlock_bh(&ssi->lock);
1021 schedule_work(&ssi->work);
1023 spin_unlock_bh(&ssi->lock);
1042 struct ssi_protocol *ssi = hsi_client_drvdata(master);
1043 dev_err(&ssi->cl->device, "CMT reset detected!\n");
1044 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");