Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 08e469de authored by Chunfeng Yun's avatar Chunfeng Yun Committed by Greg Kroah-Hartman
Browse files

usb: xhci-mtk: supports bandwidth scheduling with multi-TT 



Supports LowSpeed and FullSpeed INT/ISOC bandwidth scheduling
with USB multi-TT

Signed-off-by: default avatarChunfeng Yun <chunfeng.yun@mediatek.com>
Signed-off-by: default avatarMathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 95b516c1

drivers/usb/host/xhci-mtk-sch.c

+237 −10
Original line number Diff line number Diff line
@@ -80,10 +80,98 @@ static u32 get_esit(struct xhci_ep_ctx *ep_ctx) 
	return esit;

}



static struct mu3h_sch_tt *find_tt(struct usb_device *udev)

{

	struct usb_tt *utt = udev->tt;

	struct mu3h_sch_tt *tt, **tt_index, **ptt;

	unsigned int port;

	bool allocated_index = false;



	if (!utt)

		return NULL;	/* Not below a TT */



	/*

	 * Find/create our data structure.

	 * For hubs with a single TT, we get it directly.

	 * For hubs with multiple TTs, there's an extra level of pointers.

	 */

	tt_index = NULL;

	if (utt->multi) {

		tt_index = utt->hcpriv;

		if (!tt_index) {	/* Create the index array */

			tt_index = kcalloc(utt->hub->maxchild,

					sizeof(*tt_index), GFP_KERNEL);

			if (!tt_index)

				return ERR_PTR(-ENOMEM);

			utt->hcpriv = tt_index;

			allocated_index = true;

		}

		port = udev->ttport - 1;

		ptt = &tt_index[port];

	} else {

		port = 0;

		ptt = (struct mu3h_sch_tt **) &utt->hcpriv;

	}



	tt = *ptt;

	if (!tt) {	/* Create the mu3h_sch_tt */

		tt = kzalloc(sizeof(*tt), GFP_KERNEL);

		if (!tt) {

			if (allocated_index) {

				utt->hcpriv = NULL;

				kfree(tt_index);

			}

			return ERR_PTR(-ENOMEM);

		}

		INIT_LIST_HEAD(&tt->ep_list);

		tt->usb_tt = utt;

		tt->tt_port = port;

		*ptt = tt;

	}



	return tt;

}



/* Release the TT above udev, if it's not in use */

static void drop_tt(struct usb_device *udev)

{

	struct usb_tt *utt = udev->tt;

	struct mu3h_sch_tt *tt, **tt_index, **ptt;

	int i, cnt;



	if (!utt || !utt->hcpriv)

		return;		/* Not below a TT, or never allocated */



	cnt = 0;

	if (utt->multi) {

		tt_index = utt->hcpriv;

		ptt = &tt_index[udev->ttport - 1];

		/*  How many entries are left in tt_index? */

		for (i = 0; i < utt->hub->maxchild; ++i)

			cnt += !!tt_index[i];

	} else {

		tt_index = NULL;

		ptt = (struct mu3h_sch_tt **)&utt->hcpriv;

	}



	tt = *ptt;

	if (!tt || !list_empty(&tt->ep_list))

		return;		/* never allocated , or still in use*/



	*ptt = NULL;

	kfree(tt);



	if (cnt == 1) {

		utt->hcpriv = NULL;

		kfree(tt_index);

	}

}



static struct mu3h_sch_ep_info *create_sch_ep(struct usb_device *udev,

	struct usb_host_endpoint *ep, struct xhci_ep_ctx *ep_ctx)

{

	struct mu3h_sch_ep_info *sch_ep;

	struct mu3h_sch_tt *tt = NULL;

	u32 len_bw_budget_table;

	size_t mem_size;
@@ -101,6 +189,15 @@ static struct mu3h_sch_ep_info *create_sch_ep(struct usb_device *udev, 
	if (!sch_ep)

		return ERR_PTR(-ENOMEM);



	if (is_fs_or_ls(udev->speed)) {

		tt = find_tt(udev);

		if (IS_ERR(tt)) {

			kfree(sch_ep);

			return ERR_PTR(-ENOMEM);

		}

	}



	sch_ep->sch_tt = tt;

	sch_ep->ep = ep;



	return sch_ep;
@@ -128,6 +225,8 @@ static void setup_sch_info(struct usb_device *udev, 
		 CTX_TO_MAX_ESIT_PAYLOAD(le32_to_cpu(ep_ctx->tx_info));



	sch_ep->esit = get_esit(ep_ctx);

	sch_ep->ep_type = ep_type;

	sch_ep->maxpkt = maxpkt;

	sch_ep->offset = 0;

	sch_ep->burst_mode = 0;

	sch_ep->repeat = 0;
@@ -197,8 +296,13 @@ static void setup_sch_info(struct usb_device *udev, 
		}

	} else if (is_fs_or_ls(udev->speed)) {

		sch_ep->pkts = 1; /* at most one packet for each microframe */



		/*

		 * num_budget_microframes and cs_count will be updated when

		 * check TT for INT_OUT_EP, ISOC/INT_IN_EP type

		 */

		sch_ep->cs_count = DIV_ROUND_UP(maxpkt, FS_PAYLOAD_MAX);

		sch_ep->num_budget_microframes = sch_ep->cs_count + 2;

		sch_ep->num_budget_microframes = sch_ep->cs_count;

		sch_ep->bw_cost_per_microframe =

			(maxpkt < FS_PAYLOAD_MAX) ? maxpkt : FS_PAYLOAD_MAX;
@@ -212,7 +316,13 @@ static void setup_sch_info(struct usb_device *udev, 
		} else { /* INT_IN_EP or ISOC_IN_EP */

			bwb_table[0] = 0; /* start split */

			bwb_table[1] = 0; /* idle */

			for (i = 2; i < sch_ep->num_budget_microframes; i++)

			/*

			 * due to cs_count will be updated according to cs

			 * position, assign all remainder budget array

			 * elements as @bw_cost_per_microframe, but only first

			 * @num_budget_microframes elements will be used later

			 */

			for (i = 2; i < TT_MICROFRAMES_MAX; i++)

				bwb_table[i] =	sch_ep->bw_cost_per_microframe;

		}

	}
@@ -264,6 +374,96 @@ static void update_bus_bw(struct mu3h_sch_bw_info *sch_bw, 
	}

}



static int check_sch_tt(struct usb_device *udev,

	struct mu3h_sch_ep_info *sch_ep, u32 offset)

{

	struct mu3h_sch_tt *tt = sch_ep->sch_tt;

	u32 extra_cs_count;

	u32 fs_budget_start;

	u32 start_ss, last_ss;

	u32 start_cs, last_cs;

	int i;



	start_ss = offset % 8;

	fs_budget_start = (start_ss + 1) % 8;



	if (sch_ep->ep_type == ISOC_OUT_EP) {

		last_ss = start_ss + sch_ep->cs_count - 1;



		/*

		 * usb_20 spec section11.18:

		 * must never schedule Start-Split in Y6

		 */

		if (!(start_ss == 7 || last_ss < 6))

			return -ERANGE;



		for (i = 0; i < sch_ep->cs_count; i++)

			if (test_bit(offset + i, tt->split_bit_map))

				return -ERANGE;



	} else {

		u32 cs_count = DIV_ROUND_UP(sch_ep->maxpkt, FS_PAYLOAD_MAX);



		/*

		 * usb_20 spec section11.18:

		 * must never schedule Start-Split in Y6

		 */

		if (start_ss == 6)

			return -ERANGE;



		/* one uframe for ss + one uframe for idle */

		start_cs = (start_ss + 2) % 8;

		last_cs = start_cs + cs_count - 1;



		if (last_cs > 7)

			return -ERANGE;



		if (sch_ep->ep_type == ISOC_IN_EP)

			extra_cs_count = (last_cs == 7) ? 1 : 2;

		else /*  ep_type : INTR IN / INTR OUT */

			extra_cs_count = (fs_budget_start == 6) ? 1 : 2;



		cs_count += extra_cs_count;

		if (cs_count > 7)

			cs_count = 7; /* HW limit */



		for (i = 0; i < cs_count + 2; i++) {

			if (test_bit(offset + i, tt->split_bit_map))

				return -ERANGE;

		}



		sch_ep->cs_count = cs_count;

		/* one for ss, the other for idle */

		sch_ep->num_budget_microframes = cs_count + 2;



		/*

		 * if interval=1, maxp >752, num_budge_micoframe is larger

		 * than sch_ep->esit, will overstep boundary

		 */

		if (sch_ep->num_budget_microframes > sch_ep->esit)

			sch_ep->num_budget_microframes = sch_ep->esit;

	}



	return 0;

}



static void update_sch_tt(struct usb_device *udev,

	struct mu3h_sch_ep_info *sch_ep)

{

	struct mu3h_sch_tt *tt = sch_ep->sch_tt;

	u32 base, num_esit;

	int i, j;



	num_esit = XHCI_MTK_MAX_ESIT / sch_ep->esit;

	for (i = 0; i < num_esit; i++) {

		base = sch_ep->offset + i * sch_ep->esit;

		for (j = 0; j < sch_ep->num_budget_microframes; j++)

			set_bit(base + j, tt->split_bit_map);

	}



	list_add_tail(&sch_ep->tt_endpoint, &tt->ep_list);

}



static int check_sch_bw(struct usb_device *udev,

	struct mu3h_sch_bw_info *sch_bw, struct mu3h_sch_ep_info *sch_ep)

{
@@ -273,6 +473,10 @@ static int check_sch_bw(struct usb_device *udev, 
	u32 min_index;

	u32 worst_bw;

	u32 bw_boundary;

	u32 min_num_budget;

	u32 min_cs_count;

	bool tt_offset_ok = false;

	int ret;



	esit = sch_ep->esit;
@@ -282,26 +486,30 @@ static int check_sch_bw(struct usb_device *udev, 
	 */

	min_bw = ~0;

	min_index = 0;

	min_cs_count = sch_ep->cs_count;

	min_num_budget = sch_ep->num_budget_microframes;

	for (offset = 0; offset < esit; offset++) {

		if (is_fs_or_ls(udev->speed)) {

			ret = check_sch_tt(udev, sch_ep, offset);

			if (ret)

				continue;

			else

				tt_offset_ok = true;

		}



		if ((offset + sch_ep->num_budget_microframes) > sch_ep->esit)

			break;



		/*

		 * usb_20 spec section11.18:

		 * must never schedule Start-Split in Y6

		 */

		if (is_fs_or_ls(udev->speed) && (offset % 8 == 6))

			continue;



		worst_bw = get_max_bw(sch_bw, sch_ep, offset);

		if (min_bw > worst_bw) {

			min_bw = worst_bw;

			min_index = offset;

			min_cs_count = sch_ep->cs_count;

			min_num_budget = sch_ep->num_budget_microframes;

		}

		if (min_bw == 0)

			break;

	}

	sch_ep->offset = min_index;



	bw_boundary = (udev->speed == USB_SPEED_SUPER)

				? SS_BW_BOUNDARY : HS_BW_BOUNDARY;
@@ -310,6 +518,18 @@ static int check_sch_bw(struct usb_device *udev, 
	if (min_bw > bw_boundary)

		return -ERANGE;



	sch_ep->offset = min_index;

	sch_ep->cs_count = min_cs_count;

	sch_ep->num_budget_microframes = min_num_budget;



	if (is_fs_or_ls(udev->speed)) {

		/* all offset for tt is not ok*/

		if (!tt_offset_ok)

			return -ERANGE;



		update_sch_tt(udev, sch_ep);

	}



	/* update bus bandwidth info */

	update_bus_bw(sch_bw, sch_ep, 1);
@@ -415,6 +635,9 @@ int xhci_mtk_add_ep_quirk(struct usb_hcd *hcd, struct usb_device *udev, 
	ret = check_sch_bw(udev, sch_bw, sch_ep);

	if (ret) {

		xhci_err(xhci, "Not enough bandwidth!\n");

		if (is_fs_or_ls(udev->speed))

			drop_tt(udev);



		kfree(sch_ep);

		return -ENOSPC;

	}
@@ -466,6 +689,10 @@ void xhci_mtk_drop_ep_quirk(struct usb_hcd *hcd, struct usb_device *udev, 
		if (sch_ep->ep == ep) {

			update_bus_bw(sch_bw, sch_ep, 0);

			list_del(&sch_ep->endpoint);

			if (is_fs_or_ls(udev->speed)) {

				list_del(&sch_ep->tt_endpoint);

				drop_tt(udev);

			}

			kfree(sch_ep);

			break;

		}

drivers/usb/host/xhci-mtk.h

+21 −0
Original line number Diff line number Diff line
@@ -19,6 +19,19 @@ 
 */

#define XHCI_MTK_MAX_ESIT	64



/**

 * @split_bit_map: used to avoid split microframes overlay

 * @ep_list: Endpoints using this TT

 * @usb_tt: usb TT related

 * @tt_port: TT port number

 */

struct mu3h_sch_tt {

	DECLARE_BITMAP(split_bit_map, XHCI_MTK_MAX_ESIT);

	struct list_head ep_list;

	struct usb_tt *usb_tt;

	int tt_port;

};



/**

 * struct mu3h_sch_bw_info: schedule information for bandwidth domain

 *
@@ -41,6 +54,10 @@ struct mu3h_sch_bw_info { 
 *		(@repeat==1) scheduled within the interval

 * @bw_cost_per_microframe: bandwidth cost per microframe

 * @endpoint: linked into bandwidth domain which it belongs to

 * @tt_endpoint: linked into mu3h_sch_tt's list which it belongs to

 * @sch_tt: mu3h_sch_tt linked into

 * @ep_type: endpoint type

 * @maxpkt: max packet size of endpoint

 * @ep: address of usb_host_endpoint struct

 * @offset: which uframe of the interval that transfer should be

 *		scheduled first time within the interval
@@ -64,6 +81,10 @@ struct mu3h_sch_ep_info { 
	u32 num_budget_microframes;

	u32 bw_cost_per_microframe;

	struct list_head endpoint;

	struct list_head tt_endpoint;

	struct mu3h_sch_tt *sch_tt;

	u32 ep_type;

	u32 maxpkt;

	void *ep;

	/*

	 * mtk xHCI scheduling information put into reserved DWs