drivers/mailbox/arm_mhuv2.c

207 	int (*rx_startup)(struct mhuv2 *mhu, struct mbox_chan *chan);
208 	void (*rx_shutdown)(struct mhuv2 *mhu, struct mbox_chan *chan);
209 	void *(*read_data)(struct mhuv2 *mhu, struct mbox_chan *chan);
211 	void (*tx_startup)(struct mhuv2 *mhu, struct mbox_chan *chan);
212 	void (*tx_shutdown)(struct mhuv2 *mhu, struct mbox_chan *chan);
213 	int (*last_tx_done)(struct mhuv2 *mhu, struct mbox_chan *chan);
214 	int (*send_data)(struct mhuv2 *mhu, struct mbox_chan *chan, void *arg);
261 static int mhuv2_doorbell_rx_startup(struct mhuv2 *mhu, struct mbox_chan *chan)
266 		       &mhu->recv->ch_wn[priv->ch_wn_idx].mask_clear);
270 static void mhuv2_doorbell_rx_shutdown(struct mhuv2 *mhu,
276 		       &mhu->recv->ch_wn[priv->ch_wn_idx].mask_set);
279 static void *mhuv2_doorbell_read_data(struct mhuv2 *mhu, struct mbox_chan *chan)
284 		       &mhu->recv->ch_wn[priv->ch_wn_idx].stat_clear);
288 static int mhuv2_doorbell_last_tx_done(struct mhuv2 *mhu,
293 	return !(readl_relaxed(&mhu->send->ch_wn[priv->ch_wn_idx].stat) &
297 static int mhuv2_doorbell_send_data(struct mhuv2 *mhu, struct mbox_chan *chan,
303 	spin_lock_irqsave(&mhu->doorbell_pending_lock, flags);
307 		       &mhu->send->ch_wn[priv->ch_wn_idx].stat_set);
309 	spin_unlock_irqrestore(&mhu->doorbell_pending_lock, flags);
325 static int mhuv2_data_transfer_rx_startup(struct mhuv2 *mhu,
335 	writel_relaxed(0xFFFFFFFF, &mhu->recv->ch_wn[i].mask_clear);
339 static void mhuv2_data_transfer_rx_shutdown(struct mhuv2 *mhu,
345 	writel_relaxed(0xFFFFFFFF, &mhu->recv->ch_wn[i].mask_set);
348 static void *mhuv2_data_transfer_read_data(struct mhuv2 *mhu,
378 		data[windows - 1 - i] = readl_relaxed(&mhu->recv->ch_wn[idx].stat);
379 		writel_relaxed(0xFFFFFFFF, &mhu->recv->ch_wn[idx].stat_clear);
385 static void mhuv2_data_transfer_tx_startup(struct mhuv2 *mhu,
392 	if (mhu->minor) {
393 		writel_relaxed(0x1, &mhu->send->ch_wn[i].int_clr);
394 		writel_relaxed(0x1, &mhu->send->ch_wn[i].int_en);
398 static void mhuv2_data_transfer_tx_shutdown(struct mhuv2 *mhu,
404 	if (mhu->minor)
405 		writel_relaxed(0x0, &mhu->send->ch_wn[i].int_en);
408 static int mhuv2_data_transfer_last_tx_done(struct mhuv2 *mhu,
415 	return !readl_relaxed(&mhu->send->ch_wn[i].stat);
445 static int mhuv2_data_transfer_send_data(struct mhuv2 *mhu,
456 			dev_err(mhu->mbox.dev, "Data aligned at first window can't be zero to guarantee interrupt generation at receiver");
460 		while(!mhuv2_data_transfer_last_tx_done(mhu, chan))
477 			writel_relaxed(word, &mhu->send->ch_wn[priv->ch_wn_idx + windows - 1 - i].stat_set);
500 static struct mbox_chan *get_irq_chan_comb(struct mhuv2 *mhu, u32 __iomem *reg)
502 	struct mbox_chan *chans = mhu->mbox.chans;
513 		for (i = 0; i < mhu->length; i += 2) {
514 			protocol = mhu->protocols[i];
515 			windows = mhu->protocols[i + 1];
540 	struct mhuv2 *mhu = data;
541 	struct device *dev = mhu->mbox.dev;
548 	chan = get_irq_chan_comb(mhu, mhu->send->chcomb_int_st);
557 			writel_relaxed(1, &mhu->send->ch_wn[priv->ch_wn_idx + i].int_clr);
570 	writel_relaxed(1, &mhu->send->ch_wn[priv->ch_wn_idx].int_clr);
578 	spin_lock_irqsave(&mhu->doorbell_pending_lock, flags);
584 	stat = readl_relaxed(&mhu->send->ch_wn[priv->ch_wn_idx].stat);
605 	spin_unlock_irqrestore(&mhu->doorbell_pending_lock, flags);
621 static struct mbox_chan *get_irq_chan_comb_rx(struct mhuv2 *mhu)
627 	chan = get_irq_chan_comb(mhu, mhu->recv->chcomb_int_st);
639 	stat = readl_relaxed(&mhu->recv->ch_wn[priv->ch_wn_idx].stat_masked);
645 static struct mbox_chan *get_irq_chan_stat_rx(struct mhuv2 *mhu)
647 	struct mbox_chan *chans = mhu->mbox.chans;
652 	while (i < mhu->mbox.num_chans) {
654 		stat = readl_relaxed(&mhu->recv->ch_wn[priv->ch_wn_idx].stat_masked);
668 static struct mbox_chan *get_irq_chan_rx(struct mhuv2 *mhu)
670 	if (!mhu->minor)
671 		return get_irq_chan_stat_rx(mhu);
673 	return get_irq_chan_comb_rx(mhu);
678 	struct mhuv2 *mhu = arg;
679 	struct mbox_chan *chan = get_irq_chan_rx(mhu);
680 	struct device *dev = mhu->mbox.dev;
692 	data = priv->ops->read_data(mhu, chan);
713 	struct mhuv2 *mhu = mhu_from_mbox(chan->mbox);
716 	return priv->ops->last_tx_done(mhu, chan);
721 	struct mhuv2 *mhu = mhu_from_mbox(chan->mbox);
724 	if (!priv->ops->last_tx_done(mhu, chan))
727 	return priv->ops->send_data(mhu, chan, data);
732 	struct mhuv2 *mhu = mhu_from_mbox(chan->mbox);
736 		priv->ops->tx_startup(mhu, chan);
742 	struct mhuv2 *mhu = mhu_from_mbox(chan->mbox);
746 		priv->ops->tx_shutdown(mhu, chan);
758 	struct mhuv2 *mhu = mhu_from_mbox(chan->mbox);
761 	return priv->ops->rx_startup(mhu, chan);
766 	struct mhuv2 *mhu = mhu_from_mbox(chan->mbox);
769 	priv->ops->rx_shutdown(mhu, chan);
795 	struct mhuv2 *mhu = mhu_from_mbox(mbox);
807 	for (i = 0; i < mhu->length; i += 2) {
808 		protocol = mhu->protocols[i];
809 		windows = mhu->protocols[i + 1];
836 static int mhuv2_verify_protocol(struct mhuv2 *mhu)
838 	struct device *dev = mhu->mbox.dev;
841 	for (i = 0; i < mhu->length; i += 2) {
842 		protocol = mhu->protocols[i];
843 		windows = mhu->protocols[i + 1];
862 	if (total_windows > mhu->windows) {
864 			total_windows, mhu->windows);
868 	mhu->mbox.num_chans = channels;
872 static int mhuv2_allocate_channels(struct mhuv2 *mhu)
874 	struct mbox_controller *mbox = &mhu->mbox;
886 	for (i = 0; i < mhu->length; i += 2) {
889 		protocol = mhu->protocols[i];
890 		windows = mhu->protocols[i + 1];
920 			if (mhu->frame == SENDER_FRAME && mhu->minor)
921 				writel_relaxed(0x1, &mhu->send->ch_wn[priv->ch_wn_idx].int_en);
931 static int mhuv2_parse_channels(struct mhuv2 *mhu)
933 	struct device *dev = mhu->mbox.dev;
956 	mhu->protocols = protocols;
957 	mhu->length = count;
959 	ret = mhuv2_verify_protocol(mhu);
963 	return mhuv2_allocate_channels(mhu);
966 static int mhuv2_tx_init(struct amba_device *adev, struct mhuv2 *mhu,
969 	struct device *dev = mhu->mbox.dev;
972 	mhu->frame = SENDER_FRAME;
973 	mhu->mbox.ops = &mhuv2_sender_ops;
974 	mhu->send = reg;
976 	mhu->windows = readl_relaxed_bitfield(&mhu->send->mhu_cfg, struct mhu_cfg_t, num_ch);
977 	mhu->minor = readl_relaxed_bitfield(&mhu->send->aidr, struct aidr_t, arch_minor_rev);
979 	spin_lock_init(&mhu->doorbell_pending_lock);
985 	if (mhu->minor && adev->irq[0]) {
988 						IRQF_ONESHOT, "mhuv2-tx", mhu);
993 			mhu->mbox.txdone_irq = true;
994 			mhu->mbox.txdone_poll = false;
995 			mhu->irq = adev->irq[0];
997 			writel_relaxed_bitfield(1, &mhu->send->int_en, struct int_en_t, chcomb);
1000 			for (i = 0; i < mhu->windows; i++)
1001 				writel_relaxed(0x0, &mhu->send->ch_wn[i].int_en);
1007 	mhu->mbox.txdone_irq = false;
1008 	mhu->mbox.txdone_poll = true;
1009 	mhu->mbox.txpoll_period = 1;
1013 	writel_relaxed(0x1, &mhu->send->access_request);
1014 	while (!readl_relaxed(&mhu->send->access_ready))
1020 static int mhuv2_rx_init(struct amba_device *adev, struct mhuv2 *mhu,
1023 	struct device *dev = mhu->mbox.dev;
1026 	mhu->frame = RECEIVER_FRAME;
1027 	mhu->mbox.ops = &mhuv2_receiver_ops;
1028 	mhu->recv = reg;
1030 	mhu->windows = readl_relaxed_bitfield(&mhu->recv->mhu_cfg, struct mhu_cfg_t, num_ch);
1031 	mhu->minor = readl_relaxed_bitfield(&mhu->recv->aidr, struct aidr_t, arch_minor_rev);
1033 	mhu->irq = adev->irq[0];
1034 	if (!mhu->irq) {
1039 	ret = devm_request_threaded_irq(dev, mhu->irq, NULL,
1041 					"mhuv2-rx", mhu);
1048 	for (i = 0; i < mhu->windows; i++)
1049 		writel_relaxed(0xFFFFFFFF, &mhu->recv->ch_wn[i].mask_set);
1051 	if (mhu->minor)
1052 		writel_relaxed_bitfield(1, &mhu->recv->int_en, struct int_en_t, chcomb);
1061 	struct mhuv2 *mhu;
1069 	mhu = devm_kzalloc(dev, sizeof(*mhu), GFP_KERNEL);
1070 	if (!mhu)
1073 	mhu->mbox.dev = dev;
1074 	mhu->mbox.of_xlate = mhuv2_mbox_of_xlate;
1077 		ret = mhuv2_tx_init(adev, mhu, reg);
1079 		ret = mhuv2_rx_init(adev, mhu, reg);
1087 	BUG_ON(!mhu->windows);
1089 	ret = mhuv2_parse_channels(mhu);
1093 	amba_set_drvdata(adev, mhu);
1095 	ret = devm_mbox_controller_register(dev, &mhu->mbox);
1104 	struct mhuv2 *mhu = amba_get_drvdata(adev);
1106 	if (mhu->frame == SENDER_FRAME)
1107 		writel_relaxed(0x0, &mhu->send->access_request);