1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * bdc_cmd.c - BRCM BDC USB3.0 device controller 4 * 5 * Copyright (C) 2014 Broadcom Corporation 6 * 7 * Author: Ashwini Pahuja 8 */ 9 #include <linux/scatterlist.h> 10 #include <linux/slab.h> 11 12 #include "bdc.h" 13 #include "bdc_cmd.h" 14 #include "bdc_dbg.h" 15 16 /* Issues a cmd to cmd processor and waits for cmd completion */ 17 static int bdc_issue_cmd(struct bdc *bdc, u32 cmd_sc, u32 param0, 18 u32 param1, u32 param2) 19 { 20 u32 timeout = BDC_CMD_TIMEOUT; 21 u32 cmd_status; 22 u32 temp; 23 24 bdc_writel(bdc->regs, BDC_CMDPAR0, param0); 25 bdc_writel(bdc->regs, BDC_CMDPAR1, param1); 26 bdc_writel(bdc->regs, BDC_CMDPAR2, param2); 27 28 /* Issue the cmd */ 29 /* Make sure the cmd params are written before asking HW to exec cmd */ 30 wmb(); 31 bdc_writel(bdc->regs, BDC_CMDSC, cmd_sc | BDC_CMD_CWS | BDC_CMD_SRD); 32 do { 33 temp = bdc_readl(bdc->regs, BDC_CMDSC); 34 dev_dbg_ratelimited(bdc->dev, "cmdsc=%x", temp); 35 cmd_status = BDC_CMD_CST(temp); 36 if (cmd_status != BDC_CMDS_BUSY) { 37 dev_dbg(bdc->dev, 38 "command completed cmd_sts:%x\n", cmd_status); 39 return cmd_status; 40 } 41 udelay(1); 42 } while (timeout--); 43 44 dev_err(bdc->dev, 45 "command operation timedout cmd_status=%d\n", cmd_status); 46 47 return cmd_status; 48 } 49 50 /* Submits cmd and analyze the return value of bdc_issue_cmd */ 51 static int bdc_submit_cmd(struct bdc *bdc, u32 cmd_sc, 52 u32 param0, u32 param1, u32 param2) 53 { 54 u32 temp, cmd_status; 55 int ret; 56 57 temp = bdc_readl(bdc->regs, BDC_CMDSC); 58 dev_dbg(bdc->dev, 59 "%s:CMDSC:%08x cmdsc:%08x param0=%08x param1=%08x param2=%08x\n", 60 __func__, temp, cmd_sc, param0, param1, param2); 61 62 cmd_status = BDC_CMD_CST(temp); 63 if (cmd_status == BDC_CMDS_BUSY) { 64 dev_err(bdc->dev, "command processor busy: %x\n", cmd_status); 65 return -EBUSY; 66 } 67 ret = bdc_issue_cmd(bdc, cmd_sc, param0, param1, param2); 68 switch (ret) { 69 case BDC_CMDS_SUCC: 70 dev_dbg(bdc->dev, "command completed successfully\n"); 71 ret = 0; 72 break; 73 74 case BDC_CMDS_PARA: 75 dev_err(bdc->dev, "command parameter error\n"); 76 ret = -EINVAL; 77 break; 78 79 case BDC_CMDS_STAT: 80 dev_err(bdc->dev, "Invalid device/ep state\n"); 81 ret = -EINVAL; 82 break; 83 84 case BDC_CMDS_FAIL: 85 dev_err(bdc->dev, "Command failed?\n"); 86 ret = -EAGAIN; 87 break; 88 89 case BDC_CMDS_INTL: 90 dev_err(bdc->dev, "BDC Internal error\n"); 91 ret = -ECONNRESET; 92 break; 93 94 case BDC_CMDS_BUSY: 95 dev_err(bdc->dev, 96 "command timedout waited for %dusec\n", 97 BDC_CMD_TIMEOUT); 98 ret = -ECONNRESET; 99 break; 100 default: 101 dev_dbg(bdc->dev, "Unknown command completion code:%x\n", ret); 102 } 103 104 return ret; 105 } 106 107 /* Deconfigure the endpoint from HW */ 108 int bdc_dconfig_ep(struct bdc *bdc, struct bdc_ep *ep) 109 { 110 u32 cmd_sc; 111 112 cmd_sc = BDC_SUB_CMD_DRP_EP|BDC_CMD_EPN(ep->ep_num)|BDC_CMD_EPC; 113 dev_dbg(bdc->dev, "%s ep->ep_num =%d cmd_sc=%x\n", __func__, 114 ep->ep_num, cmd_sc); 115 116 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0); 117 } 118 119 /* Reinitalize the bdlist after config ep command */ 120 static void ep_bd_list_reinit(struct bdc_ep *ep) 121 { 122 struct bdc *bdc = ep->bdc; 123 struct bdc_bd *bd; 124 125 ep->bd_list.eqp_bdi = 0; 126 ep->bd_list.hwd_bdi = 0; 127 bd = ep->bd_list.bd_table_array[0]->start_bd; 128 dev_dbg(bdc->dev, "%s ep:%p bd:%p\n", __func__, ep, bd); 129 memset(bd, 0, sizeof(struct bdc_bd)); 130 bd->offset[3] |= cpu_to_le32(BD_SBF); 131 } 132 133 /* Configure an endpoint */ 134 int bdc_config_ep(struct bdc *bdc, struct bdc_ep *ep) 135 { 136 const struct usb_ss_ep_comp_descriptor *comp_desc; 137 const struct usb_endpoint_descriptor *desc; 138 u32 param0, param1, param2, cmd_sc; 139 u32 mps, mbs, mul, si; 140 int ret; 141 142 desc = ep->desc; 143 comp_desc = ep->comp_desc; 144 cmd_sc = mul = mbs = param2 = 0; 145 param0 = lower_32_bits(ep->bd_list.bd_table_array[0]->dma); 146 param1 = upper_32_bits(ep->bd_list.bd_table_array[0]->dma); 147 cpu_to_le32s(¶m0); 148 cpu_to_le32s(¶m1); 149 150 dev_dbg(bdc->dev, "%s: param0=%08x param1=%08x", 151 __func__, param0, param1); 152 si = desc->bInterval; 153 si = clamp_val(si, 1, 16) - 1; 154 155 mps = usb_endpoint_maxp(desc); 156 mps &= 0x7ff; 157 param2 |= mps << MP_SHIFT; 158 param2 |= usb_endpoint_type(desc) << EPT_SHIFT; 159 160 switch (bdc->gadget.speed) { 161 case USB_SPEED_SUPER: 162 if (usb_endpoint_xfer_int(desc) || 163 usb_endpoint_xfer_isoc(desc)) { 164 param2 |= si; 165 if (usb_endpoint_xfer_isoc(desc) && comp_desc) 166 mul = comp_desc->bmAttributes; 167 168 } 169 param2 |= mul << EPM_SHIFT; 170 if (comp_desc) 171 mbs = comp_desc->bMaxBurst; 172 param2 |= mbs << MB_SHIFT; 173 break; 174 175 case USB_SPEED_HIGH: 176 if (usb_endpoint_xfer_isoc(desc) || 177 usb_endpoint_xfer_int(desc)) { 178 param2 |= si; 179 180 mbs = usb_endpoint_maxp_mult(desc); 181 param2 |= mbs << MB_SHIFT; 182 } 183 break; 184 185 case USB_SPEED_FULL: 186 case USB_SPEED_LOW: 187 /* the hardware accepts SI in 125usec range */ 188 if (usb_endpoint_xfer_isoc(desc)) 189 si += 3; 190 191 /* 192 * FS Int endpoints can have si of 1-255ms but the controller 193 * accepts 2^bInterval*125usec, so convert ms to nearest power 194 * of 2 195 */ 196 if (usb_endpoint_xfer_int(desc)) 197 si = fls(desc->bInterval * 8) - 1; 198 199 param2 |= si; 200 break; 201 default: 202 dev_err(bdc->dev, "UNKNOWN speed ERR\n"); 203 return -EINVAL; 204 } 205 206 cmd_sc |= BDC_CMD_EPC|BDC_CMD_EPN(ep->ep_num)|BDC_SUB_CMD_ADD_EP; 207 208 dev_dbg(bdc->dev, "cmd_sc=%x param2=%08x\n", cmd_sc, param2); 209 ret = bdc_submit_cmd(bdc, cmd_sc, param0, param1, param2); 210 if (ret) { 211 dev_err(bdc->dev, "command failed :%x\n", ret); 212 return ret; 213 } 214 ep_bd_list_reinit(ep); 215 216 return ret; 217 } 218 219 /* 220 * Change the HW deq pointer, if this command is successful, HW will start 221 * fetching the next bd from address dma_addr. 222 */ 223 int bdc_ep_bla(struct bdc *bdc, struct bdc_ep *ep, dma_addr_t dma_addr) 224 { 225 u32 param0, param1; 226 u32 cmd_sc = 0; 227 228 dev_dbg(bdc->dev, "%s: add=%08llx\n", __func__, 229 (unsigned long long)(dma_addr)); 230 param0 = lower_32_bits(dma_addr); 231 param1 = upper_32_bits(dma_addr); 232 cpu_to_le32s(¶m0); 233 cpu_to_le32s(¶m1); 234 235 cmd_sc |= BDC_CMD_EPN(ep->ep_num)|BDC_CMD_BLA; 236 dev_dbg(bdc->dev, "cmd_sc=%x\n", cmd_sc); 237 238 return bdc_submit_cmd(bdc, cmd_sc, param0, param1, 0); 239 } 240 241 /* Set the address sent bu Host in SET_ADD request */ 242 int bdc_address_device(struct bdc *bdc, u32 add) 243 { 244 u32 cmd_sc = 0; 245 u32 param2; 246 247 dev_dbg(bdc->dev, "%s: add=%d\n", __func__, add); 248 cmd_sc |= BDC_SUB_CMD_ADD|BDC_CMD_DVC; 249 param2 = add & 0x7f; 250 251 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, param2); 252 } 253 254 /* Send a Function Wake notification packet using FH command */ 255 int bdc_function_wake_fh(struct bdc *bdc, u8 intf) 256 { 257 u32 param0, param1; 258 u32 cmd_sc = 0; 259 260 param0 = param1 = 0; 261 dev_dbg(bdc->dev, "%s intf=%d\n", __func__, intf); 262 cmd_sc |= BDC_CMD_FH; 263 param0 |= TRA_PACKET; 264 param0 |= (bdc->dev_addr << 25); 265 param1 |= DEV_NOTF_TYPE; 266 param1 |= (FWK_SUBTYPE<<4); 267 dev_dbg(bdc->dev, "param0=%08x param1=%08x\n", param0, param1); 268 269 return bdc_submit_cmd(bdc, cmd_sc, param0, param1, 0); 270 } 271 272 /* Send a Function Wake notification packet using DNC command */ 273 int bdc_function_wake(struct bdc *bdc, u8 intf) 274 { 275 u32 cmd_sc = 0; 276 u32 param2 = 0; 277 278 dev_dbg(bdc->dev, "%s intf=%d", __func__, intf); 279 param2 |= intf; 280 cmd_sc |= BDC_SUB_CMD_FWK|BDC_CMD_DNC; 281 282 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, param2); 283 } 284 285 /* Stall the endpoint */ 286 int bdc_ep_set_stall(struct bdc *bdc, int epnum) 287 { 288 u32 cmd_sc = 0; 289 290 dev_dbg(bdc->dev, "%s epnum=%d\n", __func__, epnum); 291 /* issue a stall endpoint command */ 292 cmd_sc |= BDC_SUB_CMD_EP_STL | BDC_CMD_EPN(epnum) | BDC_CMD_EPO; 293 294 return bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0); 295 } 296 297 /* resets the endpoint, called when host sends CLEAR_FEATURE(HALT) */ 298 int bdc_ep_clear_stall(struct bdc *bdc, int epnum) 299 { 300 struct bdc_ep *ep; 301 u32 cmd_sc = 0; 302 int ret; 303 304 dev_dbg(bdc->dev, "%s: epnum=%d\n", __func__, epnum); 305 ep = bdc->bdc_ep_array[epnum]; 306 /* 307 * If we are not in stalled then stall Endpoint and issue clear stall, 308 * his will reset the seq number for non EP0. 309 */ 310 if (epnum != 1) { 311 /* if the endpoint it not stallled */ 312 if (!(ep->flags & BDC_EP_STALL)) { 313 ret = bdc_ep_set_stall(bdc, epnum); 314 if (ret) 315 return ret; 316 } 317 } 318 /* Preserve the seq number for ep0 only */ 319 if (epnum != 1) 320 cmd_sc |= BDC_CMD_EPO_RST_SN; 321 322 /* issue a reset endpoint command */ 323 cmd_sc |= BDC_SUB_CMD_EP_RST | BDC_CMD_EPN(epnum) | BDC_CMD_EPO; 324 325 ret = bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0); 326 if (ret) { 327 dev_err(bdc->dev, "command failed:%x\n", ret); 328 return ret; 329 } 330 bdc_notify_xfr(bdc, epnum); 331 332 return ret; 333 } 334 335 /* Stop the endpoint, called when software wants to dequeue some request */ 336 int bdc_stop_ep(struct bdc *bdc, int epnum) 337 { 338 struct bdc_ep *ep; 339 u32 cmd_sc = 0; 340 int ret; 341 342 ep = bdc->bdc_ep_array[epnum]; 343 dev_dbg(bdc->dev, "%s: ep:%s ep->flags:%08x\n", __func__, 344 ep->name, ep->flags); 345 /* Endpoint has to be in running state to execute stop ep command */ 346 if (!(ep->flags & BDC_EP_ENABLED)) { 347 dev_err(bdc->dev, "stop endpoint called for disabled ep\n"); 348 return -EINVAL; 349 } 350 if ((ep->flags & BDC_EP_STALL) || (ep->flags & BDC_EP_STOP)) 351 return 0; 352 353 /* issue a stop endpoint command */ 354 cmd_sc |= BDC_CMD_EP0_XSD | BDC_SUB_CMD_EP_STP 355 | BDC_CMD_EPN(epnum) | BDC_CMD_EPO; 356 357 ret = bdc_submit_cmd(bdc, cmd_sc, 0, 0, 0); 358 if (ret) { 359 dev_err(bdc->dev, 360 "stop endpoint command didn't complete:%d ep:%s\n", 361 ret, ep->name); 362 return ret; 363 } 364 ep->flags |= BDC_EP_STOP; 365 bdc_dump_epsts(bdc); 366 367 return ret; 368 } 369