LXR linux/drivers/usb/gadget/udc/bdc/bdc

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