1/* 2 * Copyright (c) 2006, 2007, 2008 QLogic Corporation. 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 <linux/fs.h> 48#include <linux/export.h> 49#include <asm/uaccess.h> 50 51#include "ipath_kernel.h" 52#include "ipath_common.h" 53 54int ipath_diag_inuse; 55static int diag_set_link; 56 57static int ipath_diag_open(struct inode *in, struct file *fp); 58static int ipath_diag_release(struct inode *in, struct file *fp); 59static ssize_t ipath_diag_read(struct file *fp, char __user *data, 60 size_t count, loff_t *off); 61static ssize_t ipath_diag_write(struct file *fp, const char __user *data, 62 size_t count, loff_t *off); 63 64static const struct file_operations diag_file_ops = { 65 .owner = THIS_MODULE, 66 .write = ipath_diag_write, 67 .read = ipath_diag_read, 68 .open = ipath_diag_open, 69 .release = ipath_diag_release, 70 .llseek = default_llseek, 71}; 72 73static ssize_t ipath_diagpkt_write(struct file *fp, 74 const char __user *data, 75 size_t count, loff_t *off); 76 77static const struct file_operations diagpkt_file_ops = { 78 .owner = THIS_MODULE, 79 .write = ipath_diagpkt_write, 80 .llseek = noop_llseek, 81}; 82 83static atomic_t diagpkt_count = ATOMIC_INIT(0); 84static struct cdev *diagpkt_cdev; 85static struct device *diagpkt_dev; 86 87int ipath_diag_add(struct ipath_devdata *dd) 88{ 89 char name[16]; 90 int ret = 0; 91 92 if (atomic_inc_return(&diagpkt_count) == 1) { 93 ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR, 94 "ipath_diagpkt", &diagpkt_file_ops, 95 &diagpkt_cdev, &diagpkt_dev); 96 97 if (ret) { 98 ipath_dev_err(dd, "Couldn't create ipath_diagpkt " 99 "device: %d", ret); 100 goto done; 101 } 102 } 103 104 snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit); 105 106 ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name, 107 &diag_file_ops, &dd->diag_cdev, 108 &dd->diag_dev); 109 if (ret) 110 ipath_dev_err(dd, "Couldn't create %s device: %d", 111 name, ret); 112 113done: 114 return ret; 115} 116 117void ipath_diag_remove(struct ipath_devdata *dd) 118{ 119 if (atomic_dec_and_test(&diagpkt_count)) 120 ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev); 121 122 ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev); 123} 124 125/** 126 * ipath_read_umem64 - read a 64-bit quantity from the chip into user space 127 * @dd: the infinipath device 128 * @uaddr: the location to store the data in user memory 129 * @caddr: the source chip address (full pointer, not offset) 130 * @count: number of bytes to copy (multiple of 32 bits) 131 * 132 * This function also localizes all chip memory accesses. 133 * The copy should be written such that we read full cacheline packets 134 * from the chip. This is usually used for a single qword 135 * 136 * NOTE: This assumes the chip address is 64-bit aligned. 137 */ 138static int ipath_read_umem64(struct ipath_devdata *dd, void __user *uaddr, 139 const void __iomem *caddr, size_t count) 140{ 141 const u64 __iomem *reg_addr = caddr; 142 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64)); 143 int ret; 144 145 /* not very efficient, but it works for now */ 146 if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) { 147 ret = -EINVAL; 148 goto bail; 149 } 150 while (reg_addr < reg_end) { 151 u64 data = readq(reg_addr); 152 if (copy_to_user(uaddr, &data, sizeof(u64))) { 153 ret = -EFAULT; 154 goto bail; 155 } 156 reg_addr++; 157 uaddr += sizeof(u64); 158 } 159 ret = 0; 160bail: 161 return ret; 162} 163 164/** 165 * ipath_write_umem64 - write a 64-bit quantity to the chip from user space 166 * @dd: the infinipath device 167 * @caddr: the destination chip address (full pointer, not offset) 168 * @uaddr: the source of the data in user memory 169 * @count: the number of bytes to copy (multiple of 32 bits) 170 * 171 * This is usually used for a single qword 172 * NOTE: This assumes the chip address is 64-bit aligned. 173 */ 174 175static int ipath_write_umem64(struct ipath_devdata *dd, void __iomem *caddr, 176 const void __user *uaddr, size_t count) 177{ 178 u64 __iomem *reg_addr = caddr; 179 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64)); 180 int ret; 181 182 /* not very efficient, but it works for now */ 183 if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) { 184 ret = -EINVAL; 185 goto bail; 186 } 187 while (reg_addr < reg_end) { 188 u64 data; 189 if (copy_from_user(&data, uaddr, sizeof(data))) { 190 ret = -EFAULT; 191 goto bail; 192 } 193 writeq(data, reg_addr); 194 195 reg_addr++; 196 uaddr += sizeof(u64); 197 } 198 ret = 0; 199bail: 200 return ret; 201} 202 203/** 204 * ipath_read_umem32 - read a 32-bit quantity from the chip into user space 205 * @dd: the infinipath device 206 * @uaddr: the location to store the data in user memory 207 * @caddr: the source chip address (full pointer, not offset) 208 * @count: number of bytes to copy 209 * 210 * read 32 bit values, not 64 bit; for memories that only 211 * support 32 bit reads; usually a single dword. 212 */ 213static int ipath_read_umem32(struct ipath_devdata *dd, void __user *uaddr, 214 const void __iomem *caddr, size_t count) 215{ 216 const u32 __iomem *reg_addr = caddr; 217 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32)); 218 int ret; 219 220 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase || 221 reg_end > (u32 __iomem *) dd->ipath_kregend) { 222 ret = -EINVAL; 223 goto bail; 224 } 225 /* not very efficient, but it works for now */ 226 while (reg_addr < reg_end) { 227 u32 data = readl(reg_addr); 228 if (copy_to_user(uaddr, &data, sizeof(data))) { 229 ret = -EFAULT; 230 goto bail; 231 } 232 233 reg_addr++; 234 uaddr += sizeof(u32); 235 236 } 237 ret = 0; 238bail: 239 return ret; 240} 241 242/** 243 * ipath_write_umem32 - write a 32-bit quantity to the chip from user space 244 * @dd: the infinipath device 245 * @caddr: the destination chip address (full pointer, not offset) 246 * @uaddr: the source of the data in user memory 247 * @count: number of bytes to copy 248 * 249 * write 32 bit values, not 64 bit; for memories that only 250 * support 32 bit write; usually a single dword. 251 */ 252 253static int ipath_write_umem32(struct ipath_devdata *dd, void __iomem *caddr, 254 const void __user *uaddr, size_t count) 255{ 256 u32 __iomem *reg_addr = caddr; 257 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32)); 258 int ret; 259 260 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase || 261 reg_end > (u32 __iomem *) dd->ipath_kregend) { 262 ret = -EINVAL; 263 goto bail; 264 } 265 while (reg_addr < reg_end) { 266 u32 data; 267 if (copy_from_user(&data, uaddr, sizeof(data))) { 268 ret = -EFAULT; 269 goto bail; 270 } 271 writel(data, reg_addr); 272 273 reg_addr++; 274 uaddr += sizeof(u32); 275 } 276 ret = 0; 277bail: 278 return ret; 279} 280 281static int ipath_diag_open(struct inode *in, struct file *fp) 282{ 283 int unit = iminor(in) - IPATH_DIAG_MINOR_BASE; 284 struct ipath_devdata *dd; 285 int ret; 286 287 mutex_lock(&ipath_mutex); 288 289 if (ipath_diag_inuse) { 290 ret = -EBUSY; 291 goto bail; 292 } 293 294 dd = ipath_lookup(unit); 295 296 if (dd == NULL || !(dd->ipath_flags & IPATH_PRESENT) || 297 !dd->ipath_kregbase) { 298 ret = -ENODEV; 299 goto bail; 300 } 301 302 fp->private_data = dd; 303 ipath_diag_inuse = -2; 304 diag_set_link = 0; 305 ret = 0; 306 307 /* Only expose a way to reset the device if we 308 make it into diag mode. */ 309 ipath_expose_reset(&dd->pcidev->dev); 310 311bail: 312 mutex_unlock(&ipath_mutex); 313 314 return ret; 315} 316 317/** 318 * ipath_diagpkt_write - write an IB packet 319 * @fp: the diag data device file pointer 320 * @data: ipath_diag_pkt structure saying where to get the packet 321 * @count: size of data to write 322 * @off: unused by this code 323 */ 324static ssize_t ipath_diagpkt_write(struct file *fp, 325 const char __user *data, 326 size_t count, loff_t *off) 327{ 328 u32 __iomem *piobuf; 329 u32 plen, pbufn, maxlen_reserve; 330 struct ipath_diag_pkt odp; 331 struct ipath_diag_xpkt dp; 332 u32 *tmpbuf = NULL; 333 struct ipath_devdata *dd; 334 ssize_t ret = 0; 335 u64 val; 336 u32 l_state, lt_state; /* LinkState, LinkTrainingState */ 337 338 339 if (count == sizeof(dp)) { 340 if (copy_from_user(&dp, data, sizeof(dp))) { 341 ret = -EFAULT; 342 goto bail; 343 } 344 } else if (count == sizeof(odp)) { 345 if (copy_from_user(&odp, data, sizeof(odp))) { 346 ret = -EFAULT; 347 goto bail; 348 } 349 dp.len = odp.len; 350 dp.unit = odp.unit; 351 dp.data = odp.data; 352 dp.pbc_wd = 0; 353 } else { 354 ret = -EINVAL; 355 goto bail; 356 } 357 358 /* send count must be an exact number of dwords */ 359 if (dp.len & 3) { 360 ret = -EINVAL; 361 goto bail; 362 } 363 364 plen = dp.len >> 2; 365 366 dd = ipath_lookup(dp.unit); 367 if (!dd || !(dd->ipath_flags & IPATH_PRESENT) || 368 !dd->ipath_kregbase) { 369 ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n", 370 dp.unit); 371 ret = -ENODEV; 372 goto bail; 373 } 374 375 if (ipath_diag_inuse && !diag_set_link && 376 !(dd->ipath_flags & IPATH_LINKACTIVE)) { 377 diag_set_link = 1; 378 ipath_cdbg(VERBOSE, "Trying to set to set link active for " 379 "diag pkt\n"); 380 ipath_set_linkstate(dd, IPATH_IB_LINKARM); 381 ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE); 382 } 383 384 if (!(dd->ipath_flags & IPATH_INITTED)) { 385 /* no hardware, freeze, etc. */ 386 ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit); 387 ret = -ENODEV; 388 goto bail; 389 } 390 /* 391 * Want to skip check for l_state if using custom PBC, 392 * because we might be trying to force an SM packet out. 393 * first-cut, skip _all_ state checking in that case. 394 */ 395 val = ipath_ib_state(dd, dd->ipath_lastibcstat); 396 lt_state = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat); 397 l_state = ipath_ib_linkstate(dd, dd->ipath_lastibcstat); 398 if (!dp.pbc_wd && (lt_state != INFINIPATH_IBCS_LT_STATE_LINKUP || 399 (val != dd->ib_init && val != dd->ib_arm && 400 val != dd->ib_active))) { 401 ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n", 402 dd->ipath_unit, (unsigned long long) val); 403 ret = -EINVAL; 404 goto bail; 405 } 406 407 /* 408 * need total length before first word written, plus 2 Dwords. One Dword 409 * is for padding so we get the full user data when not aligned on 410 * a word boundary. The other Dword is to make sure we have room for the 411 * ICRC which gets tacked on later. 412 */ 413 maxlen_reserve = 2 * sizeof(u32); 414 if (dp.len > dd->ipath_ibmaxlen - maxlen_reserve) { 415 ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n", 416 dp.len, dd->ipath_ibmaxlen); 417 ret = -EINVAL; 418 goto bail; 419 } 420 421 plen = sizeof(u32) + dp.len; 422 423 tmpbuf = vmalloc(plen); 424 if (!tmpbuf) { 425 dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, " 426 "failing\n"); 427 ret = -ENOMEM; 428 goto bail; 429 } 430 431 if (copy_from_user(tmpbuf, 432 (const void __user *) (unsigned long) dp.data, 433 dp.len)) { 434 ret = -EFAULT; 435 goto bail; 436 } 437 438 plen >>= 2; /* in dwords */ 439 440 piobuf = ipath_getpiobuf(dd, plen, &pbufn); 441 if (!piobuf) { 442 ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n", 443 dd->ipath_unit); 444 ret = -EBUSY; 445 goto bail; 446 } 447 /* disarm it just to be extra sure */ 448 ipath_disarm_piobufs(dd, pbufn, 1); 449 450 if (ipath_debug & __IPATH_PKTDBG) 451 ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n", 452 dd->ipath_unit, plen - 1, pbufn); 453 454 if (dp.pbc_wd == 0) 455 dp.pbc_wd = plen; 456 writeq(dp.pbc_wd, piobuf); 457 /* 458 * Copy all by the trigger word, then flush, so it's written 459 * to chip before trigger word, then write trigger word, then 460 * flush again, so packet is sent. 461 */ 462 if (dd->ipath_flags & IPATH_PIO_FLUSH_WC) { 463 ipath_flush_wc(); 464 __iowrite32_copy(piobuf + 2, tmpbuf, plen - 1); 465 ipath_flush_wc(); 466 __raw_writel(tmpbuf[plen - 1], piobuf + plen + 1); 467 } else 468 __iowrite32_copy(piobuf + 2, tmpbuf, plen); 469 470 ipath_flush_wc(); 471 472 ret = sizeof(dp); 473 474bail: 475 vfree(tmpbuf); 476 return ret; 477} 478 479static int ipath_diag_release(struct inode *in, struct file *fp) 480{ 481 mutex_lock(&ipath_mutex); 482 ipath_diag_inuse = 0; 483 fp->private_data = NULL; 484 mutex_unlock(&ipath_mutex); 485 return 0; 486} 487 488static ssize_t ipath_diag_read(struct file *fp, char __user *data, 489 size_t count, loff_t *off) 490{ 491 struct ipath_devdata *dd = fp->private_data; 492 void __iomem *kreg_base; 493 ssize_t ret; 494 495 kreg_base = dd->ipath_kregbase; 496 497 if (count == 0) 498 ret = 0; 499 else if ((count % 4) || (*off % 4)) 500 /* address or length is not 32-bit aligned, hence invalid */ 501 ret = -EINVAL; 502 else if (ipath_diag_inuse < 1 && (*off || count != 8)) 503 ret = -EINVAL; /* prevent cat /dev/ipath_diag* */ 504 else if ((count % 8) || (*off % 8)) 505 /* address or length not 64-bit aligned; do 32-bit reads */ 506 ret = ipath_read_umem32(dd, data, kreg_base + *off, count); 507 else 508 ret = ipath_read_umem64(dd, data, kreg_base + *off, count); 509 510 if (ret >= 0) { 511 *off += count; 512 ret = count; 513 if (ipath_diag_inuse == -2) 514 ipath_diag_inuse++; 515 } 516 517 return ret; 518} 519 520static ssize_t ipath_diag_write(struct file *fp, const char __user *data, 521 size_t count, loff_t *off) 522{ 523 struct ipath_devdata *dd = fp->private_data; 524 void __iomem *kreg_base; 525 ssize_t ret; 526 527 kreg_base = dd->ipath_kregbase; 528 529 if (count == 0) 530 ret = 0; 531 else if ((count % 4) || (*off % 4)) 532 /* address or length is not 32-bit aligned, hence invalid */ 533 ret = -EINVAL; 534 else if ((ipath_diag_inuse == -1 && (*off || count != 8)) || 535 ipath_diag_inuse == -2) /* read qw off 0, write qw off 0 */ 536 ret = -EINVAL; /* before any other write allowed */ 537 else if ((count % 8) || (*off % 8)) 538 /* address or length not 64-bit aligned; do 32-bit writes */ 539 ret = ipath_write_umem32(dd, kreg_base + *off, data, count); 540 else 541 ret = ipath_write_umem64(dd, kreg_base + *off, data, count); 542 543 if (ret >= 0) { 544 *off += count; 545 ret = count; 546 if (ipath_diag_inuse == -1) 547 ipath_diag_inuse = 1; /* all read/write OK now */ 548 } 549 550 return ret; 551} 552