drivers/usb/chipidea/debug.c

   1 #include <linux/delay.h>
   2 #include <linux/device.h>
   3 #include <linux/dmapool.h>
   4 #include <linux/dma-mapping.h>
   5 #include <linux/init.h>
   6 #include <linux/platform_device.h>
   7 #include <linux/module.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/io.h>
  10 #include <linux/irq.h>
  11 #include <linux/kernel.h>
  12 #include <linux/slab.h>
  13 #include <linux/pm_runtime.h>
  14 #include <linux/usb/ch9.h>
  15 #include <linux/usb/gadget.h>
  16 #include <linux/usb/otg.h>
  17 #include <linux/usb/chipidea.h>
  18
  19 #include "ci.h"
  20 #include "udc.h"
  21 #include "bits.h"
  22 #include "debug.h"
  23
  24 /* Interrupt statistics */
  25 #define ISR_MASK   0x1F
  26 static struct isr_statistics {
  27         u32 test;
  28         u32 ui;
  29         u32 uei;
  30         u32 pci;
  31         u32 uri;
  32         u32 sli;
  33         u32 none;
  34         struct {
  35                 u32 cnt;
  36                 u32 buf[ISR_MASK+1];
  37                 u32 idx;
  38         } hndl;
  39 } isr_statistics;
  40
  41 void dbg_interrupt(u32 intmask)
  42 {
  43         if (!intmask) {
  44                 isr_statistics.none++;
  45                 return;
  46         }
  47
  48         isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intmask;
  49         isr_statistics.hndl.idx &= ISR_MASK;
  50         isr_statistics.hndl.cnt++;
  51
  52         if (USBi_URI & intmask)
  53                 isr_statistics.uri++;
  54         if (USBi_PCI & intmask)
  55                 isr_statistics.pci++;
  56         if (USBi_UEI & intmask)
  57                 isr_statistics.uei++;
  58         if (USBi_UI  & intmask)
  59                 isr_statistics.ui++;
  60         if (USBi_SLI & intmask)
  61                 isr_statistics.sli++;
  62 }
  63
  64 /**
  65  * hw_register_read: reads all device registers (execute without interruption)
  66  * @buf:  destination buffer
  67  * @size: buffer size
  68  *
  69  * This function returns number of registers read
  70  */
  71 static size_t hw_register_read(struct ci13xxx *ci, u32 *buf, size_t size)
  72 {
  73         unsigned i;
  74
  75         if (size > ci->hw_bank.size)
  76                 size = ci->hw_bank.size;
  77
  78         for (i = 0; i < size; i++)
  79                 buf[i] = hw_read(ci, i * sizeof(u32), ~0);
  80
  81         return size;
  82 }
  83
  84 /**
  85  * hw_register_write: writes to register
  86  * @addr: register address
  87  * @data: register value
  88  *
  89  * This function returns an error code
  90  */
  91 static int hw_register_write(struct ci13xxx *ci, u16 addr, u32 data)
  92 {
  93         /* align */
  94         addr /= sizeof(u32);
  95
  96         if (addr >= ci->hw_bank.size)
  97                 return -EINVAL;
  98
  99         /* align */
 100         addr *= sizeof(u32);
 101
 102         hw_write(ci, addr, ~0, data);
 103         return 0;
 104 }
 105
 106 /**
 107  * hw_intr_clear: disables interrupt & clears interrupt status (execute without
 108  *                interruption)
 109  * @n: interrupt bit
 110  *
 111  * This function returns an error code
 112  */
 113 static int hw_intr_clear(struct ci13xxx *ci, int n)
 114 {
 115         if (n >= REG_BITS)
 116                 return -EINVAL;
 117
 118         hw_write(ci, OP_USBINTR, BIT(n), 0);
 119         hw_write(ci, OP_USBSTS,  BIT(n), BIT(n));
 120         return 0;
 121 }
 122
 123 /**
 124  * hw_intr_force: enables interrupt & forces interrupt status (execute without
 125  *                interruption)
 126  * @n: interrupt bit
 127  *
 128  * This function returns an error code
 129  */
 130 static int hw_intr_force(struct ci13xxx *ci, int n)
 131 {
 132         if (n >= REG_BITS)
 133                 return -EINVAL;
 134
 135         hw_write(ci, CAP_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
 136         hw_write(ci, OP_USBINTR,  BIT(n), BIT(n));
 137         hw_write(ci, OP_USBSTS,   BIT(n), BIT(n));
 138         hw_write(ci, CAP_TESTMODE, TESTMODE_FORCE, 0);
 139         return 0;
 140 }
 141
 142 /**
 143  * show_device: prints information about device capabilities and status
 144  *
 145  * Check "device.h" for details
 146  */
 147 static ssize_t show_device(struct device *dev, struct device_attribute *attr,
 148                            char *buf)
 149 {
 150         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 151         struct usb_gadget *gadget = &ci->gadget;
 152         int n = 0;
 153
 154         if (attr == NULL || buf == NULL) {
 155                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 156                 return 0;
 157         }
 158
 159         n += scnprintf(buf + n, PAGE_SIZE - n, "speed             = %d\n",
 160                        gadget->speed);
 161         n += scnprintf(buf + n, PAGE_SIZE - n, "max_speed         = %d\n",
 162                        gadget->max_speed);
 163         /* TODO: Scheduled for removal in 3.8. */
 164         n += scnprintf(buf + n, PAGE_SIZE - n, "is_dualspeed      = %d\n",
 165                        gadget_is_dualspeed(gadget));
 166         n += scnprintf(buf + n, PAGE_SIZE - n, "is_otg            = %d\n",
 167                        gadget->is_otg);
 168         n += scnprintf(buf + n, PAGE_SIZE - n, "is_a_peripheral   = %d\n",
 169                        gadget->is_a_peripheral);
 170         n += scnprintf(buf + n, PAGE_SIZE - n, "b_hnp_enable      = %d\n",
 171                        gadget->b_hnp_enable);
 172         n += scnprintf(buf + n, PAGE_SIZE - n, "a_hnp_support     = %d\n",
 173                        gadget->a_hnp_support);
 174         n += scnprintf(buf + n, PAGE_SIZE - n, "a_alt_hnp_support = %d\n",
 175                        gadget->a_alt_hnp_support);
 176         n += scnprintf(buf + n, PAGE_SIZE - n, "name              = %s\n",
 177                        (gadget->name ? gadget->name : ""));
 178
 179         return n;
 180 }
 181 static DEVICE_ATTR(device, S_IRUSR, show_device, NULL);
 182
 183 /**
 184  * show_driver: prints information about attached gadget (if any)
 185  *
 186  * Check "device.h" for details
 187  */
 188 static ssize_t show_driver(struct device *dev, struct device_attribute *attr,
 189                            char *buf)
 190 {
 191         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 192         struct usb_gadget_driver *driver = ci->driver;
 193         int n = 0;
 194
 195         if (attr == NULL || buf == NULL) {
 196                 dev_err(dev, "[%s] EINVAL\n", __func__);
 197                 return 0;
 198         }
 199
 200         if (driver == NULL)
 201                 return scnprintf(buf, PAGE_SIZE,
 202                                  "There is no gadget attached!\n");
 203
 204         n += scnprintf(buf + n, PAGE_SIZE - n, "function  = %s\n",
 205                        (driver->function ? driver->function : ""));
 206         n += scnprintf(buf + n, PAGE_SIZE - n, "max speed = %d\n",
 207                        driver->max_speed);
 208
 209         return n;
 210 }
 211 static DEVICE_ATTR(driver, S_IRUSR, show_driver, NULL);
 212
 213 /* Maximum event message length */
 214 #define DBG_DATA_MSG   64UL
 215
 216 /* Maximum event messages */
 217 #define DBG_DATA_MAX   128UL
 218
 219 /* Event buffer descriptor */
 220 static struct {
 221         char     (buf[DBG_DATA_MAX])[DBG_DATA_MSG];   /* buffer */
 222         unsigned idx;   /* index */
 223         unsigned tty;   /* print to console? */
 224         rwlock_t lck;   /* lock */
 225 } dbg_data = {
 226         .idx = 0,
 227         .tty = 0,
 228         .lck = __RW_LOCK_UNLOCKED(lck)
 229 };
 230
 231 /**
 232  * dbg_dec: decrements debug event index
 233  * @idx: buffer index
 234  */
 235 static void dbg_dec(unsigned *idx)
 236 {
 237         *idx = (*idx - 1) & (DBG_DATA_MAX-1);
 238 }
 239
 240 /**
 241  * dbg_inc: increments debug event index
 242  * @idx: buffer index
 243  */
 244 static void dbg_inc(unsigned *idx)
 245 {
 246         *idx = (*idx + 1) & (DBG_DATA_MAX-1);
 247 }
 248
 249 /**
 250  * dbg_print:  prints the common part of the event
 251  * @addr:   endpoint address
 252  * @name:   event name
 253  * @status: status
 254  * @extra:  extra information
 255  */
 256 static void dbg_print(u8 addr, const char *name, int status, const char *extra)
 257 {
 258         struct timeval tval;
 259         unsigned int stamp;
 260         unsigned long flags;
 261
 262         write_lock_irqsave(&dbg_data.lck, flags);
 263
 264         do_gettimeofday(&tval);
 265         stamp = tval.tv_sec & 0xFFFF;   /* 2^32 = 4294967296. Limit to 4096s */
 266         stamp = stamp * 1000000 + tval.tv_usec;
 267
 268         scnprintf(dbg_data.buf[dbg_data.idx], DBG_DATA_MSG,
 269                   "%04X\t? %02X %-7.7s %4i ?\t%s\n",
 270                   stamp, addr, name, status, extra);
 271
 272         dbg_inc(&dbg_data.idx);
 273
 274         write_unlock_irqrestore(&dbg_data.lck, flags);
 275
 276         if (dbg_data.tty != 0)
 277                 pr_notice("%04X\t? %02X %-7.7s %4i ?\t%s\n",
 278                           stamp, addr, name, status, extra);
 279 }
 280
 281 /**
 282  * dbg_done: prints a DONE event
 283  * @addr:   endpoint address
 284  * @td:     transfer descriptor
 285  * @status: status
 286  */
 287 void dbg_done(u8 addr, const u32 token, int status)
 288 {
 289         char msg[DBG_DATA_MSG];
 290
 291         scnprintf(msg, sizeof(msg), "%d %02X",
 292                   (int)(token & TD_TOTAL_BYTES) >> ffs_nr(TD_TOTAL_BYTES),
 293                   (int)(token & TD_STATUS)      >> ffs_nr(TD_STATUS));
 294         dbg_print(addr, "DONE", status, msg);
 295 }
 296
 297 /**
 298  * dbg_event: prints a generic event
 299  * @addr:   endpoint address
 300  * @name:   event name
 301  * @status: status
 302  */
 303 void dbg_event(u8 addr, const char *name, int status)
 304 {
 305         if (name != NULL)
 306                 dbg_print(addr, name, status, "");
 307 }
 308
 309 /*
 310  * dbg_queue: prints a QUEUE event
 311  * @addr:   endpoint address
 312  * @req:    USB request
 313  * @status: status
 314  */
 315 void dbg_queue(u8 addr, const struct usb_request *req, int status)
 316 {
 317         char msg[DBG_DATA_MSG];
 318
 319         if (req != NULL) {
 320                 scnprintf(msg, sizeof(msg),
 321                           "%d %d", !req->no_interrupt, req->length);
 322                 dbg_print(addr, "QUEUE", status, msg);
 323         }
 324 }
 325
 326 /**
 327  * dbg_setup: prints a SETUP event
 328  * @addr: endpoint address
 329  * @req:  setup request
 330  */
 331 void dbg_setup(u8 addr, const struct usb_ctrlrequest *req)
 332 {
 333         char msg[DBG_DATA_MSG];
 334
 335         if (req != NULL) {
 336                 scnprintf(msg, sizeof(msg),
 337                           "%02X %02X %04X %04X %d", req->bRequestType,
 338                           req->bRequest, le16_to_cpu(req->wValue),
 339                           le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength));
 340                 dbg_print(addr, "SETUP", 0, msg);
 341         }
 342 }
 343
 344 /**
 345  * show_events: displays the event buffer
 346  *
 347  * Check "device.h" for details
 348  */
 349 static ssize_t show_events(struct device *dev, struct device_attribute *attr,
 350                            char *buf)
 351 {
 352         unsigned long flags;
 353         unsigned i, j, n = 0;
 354
 355         if (attr == NULL || buf == NULL) {
 356                 dev_err(dev->parent, "[%s] EINVAL\n", __func__);
 357                 return 0;
 358         }
 359
 360         read_lock_irqsave(&dbg_data.lck, flags);
 361
 362         i = dbg_data.idx;
 363         for (dbg_dec(&i); i != dbg_data.idx; dbg_dec(&i)) {
 364                 n += strlen(dbg_data.buf[i]);
 365                 if (n >= PAGE_SIZE) {
 366                         n -= strlen(dbg_data.buf[i]);
 367                         break;
 368                 }
 369         }
 370         for (j = 0, dbg_inc(&i); j < n; dbg_inc(&i))
 371                 j += scnprintf(buf + j, PAGE_SIZE - j,
 372                                "%s", dbg_data.buf[i]);
 373
 374         read_unlock_irqrestore(&dbg_data.lck, flags);
 375
 376         return n;
 377 }
 378
 379 /**
 380  * store_events: configure if events are going to be also printed to console
 381  *
 382  * Check "device.h" for details
 383  */
 384 static ssize_t store_events(struct device *dev, struct device_attribute *attr,
 385                             const char *buf, size_t count)
 386 {
 387         unsigned tty;
 388
 389         if (attr == NULL || buf == NULL) {
 390                 dev_err(dev, "[%s] EINVAL\n", __func__);
 391                 goto done;
 392         }
 393
 394         if (sscanf(buf, "%u", &tty) != 1 || tty > 1) {
 395                 dev_err(dev, "<1|0>: enable|disable console log\n");
 396                 goto done;
 397         }
 398
 399         dbg_data.tty = tty;
 400         dev_info(dev, "tty = %u", dbg_data.tty);
 401
 402  done:
 403         return count;
 404 }
 405 static DEVICE_ATTR(events, S_IRUSR | S_IWUSR, show_events, store_events);
 406
 407 /**
 408  * show_inters: interrupt status, enable status and historic
 409  *
 410  * Check "device.h" for details
 411  */
 412 static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
 413                            char *buf)
 414 {
 415         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 416         unsigned long flags;
 417         u32 intr;
 418         unsigned i, j, n = 0;
 419
 420         if (attr == NULL || buf == NULL) {
 421                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 422                 return 0;
 423         }
 424
 425         spin_lock_irqsave(&ci->lock, flags);
 426
 427         /*n += scnprintf(buf + n, PAGE_SIZE - n,
 428                        "status = %08x\n", hw_read_intr_status(ci));
 429         n += scnprintf(buf + n, PAGE_SIZE - n,
 430         "enable = %08x\n", hw_read_intr_enable(ci));*/
 431
 432         n += scnprintf(buf + n, PAGE_SIZE - n, "*test = %d\n",
 433                        isr_statistics.test);
 434         n += scnprintf(buf + n, PAGE_SIZE - n, "? ui  = %d\n",
 435                        isr_statistics.ui);
 436         n += scnprintf(buf + n, PAGE_SIZE - n, "? uei = %d\n",
 437                        isr_statistics.uei);
 438         n += scnprintf(buf + n, PAGE_SIZE - n, "? pci = %d\n",
 439                        isr_statistics.pci);
 440         n += scnprintf(buf + n, PAGE_SIZE - n, "? uri = %d\n",
 441                        isr_statistics.uri);
 442         n += scnprintf(buf + n, PAGE_SIZE - n, "? sli = %d\n",
 443                        isr_statistics.sli);
 444         n += scnprintf(buf + n, PAGE_SIZE - n, "*none = %d\n",
 445                        isr_statistics.none);
 446         n += scnprintf(buf + n, PAGE_SIZE - n, "*hndl = %d\n",
 447                        isr_statistics.hndl.cnt);
 448
 449         for (i = isr_statistics.hndl.idx, j = 0; j <= ISR_MASK; j++, i++) {
 450                 i   &= ISR_MASK;
 451                 intr = isr_statistics.hndl.buf[i];
 452
 453                 if (USBi_UI  & intr)
 454                         n += scnprintf(buf + n, PAGE_SIZE - n, "ui  ");
 455                 intr &= ~USBi_UI;
 456                 if (USBi_UEI & intr)
 457                         n += scnprintf(buf + n, PAGE_SIZE - n, "uei ");
 458                 intr &= ~USBi_UEI;
 459                 if (USBi_PCI & intr)
 460                         n += scnprintf(buf + n, PAGE_SIZE - n, "pci ");
 461                 intr &= ~USBi_PCI;
 462                 if (USBi_URI & intr)
 463                         n += scnprintf(buf + n, PAGE_SIZE - n, "uri ");
 464                 intr &= ~USBi_URI;
 465                 if (USBi_SLI & intr)
 466                         n += scnprintf(buf + n, PAGE_SIZE - n, "sli ");
 467                 intr &= ~USBi_SLI;
 468                 if (intr)
 469                         n += scnprintf(buf + n, PAGE_SIZE - n, "??? ");
 470                 if (isr_statistics.hndl.buf[i])
 471                         n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
 472         }
 473
 474         spin_unlock_irqrestore(&ci->lock, flags);
 475
 476         return n;
 477 }
 478
 479 /**
 480  * store_inters: enable & force or disable an individual interrutps
 481  *                   (to be used for test purposes only)
 482  *
 483  * Check "device.h" for details
 484  */
 485 static ssize_t store_inters(struct device *dev, struct device_attribute *attr,
 486                             const char *buf, size_t count)
 487 {
 488         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 489         unsigned long flags;
 490         unsigned en, bit;
 491
 492         if (attr == NULL || buf == NULL) {
 493                 dev_err(ci->dev, "EINVAL\n");
 494                 goto done;
 495         }
 496
 497         if (sscanf(buf, "%u %u", &en, &bit) != 2 || en > 1) {
 498                 dev_err(ci->dev, "<1|0> <bit>: enable|disable interrupt\n");
 499                 goto done;
 500         }
 501
 502         spin_lock_irqsave(&ci->lock, flags);
 503         if (en) {
 504                 if (hw_intr_force(ci, bit))
 505                         dev_err(dev, "invalid bit number\n");
 506                 else
 507                         isr_statistics.test++;
 508         } else {
 509                 if (hw_intr_clear(ci, bit))
 510                         dev_err(dev, "invalid bit number\n");
 511         }
 512         spin_unlock_irqrestore(&ci->lock, flags);
 513
 514  done:
 515         return count;
 516 }
 517 static DEVICE_ATTR(inters, S_IRUSR | S_IWUSR, show_inters, store_inters);
 518
 519 /**
 520  * show_port_test: reads port test mode
 521  *
 522  * Check "device.h" for details
 523  */
 524 static ssize_t show_port_test(struct device *dev,
 525                               struct device_attribute *attr, char *buf)
 526 {
 527         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 528         unsigned long flags;
 529         unsigned mode;
 530
 531         if (attr == NULL || buf == NULL) {
 532                 dev_err(ci->dev, "EINVAL\n");
 533                 return 0;
 534         }
 535
 536         spin_lock_irqsave(&ci->lock, flags);
 537         mode = hw_port_test_get(ci);
 538         spin_unlock_irqrestore(&ci->lock, flags);
 539
 540         return scnprintf(buf, PAGE_SIZE, "mode = %u\n", mode);
 541 }
 542
 543 /**
 544  * store_port_test: writes port test mode
 545  *
 546  * Check "device.h" for details
 547  */
 548 static ssize_t store_port_test(struct device *dev,
 549                                struct device_attribute *attr,
 550                                const char *buf, size_t count)
 551 {
 552         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 553         unsigned long flags;
 554         unsigned mode;
 555
 556         if (attr == NULL || buf == NULL) {
 557                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 558                 goto done;
 559         }
 560
 561         if (sscanf(buf, "%u", &mode) != 1) {
 562                 dev_err(ci->dev, "<mode>: set port test mode");
 563                 goto done;
 564         }
 565
 566         spin_lock_irqsave(&ci->lock, flags);
 567         if (hw_port_test_set(ci, mode))
 568                 dev_err(ci->dev, "invalid mode\n");
 569         spin_unlock_irqrestore(&ci->lock, flags);
 570
 571  done:
 572         return count;
 573 }
 574 static DEVICE_ATTR(port_test, S_IRUSR | S_IWUSR,
 575                    show_port_test, store_port_test);
 576
 577 /**
 578  * show_qheads: DMA contents of all queue heads
 579  *
 580  * Check "device.h" for details
 581  */
 582 static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
 583                            char *buf)
 584 {
 585         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 586         unsigned long flags;
 587         unsigned i, j, n = 0;
 588
 589         if (attr == NULL || buf == NULL) {
 590                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 591                 return 0;
 592         }
 593
 594         spin_lock_irqsave(&ci->lock, flags);
 595         for (i = 0; i < ci->hw_ep_max/2; i++) {
 596                 struct ci13xxx_ep *mEpRx = &ci->ci13xxx_ep[i];
 597                 struct ci13xxx_ep *mEpTx =
 598                         &ci->ci13xxx_ep[i + ci->hw_ep_max/2];
 599                 n += scnprintf(buf + n, PAGE_SIZE - n,
 600                                "EP=%02i: RX=%08X TX=%08X\n",
 601                                i, (u32)mEpRx->qh.dma, (u32)mEpTx->qh.dma);
 602                 for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++) {
 603                         n += scnprintf(buf + n, PAGE_SIZE - n,
 604                                        " %04X:    %08X    %08X\n", j,
 605                                        *((u32 *)mEpRx->qh.ptr + j),
 606                                        *((u32 *)mEpTx->qh.ptr + j));
 607                 }
 608         }
 609         spin_unlock_irqrestore(&ci->lock, flags);
 610
 611         return n;
 612 }
 613 static DEVICE_ATTR(qheads, S_IRUSR, show_qheads, NULL);
 614
 615 /**
 616  * show_registers: dumps all registers
 617  *
 618  * Check "device.h" for details
 619  */
 620 #define DUMP_ENTRIES    512
 621 static ssize_t show_registers(struct device *dev,
 622                               struct device_attribute *attr, char *buf)
 623 {
 624         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 625         unsigned long flags;
 626         u32 *dump;
 627         unsigned i, k, n = 0;
 628
 629         if (attr == NULL || buf == NULL) {
 630                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 631                 return 0;
 632         }
 633
 634         dump = kmalloc(sizeof(u32) * DUMP_ENTRIES, GFP_KERNEL);
 635         if (!dump) {
 636                 dev_err(ci->dev, "%s: out of memory\n", __func__);
 637                 return 0;
 638         }
 639
 640         spin_lock_irqsave(&ci->lock, flags);
 641         k = hw_register_read(ci, dump, DUMP_ENTRIES);
 642         spin_unlock_irqrestore(&ci->lock, flags);
 643
 644         for (i = 0; i < k; i++) {
 645                 n += scnprintf(buf + n, PAGE_SIZE - n,
 646                                "reg[0x%04X] = 0x%08X\n",
 647                                i * (unsigned)sizeof(u32), dump[i]);
 648         }
 649         kfree(dump);
 650
 651         return n;
 652 }
 653
 654 /**
 655  * store_registers: writes value to register address
 656  *
 657  * Check "device.h" for details
 658  */
 659 static ssize_t store_registers(struct device *dev,
 660                                struct device_attribute *attr,
 661                                const char *buf, size_t count)
 662 {
 663         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 664         unsigned long addr, data, flags;
 665
 666         if (attr == NULL || buf == NULL) {
 667                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 668                 goto done;
 669         }
 670
 671         if (sscanf(buf, "%li %li", &addr, &data) != 2) {
 672                 dev_err(ci->dev,
 673                         "<addr> <data>: write data to register address\n");
 674                 goto done;
 675         }
 676
 677         spin_lock_irqsave(&ci->lock, flags);
 678         if (hw_register_write(ci, addr, data))
 679                 dev_err(ci->dev, "invalid address range\n");
 680         spin_unlock_irqrestore(&ci->lock, flags);
 681
 682  done:
 683         return count;
 684 }
 685 static DEVICE_ATTR(registers, S_IRUSR | S_IWUSR,
 686                    show_registers, store_registers);
 687
 688 /**
 689  * show_requests: DMA contents of all requests currently queued (all endpts)
 690  *
 691  * Check "device.h" for details
 692  */
 693 static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
 694                              char *buf)
 695 {
 696         struct ci13xxx *ci = container_of(dev, struct ci13xxx, gadget.dev);
 697         unsigned long flags;
 698         struct list_head   *ptr = NULL;
 699         struct ci13xxx_req *req = NULL;
 700         unsigned i, j, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
 701
 702         if (attr == NULL || buf == NULL) {
 703                 dev_err(ci->dev, "[%s] EINVAL\n", __func__);
 704                 return 0;
 705         }
 706
 707         spin_lock_irqsave(&ci->lock, flags);
 708         for (i = 0; i < ci->hw_ep_max; i++)
 709                 list_for_each(ptr, &ci->ci13xxx_ep[i].qh.queue)
 710                 {
 711                         req = list_entry(ptr, struct ci13xxx_req, queue);
 712
 713                         n += scnprintf(buf + n, PAGE_SIZE - n,
 714                                         "EP=%02i: TD=%08X %s\n",
 715                                         i % ci->hw_ep_max/2, (u32)req->dma,
 716                                         ((i < ci->hw_ep_max/2) ? "RX" : "TX"));
 717
 718                         for (j = 0; j < qSize; j++)
 719                                 n += scnprintf(buf + n, PAGE_SIZE - n,
 720                                                 " %04X:    %08X\n", j,
 721                                                 *((u32 *)req->ptr + j));
 722                 }
 723         spin_unlock_irqrestore(&ci->lock, flags);
 724
 725         return n;
 726 }
 727 static DEVICE_ATTR(requests, S_IRUSR, show_requests, NULL);
 728
 729 /**
 730  * dbg_create_files: initializes the attribute interface
 731  * @dev: device
 732  *
 733  * This function returns an error code
 734  */
 735 int dbg_create_files(struct device *dev)
 736 {
 737         int retval = 0;
 738
 739         if (dev == NULL)
 740                 return -EINVAL;
 741         retval = device_create_file(dev, &dev_attr_device);
 742         if (retval)
 743                 goto done;
 744         retval = device_create_file(dev, &dev_attr_driver);
 745         if (retval)
 746                 goto rm_device;
 747         retval = device_create_file(dev, &dev_attr_events);
 748         if (retval)
 749                 goto rm_driver;
 750         retval = device_create_file(dev, &dev_attr_inters);
 751         if (retval)
 752                 goto rm_events;
 753         retval = device_create_file(dev, &dev_attr_port_test);
 754         if (retval)
 755                 goto rm_inters;
 756         retval = device_create_file(dev, &dev_attr_qheads);
 757         if (retval)
 758                 goto rm_port_test;
 759         retval = device_create_file(dev, &dev_attr_registers);
 760         if (retval)
 761                 goto rm_qheads;
 762         retval = device_create_file(dev, &dev_attr_requests);
 763         if (retval)
 764                 goto rm_registers;
 765         return 0;
 766
 767  rm_registers:
 768         device_remove_file(dev, &dev_attr_registers);
 769  rm_qheads:
 770         device_remove_file(dev, &dev_attr_qheads);
 771  rm_port_test:
 772         device_remove_file(dev, &dev_attr_port_test);
 773  rm_inters:
 774         device_remove_file(dev, &dev_attr_inters);
 775  rm_events:
 776         device_remove_file(dev, &dev_attr_events);
 777  rm_driver:
 778         device_remove_file(dev, &dev_attr_driver);
 779  rm_device:
 780         device_remove_file(dev, &dev_attr_device);
 781  done:
 782         return retval;
 783 }
 784
 785 /**
 786  * dbg_remove_files: destroys the attribute interface
 787  * @dev: device
 788  *
 789  * This function returns an error code
 790  */
 791 int dbg_remove_files(struct device *dev)
 792 {
 793         if (dev == NULL)
 794                 return -EINVAL;
 795         device_remove_file(dev, &dev_attr_requests);
 796         device_remove_file(dev, &dev_attr_registers);
 797         device_remove_file(dev, &dev_attr_qheads);
 798         device_remove_file(dev, &dev_attr_port_test);
 799         device_remove_file(dev, &dev_attr_inters);
 800         device_remove_file(dev, &dev_attr_events);
 801         device_remove_file(dev, &dev_attr_driver);
 802         device_remove_file(dev, &dev_attr_device);
 803         return 0;
 804 }