drivers/usb/c67x00/c67x00-hcd.c

   1 /*
   2  * c67x00-hcd.c: Cypress C67X00 USB Host Controller Driver
   3  *
   4  * Copyright (C) 2006-2008 Barco N.V.
   5  *    Derived from the Cypress cy7c67200/300 ezusb linux driver and
   6  *    based on multiple host controller drivers inside the linux kernel.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  21  * MA  02110-1301  USA.
  22  */
  23
  24 #include <linux/device.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/usb.h>
  27
  28 #include "c67x00.h"
  29 #include "c67x00-hcd.h"
  30
  31 /* --------------------------------------------------------------------------
  32  * Root Hub Support
  33  */
  34
  35 static __u8 c67x00_hub_des[] = {
  36         0x09,                   /*  __u8  bLength; */
  37         0x29,                   /*  __u8  bDescriptorType; Hub-descriptor */
  38         0x02,                   /*  __u8  bNbrPorts; */
  39         0x00,                   /* __u16  wHubCharacteristics; */
  40         0x00,                   /*   (per-port OC, no power switching) */
  41         0x32,                   /*  __u8  bPwrOn2pwrGood; 2ms */
  42         0x00,                   /*  __u8  bHubContrCurrent; 0 mA */
  43         0x00,                   /*  __u8  DeviceRemovable; ** 7 Ports max ** */
  44         0xff,                   /*  __u8  PortPwrCtrlMask; ** 7 ports max ** */
  45 };
  46
  47 static void c67x00_hub_reset_host_port(struct c67x00_sie *sie, int port)
  48 {
  49         struct c67x00_hcd *c67x00 = sie->private_data;
  50         unsigned long flags;
  51
  52         c67x00_ll_husb_reset(sie, port);
  53
  54         spin_lock_irqsave(&c67x00->lock, flags);
  55         c67x00_ll_husb_reset_port(sie, port);
  56         spin_unlock_irqrestore(&c67x00->lock, flags);
  57
  58         c67x00_ll_set_husb_eot(sie->dev, DEFAULT_EOT);
  59 }
  60
  61 static int c67x00_hub_status_data(struct usb_hcd *hcd, char *buf)
  62 {
  63         struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
  64         struct c67x00_sie *sie = c67x00->sie;
  65         u16 status;
  66         int i;
  67
  68         *buf = 0;
  69         status = c67x00_ll_usb_get_status(sie);
  70         for (i = 0; i < C67X00_PORTS; i++)
  71                 if (status & PORT_CONNECT_CHANGE(i))
  72                         *buf |= (1 << i);
  73
  74         /* bit 0 denotes hub change, b1..n port change */
  75         *buf <<= 1;
  76
  77         return !!*buf;
  78 }
  79
  80 static int c67x00_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
  81                               u16 wIndex, char *buf, u16 wLength)
  82 {
  83         struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
  84         struct c67x00_sie *sie = c67x00->sie;
  85         u16 status, usb_status;
  86         int len = 0;
  87         unsigned int port = wIndex-1;
  88         u16 wPortChange, wPortStatus;
  89
  90         switch (typeReq) {
  91
  92         case GetHubStatus:
  93                 *(__le32 *) buf = cpu_to_le32(0);
  94                 len = 4;                /* hub power */
  95                 break;
  96
  97         case GetPortStatus:
  98                 if (wIndex > C67X00_PORTS)
  99                         return -EPIPE;
 100
 101                 status = c67x00_ll_usb_get_status(sie);
 102                 usb_status = c67x00_ll_get_usb_ctl(sie);
 103
 104                 wPortChange = 0;
 105                 if (status & PORT_CONNECT_CHANGE(port))
 106                         wPortChange |= USB_PORT_STAT_C_CONNECTION;
 107
 108                 wPortStatus = USB_PORT_STAT_POWER;
 109                 if (!(status & PORT_SE0_STATUS(port)))
 110                         wPortStatus |= USB_PORT_STAT_CONNECTION;
 111                 if (usb_status & LOW_SPEED_PORT(port)) {
 112                         wPortStatus |= USB_PORT_STAT_LOW_SPEED;
 113                         c67x00->low_speed_ports |= (1 << port);
 114                 } else
 115                         c67x00->low_speed_ports &= ~(1 << port);
 116
 117                 if (usb_status & SOF_EOP_EN(port))
 118                         wPortStatus |= USB_PORT_STAT_ENABLE;
 119
 120                 *(__le16 *) buf = cpu_to_le16(wPortStatus);
 121                 *(__le16 *) (buf + 2) = cpu_to_le16(wPortChange);
 122                 len = 4;
 123                 break;
 124
 125         case SetHubFeature:     /* We don't implement these */
 126         case ClearHubFeature:
 127                 switch (wValue) {
 128                 case C_HUB_OVER_CURRENT:
 129                 case C_HUB_LOCAL_POWER:
 130                         len = 0;
 131                         break;
 132
 133                 default:
 134                         return -EPIPE;
 135                 }
 136                 break;
 137
 138         case SetPortFeature:
 139                 if (wIndex > C67X00_PORTS)
 140                         return -EPIPE;
 141
 142                 switch (wValue) {
 143                 case USB_PORT_FEAT_SUSPEND:
 144                         dev_dbg(c67x00_hcd_dev(c67x00),
 145                                 "SetPortFeature %d (SUSPEND)\n", port);
 146                         len = 0;
 147                         break;
 148
 149                 case USB_PORT_FEAT_RESET:
 150                         c67x00_hub_reset_host_port(sie, port);
 151                         len = 0;
 152                         break;
 153
 154                 case USB_PORT_FEAT_POWER:
 155                         /* Power always enabled */
 156                         len = 0;
 157                         break;
 158
 159                 default:
 160                         dev_dbg(c67x00_hcd_dev(c67x00),
 161                                 "%s: SetPortFeature %d (0x%04x) Error!\n",
 162                                 __func__, port, wValue);
 163                         return -EPIPE;
 164                 }
 165                 break;
 166
 167         case ClearPortFeature:
 168                 if (wIndex > C67X00_PORTS)
 169                         return -EPIPE;
 170
 171                 switch (wValue) {
 172                 case USB_PORT_FEAT_ENABLE:
 173                         /* Reset the port so that the c67x00 also notices the
 174                          * disconnect */
 175                         c67x00_hub_reset_host_port(sie, port);
 176                         len = 0;
 177                         break;
 178
 179                 case USB_PORT_FEAT_C_ENABLE:
 180                         dev_dbg(c67x00_hcd_dev(c67x00),
 181                                 "ClearPortFeature (%d): C_ENABLE\n", port);
 182                         len = 0;
 183                         break;
 184
 185                 case USB_PORT_FEAT_SUSPEND:
 186                         dev_dbg(c67x00_hcd_dev(c67x00),
 187                                 "ClearPortFeature (%d): SUSPEND\n", port);
 188                         len = 0;
 189                         break;
 190
 191                 case USB_PORT_FEAT_C_SUSPEND:
 192                         dev_dbg(c67x00_hcd_dev(c67x00),
 193                                 "ClearPortFeature (%d): C_SUSPEND\n", port);
 194                         len = 0;
 195                         break;
 196
 197                 case USB_PORT_FEAT_POWER:
 198                         dev_dbg(c67x00_hcd_dev(c67x00),
 199                                 "ClearPortFeature (%d): POWER\n", port);
 200                         return -EPIPE;
 201
 202                 case USB_PORT_FEAT_C_CONNECTION:
 203                         c67x00_ll_usb_clear_status(sie,
 204                                                    PORT_CONNECT_CHANGE(port));
 205                         len = 0;
 206                         break;
 207
 208                 case USB_PORT_FEAT_C_OVER_CURRENT:
 209                         dev_dbg(c67x00_hcd_dev(c67x00),
 210                                 "ClearPortFeature (%d): OVER_CURRENT\n", port);
 211                         len = 0;
 212                         break;
 213
 214                 case USB_PORT_FEAT_C_RESET:
 215                         dev_dbg(c67x00_hcd_dev(c67x00),
 216                                 "ClearPortFeature (%d): C_RESET\n", port);
 217                         len = 0;
 218                         break;
 219
 220                 default:
 221                         dev_dbg(c67x00_hcd_dev(c67x00),
 222                                 "%s: ClearPortFeature %d (0x%04x) Error!\n",
 223                                 __func__, port, wValue);
 224                         return -EPIPE;
 225                 }
 226                 break;
 227
 228         case GetHubDescriptor:
 229                 len = min_t(unsigned int, sizeof(c67x00_hub_des), wLength);
 230                 memcpy(buf, c67x00_hub_des, len);
 231                 break;
 232
 233         default:
 234                 dev_dbg(c67x00_hcd_dev(c67x00), "%s: unknown\n", __func__);
 235                 return -EPIPE;
 236         }
 237
 238         return 0;
 239 }
 240
 241 /* ---------------------------------------------------------------------
 242  * Main part of host controller driver
 243  */
 244
 245 /**
 246  * c67x00_hcd_irq
 247  *
 248  * This function is called from the interrupt handler in c67x00-drv.c
 249  */
 250 static void c67x00_hcd_irq(struct c67x00_sie *sie, u16 int_status, u16 msg)
 251 {
 252         struct c67x00_hcd *c67x00 = sie->private_data;
 253         struct usb_hcd *hcd = c67x00_hcd_to_hcd(c67x00);
 254
 255         /* Handle sie message flags */
 256         if (msg) {
 257                 if (msg & HUSB_TDListDone)
 258                         c67x00_sched_kick(c67x00);
 259                 else
 260                         dev_warn(c67x00_hcd_dev(c67x00),
 261                                  "Unknown SIE msg flag(s): 0x%04x\n", msg);
 262         }
 263
 264         if (unlikely(hcd->state == HC_STATE_HALT))
 265                 return;
 266
 267         if (!HCD_HW_ACCESSIBLE(hcd))
 268                 return;
 269
 270         /* Handle Start of frame events */
 271         if (int_status & SOFEOP_FLG(sie->sie_num)) {
 272                 c67x00_ll_usb_clear_status(sie, SOF_EOP_IRQ_FLG);
 273                 c67x00_sched_kick(c67x00);
 274         }
 275 }
 276
 277 /**
 278  * c67x00_hcd_start: Host controller start hook
 279  */
 280 static int c67x00_hcd_start(struct usb_hcd *hcd)
 281 {
 282         hcd->uses_new_polling = 1;
 283         hcd->state = HC_STATE_RUNNING;
 284         set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
 285
 286         return 0;
 287 }
 288
 289 /**
 290  * c67x00_hcd_stop: Host controller stop hook
 291  */
 292 static void c67x00_hcd_stop(struct usb_hcd *hcd)
 293 {
 294         /* Nothing to do */
 295 }
 296
 297 static int c67x00_hcd_get_frame(struct usb_hcd *hcd)
 298 {
 299         struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
 300         u16 temp_val;
 301
 302         dev_dbg(c67x00_hcd_dev(c67x00), "%s\n", __func__);
 303         temp_val = c67x00_ll_husb_get_frame(c67x00->sie);
 304         temp_val &= HOST_FRAME_MASK;
 305         return temp_val ? (temp_val - 1) : HOST_FRAME_MASK;
 306 }
 307
 308 static struct hc_driver c67x00_hc_driver = {
 309         .description    = "c67x00-hcd",
 310         .product_desc   = "Cypress C67X00 Host Controller",
 311         .hcd_priv_size  = sizeof(struct c67x00_hcd),
 312         .flags          = HCD_USB11 | HCD_MEMORY,
 313
 314         /*
 315          * basic lifecycle operations
 316          */
 317         .start          = c67x00_hcd_start,
 318         .stop           = c67x00_hcd_stop,
 319
 320         /*
 321          * managing i/o requests and associated device resources
 322          */
 323         .urb_enqueue    = c67x00_urb_enqueue,
 324         .urb_dequeue    = c67x00_urb_dequeue,
 325         .endpoint_disable = c67x00_endpoint_disable,
 326
 327         /*
 328          * scheduling support
 329          */
 330         .get_frame_number = c67x00_hcd_get_frame,
 331
 332         /*
 333          * root hub support
 334          */
 335         .hub_status_data = c67x00_hub_status_data,
 336         .hub_control    = c67x00_hub_control,
 337 };
 338
 339 /* ---------------------------------------------------------------------
 340  * Setup/Teardown routines
 341  */
 342
 343 int c67x00_hcd_probe(struct c67x00_sie *sie)
 344 {
 345         struct c67x00_hcd *c67x00;
 346         struct usb_hcd *hcd;
 347         unsigned long flags;
 348         int retval;
 349
 350         if (usb_disabled())
 351                 return -ENODEV;
 352
 353         hcd = usb_create_hcd(&c67x00_hc_driver, sie_dev(sie), "c67x00_sie");
 354         if (!hcd) {
 355                 retval = -ENOMEM;
 356                 goto err0;
 357         }
 358         c67x00 = hcd_to_c67x00_hcd(hcd);
 359
 360         spin_lock_init(&c67x00->lock);
 361         c67x00->sie = sie;
 362
 363         INIT_LIST_HEAD(&c67x00->list[PIPE_ISOCHRONOUS]);
 364         INIT_LIST_HEAD(&c67x00->list[PIPE_INTERRUPT]);
 365         INIT_LIST_HEAD(&c67x00->list[PIPE_CONTROL]);
 366         INIT_LIST_HEAD(&c67x00->list[PIPE_BULK]);
 367         c67x00->urb_count = 0;
 368         INIT_LIST_HEAD(&c67x00->td_list);
 369         c67x00->td_base_addr = CY_HCD_BUF_ADDR + SIE_TD_OFFSET(sie->sie_num);
 370         c67x00->buf_base_addr = CY_HCD_BUF_ADDR + SIE_BUF_OFFSET(sie->sie_num);
 371         c67x00->max_frame_bw = MAX_FRAME_BW_STD;
 372
 373         c67x00_ll_husb_init_host_port(sie);
 374
 375         init_completion(&c67x00->endpoint_disable);
 376         retval = c67x00_sched_start_scheduler(c67x00);
 377         if (retval)
 378                 goto err1;
 379
 380         retval = usb_add_hcd(hcd, 0, 0);
 381         if (retval) {
 382                 dev_dbg(sie_dev(sie), "%s: usb_add_hcd returned %d\n",
 383                         __func__, retval);
 384                 goto err2;
 385         }
 386
 387         device_wakeup_enable(hcd->self.controller);
 388
 389         spin_lock_irqsave(&sie->lock, flags);
 390         sie->private_data = c67x00;
 391         sie->irq = c67x00_hcd_irq;
 392         spin_unlock_irqrestore(&sie->lock, flags);
 393
 394         return retval;
 395
 396  err2:
 397         c67x00_sched_stop_scheduler(c67x00);
 398  err1:
 399         usb_put_hcd(hcd);
 400  err0:
 401         return retval;
 402 }
 403
 404 /* may be called with controller, bus, and devices active */
 405 void c67x00_hcd_remove(struct c67x00_sie *sie)
 406 {
 407         struct c67x00_hcd *c67x00 = sie->private_data;
 408         struct usb_hcd *hcd = c67x00_hcd_to_hcd(c67x00);
 409
 410         c67x00_sched_stop_scheduler(c67x00);
 411         usb_remove_hcd(hcd);
 412         usb_put_hcd(hcd);
 413 }