drivers/infiniband/hw/ipath/ipath_diag.c

   1 /*
   2  * Copyright (c) 2006 QLogic, Inc. All rights reserved.
   3  * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 /*
  35  * This file contains support for diagnostic functions.  It is accessed by
  36  * opening the ipath_diag device, normally minor number 129.  Diagnostic use
  37  * of the InfiniPath chip may render the chip or board unusable until the
  38  * driver is unloaded, or in some cases, until the system is rebooted.
  39  *
  40  * Accesses to the chip through this interface are not similar to going
  41  * through the /sys/bus/pci resource mmap interface.
  42  */
  43
  44 #include <linux/io.h>
  45 #include <linux/pci.h>
  46 #include <linux/vmalloc.h>
  47 #include <asm/uaccess.h>
  48
  49 #include "ipath_kernel.h"
  50 #include "ipath_common.h"
  51
  52 int ipath_diag_inuse;
  53 static int diag_set_link;
  54
  55 static int ipath_diag_open(struct inode *in, struct file *fp);
  56 static int ipath_diag_release(struct inode *in, struct file *fp);
  57 static ssize_t ipath_diag_read(struct file *fp, char __user *data,
  58                                size_t count, loff_t *off);
  59 static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
  60                                 size_t count, loff_t *off);
  61
  62 static struct file_operations diag_file_ops = {
  63         .owner = THIS_MODULE,
  64         .write = ipath_diag_write,
  65         .read = ipath_diag_read,
  66         .open = ipath_diag_open,
  67         .release = ipath_diag_release
  68 };
  69
  70 int ipath_diag_add(struct ipath_devdata *dd)
  71 {
  72         char name[16];
  73
  74         snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);
  75
  76         return ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
  77                                &diag_file_ops, &dd->diag_cdev,
  78                                &dd->diag_class_dev);
  79 }
  80
  81 void ipath_diag_remove(struct ipath_devdata *dd)
  82 {
  83         ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_dev);
  84 }
  85
  86 /**
  87  * ipath_read_umem64 - read a 64-bit quantity from the chip into user space
  88  * @dd: the infinipath device
  89  * @uaddr: the location to store the data in user memory
  90  * @caddr: the source chip address (full pointer, not offset)
  91  * @count: number of bytes to copy (multiple of 32 bits)
  92  *
  93  * This function also localizes all chip memory accesses.
  94  * The copy should be written such that we read full cacheline packets
  95  * from the chip.  This is usually used for a single qword
  96  *
  97  * NOTE:  This assumes the chip address is 64-bit aligned.
  98  */
  99 static int ipath_read_umem64(struct ipath_devdata *dd, void __user *uaddr,
 100                              const void __iomem *caddr, size_t count)
 101 {
 102         const u64 __iomem *reg_addr = caddr;
 103         const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
 104         int ret;
 105
 106         /* not very efficient, but it works for now */
 107         if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
 108                 ret = -EINVAL;
 109                 goto bail;
 110         }
 111         while (reg_addr < reg_end) {
 112                 u64 data = readq(reg_addr);
 113                 if (copy_to_user(uaddr, &data, sizeof(u64))) {
 114                         ret = -EFAULT;
 115                         goto bail;
 116                 }
 117                 reg_addr++;
 118                 uaddr += sizeof(u64);
 119         }
 120         ret = 0;
 121 bail:
 122         return ret;
 123 }
 124
 125 /**
 126  * ipath_write_umem64 - write a 64-bit quantity to the chip from user space
 127  * @dd: the infinipath device
 128  * @caddr: the destination chip address (full pointer, not offset)
 129  * @uaddr: the source of the data in user memory
 130  * @count: the number of bytes to copy (multiple of 32 bits)
 131  *
 132  * This is usually used for a single qword
 133  * NOTE:  This assumes the chip address is 64-bit aligned.
 134  */
 135
 136 static int ipath_write_umem64(struct ipath_devdata *dd, void __iomem *caddr,
 137                               const void __user *uaddr, size_t count)
 138 {
 139         u64 __iomem *reg_addr = caddr;
 140         const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
 141         int ret;
 142
 143         /* not very efficient, but it works for now */
 144         if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
 145                 ret = -EINVAL;
 146                 goto bail;
 147         }
 148         while (reg_addr < reg_end) {
 149                 u64 data;
 150                 if (copy_from_user(&data, uaddr, sizeof(data))) {
 151                         ret = -EFAULT;
 152                         goto bail;
 153                 }
 154                 writeq(data, reg_addr);
 155
 156                 reg_addr++;
 157                 uaddr += sizeof(u64);
 158         }
 159         ret = 0;
 160 bail:
 161         return ret;
 162 }
 163
 164 /**
 165  * ipath_read_umem32 - read a 32-bit quantity from the chip into user space
 166  * @dd: the infinipath device
 167  * @uaddr: the location to store the data in user memory
 168  * @caddr: the source chip address (full pointer, not offset)
 169  * @count: number of bytes to copy
 170  *
 171  * read 32 bit values, not 64 bit; for memories that only
 172  * support 32 bit reads; usually a single dword.
 173  */
 174 static int ipath_read_umem32(struct ipath_devdata *dd, void __user *uaddr,
 175                              const void __iomem *caddr, size_t count)
 176 {
 177         const u32 __iomem *reg_addr = caddr;
 178         const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
 179         int ret;
 180
 181         if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
 182             reg_end > (u32 __iomem *) dd->ipath_kregend) {
 183                 ret = -EINVAL;
 184                 goto bail;
 185         }
 186         /* not very efficient, but it works for now */
 187         while (reg_addr < reg_end) {
 188                 u32 data = readl(reg_addr);
 189                 if (copy_to_user(uaddr, &data, sizeof(data))) {
 190                         ret = -EFAULT;
 191                         goto bail;
 192                 }
 193
 194                 reg_addr++;
 195                 uaddr += sizeof(u32);
 196
 197         }
 198         ret = 0;
 199 bail:
 200         return ret;
 201 }
 202
 203 /**
 204  * ipath_write_umem32 - write a 32-bit quantity to the chip from user space
 205  * @dd: the infinipath device
 206  * @caddr: the destination chip address (full pointer, not offset)
 207  * @uaddr: the source of the data in user memory
 208  * @count: number of bytes to copy
 209  *
 210  * write 32 bit values, not 64 bit; for memories that only
 211  * support 32 bit write; usually a single dword.
 212  */
 213
 214 static int ipath_write_umem32(struct ipath_devdata *dd, void __iomem *caddr,
 215                               const void __user *uaddr, size_t count)
 216 {
 217         u32 __iomem *reg_addr = caddr;
 218         const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
 219         int ret;
 220
 221         if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
 222             reg_end > (u32 __iomem *) dd->ipath_kregend) {
 223                 ret = -EINVAL;
 224                 goto bail;
 225         }
 226         while (reg_addr < reg_end) {
 227                 u32 data;
 228                 if (copy_from_user(&data, uaddr, sizeof(data))) {
 229                         ret = -EFAULT;
 230                         goto bail;
 231                 }
 232                 writel(data, reg_addr);
 233
 234                 reg_addr++;
 235                 uaddr += sizeof(u32);
 236         }
 237         ret = 0;
 238 bail:
 239         return ret;
 240 }
 241
 242 static int ipath_diag_open(struct inode *in, struct file *fp)
 243 {
 244         int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
 245         struct ipath_devdata *dd;
 246         int ret;
 247
 248         mutex_lock(&ipath_mutex);
 249
 250         if (ipath_diag_inuse) {
 251                 ret = -EBUSY;
 252                 goto bail;
 253         }
 254
 255         dd = ipath_lookup(unit);
 256
 257         if (dd == NULL || !(dd->ipath_flags & IPATH_PRESENT) ||
 258             !dd->ipath_kregbase) {
 259                 ret = -ENODEV;
 260                 goto bail;
 261         }
 262
 263         fp->private_data = dd;
 264         ipath_diag_inuse = 1;
 265         diag_set_link = 0;
 266         ret = 0;
 267
 268         /* Only expose a way to reset the device if we
 269            make it into diag mode. */
 270         ipath_expose_reset(&dd->pcidev->dev);
 271
 272 bail:
 273         mutex_unlock(&ipath_mutex);
 274
 275         return ret;
 276 }
 277
 278 static ssize_t ipath_diagpkt_write(struct file *fp,
 279                                    const char __user *data,
 280                                    size_t count, loff_t *off);
 281
 282 static struct file_operations diagpkt_file_ops = {
 283         .owner = THIS_MODULE,
 284         .write = ipath_diagpkt_write,
 285 };
 286
 287 static struct cdev *diagpkt_cdev;
 288 static struct class_device *diagpkt_class_dev;
 289
 290 int __init ipath_diagpkt_add(void)
 291 {
 292         return ipath_cdev_init(IPATH_DIAGPKT_MINOR,
 293                                "ipath_diagpkt", &diagpkt_file_ops,
 294                                &diagpkt_cdev, &diagpkt_class_dev);
 295 }
 296
 297 void __exit ipath_diagpkt_remove(void)
 298 {
 299         ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_class_dev);
 300 }
 301
 302 /**
 303  * ipath_diagpkt_write - write an IB packet
 304  * @fp: the diag data device file pointer
 305  * @data: ipath_diag_pkt structure saying where to get the packet
 306  * @count: size of data to write
 307  * @off: unused by this code
 308  */
 309 static ssize_t ipath_diagpkt_write(struct file *fp,
 310                                    const char __user *data,
 311                                    size_t count, loff_t *off)
 312 {
 313         u32 __iomem *piobuf;
 314         u32 plen, clen, pbufn;
 315         struct ipath_diag_pkt dp;
 316         u32 *tmpbuf = NULL;
 317         struct ipath_devdata *dd;
 318         ssize_t ret = 0;
 319         u64 val;
 320
 321         if (count < sizeof(dp)) {
 322                 ret = -EINVAL;
 323                 goto bail;
 324         }
 325
 326         if (copy_from_user(&dp, data, sizeof(dp))) {
 327                 ret = -EFAULT;
 328                 goto bail;
 329         }
 330
 331         /* send count must be an exact number of dwords */
 332         if (dp.len & 3) {
 333                 ret = -EINVAL;
 334                 goto bail;
 335         }
 336
 337         clen = dp.len >> 2;
 338
 339         dd = ipath_lookup(dp.unit);
 340         if (!dd || !(dd->ipath_flags & IPATH_PRESENT) ||
 341             !dd->ipath_kregbase) {
 342                 ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n",
 343                            dp.unit);
 344                 ret = -ENODEV;
 345                 goto bail;
 346         }
 347
 348         if (ipath_diag_inuse && !diag_set_link &&
 349             !(dd->ipath_flags & IPATH_LINKACTIVE)) {
 350                 diag_set_link = 1;
 351                 ipath_cdbg(VERBOSE, "Trying to set to set link active for "
 352                            "diag pkt\n");
 353                 ipath_set_linkstate(dd, IPATH_IB_LINKARM);
 354                 ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
 355         }
 356
 357         if (!(dd->ipath_flags & IPATH_INITTED)) {
 358                 /* no hardware, freeze, etc. */
 359                 ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit);
 360                 ret = -ENODEV;
 361                 goto bail;
 362         }
 363         val = dd->ipath_lastibcstat & IPATH_IBSTATE_MASK;
 364         if (val != IPATH_IBSTATE_INIT && val != IPATH_IBSTATE_ARM &&
 365             val != IPATH_IBSTATE_ACTIVE) {
 366                 ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
 367                            dd->ipath_unit, (unsigned long long) val);
 368                 ret = -EINVAL;
 369                 goto bail;
 370         }
 371
 372         /* need total length before first word written */
 373         /* +1 word is for the qword padding */
 374         plen = sizeof(u32) + dp.len;
 375
 376         if ((plen + 4) > dd->ipath_ibmaxlen) {
 377                 ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
 378                           plen - 4, dd->ipath_ibmaxlen);
 379                 ret = -EINVAL;
 380                 goto bail;      /* before writing pbc */
 381         }
 382         tmpbuf = vmalloc(plen);
 383         if (!tmpbuf) {
 384                 dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, "
 385                          "failing\n");
 386                 ret = -ENOMEM;
 387                 goto bail;
 388         }
 389
 390         if (copy_from_user(tmpbuf,
 391                            (const void __user *) (unsigned long) dp.data,
 392                            dp.len)) {
 393                 ret = -EFAULT;
 394                 goto bail;
 395         }
 396
 397         piobuf = ipath_getpiobuf(dd, &pbufn);
 398         if (!piobuf) {
 399                 ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
 400                            dd->ipath_unit);
 401                 ret = -EBUSY;
 402                 goto bail;
 403         }
 404
 405         plen >>= 2;             /* in dwords */
 406
 407         if (ipath_debug & __IPATH_PKTDBG)
 408                 ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n",
 409                            dd->ipath_unit, plen - 1, pbufn);
 410
 411         /* we have to flush after the PBC for correctness on some cpus
 412          * or WC buffer can be written out of order */
 413         writeq(plen, piobuf);
 414         ipath_flush_wc();
 415         /* copy all by the trigger word, then flush, so it's written
 416          * to chip before trigger word, then write trigger word, then
 417          * flush again, so packet is sent. */
 418         __iowrite32_copy(piobuf + 2, tmpbuf, clen - 1);
 419         ipath_flush_wc();
 420         __raw_writel(tmpbuf[clen - 1], piobuf + clen + 1);
 421         ipath_flush_wc();
 422
 423         ret = sizeof(dp);
 424
 425 bail:
 426         vfree(tmpbuf);
 427         return ret;
 428 }
 429
 430 static int ipath_diag_release(struct inode *in, struct file *fp)
 431 {
 432         mutex_lock(&ipath_mutex);
 433         ipath_diag_inuse = 0;
 434         fp->private_data = NULL;
 435         mutex_unlock(&ipath_mutex);
 436         return 0;
 437 }
 438
 439 static ssize_t ipath_diag_read(struct file *fp, char __user *data,
 440                                size_t count, loff_t *off)
 441 {
 442         struct ipath_devdata *dd = fp->private_data;
 443         void __iomem *kreg_base;
 444         ssize_t ret;
 445
 446         kreg_base = dd->ipath_kregbase;
 447
 448         if (count == 0)
 449                 ret = 0;
 450         else if ((count % 4) || (*off % 4))
 451                 /* address or length is not 32-bit aligned, hence invalid */
 452                 ret = -EINVAL;
 453         else if ((count % 8) || (*off % 8))
 454                 /* address or length not 64-bit aligned; do 32-bit reads */
 455                 ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
 456         else
 457                 ret = ipath_read_umem64(dd, data, kreg_base + *off, count);
 458
 459         if (ret >= 0) {
 460                 *off += count;
 461                 ret = count;
 462         }
 463
 464         return ret;
 465 }
 466
 467 static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
 468                                 size_t count, loff_t *off)
 469 {
 470         struct ipath_devdata *dd = fp->private_data;
 471         void __iomem *kreg_base;
 472         ssize_t ret;
 473
 474         kreg_base = dd->ipath_kregbase;
 475
 476         if (count == 0)
 477                 ret = 0;
 478         else if ((count % 4) || (*off % 4))
 479                 /* address or length is not 32-bit aligned, hence invalid */
 480                 ret = -EINVAL;
 481         else if ((count % 8) || (*off % 8))
 482                 /* address or length not 64-bit aligned; do 32-bit writes */
 483                 ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
 484         else
 485                 ret = ipath_write_umem64(dd, kreg_base + *off, data, count);
 486
 487         if (ret >= 0) {
 488                 *off += count;
 489                 ret = count;
 490         }
 491
 492         return ret;
 493 }