drivers/usb/renesas_usbhs/mod_host.c

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