hsi/clients/ssi_protocol.c

5  * Implementation of the SSI McSAAB improved protocol.
45  * SSI protocol command definitions
101  * struct ssi_protocol - SSI protocol (McSAAB) data
111  * @keep_alive: Workaround for SSI HW bug
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 		timer_delete(&ssi->rx_wd);
285 		if (ssi->send_state == SEND_IDLE)
286 			timer_delete(&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 		timer_delete(&ssi->tx_wd);
310 		if (ssi->recv_state == RECV_IDLE)
311 			timer_delete(&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 	timer_delete(&ssi->rx_wd);
402 	timer_delete(&ssi->tx_wd);
403 	timer_delete(&ssi->keep_alive);
404 	cancel_work_sync(&ssi->work);
405 	ssi->main_state = 0;
406 	ssi->send_state = 0;
407 	ssi->recv_state = 0;
408 	ssi->flags = 0;
409 	ssi->rxid = 0;
410 	ssi->txid = 0;
411 	list_for_each_safe(head, tmp, &ssi->txqueue) {
417 	ssi->txqueue_len = 0;
418 	spin_unlock_bh(&ssi->lock);
423 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
426 	spin_lock_bh(&ssi->lock);
427 	dev_err(&cl->device, "Main state: %d\n", ssi->main_state);
428 	dev_err(&cl->device, "Recv state: %d\n", ssi->recv_state);
429 	dev_err(&cl->device, "Send state: %d\n", ssi->send_state);
430 	dev_err(&cl->device, "CMT %s\n", (ssi->main_state == ACTIVE) ?
433 				test_bit(SSIP_WAKETEST_FLAG, &ssi->flags));
434 	dev_err(&cl->device, "Data RX id: %d\n", ssi->rxid);
435 	dev_err(&cl->device, "Data TX id: %d\n", ssi->txid);
437 	list_for_each_entry(msg, &ssi->txqueue, link)
439 	spin_unlock_bh(&ssi->lock);
444 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
449 	msg = ssip_claim_cmd(ssi);
456 	struct ssi_protocol *ssi = timer_container_of(ssi, t, keep_alive);
457 	struct hsi_client *cl = ssi->cl;
460 		ssi->main_state, ssi->recv_state, ssi->send_state);
462 	spin_lock(&ssi->lock);
463 	if (ssi->recv_state == RECV_IDLE)
464 		switch (ssi->send_state) {
466 			if (atomic_read(&ssi->tx_usecnt) == 0)
474 			spin_unlock(&ssi->lock);
477 	mod_timer(&ssi->keep_alive, jiffies + msecs_to_jiffies(SSIP_KATOUT));
478 	spin_unlock(&ssi->lock);
483 	struct ssi_protocol *ssi = timer_container_of(ssi, t, rx_wd);
484 	struct hsi_client *cl = ssi->cl;
492 	struct ssi_protocol *ssi = timer_container_of(ssi, t, tx_wd);
493 	struct hsi_client *cl = ssi->cl;
501 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
505 	msg = ssip_claim_cmd(ssi);
510 	msg = ssip_claim_cmd(ssi);
517 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
520 	dev_dbg(&cl->device, "RX start M(%d) R(%d)\n", ssi->main_state,
521 						ssi->recv_state);
522 	spin_lock_bh(&ssi->lock);
527 	if ((ssi->main_state != ACTIVE) || (ssi->recv_state == RECV_READY)) {
528 		spin_unlock_bh(&ssi->lock);
531 	ssip_set_rxstate(ssi, RECV_READY);
532 	spin_unlock_bh(&ssi->lock);
534 	msg = ssip_claim_cmd(ssi);
543 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
545 	dev_dbg(&cl->device, "RX stop M(%d)\n", ssi->main_state);
546 	spin_lock_bh(&ssi->lock);
547 	if (likely(ssi->main_state == ACTIVE))
548 		ssip_set_rxstate(ssi, RECV_IDLE);
549 	spin_unlock_bh(&ssi->lock);
561 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
566 	spin_lock_bh(&ssi->lock);
567 	ssip_set_txstate(ssi, SENDING);
568 	spin_unlock_bh(&ssi->lock);
574 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
578 	spin_lock_bh(&ssi->lock);
579 	if (list_empty(&ssi->txqueue)) {
580 		spin_unlock_bh(&ssi->lock);
583 	dmsg = list_first_entry(&ssi->txqueue, struct hsi_msg, link);
585 	ssi->txqueue_len--;
586 	spin_unlock_bh(&ssi->lock);
588 	msg = ssip_claim_cmd(ssi);
594 	spin_lock_bh(&ssi->lock);
596 								ssi->txid));
597 	ssi->txid++;
598 	ssip_set_txstate(ssi, SENDING);
599 	spin_unlock_bh(&ssi->lock);
642 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
651 	timer_delete(&ssi->rx_wd); /* FIXME: Revisit */
659 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
666 	switch (ssi->main_state) {
673 		spin_lock_bh(&ssi->lock);
674 		ssi->main_state = HANDSHAKE;
675 		spin_unlock_bh(&ssi->lock);
677 		if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
680 		spin_lock_bh(&ssi->lock);
682 		mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
683 		spin_unlock_bh(&ssi->lock);
687 		msg = ssip_claim_cmd(ssi);
693 		dev_dbg(&cl->device, "Wrong state M(%d)\n", ssi->main_state);
700 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
705 	spin_lock_bh(&ssi->lock);
706 	if (ssi->main_state != ACTIVE)
708 		mod_timer(&ssi->tx_wd, jiffies + msecs_to_jiffies(SSIP_WDTOUT));
711 							ssi->main_state);
712 	spin_unlock_bh(&ssi->lock);
717 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
720 	spin_lock_bh(&ssi->lock);
721 	if (ssi->main_state != HANDSHAKE) {
723 							ssi->main_state);
724 		spin_unlock_bh(&ssi->lock);
727 	spin_unlock_bh(&ssi->lock);
729 	if (test_and_clear_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
732 	spin_lock_bh(&ssi->lock);
733 	ssi->main_state = ACTIVE;
734 	timer_delete(&ssi->tx_wd); /* Stop boot handshake timer */
735 	spin_unlock_bh(&ssi->lock);
744 	netif_wake_queue(ssi->netdev);
745 	netif_carrier_on(ssi->netdev);
750 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
752 	spin_lock_bh(&ssi->lock);
753 	if (unlikely(ssi->main_state != ACTIVE)) {
755 					ssi->send_state, ssi->main_state);
756 		spin_unlock_bh(&ssi->lock);
759 	if (ssi->send_state != WAIT4READY) {
761 		spin_unlock_bh(&ssi->lock);
764 	ssip_set_txstate(ssi, SEND_READY);
765 	spin_unlock_bh(&ssi->lock);
771 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
777 	spin_lock_bh(&ssi->lock);
778 	if (unlikely(ssi->main_state != ACTIVE)) {
780 					ssi->send_state, ssi->main_state);
781 		spin_unlock_bh(&ssi->lock);
784 	ssip_set_rxstate(ssi, RECEIVING);
785 	if (unlikely(SSIP_MSG_ID(cmd) != ssi->rxid)) {
787 					SSIP_MSG_ID(cmd), ssi->rxid);
788 		spin_unlock_bh(&ssi->lock);
791 	ssi->rxid++;
792 	spin_unlock_bh(&ssi->lock);
793 	skb = netdev_alloc_skb(ssi->netdev, len * 4);
799 	msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC);
856 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
859 	spin_lock_bh(&ssi->lock);
860 	if (list_empty(&ssi->txqueue)) {
861 		if (atomic_read(&ssi->tx_usecnt)) {
862 			ssip_set_txstate(ssi, SEND_READY);
864 			ssip_set_txstate(ssi, SEND_IDLE);
867 		spin_unlock_bh(&ssi->lock);
869 		spin_unlock_bh(&ssi->lock);
872 	netif_wake_queue(ssi->netdev);
878 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
886 	spin_lock_bh(&ssi->lock);
887 	if (list_empty(&ssi->txqueue)) {
888 		ssip_set_txstate(ssi, SENDING_SWBREAK);
889 		spin_unlock_bh(&ssi->lock);
890 		cmsg = ssip_claim_cmd(ssi);
896 		spin_unlock_bh(&ssi->lock);
920 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
925 		dev_err(&cl->device, "SSI port already claimed\n");
935 	dev_dbg(&cl->device, "Configuring SSI port\n");
938 	if (!test_and_set_bit(SSIP_WAKETEST_FLAG, &ssi->flags))
941 	spin_lock_bh(&ssi->lock);
942 	ssi->main_state = HANDSHAKE;
943 	spin_unlock_bh(&ssi->lock);
963 	struct ssi_protocol *ssi =
965 	struct hsi_client *cl = ssi->cl;
973 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
984 	 * Modem sends Phonet messages over SSI with its own endianness.
993 	msg = ssip_alloc_data(ssi, skb, GFP_ATOMIC);
1000 	spin_lock_bh(&ssi->lock);
1001 	if (unlikely(ssi->main_state != ACTIVE)) {
1002 		spin_unlock_bh(&ssi->lock);
1006 	list_add_tail(&msg->link, &ssi->txqueue);
1007 	ssi->txqueue_len++;
1008 	if (dev->tx_queue_len < ssi->txqueue_len) {
1009 		dev_info(&cl->device, "TX queue full %d\n", ssi->txqueue_len);
1012 	if (ssi->send_state == SEND_IDLE) {
1013 		ssip_set_txstate(ssi, WAIT4READY);
1014 		spin_unlock_bh(&ssi->lock);
1015 		dev_dbg(&cl->device, "Start TX qlen %d\n", ssi->txqueue_len);
1017 	} else if (ssi->send_state == SEND_READY) {
1020 							ssi->txqueue_len);
1021 		spin_unlock_bh(&ssi->lock);
1022 		schedule_work(&ssi->work);
1024 		spin_unlock_bh(&ssi->lock);
1043 	struct ssi_protocol *ssi = hsi_client_drvdata(master);
1044 	dev_err(&ssi->cl->device, "CMT reset detected!\n");
1045 	ssip_error(ssi->cl);
1077 	struct ssi_protocol *ssi;
1080 	ssi = kzalloc(sizeof(*ssi), GFP_KERNEL);
1081 	if (!ssi)
1084 	spin_lock_init(&ssi->lock);
1085 	timer_setup(&ssi->rx_wd, ssip_rx_wd, TIMER_DEFERRABLE);
1086 	timer_setup(&ssi->tx_wd, ssip_tx_wd, TIMER_DEFERRABLE);
1087 	timer_setup(&ssi->keep_alive, ssip_keep_alive, 0);
1088 	INIT_LIST_HEAD(&ssi->txqueue);
1089 	INIT_LIST_HEAD(&ssi->cmdqueue);
1090 	atomic_set(&ssi->tx_usecnt, 0);
1091 	hsi_client_set_drvdata(cl, ssi);
1092 	ssi->cl = cl;
1093 	INIT_WORK(&ssi->work, ssip_xmit_work);
1095 	ssi->channel_id_cmd = hsi_get_channel_id_by_name(cl, "mcsaab-control");
1096 	if (ssi->channel_id_cmd < 0) {
1097 		err = ssi->channel_id_cmd;
1102 	ssi->channel_id_data = hsi_get_channel_id_by_name(cl, "mcsaab-data");
1103 	if (ssi->channel_id_data < 0) {
1104 		err = ssi->channel_id_data;
1109 	err = ssip_alloc_cmds(ssi);
1115 	ssi->netdev = alloc_netdev(0, ifname, NET_NAME_UNKNOWN, ssip_pn_setup);
1116 	if (!ssi->netdev) {
1123 	ssi->netdev->min_mtu = PHONET_MIN_MTU;
1124 	ssi->netdev->max_mtu = SSIP_MAX_MTU;
1126 	SET_NETDEV_DEV(ssi->netdev, dev);
1127 	netif_carrier_off(ssi->netdev);
1128 	err = register_netdev(ssi->netdev);
1134 	list_add(&ssi->link, &ssip_list);
1137 		ssi->channel_id_cmd, ssi->channel_id_data);
1141 	free_netdev(ssi->netdev);
1143 	ssip_free_cmds(ssi);
1145 	kfree(ssi);
1153 	struct ssi_protocol *ssi = hsi_client_drvdata(cl);
1155 	list_del(&ssi->link);
1156 	unregister_netdev(ssi->netdev);
1157 	ssip_free_cmds(ssi);
1159 	kfree(ssi);
1166 		.name	= "ssi-protocol",
1175 	pr_info("SSI protocol aka McSAAB added\n");
1184 	pr_info("SSI protocol driver removed\n");
1188 MODULE_ALIAS("hsi:ssi-protocol");
1191 MODULE_DESCRIPTION("SSI protocol improved aka McSAAB");