linux/drivers/usb/renesas_usbhs/mod_host.c
<<
>>
Prefs
   1/*
   2 * Renesas USB driver
   3 *
   4 * Copyright (C) 2011 Renesas Solutions Corp.
   5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6 *
   7 * This program is distributed in the hope that it will be useful,
   8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 * GNU General Public License for more details.
  11 *
  12 * You should have received a copy of the GNU General Public License
  13 * along with this program; if not, write to the Free Software
  14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  15 *
  16 */
  17#include <linux/io.h>
  18#include <linux/list.h>
  19#include <linux/module.h>
  20#include <linux/platform_device.h>
  21#include <linux/slab.h>
  22#include <linux/usb.h>
  23#include <linux/usb/hcd.h>
  24#include "common.h"
  25
  26/*
  27 *** HARDWARE LIMITATION ***
  28 *
  29 * 1) renesas_usbhs has a limited number of controllable devices.
  30 *    it can control only 9 devices in generally.
  31 *      see DEVADDn / DCPMAXP / PIPEMAXP.
  32 *
  33 * 2) renesas_usbhs pipe number is limited.
  34 *    the pipe will be re-used for each devices.
  35 *    so, software should control DATA0/1 sequence of each devices.
  36 */
  37
  38
  39/*
  40 *              image of mod_host
  41 *
  42 * +--------+
  43 * | udev 0 | --> it is used when set address
  44 * +--------+
  45 *
  46 * +--------+                                   pipes are reused for each uep.
  47 * | udev 1 |-+- [uep 0 (dcp) ] --+             pipe will be switched when
  48 * +--------+ |                   |             other device requested
  49 *            +- [uep 1 (bulk)] --|---+            +--------------+
  50 *            |                   +--------------> | pipe0 (dcp)  |
  51 *            +- [uep 2 (bulk)] -@    |            +--------------+
  52 *                                    |            | pipe1 (isoc) |
  53 * +--------+                         |            +--------------+
  54 * | udev 2 |-+- [uep 0 (dcp) ] -@    +----------> | pipe2 (bulk) |
  55 * +--------+ |                                    +--------------+
  56 *            +- [uep 1 (int) ] ----+     +------> | pipe3 (bulk) |
  57 *                                  |     |        +--------------+
  58 * +--------+                       +-----|------> | pipe4 (int)  |
  59 * | udev 3 |-+- [uep 0 (dcp) ] -@        |        +--------------+
  60 * +--------+ |                           |        | ....         |
  61 *            +- [uep 1 (bulk)] -@        |        | ....         |
  62 *            |                           |
  63 *            +- [uep 2 (bulk)]-----------+
  64 *
  65 * @ :  uep requested free pipe, but all have been used.
  66 *      now it is waiting for free pipe
  67 */
  68
  69
  70/*
  71 *              struct
  72 */
  73struct usbhsh_request {
  74        struct urb              *urb;
  75        struct usbhs_pkt        pkt;
  76};
  77
  78struct usbhsh_device {
  79        struct usb_device       *usbv;
  80        struct list_head        ep_list_head; /* list of usbhsh_ep */
  81};
  82
  83struct usbhsh_ep {
  84        struct usbhs_pipe       *pipe;   /* attached pipe */
  85        struct usbhsh_device    *udev;   /* attached udev */
  86        struct usb_host_endpoint *ep;
  87        struct list_head        ep_list; /* list to usbhsh_device */
  88        unsigned int            counter; /* pipe attach counter */
  89};
  90
  91#define USBHSH_DEVICE_MAX       10 /* see DEVADDn / DCPMAXP / PIPEMAXP */
  92#define USBHSH_PORT_MAX          7 /* see DEVADDn :: HUBPORT */
  93struct usbhsh_hpriv {
  94        struct usbhs_mod        mod;
  95        struct usbhs_pipe       *dcp;
  96
  97        struct usbhsh_device    udev[USBHSH_DEVICE_MAX];
  98
  99        u32     port_stat;      /* USB_PORT_STAT_xxx */
 100
 101        struct completion       setup_ack_done;
 102};
 103
 104
 105static const char usbhsh_hcd_name[] = "renesas_usbhs host";
 106
 107/*
 108 *              macro
 109 */
 110#define usbhsh_priv_to_hpriv(priv) \
 111        container_of(usbhs_mod_get(priv, USBHS_HOST), struct usbhsh_hpriv, mod)
 112
 113#define __usbhsh_for_each_udev(start, pos, h, i)        \
 114        for (i = start, pos = (h)->udev + i;            \
 115             i < USBHSH_DEVICE_MAX;                     \
 116             i++, pos = (h)->udev + i)
 117
 118#define usbhsh_for_each_udev(pos, hpriv, i)     \
 119        __usbhsh_for_each_udev(1, pos, hpriv, i)
 120
 121#define usbhsh_for_each_udev_with_dev0(pos, hpriv, i)   \
 122        __usbhsh_for_each_udev(0, pos, hpriv, i)
 123
 124#define usbhsh_hcd_to_hpriv(h)  (struct usbhsh_hpriv *)((h)->hcd_priv)
 125#define usbhsh_hcd_to_dev(h)    ((h)->self.controller)
 126
 127#define usbhsh_hpriv_to_priv(h) ((h)->mod.priv)
 128#define usbhsh_hpriv_to_dcp(h)  ((h)->dcp)
 129#define usbhsh_hpriv_to_hcd(h)  \
 130        container_of((void *)h, struct usb_hcd, hcd_priv)
 131
 132#define usbhsh_ep_to_uep(u)     ((u)->hcpriv)
 133#define usbhsh_uep_to_pipe(u)   ((u)->pipe)
 134#define usbhsh_uep_to_udev(u)   ((u)->udev)
 135#define usbhsh_uep_to_ep(u)     ((u)->ep)
 136
 137#define usbhsh_urb_to_ureq(u)   ((u)->hcpriv)
 138#define usbhsh_urb_to_usbv(u)   ((u)->dev)
 139
 140#define usbhsh_usbv_to_udev(d)  dev_get_drvdata(&(d)->dev)
 141
 142#define usbhsh_udev_to_usbv(h)  ((h)->usbv)
 143#define usbhsh_udev_is_used(h)  usbhsh_udev_to_usbv(h)
 144
 145#define usbhsh_pipe_to_uep(p)   ((p)->mod_private)
 146
 147#define usbhsh_device_parent(d)         (usbhsh_usbv_to_udev((d)->usbv->parent))
 148#define usbhsh_device_hubport(d)        ((d)->usbv->portnum)
 149#define usbhsh_device_number(h, d)      ((int)((d) - (h)->udev))
 150#define usbhsh_device_nth(h, d)         ((h)->udev + d)
 151#define usbhsh_device0(h)               usbhsh_device_nth(h, 0)
 152
 153#define usbhsh_port_stat_init(h)        ((h)->port_stat = 0)
 154#define usbhsh_port_stat_set(h, s)      ((h)->port_stat |= (s))
 155#define usbhsh_port_stat_clear(h, s)    ((h)->port_stat &= ~(s))
 156#define usbhsh_port_stat_get(h)         ((h)->port_stat)
 157
 158#define usbhsh_pkt_to_ureq(p)   \
 159        container_of((void *)p, struct usbhsh_request, pkt)
 160
 161/*
 162 *              req alloc/free
 163 */
 164static struct usbhsh_request *usbhsh_ureq_alloc(struct usbhsh_hpriv *hpriv,
 165                                               struct urb *urb,
 166                                               gfp_t mem_flags)
 167{
 168        struct usbhsh_request *ureq;
 169        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 170        struct device *dev = usbhs_priv_to_dev(priv);
 171
 172        ureq = kzalloc(sizeof(struct usbhsh_request), mem_flags);
 173        if (!ureq) {
 174                dev_err(dev, "ureq alloc fail\n");
 175                return NULL;
 176        }
 177
 178        usbhs_pkt_init(&ureq->pkt);
 179        ureq->urb = urb;
 180        usbhsh_urb_to_ureq(urb) = ureq;
 181
 182        return ureq;
 183}
 184
 185static void usbhsh_ureq_free(struct usbhsh_hpriv *hpriv,
 186                            struct usbhsh_request *ureq)
 187{
 188        usbhsh_urb_to_ureq(ureq->urb) = NULL;
 189        ureq->urb = NULL;
 190
 191        kfree(ureq);
 192}
 193
 194/*
 195 *              status
 196 */
 197static int usbhsh_is_running(struct usbhsh_hpriv *hpriv)
 198{
 199        /*
 200         * we can decide some device is attached or not
 201         * by checking mod.irq_attch
 202         * see
 203         *      usbhsh_irq_attch()
 204         *      usbhsh_irq_dtch()
 205         */
 206        return (hpriv->mod.irq_attch == NULL);
 207}
 208
 209/*
 210 *              pipe control
 211 */
 212static void usbhsh_endpoint_sequence_save(struct usbhsh_hpriv *hpriv,
 213                                          struct urb *urb,
 214                                          struct usbhs_pkt *pkt)
 215{
 216        int len = urb->actual_length;
 217        int maxp = usb_endpoint_maxp(&urb->ep->desc);
 218        int t = 0;
 219
 220        /* DCP is out of sequence control */
 221        if (usb_pipecontrol(urb->pipe))
 222                return;
 223
 224        /*
 225         * renesas_usbhs pipe has a limitation in a number.
 226         * So, driver should re-use the limited pipe for each device/endpoint.
 227         * DATA0/1 sequence should be saved for it.
 228         * see [image of mod_host]
 229         *     [HARDWARE LIMITATION]
 230         */
 231
 232        /*
 233         * next sequence depends on actual_length
 234         *
 235         * ex) actual_length = 1147, maxp = 512
 236         * data0 : 512
 237         * data1 : 512
 238         * data0 : 123
 239         * data1 is the next sequence
 240         */
 241        t = len / maxp;
 242        if (len % maxp)
 243                t++;
 244        if (pkt->zero)
 245                t++;
 246        t %= 2;
 247
 248        if (t)
 249                usb_dotoggle(urb->dev,
 250                             usb_pipeendpoint(urb->pipe),
 251                             usb_pipeout(urb->pipe));
 252}
 253
 254static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv,
 255                                               struct urb *urb);
 256
 257static int usbhsh_pipe_attach(struct usbhsh_hpriv *hpriv,
 258                              struct urb *urb)
 259{
 260        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 261        struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
 262        struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb);
 263        struct usbhs_pipe *pipe;
 264        struct usb_endpoint_descriptor *desc = &urb->ep->desc;
 265        struct device *dev = usbhs_priv_to_dev(priv);
 266        unsigned long flags;
 267        int dir_in_req = !!usb_pipein(urb->pipe);
 268        int is_dcp = usb_endpoint_xfer_control(desc);
 269        int i, dir_in;
 270        int ret = -EBUSY;
 271
 272        /********************  spin lock ********************/
 273        usbhs_lock(priv, flags);
 274
 275        /*
 276         * if uep has been attached to pipe,
 277         * reuse it
 278         */
 279        if (usbhsh_uep_to_pipe(uep)) {
 280                ret = 0;
 281                goto usbhsh_pipe_attach_done;
 282        }
 283
 284        usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 285
 286                /* check pipe type */
 287                if (!usbhs_pipe_type_is(pipe, usb_endpoint_type(desc)))
 288                        continue;
 289
 290                /* check pipe direction if normal pipe */
 291                if (!is_dcp) {
 292                        dir_in = !!usbhs_pipe_is_dir_in(pipe);
 293                        if (0 != (dir_in - dir_in_req))
 294                                continue;
 295                }
 296
 297                /* check pipe is free */
 298                if (usbhsh_pipe_to_uep(pipe))
 299                        continue;
 300
 301                /*
 302                 * attach pipe to uep
 303                 *
 304                 * usbhs_pipe_config_update() should be called after
 305                 * usbhs_set_device_config()
 306                 * see
 307                 *  DCPMAXP/PIPEMAXP
 308                 */
 309                usbhsh_uep_to_pipe(uep)         = pipe;
 310                usbhsh_pipe_to_uep(pipe)        = uep;
 311
 312                usbhs_pipe_config_update(pipe,
 313                                         usbhsh_device_number(hpriv, udev),
 314                                         usb_endpoint_num(desc),
 315                                         usb_endpoint_maxp(desc));
 316
 317                dev_dbg(dev, "%s [%d-%d(%s:%s)]\n", __func__,
 318                        usbhsh_device_number(hpriv, udev),
 319                        usb_endpoint_num(desc),
 320                        usbhs_pipe_name(pipe),
 321                        dir_in_req ? "in" : "out");
 322
 323                ret = 0;
 324                break;
 325        }
 326
 327usbhsh_pipe_attach_done:
 328        if (0 == ret)
 329                uep->counter++;
 330
 331        usbhs_unlock(priv, flags);
 332        /********************  spin unlock ******************/
 333
 334        return ret;
 335}
 336
 337static void usbhsh_pipe_detach(struct usbhsh_hpriv *hpriv,
 338                               struct usbhsh_ep *uep)
 339{
 340        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 341        struct usbhs_pipe *pipe;
 342        struct device *dev = usbhs_priv_to_dev(priv);
 343        unsigned long flags;
 344
 345        if (unlikely(!uep)) {
 346                dev_err(dev, "no uep\n");
 347                return;
 348        }
 349
 350        /********************  spin lock ********************/
 351        usbhs_lock(priv, flags);
 352
 353        pipe = usbhsh_uep_to_pipe(uep);
 354
 355        if (unlikely(!pipe)) {
 356                dev_err(dev, "uep doens't have pipe\n");
 357        } else if (1 == uep->counter--) { /* last user */
 358                struct usb_host_endpoint *ep = usbhsh_uep_to_ep(uep);
 359                struct usbhsh_device *udev = usbhsh_uep_to_udev(uep);
 360
 361                /* detach pipe from uep */
 362                usbhsh_uep_to_pipe(uep)         = NULL;
 363                usbhsh_pipe_to_uep(pipe)        = NULL;
 364
 365                dev_dbg(dev, "%s [%d-%d(%s)]\n", __func__,
 366                        usbhsh_device_number(hpriv, udev),
 367                        usb_endpoint_num(&ep->desc),
 368                        usbhs_pipe_name(pipe));
 369        }
 370
 371        usbhs_unlock(priv, flags);
 372        /********************  spin unlock ******************/
 373}
 374
 375/*
 376 *              endpoint control
 377 */
 378static int usbhsh_endpoint_attach(struct usbhsh_hpriv *hpriv,
 379                                  struct urb *urb,
 380                                  gfp_t mem_flags)
 381{
 382        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 383        struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb);
 384        struct usb_host_endpoint *ep = urb->ep;
 385        struct usbhsh_ep *uep;
 386        struct device *dev = usbhs_priv_to_dev(priv);
 387        struct usb_endpoint_descriptor *desc = &ep->desc;
 388        unsigned long flags;
 389
 390        uep = kzalloc(sizeof(struct usbhsh_ep), mem_flags);
 391        if (!uep) {
 392                dev_err(dev, "usbhsh_ep alloc fail\n");
 393                return -ENOMEM;
 394        }
 395
 396        /********************  spin lock ********************/
 397        usbhs_lock(priv, flags);
 398
 399        /*
 400         * init endpoint
 401         */
 402        uep->counter = 0;
 403        INIT_LIST_HEAD(&uep->ep_list);
 404        list_add_tail(&uep->ep_list, &udev->ep_list_head);
 405
 406        usbhsh_uep_to_udev(uep) = udev;
 407        usbhsh_uep_to_ep(uep)   = ep;
 408        usbhsh_ep_to_uep(ep)    = uep;
 409
 410        usbhs_unlock(priv, flags);
 411        /********************  spin unlock ******************/
 412
 413        dev_dbg(dev, "%s [%d-%d]\n", __func__,
 414                usbhsh_device_number(hpriv, udev),
 415                usb_endpoint_num(desc));
 416
 417        return 0;
 418}
 419
 420static void usbhsh_endpoint_detach(struct usbhsh_hpriv *hpriv,
 421                                   struct usb_host_endpoint *ep)
 422{
 423        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 424        struct device *dev = usbhs_priv_to_dev(priv);
 425        struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep);
 426        unsigned long flags;
 427
 428        if (!uep)
 429                return;
 430
 431        dev_dbg(dev, "%s [%d-%d]\n", __func__,
 432                usbhsh_device_number(hpriv, usbhsh_uep_to_udev(uep)),
 433                usb_endpoint_num(&ep->desc));
 434
 435        if (usbhsh_uep_to_pipe(uep))
 436                usbhsh_pipe_detach(hpriv, uep);
 437
 438        /********************  spin lock ********************/
 439        usbhs_lock(priv, flags);
 440
 441        /* remove this endpoint from udev */
 442        list_del_init(&uep->ep_list);
 443
 444        usbhsh_uep_to_udev(uep) = NULL;
 445        usbhsh_uep_to_ep(uep)   = NULL;
 446        usbhsh_ep_to_uep(ep)    = NULL;
 447
 448        usbhs_unlock(priv, flags);
 449        /********************  spin unlock ******************/
 450
 451        kfree(uep);
 452}
 453
 454static void usbhsh_endpoint_detach_all(struct usbhsh_hpriv *hpriv,
 455                                       struct usbhsh_device *udev)
 456{
 457        struct usbhsh_ep *uep, *next;
 458
 459        list_for_each_entry_safe(uep, next, &udev->ep_list_head, ep_list)
 460                usbhsh_endpoint_detach(hpriv, usbhsh_uep_to_ep(uep));
 461}
 462
 463/*
 464 *              device control
 465 */
 466static int usbhsh_connected_to_rhdev(struct usb_hcd *hcd,
 467                                     struct usbhsh_device *udev)
 468{
 469        struct usb_device *usbv = usbhsh_udev_to_usbv(udev);
 470
 471        return hcd->self.root_hub == usbv->parent;
 472}
 473
 474static int usbhsh_device_has_endpoint(struct usbhsh_device *udev)
 475{
 476        return !list_empty(&udev->ep_list_head);
 477}
 478
 479static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv,
 480                                               struct urb *urb)
 481{
 482        struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
 483        struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv);
 484
 485        /* usbhsh_device_attach() is still not called */
 486        if (!udev)
 487                return NULL;
 488
 489        /* if it is device0, return it */
 490        if (0 == usb_pipedevice(urb->pipe))
 491                return usbhsh_device0(hpriv);
 492
 493        /* return attached device */
 494        return udev;
 495}
 496
 497static struct usbhsh_device *usbhsh_device_attach(struct usbhsh_hpriv *hpriv,
 498                                                 struct urb *urb)
 499{
 500        struct usbhsh_device *udev = NULL;
 501        struct usbhsh_device *udev0 = usbhsh_device0(hpriv);
 502        struct usbhsh_device *pos;
 503        struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
 504        struct device *dev = usbhsh_hcd_to_dev(hcd);
 505        struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
 506        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 507        unsigned long flags;
 508        u16 upphub, hubport;
 509        int i;
 510
 511        /*
 512         * This function should be called only while urb is pointing to device0.
 513         * It will attach unused usbhsh_device to urb (usbv),
 514         * and initialize device0.
 515         * You can use usbhsh_device_get() to get "current" udev,
 516         * and usbhsh_usbv_to_udev() is for "attached" udev.
 517         */
 518        if (0 != usb_pipedevice(urb->pipe)) {
 519                dev_err(dev, "%s fail: urb isn't pointing device0\n", __func__);
 520                return NULL;
 521        }
 522
 523        /********************  spin lock ********************/
 524        usbhs_lock(priv, flags);
 525
 526        /*
 527         * find unused device
 528         */
 529        usbhsh_for_each_udev(pos, hpriv, i) {
 530                if (usbhsh_udev_is_used(pos))
 531                        continue;
 532                udev = pos;
 533                break;
 534        }
 535
 536        if (udev) {
 537                /*
 538                 * usbhsh_usbv_to_udev()
 539                 * usbhsh_udev_to_usbv()
 540                 * will be enable
 541                 */
 542                dev_set_drvdata(&usbv->dev, udev);
 543                udev->usbv = usbv;
 544        }
 545
 546        usbhs_unlock(priv, flags);
 547        /********************  spin unlock ******************/
 548
 549        if (!udev) {
 550                dev_err(dev, "no free usbhsh_device\n");
 551                return NULL;
 552        }
 553
 554        if (usbhsh_device_has_endpoint(udev)) {
 555                dev_warn(dev, "udev have old endpoint\n");
 556                usbhsh_endpoint_detach_all(hpriv, udev);
 557        }
 558
 559        if (usbhsh_device_has_endpoint(udev0)) {
 560                dev_warn(dev, "udev0 have old endpoint\n");
 561                usbhsh_endpoint_detach_all(hpriv, udev0);
 562        }
 563
 564        /* uep will be attached */
 565        INIT_LIST_HEAD(&udev0->ep_list_head);
 566        INIT_LIST_HEAD(&udev->ep_list_head);
 567
 568        /*
 569         * set device0 config
 570         */
 571        usbhs_set_device_config(priv,
 572                                0, 0, 0, usbv->speed);
 573
 574        /*
 575         * set new device config
 576         */
 577        upphub  = 0;
 578        hubport = 0;
 579        if (!usbhsh_connected_to_rhdev(hcd, udev)) {
 580                /* if udev is not connected to rhdev, it means parent is Hub */
 581                struct usbhsh_device *parent = usbhsh_device_parent(udev);
 582
 583                upphub  = usbhsh_device_number(hpriv, parent);
 584                hubport = usbhsh_device_hubport(udev);
 585
 586                dev_dbg(dev, "%s connecte to Hub [%d:%d](%p)\n", __func__,
 587                        upphub, hubport, parent);
 588        }
 589
 590        usbhs_set_device_config(priv,
 591                               usbhsh_device_number(hpriv, udev),
 592                               upphub, hubport, usbv->speed);
 593
 594        dev_dbg(dev, "%s [%d](%p)\n", __func__,
 595                usbhsh_device_number(hpriv, udev), udev);
 596
 597        return udev;
 598}
 599
 600static void usbhsh_device_detach(struct usbhsh_hpriv *hpriv,
 601                               struct usbhsh_device *udev)
 602{
 603        struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
 604        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 605        struct device *dev = usbhsh_hcd_to_dev(hcd);
 606        struct usb_device *usbv = usbhsh_udev_to_usbv(udev);
 607        unsigned long flags;
 608
 609        dev_dbg(dev, "%s [%d](%p)\n", __func__,
 610                usbhsh_device_number(hpriv, udev), udev);
 611
 612        if (usbhsh_device_has_endpoint(udev)) {
 613                dev_warn(dev, "udev still have endpoint\n");
 614                usbhsh_endpoint_detach_all(hpriv, udev);
 615        }
 616
 617        /*
 618         * There is nothing to do if it is device0.
 619         * see
 620         *  usbhsh_device_attach()
 621         *  usbhsh_device_get()
 622         */
 623        if (0 == usbhsh_device_number(hpriv, udev))
 624                return;
 625
 626        /********************  spin lock ********************/
 627        usbhs_lock(priv, flags);
 628
 629        /*
 630         * usbhsh_usbv_to_udev()
 631         * usbhsh_udev_to_usbv()
 632         * will be disable
 633         */
 634        dev_set_drvdata(&usbv->dev, NULL);
 635        udev->usbv = NULL;
 636
 637        usbhs_unlock(priv, flags);
 638        /********************  spin unlock ******************/
 639}
 640
 641/*
 642 *              queue push/pop
 643 */
 644static void usbhsh_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
 645{
 646        struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
 647        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
 648        struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
 649        struct urb *urb = ureq->urb;
 650        struct device *dev = usbhs_priv_to_dev(priv);
 651        int status = 0;
 652
 653        dev_dbg(dev, "%s\n", __func__);
 654
 655        if (!urb) {
 656                dev_warn(dev, "pkt doesn't have urb\n");
 657                return;
 658        }
 659
 660        if (!usbhsh_is_running(hpriv))
 661                status = -ESHUTDOWN;
 662
 663        urb->actual_length = pkt->actual;
 664
 665        usbhsh_endpoint_sequence_save(hpriv, urb, pkt);
 666        usbhsh_ureq_free(hpriv, ureq);
 667
 668        usbhsh_pipe_detach(hpriv, usbhsh_ep_to_uep(urb->ep));
 669
 670        usb_hcd_unlink_urb_from_ep(hcd, urb);
 671        usb_hcd_giveback_urb(hcd, urb, status);
 672}
 673
 674static int usbhsh_queue_push(struct usb_hcd *hcd,
 675                             struct urb *urb,
 676                             gfp_t mem_flags)
 677{
 678        struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
 679        struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
 680        struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep);
 681        struct device *dev = usbhsh_hcd_to_dev(hcd);
 682        struct usbhsh_request *ureq;
 683        void *buf;
 684        int len, sequence;
 685
 686        if (usb_pipeisoc(urb->pipe)) {
 687                dev_err(dev, "pipe iso is not supported now\n");
 688                return -EIO;
 689        }
 690
 691        /* this ureq will be freed on usbhsh_queue_done() */
 692        ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
 693        if (unlikely(!ureq)) {
 694                dev_err(dev, "ureq alloc fail\n");
 695                return -ENOMEM;
 696        }
 697
 698        if (usb_pipein(urb->pipe))
 699                pipe->handler = &usbhs_fifo_dma_pop_handler;
 700        else
 701                pipe->handler = &usbhs_fifo_dma_push_handler;
 702
 703        buf = (void *)(urb->transfer_buffer + urb->actual_length);
 704        len = urb->transfer_buffer_length - urb->actual_length;
 705
 706        sequence = usb_gettoggle(urb->dev,
 707                                 usb_pipeendpoint(urb->pipe),
 708                                 usb_pipeout(urb->pipe));
 709
 710        dev_dbg(dev, "%s\n", __func__);
 711        usbhs_pkt_push(pipe, &ureq->pkt, usbhsh_queue_done,
 712                       buf, len, (urb->transfer_flags & URB_ZERO_PACKET),
 713                       sequence);
 714
 715        usbhs_pkt_start(pipe);
 716
 717        return 0;
 718}
 719
 720static void usbhsh_queue_force_pop(struct usbhs_priv *priv,
 721                                   struct usbhs_pipe *pipe)
 722{
 723        struct usbhs_pkt *pkt;
 724
 725        while (1) {
 726                pkt = usbhs_pkt_pop(pipe, NULL);
 727                if (!pkt)
 728                        break;
 729
 730                /*
 731                 * if all packet are gone, usbhsh_endpoint_disable()
 732                 * will be called.
 733                 * then, attached device/endpoint/pipe will be detached
 734                 */
 735                usbhsh_queue_done(priv, pkt);
 736        }
 737}
 738
 739static void usbhsh_queue_force_pop_all(struct usbhs_priv *priv)
 740{
 741        struct usbhs_pipe *pos;
 742        int i;
 743
 744        usbhs_for_each_pipe_with_dcp(pos, priv, i)
 745                usbhsh_queue_force_pop(priv, pos);
 746}
 747
 748/*
 749 *              DCP setup stage
 750 */
 751static int usbhsh_is_request_address(struct urb *urb)
 752{
 753        struct usb_ctrlrequest *req;
 754
 755        req = (struct usb_ctrlrequest *)urb->setup_packet;
 756
 757        if ((DeviceOutRequest    == req->bRequestType << 8) &&
 758            (USB_REQ_SET_ADDRESS == req->bRequest))
 759                return 1;
 760        else
 761                return 0;
 762}
 763
 764static void usbhsh_setup_stage_packet_push(struct usbhsh_hpriv *hpriv,
 765                                           struct urb *urb,
 766                                           struct usbhs_pipe *pipe)
 767{
 768        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 769        struct usb_ctrlrequest req;
 770        struct device *dev = usbhs_priv_to_dev(priv);
 771
 772        /*
 773         * wait setup packet ACK
 774         * see
 775         *      usbhsh_irq_setup_ack()
 776         *      usbhsh_irq_setup_err()
 777         */
 778        init_completion(&hpriv->setup_ack_done);
 779
 780        /* copy original request */
 781        memcpy(&req, urb->setup_packet, sizeof(struct usb_ctrlrequest));
 782
 783        /*
 784         * renesas_usbhs can not use original usb address.
 785         * see HARDWARE LIMITATION.
 786         * modify usb address here to use attached device.
 787         * see usbhsh_device_attach()
 788         */
 789        if (usbhsh_is_request_address(urb)) {
 790                struct usb_device *usbv = usbhsh_urb_to_usbv(urb);
 791                struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv);
 792
 793                /* udev is a attached device */
 794                req.wValue = usbhsh_device_number(hpriv, udev);
 795                dev_dbg(dev, "create new address - %d\n", req.wValue);
 796        }
 797
 798        /* set request */
 799        usbhs_usbreq_set_val(priv, &req);
 800
 801        /*
 802         * wait setup packet ACK
 803         */
 804        wait_for_completion(&hpriv->setup_ack_done);
 805
 806        dev_dbg(dev, "%s done\n", __func__);
 807}
 808
 809/*
 810 *              DCP data stage
 811 */
 812static void usbhsh_data_stage_packet_done(struct usbhs_priv *priv,
 813                                          struct usbhs_pkt *pkt)
 814{
 815        struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
 816        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
 817
 818        /* this ureq was connected to urb when usbhsh_urb_enqueue()  */
 819
 820        usbhsh_ureq_free(hpriv, ureq);
 821}
 822
 823static int usbhsh_data_stage_packet_push(struct usbhsh_hpriv *hpriv,
 824                                         struct urb *urb,
 825                                         struct usbhs_pipe *pipe,
 826                                         gfp_t mem_flags)
 827
 828{
 829        struct usbhsh_request *ureq;
 830
 831        /* this ureq will be freed on usbhsh_data_stage_packet_done() */
 832        ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
 833        if (unlikely(!ureq))
 834                return -ENOMEM;
 835
 836        if (usb_pipein(urb->pipe))
 837                pipe->handler = &usbhs_dcp_data_stage_in_handler;
 838        else
 839                pipe->handler = &usbhs_dcp_data_stage_out_handler;
 840
 841        usbhs_pkt_push(pipe, &ureq->pkt,
 842                       usbhsh_data_stage_packet_done,
 843                       urb->transfer_buffer,
 844                       urb->transfer_buffer_length,
 845                       (urb->transfer_flags & URB_ZERO_PACKET),
 846                       -1);
 847
 848        return 0;
 849}
 850
 851/*
 852 *              DCP status stage
 853 */
 854static int usbhsh_status_stage_packet_push(struct usbhsh_hpriv *hpriv,
 855                                            struct urb *urb,
 856                                            struct usbhs_pipe *pipe,
 857                                            gfp_t mem_flags)
 858{
 859        struct usbhsh_request *ureq;
 860
 861        /* This ureq will be freed on usbhsh_queue_done() */
 862        ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags);
 863        if (unlikely(!ureq))
 864                return -ENOMEM;
 865
 866        if (usb_pipein(urb->pipe))
 867                pipe->handler = &usbhs_dcp_status_stage_in_handler;
 868        else
 869                pipe->handler = &usbhs_dcp_status_stage_out_handler;
 870
 871        usbhs_pkt_push(pipe, &ureq->pkt,
 872                       usbhsh_queue_done,
 873                       NULL,
 874                       urb->transfer_buffer_length,
 875                       0, -1);
 876
 877        return 0;
 878}
 879
 880static int usbhsh_dcp_queue_push(struct usb_hcd *hcd,
 881                                 struct urb *urb,
 882                                 gfp_t mflags)
 883{
 884        struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
 885        struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep);
 886        struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep);
 887        struct device *dev = usbhsh_hcd_to_dev(hcd);
 888        int ret;
 889
 890        dev_dbg(dev, "%s\n", __func__);
 891
 892        /*
 893         * setup stage
 894         *
 895         * usbhsh_send_setup_stage_packet() wait SACK/SIGN
 896         */
 897        usbhsh_setup_stage_packet_push(hpriv, urb, pipe);
 898
 899        /*
 900         * data stage
 901         *
 902         * It is pushed only when urb has buffer.
 903         */
 904        if (urb->transfer_buffer_length) {
 905                ret = usbhsh_data_stage_packet_push(hpriv, urb, pipe, mflags);
 906                if (ret < 0) {
 907                        dev_err(dev, "data stage failed\n");
 908                        return ret;
 909                }
 910        }
 911
 912        /*
 913         * status stage
 914         */
 915        ret = usbhsh_status_stage_packet_push(hpriv, urb, pipe, mflags);
 916        if (ret < 0) {
 917                dev_err(dev, "status stage failed\n");
 918                return ret;
 919        }
 920
 921        /*
 922         * start pushed packets
 923         */
 924        usbhs_pkt_start(pipe);
 925
 926        return 0;
 927}
 928
 929/*
 930 *              dma map functions
 931 */
 932static int usbhsh_dma_map_ctrl(struct usbhs_pkt *pkt, int map)
 933{
 934        if (map) {
 935                struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt);
 936                struct urb *urb = ureq->urb;
 937
 938                /* it can not use scatter/gather */
 939                if (urb->num_sgs)
 940                        return -EINVAL;
 941
 942                pkt->dma = urb->transfer_dma;
 943                if (!pkt->dma)
 944                        return -EINVAL;
 945        }
 946
 947        return 0;
 948}
 949
 950/*
 951 *              for hc_driver
 952 */
 953static int usbhsh_host_start(struct usb_hcd *hcd)
 954{
 955        return 0;
 956}
 957
 958static void usbhsh_host_stop(struct usb_hcd *hcd)
 959{
 960}
 961
 962static int usbhsh_urb_enqueue(struct usb_hcd *hcd,
 963                              struct urb *urb,
 964                              gfp_t mem_flags)
 965{
 966        struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
 967        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
 968        struct device *dev = usbhs_priv_to_dev(priv);
 969        struct usb_host_endpoint *ep = urb->ep;
 970        struct usbhsh_device *new_udev = NULL;
 971        int is_dir_in = usb_pipein(urb->pipe);
 972        int ret;
 973
 974        dev_dbg(dev, "%s (%s)\n", __func__, is_dir_in ? "in" : "out");
 975
 976        if (!usbhsh_is_running(hpriv)) {
 977                ret = -EIO;
 978                dev_err(dev, "host is not running\n");
 979                goto usbhsh_urb_enqueue_error_not_linked;
 980        }
 981
 982        ret = usb_hcd_link_urb_to_ep(hcd, urb);
 983        if (ret) {
 984                dev_err(dev, "urb link failed\n");
 985                goto usbhsh_urb_enqueue_error_not_linked;
 986        }
 987
 988        /*
 989         * attach udev if needed
 990         * see [image of mod_host]
 991         */
 992        if (!usbhsh_device_get(hpriv, urb)) {
 993                new_udev = usbhsh_device_attach(hpriv, urb);
 994                if (!new_udev) {
 995                        ret = -EIO;
 996                        dev_err(dev, "device attach failed\n");
 997                        goto usbhsh_urb_enqueue_error_not_linked;
 998                }
 999        }
1000
1001        /*
1002         * attach endpoint if needed
1003         * see [image of mod_host]
1004         */
1005        if (!usbhsh_ep_to_uep(ep)) {
1006                ret = usbhsh_endpoint_attach(hpriv, urb, mem_flags);
1007                if (ret < 0) {
1008                        dev_err(dev, "endpoint attach failed\n");
1009                        goto usbhsh_urb_enqueue_error_free_device;
1010                }
1011        }
1012
1013        /*
1014         * attach pipe to endpoint
1015         * see [image of mod_host]
1016         */
1017        ret = usbhsh_pipe_attach(hpriv, urb);
1018        if (ret < 0) {
1019                dev_err(dev, "pipe attach failed\n");
1020                goto usbhsh_urb_enqueue_error_free_endpoint;
1021        }
1022
1023        /*
1024         * push packet
1025         */
1026        if (usb_pipecontrol(urb->pipe))
1027                ret = usbhsh_dcp_queue_push(hcd, urb, mem_flags);
1028        else
1029                ret = usbhsh_queue_push(hcd, urb, mem_flags);
1030
1031        return ret;
1032
1033usbhsh_urb_enqueue_error_free_endpoint:
1034        usbhsh_endpoint_detach(hpriv, ep);
1035usbhsh_urb_enqueue_error_free_device:
1036        if (new_udev)
1037                usbhsh_device_detach(hpriv, new_udev);
1038usbhsh_urb_enqueue_error_not_linked:
1039
1040        dev_dbg(dev, "%s error\n", __func__);
1041
1042        return ret;
1043}
1044
1045static int usbhsh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1046{
1047        struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1048        struct usbhsh_request *ureq = usbhsh_urb_to_ureq(urb);
1049
1050        if (ureq) {
1051                struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1052                struct usbhs_pkt *pkt = &ureq->pkt;
1053
1054                usbhs_pkt_pop(pkt->pipe, pkt);
1055                usbhsh_queue_done(priv, pkt);
1056        }
1057
1058        return 0;
1059}
1060
1061static void usbhsh_endpoint_disable(struct usb_hcd *hcd,
1062                                    struct usb_host_endpoint *ep)
1063{
1064        struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep);
1065        struct usbhsh_device *udev;
1066        struct usbhsh_hpriv *hpriv;
1067
1068        /*
1069         * this function might be called manytimes by same hcd/ep
1070         * in-endpoint == out-endpoint if ep == dcp.
1071         */
1072        if (!uep)
1073                return;
1074
1075        udev    = usbhsh_uep_to_udev(uep);
1076        hpriv   = usbhsh_hcd_to_hpriv(hcd);
1077
1078        usbhsh_endpoint_detach(hpriv, ep);
1079
1080        /*
1081         * if there is no endpoint,
1082         * free device
1083         */
1084        if (!usbhsh_device_has_endpoint(udev))
1085                usbhsh_device_detach(hpriv, udev);
1086}
1087
1088static int usbhsh_hub_status_data(struct usb_hcd *hcd, char *buf)
1089{
1090        struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1091        int roothub_id = 1; /* only 1 root hub */
1092
1093        /*
1094         * does port stat was changed ?
1095         * check USB_PORT_STAT_C_xxx << 16
1096         */
1097        if (usbhsh_port_stat_get(hpriv) & 0xFFFF0000)
1098                *buf = (1 << roothub_id);
1099        else
1100                *buf = 0;
1101
1102        return !!(*buf);
1103}
1104
1105static int __usbhsh_hub_hub_feature(struct usbhsh_hpriv *hpriv,
1106                                    u16 typeReq, u16 wValue,
1107                                    u16 wIndex, char *buf, u16 wLength)
1108{
1109        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1110        struct device *dev = usbhs_priv_to_dev(priv);
1111
1112        switch (wValue) {
1113        case C_HUB_OVER_CURRENT:
1114        case C_HUB_LOCAL_POWER:
1115                dev_dbg(dev, "%s :: C_HUB_xx\n", __func__);
1116                return 0;
1117        }
1118
1119        return -EPIPE;
1120}
1121
1122static int __usbhsh_hub_port_feature(struct usbhsh_hpriv *hpriv,
1123                                     u16 typeReq, u16 wValue,
1124                                     u16 wIndex, char *buf, u16 wLength)
1125{
1126        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1127        struct device *dev = usbhs_priv_to_dev(priv);
1128        int enable = (typeReq == SetPortFeature);
1129        int speed, i, timeout = 128;
1130        int roothub_id = 1; /* only 1 root hub */
1131
1132        /* common error */
1133        if (wIndex > roothub_id || wLength != 0)
1134                return -EPIPE;
1135
1136        /* check wValue */
1137        switch (wValue) {
1138        case USB_PORT_FEAT_POWER:
1139                usbhs_vbus_ctrl(priv, enable);
1140                dev_dbg(dev, "%s :: USB_PORT_FEAT_POWER\n", __func__);
1141                break;
1142
1143        case USB_PORT_FEAT_ENABLE:
1144        case USB_PORT_FEAT_SUSPEND:
1145        case USB_PORT_FEAT_C_ENABLE:
1146        case USB_PORT_FEAT_C_SUSPEND:
1147        case USB_PORT_FEAT_C_CONNECTION:
1148        case USB_PORT_FEAT_C_OVER_CURRENT:
1149        case USB_PORT_FEAT_C_RESET:
1150                dev_dbg(dev, "%s :: USB_PORT_FEAT_xxx\n", __func__);
1151                break;
1152
1153        case USB_PORT_FEAT_RESET:
1154                if (!enable)
1155                        break;
1156
1157                usbhsh_port_stat_clear(hpriv,
1158                                       USB_PORT_STAT_HIGH_SPEED |
1159                                       USB_PORT_STAT_LOW_SPEED);
1160
1161                usbhsh_queue_force_pop_all(priv);
1162
1163                usbhs_bus_send_reset(priv);
1164                msleep(20);
1165                usbhs_bus_send_sof_enable(priv);
1166
1167                for (i = 0; i < timeout ; i++) {
1168                        switch (usbhs_bus_get_speed(priv)) {
1169                        case USB_SPEED_LOW:
1170                                speed = USB_PORT_STAT_LOW_SPEED;
1171                                goto got_usb_bus_speed;
1172                        case USB_SPEED_HIGH:
1173                                speed = USB_PORT_STAT_HIGH_SPEED;
1174                                goto got_usb_bus_speed;
1175                        case USB_SPEED_FULL:
1176                                speed = 0;
1177                                goto got_usb_bus_speed;
1178                        }
1179
1180                        msleep(20);
1181                }
1182                return -EPIPE;
1183
1184got_usb_bus_speed:
1185                usbhsh_port_stat_set(hpriv, speed);
1186                usbhsh_port_stat_set(hpriv, USB_PORT_STAT_ENABLE);
1187
1188                dev_dbg(dev, "%s :: USB_PORT_FEAT_RESET (speed = %d)\n",
1189                        __func__, speed);
1190
1191                /* status change is not needed */
1192                return 0;
1193
1194        default:
1195                return -EPIPE;
1196        }
1197
1198        /* set/clear status */
1199        if (enable)
1200                usbhsh_port_stat_set(hpriv, (1 << wValue));
1201        else
1202                usbhsh_port_stat_clear(hpriv, (1 << wValue));
1203
1204        return 0;
1205}
1206
1207static int __usbhsh_hub_get_status(struct usbhsh_hpriv *hpriv,
1208                                   u16 typeReq, u16 wValue,
1209                                   u16 wIndex, char *buf, u16 wLength)
1210{
1211        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1212        struct usb_hub_descriptor *desc = (struct usb_hub_descriptor *)buf;
1213        struct device *dev = usbhs_priv_to_dev(priv);
1214        int roothub_id = 1; /* only 1 root hub */
1215
1216        switch (typeReq) {
1217        case GetHubStatus:
1218                dev_dbg(dev, "%s :: GetHubStatus\n", __func__);
1219
1220                *buf = 0x00;
1221                break;
1222
1223        case GetPortStatus:
1224                if (wIndex != roothub_id)
1225                        return -EPIPE;
1226
1227                dev_dbg(dev, "%s :: GetPortStatus\n", __func__);
1228                *(__le32 *)buf = cpu_to_le32(usbhsh_port_stat_get(hpriv));
1229                break;
1230
1231        case GetHubDescriptor:
1232                desc->bDescriptorType           = 0x29;
1233                desc->bHubContrCurrent          = 0;
1234                desc->bNbrPorts                 = roothub_id;
1235                desc->bDescLength               = 9;
1236                desc->bPwrOn2PwrGood            = 0;
1237                desc->wHubCharacteristics       = cpu_to_le16(0x0011);
1238                desc->u.hs.DeviceRemovable[0]   = (roothub_id << 1);
1239                desc->u.hs.DeviceRemovable[1]   = ~0;
1240                dev_dbg(dev, "%s :: GetHubDescriptor\n", __func__);
1241                break;
1242        }
1243
1244        return 0;
1245}
1246
1247static int usbhsh_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
1248                              u16 wIndex, char *buf, u16 wLength)
1249{
1250        struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd);
1251        struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv);
1252        struct device *dev = usbhs_priv_to_dev(priv);
1253        int ret = -EPIPE;
1254
1255        switch (typeReq) {
1256
1257        /* Hub Feature */
1258        case ClearHubFeature:
1259        case SetHubFeature:
1260                ret = __usbhsh_hub_hub_feature(hpriv, typeReq,
1261                                               wValue, wIndex, buf, wLength);
1262                break;
1263
1264        /* Port Feature */
1265        case SetPortFeature:
1266        case ClearPortFeature:
1267                ret = __usbhsh_hub_port_feature(hpriv, typeReq,
1268                                                wValue, wIndex, buf, wLength);
1269                break;
1270
1271        /* Get status */
1272        case GetHubStatus:
1273        case GetPortStatus:
1274        case GetHubDescriptor:
1275                ret = __usbhsh_hub_get_status(hpriv, typeReq,
1276                                              wValue, wIndex, buf, wLength);
1277                break;
1278        }
1279
1280        dev_dbg(dev, "typeReq = %x, ret = %d, port_stat = %x\n",
1281                typeReq, ret, usbhsh_port_stat_get(hpriv));
1282
1283        return ret;
1284}
1285
1286static int usbhsh_bus_nop(struct usb_hcd *hcd)
1287{
1288        /* nothing to do */
1289        return 0;
1290}
1291
1292static struct hc_driver usbhsh_driver = {
1293        .description =          usbhsh_hcd_name,
1294        .hcd_priv_size =        sizeof(struct usbhsh_hpriv),
1295
1296        /*
1297         * generic hardware linkage
1298         */
1299        .flags =                HCD_USB2,
1300
1301        .start =                usbhsh_host_start,
1302        .stop =                 usbhsh_host_stop,
1303
1304        /*
1305         * managing i/o requests and associated device resources
1306         */
1307        .urb_enqueue =          usbhsh_urb_enqueue,
1308        .urb_dequeue =          usbhsh_urb_dequeue,
1309        .endpoint_disable =     usbhsh_endpoint_disable,
1310
1311        /*
1312         * root hub
1313         */
1314        .hub_status_data =      usbhsh_hub_status_data,
1315        .hub_control =          usbhsh_hub_control,
1316        .bus_suspend =          usbhsh_bus_nop,
1317        .bus_resume =           usbhsh_bus_nop,
1318};
1319
1320/*
1321 *              interrupt functions
1322 */
1323static int usbhsh_irq_attch(struct usbhs_priv *priv,
1324                            struct usbhs_irq_state *irq_state)
1325{
1326        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1327        struct device *dev = usbhs_priv_to_dev(priv);
1328
1329        dev_dbg(dev, "device attached\n");
1330
1331        usbhsh_port_stat_set(hpriv, USB_PORT_STAT_CONNECTION);
1332        usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16);
1333
1334        /*
1335         * attch interrupt might happen infinitely on some device
1336         * (on self power USB hub ?)
1337         * disable it here.
1338         *
1339         * usbhsh_is_running() becomes effective
1340         * according to this process.
1341         * see
1342         *      usbhsh_is_running()
1343         *      usbhsh_urb_enqueue()
1344         */
1345        hpriv->mod.irq_attch = NULL;
1346        usbhs_irq_callback_update(priv, &hpriv->mod);
1347
1348        return 0;
1349}
1350
1351static int usbhsh_irq_dtch(struct usbhs_priv *priv,
1352                           struct usbhs_irq_state *irq_state)
1353{
1354        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1355        struct device *dev = usbhs_priv_to_dev(priv);
1356
1357        dev_dbg(dev, "device detached\n");
1358
1359        usbhsh_port_stat_clear(hpriv, USB_PORT_STAT_CONNECTION);
1360        usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16);
1361
1362        /*
1363         * enable attch interrupt again
1364         *
1365         * usbhsh_is_running() becomes invalid
1366         * according to this process.
1367         * see
1368         *      usbhsh_is_running()
1369         *      usbhsh_urb_enqueue()
1370         */
1371        hpriv->mod.irq_attch = usbhsh_irq_attch;
1372        usbhs_irq_callback_update(priv, &hpriv->mod);
1373
1374        /*
1375         * usbhsh_queue_force_pop_all() should be called
1376         * after usbhsh_is_running() becomes invalid.
1377         */
1378        usbhsh_queue_force_pop_all(priv);
1379
1380        return 0;
1381}
1382
1383static int usbhsh_irq_setup_ack(struct usbhs_priv *priv,
1384                                struct usbhs_irq_state *irq_state)
1385{
1386        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1387        struct device *dev = usbhs_priv_to_dev(priv);
1388
1389        dev_dbg(dev, "setup packet OK\n");
1390
1391        complete(&hpriv->setup_ack_done); /* see usbhsh_urb_enqueue() */
1392
1393        return 0;
1394}
1395
1396static int usbhsh_irq_setup_err(struct usbhs_priv *priv,
1397                                struct usbhs_irq_state *irq_state)
1398{
1399        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1400        struct device *dev = usbhs_priv_to_dev(priv);
1401
1402        dev_dbg(dev, "setup packet Err\n");
1403
1404        complete(&hpriv->setup_ack_done); /* see usbhsh_urb_enqueue() */
1405
1406        return 0;
1407}
1408
1409/*
1410 *              module start/stop
1411 */
1412static void usbhsh_pipe_init_for_host(struct usbhs_priv *priv)
1413{
1414        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1415        struct usbhs_pipe *pipe;
1416        u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
1417        int pipe_size = usbhs_get_dparam(priv, pipe_size);
1418        int old_type, dir_in, i;
1419
1420        /* init all pipe */
1421        old_type = USB_ENDPOINT_XFER_CONTROL;
1422        for (i = 0; i < pipe_size; i++) {
1423
1424                /*
1425                 * data "output" will be finished as soon as possible,
1426                 * but there is no guaranty at data "input" case.
1427                 *
1428                 * "input" needs "standby" pipe.
1429                 * So, "input" direction pipe > "output" direction pipe
1430                 * is good idea.
1431                 *
1432                 * 1st USB_ENDPOINT_XFER_xxx will be output direction,
1433                 * and the other will be input direction here.
1434                 *
1435                 * ex)
1436                 * ...
1437                 * USB_ENDPOINT_XFER_ISOC -> dir out
1438                 * USB_ENDPOINT_XFER_ISOC -> dir in
1439                 * USB_ENDPOINT_XFER_BULK -> dir out
1440                 * USB_ENDPOINT_XFER_BULK -> dir in
1441                 * USB_ENDPOINT_XFER_BULK -> dir in
1442                 * ...
1443                 */
1444                dir_in = (pipe_type[i] == old_type);
1445                old_type = pipe_type[i];
1446
1447                if (USB_ENDPOINT_XFER_CONTROL == pipe_type[i]) {
1448                        pipe = usbhs_dcp_malloc(priv);
1449                        usbhsh_hpriv_to_dcp(hpriv) = pipe;
1450                } else {
1451                        pipe = usbhs_pipe_malloc(priv,
1452                                                 pipe_type[i],
1453                                                 dir_in);
1454                }
1455
1456                pipe->mod_private = NULL;
1457        }
1458}
1459
1460static int usbhsh_start(struct usbhs_priv *priv)
1461{
1462        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1463        struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1464        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
1465        struct device *dev = usbhs_priv_to_dev(priv);
1466        int ret;
1467
1468        /* add hcd */
1469        ret = usb_add_hcd(hcd, 0, 0);
1470        if (ret < 0)
1471                return 0;
1472
1473        /*
1474         * pipe initialize and enable DCP
1475         */
1476        usbhs_pipe_init(priv,
1477                        usbhsh_dma_map_ctrl);
1478        usbhs_fifo_init(priv);
1479        usbhsh_pipe_init_for_host(priv);
1480
1481        /*
1482         * system config enble
1483         * - HI speed
1484         * - host
1485         * - usb module
1486         */
1487        usbhs_sys_host_ctrl(priv, 1);
1488
1489        /*
1490         * enable irq callback
1491         */
1492        mod->irq_attch          = usbhsh_irq_attch;
1493        mod->irq_dtch           = usbhsh_irq_dtch;
1494        mod->irq_sack           = usbhsh_irq_setup_ack;
1495        mod->irq_sign           = usbhsh_irq_setup_err;
1496        usbhs_irq_callback_update(priv, mod);
1497
1498        dev_dbg(dev, "start host\n");
1499
1500        return ret;
1501}
1502
1503static int usbhsh_stop(struct usbhs_priv *priv)
1504{
1505        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1506        struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1507        struct usbhs_mod *mod = usbhs_mod_get_current(priv);
1508        struct device *dev = usbhs_priv_to_dev(priv);
1509
1510        /*
1511         * disable irq callback
1512         */
1513        mod->irq_attch  = NULL;
1514        mod->irq_dtch   = NULL;
1515        mod->irq_sack   = NULL;
1516        mod->irq_sign   = NULL;
1517        usbhs_irq_callback_update(priv, mod);
1518
1519        usb_remove_hcd(hcd);
1520
1521        /* disable sys */
1522        usbhs_sys_host_ctrl(priv, 0);
1523
1524        dev_dbg(dev, "quit host\n");
1525
1526        return 0;
1527}
1528
1529int usbhs_mod_host_probe(struct usbhs_priv *priv)
1530{
1531        struct usbhsh_hpriv *hpriv;
1532        struct usb_hcd *hcd;
1533        struct usbhsh_device *udev;
1534        struct device *dev = usbhs_priv_to_dev(priv);
1535        int i;
1536
1537        /* initialize hcd */
1538        hcd = usb_create_hcd(&usbhsh_driver, dev, usbhsh_hcd_name);
1539        if (!hcd) {
1540                dev_err(dev, "Failed to create hcd\n");
1541                return -ENOMEM;
1542        }
1543        hcd->has_tt = 1; /* for low/full speed */
1544
1545        /*
1546         * CAUTION
1547         *
1548         * There is no guarantee that it is possible to access usb module here.
1549         * Don't accesses to it.
1550         * The accesse will be enable after "usbhsh_start"
1551         */
1552
1553        hpriv = usbhsh_hcd_to_hpriv(hcd);
1554
1555        /*
1556         * register itself
1557         */
1558        usbhs_mod_register(priv, &hpriv->mod, USBHS_HOST);
1559
1560        /* init hpriv */
1561        hpriv->mod.name         = "host";
1562        hpriv->mod.start        = usbhsh_start;
1563        hpriv->mod.stop         = usbhsh_stop;
1564        usbhsh_port_stat_init(hpriv);
1565
1566        /* init all device */
1567        usbhsh_for_each_udev_with_dev0(udev, hpriv, i) {
1568                udev->usbv      = NULL;
1569                INIT_LIST_HEAD(&udev->ep_list_head);
1570        }
1571
1572        dev_info(dev, "host probed\n");
1573
1574        return 0;
1575}
1576
1577int usbhs_mod_host_remove(struct usbhs_priv *priv)
1578{
1579        struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv);
1580        struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv);
1581
1582        usb_put_hcd(hcd);
1583
1584        return 0;
1585}
1586