1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44#include <linux/io.h>
45#include <linux/pci.h>
46#include <linux/vmalloc.h>
47#include <linux/fs.h>
48#include <asm/uaccess.h>
49
50#include "ipath_kernel.h"
51#include "ipath_common.h"
52
53int ipath_diag_inuse;
54static int diag_set_link;
55
56static int ipath_diag_open(struct inode *in, struct file *fp);
57static int ipath_diag_release(struct inode *in, struct file *fp);
58static ssize_t ipath_diag_read(struct file *fp, char __user *data,
59 size_t count, loff_t *off);
60static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
61 size_t count, loff_t *off);
62
63static const struct file_operations diag_file_ops = {
64 .owner = THIS_MODULE,
65 .write = ipath_diag_write,
66 .read = ipath_diag_read,
67 .open = ipath_diag_open,
68 .release = ipath_diag_release
69};
70
71static ssize_t ipath_diagpkt_write(struct file *fp,
72 const char __user *data,
73 size_t count, loff_t *off);
74
75static const struct file_operations diagpkt_file_ops = {
76 .owner = THIS_MODULE,
77 .write = ipath_diagpkt_write,
78};
79
80static atomic_t diagpkt_count = ATOMIC_INIT(0);
81static struct cdev *diagpkt_cdev;
82static struct device *diagpkt_dev;
83
84int ipath_diag_add(struct ipath_devdata *dd)
85{
86 char name[16];
87 int ret = 0;
88
89 if (atomic_inc_return(&diagpkt_count) == 1) {
90 ret = ipath_cdev_init(IPATH_DIAGPKT_MINOR,
91 "ipath_diagpkt", &diagpkt_file_ops,
92 &diagpkt_cdev, &diagpkt_dev);
93
94 if (ret) {
95 ipath_dev_err(dd, "Couldn't create ipath_diagpkt "
96 "device: %d", ret);
97 goto done;
98 }
99 }
100
101 snprintf(name, sizeof(name), "ipath_diag%d", dd->ipath_unit);
102
103 ret = ipath_cdev_init(IPATH_DIAG_MINOR_BASE + dd->ipath_unit, name,
104 &diag_file_ops, &dd->diag_cdev,
105 &dd->diag_dev);
106 if (ret)
107 ipath_dev_err(dd, "Couldn't create %s device: %d",
108 name, ret);
109
110done:
111 return ret;
112}
113
114void ipath_diag_remove(struct ipath_devdata *dd)
115{
116 if (atomic_dec_and_test(&diagpkt_count))
117 ipath_cdev_cleanup(&diagpkt_cdev, &diagpkt_dev);
118
119 ipath_cdev_cleanup(&dd->diag_cdev, &dd->diag_dev);
120}
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135static int ipath_read_umem64(struct ipath_devdata *dd, void __user *uaddr,
136 const void __iomem *caddr, size_t count)
137{
138 const u64 __iomem *reg_addr = caddr;
139 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
140 int ret;
141
142
143 if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
144 ret = -EINVAL;
145 goto bail;
146 }
147 while (reg_addr < reg_end) {
148 u64 data = readq(reg_addr);
149 if (copy_to_user(uaddr, &data, sizeof(u64))) {
150 ret = -EFAULT;
151 goto bail;
152 }
153 reg_addr++;
154 uaddr += sizeof(u64);
155 }
156 ret = 0;
157bail:
158 return ret;
159}
160
161
162
163
164
165
166
167
168
169
170
171
172static int ipath_write_umem64(struct ipath_devdata *dd, void __iomem *caddr,
173 const void __user *uaddr, size_t count)
174{
175 u64 __iomem *reg_addr = caddr;
176 const u64 __iomem *reg_end = reg_addr + (count / sizeof(u64));
177 int ret;
178
179
180 if (reg_addr < dd->ipath_kregbase || reg_end > dd->ipath_kregend) {
181 ret = -EINVAL;
182 goto bail;
183 }
184 while (reg_addr < reg_end) {
185 u64 data;
186 if (copy_from_user(&data, uaddr, sizeof(data))) {
187 ret = -EFAULT;
188 goto bail;
189 }
190 writeq(data, reg_addr);
191
192 reg_addr++;
193 uaddr += sizeof(u64);
194 }
195 ret = 0;
196bail:
197 return ret;
198}
199
200
201
202
203
204
205
206
207
208
209
210static int ipath_read_umem32(struct ipath_devdata *dd, void __user *uaddr,
211 const void __iomem *caddr, size_t count)
212{
213 const u32 __iomem *reg_addr = caddr;
214 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
215 int ret;
216
217 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
218 reg_end > (u32 __iomem *) dd->ipath_kregend) {
219 ret = -EINVAL;
220 goto bail;
221 }
222
223 while (reg_addr < reg_end) {
224 u32 data = readl(reg_addr);
225 if (copy_to_user(uaddr, &data, sizeof(data))) {
226 ret = -EFAULT;
227 goto bail;
228 }
229
230 reg_addr++;
231 uaddr += sizeof(u32);
232
233 }
234 ret = 0;
235bail:
236 return ret;
237}
238
239
240
241
242
243
244
245
246
247
248
249
250static int ipath_write_umem32(struct ipath_devdata *dd, void __iomem *caddr,
251 const void __user *uaddr, size_t count)
252{
253 u32 __iomem *reg_addr = caddr;
254 const u32 __iomem *reg_end = reg_addr + (count / sizeof(u32));
255 int ret;
256
257 if (reg_addr < (u32 __iomem *) dd->ipath_kregbase ||
258 reg_end > (u32 __iomem *) dd->ipath_kregend) {
259 ret = -EINVAL;
260 goto bail;
261 }
262 while (reg_addr < reg_end) {
263 u32 data;
264 if (copy_from_user(&data, uaddr, sizeof(data))) {
265 ret = -EFAULT;
266 goto bail;
267 }
268 writel(data, reg_addr);
269
270 reg_addr++;
271 uaddr += sizeof(u32);
272 }
273 ret = 0;
274bail:
275 return ret;
276}
277
278static int ipath_diag_open(struct inode *in, struct file *fp)
279{
280 int unit = iminor(in) - IPATH_DIAG_MINOR_BASE;
281 struct ipath_devdata *dd;
282 int ret;
283
284 mutex_lock(&ipath_mutex);
285
286 if (ipath_diag_inuse) {
287 ret = -EBUSY;
288 goto bail;
289 }
290
291 dd = ipath_lookup(unit);
292
293 if (dd == NULL || !(dd->ipath_flags & IPATH_PRESENT) ||
294 !dd->ipath_kregbase) {
295 ret = -ENODEV;
296 goto bail;
297 }
298
299 fp->private_data = dd;
300 ipath_diag_inuse = -2;
301 diag_set_link = 0;
302 ret = 0;
303
304
305
306 ipath_expose_reset(&dd->pcidev->dev);
307
308bail:
309 mutex_unlock(&ipath_mutex);
310
311 return ret;
312}
313
314
315
316
317
318
319
320
321static ssize_t ipath_diagpkt_write(struct file *fp,
322 const char __user *data,
323 size_t count, loff_t *off)
324{
325 u32 __iomem *piobuf;
326 u32 plen, clen, pbufn;
327 struct ipath_diag_pkt odp;
328 struct ipath_diag_xpkt dp;
329 u32 *tmpbuf = NULL;
330 struct ipath_devdata *dd;
331 ssize_t ret = 0;
332 u64 val;
333 u32 l_state, lt_state;
334
335 if (count < sizeof(odp)) {
336 ret = -EINVAL;
337 goto bail;
338 }
339
340 if (count == sizeof(dp)) {
341 if (copy_from_user(&dp, data, sizeof(dp))) {
342 ret = -EFAULT;
343 goto bail;
344 }
345 } else if (copy_from_user(&odp, data, sizeof(odp))) {
346 ret = -EFAULT;
347 goto bail;
348 }
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363 if (dp.unit >= 20 && dp.data < 512) {
364
365 memcpy(&odp, &dp, sizeof(odp));
366
367 dp.unit = odp.unit;
368 dp.data = odp.data;
369 dp.len = odp.len;
370 dp.pbc_wd = 0;
371 }
372
373
374 if (dp.len & 3) {
375 ret = -EINVAL;
376 goto bail;
377 }
378
379 clen = dp.len >> 2;
380
381 dd = ipath_lookup(dp.unit);
382 if (!dd || !(dd->ipath_flags & IPATH_PRESENT) ||
383 !dd->ipath_kregbase) {
384 ipath_cdbg(VERBOSE, "illegal unit %u for diag data send\n",
385 dp.unit);
386 ret = -ENODEV;
387 goto bail;
388 }
389
390 if (ipath_diag_inuse && !diag_set_link &&
391 !(dd->ipath_flags & IPATH_LINKACTIVE)) {
392 diag_set_link = 1;
393 ipath_cdbg(VERBOSE, "Trying to set to set link active for "
394 "diag pkt\n");
395 ipath_set_linkstate(dd, IPATH_IB_LINKARM);
396 ipath_set_linkstate(dd, IPATH_IB_LINKACTIVE);
397 }
398
399 if (!(dd->ipath_flags & IPATH_INITTED)) {
400
401 ipath_cdbg(VERBOSE, "unit %u not usable\n", dd->ipath_unit);
402 ret = -ENODEV;
403 goto bail;
404 }
405
406
407
408
409
410 val = ipath_ib_state(dd, dd->ipath_lastibcstat);
411 lt_state = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat);
412 l_state = ipath_ib_linkstate(dd, dd->ipath_lastibcstat);
413 if (!dp.pbc_wd && (lt_state != INFINIPATH_IBCS_LT_STATE_LINKUP ||
414 (val != dd->ib_init && val != dd->ib_arm &&
415 val != dd->ib_active))) {
416 ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
417 dd->ipath_unit, (unsigned long long) val);
418 ret = -EINVAL;
419 goto bail;
420 }
421
422
423
424 plen = sizeof(u32) + dp.len;
425
426 if ((plen + 4) > dd->ipath_ibmaxlen) {
427 ipath_dbg("Pkt len 0x%x > ibmaxlen %x\n",
428 plen - 4, dd->ipath_ibmaxlen);
429 ret = -EINVAL;
430 goto bail;
431 }
432 tmpbuf = vmalloc(plen);
433 if (!tmpbuf) {
434 dev_info(&dd->pcidev->dev, "Unable to allocate tmp buffer, "
435 "failing\n");
436 ret = -ENOMEM;
437 goto bail;
438 }
439
440 if (copy_from_user(tmpbuf,
441 (const void __user *) (unsigned long) dp.data,
442 dp.len)) {
443 ret = -EFAULT;
444 goto bail;
445 }
446
447 plen >>= 2;
448
449 piobuf = ipath_getpiobuf(dd, plen, &pbufn);
450 if (!piobuf) {
451 ipath_cdbg(VERBOSE, "No PIO buffers avail unit for %u\n",
452 dd->ipath_unit);
453 ret = -EBUSY;
454 goto bail;
455 }
456
457 ipath_disarm_piobufs(dd, pbufn, 1);
458
459 if (ipath_debug & __IPATH_PKTDBG)
460 ipath_cdbg(VERBOSE, "unit %u 0x%x+1w pio%d\n",
461 dd->ipath_unit, plen - 1, pbufn);
462
463 if (dp.pbc_wd == 0)
464 dp.pbc_wd = plen;
465 writeq(dp.pbc_wd, piobuf);
466
467
468
469
470
471 if (dd->ipath_flags & IPATH_PIO_FLUSH_WC) {
472 ipath_flush_wc();
473 __iowrite32_copy(piobuf + 2, tmpbuf, clen - 1);
474 ipath_flush_wc();
475 __raw_writel(tmpbuf[clen - 1], piobuf + clen + 1);
476 } else
477 __iowrite32_copy(piobuf + 2, tmpbuf, clen);
478
479 ipath_flush_wc();
480
481 ret = sizeof(dp);
482
483bail:
484 vfree(tmpbuf);
485 return ret;
486}
487
488static int ipath_diag_release(struct inode *in, struct file *fp)
489{
490 mutex_lock(&ipath_mutex);
491 ipath_diag_inuse = 0;
492 fp->private_data = NULL;
493 mutex_unlock(&ipath_mutex);
494 return 0;
495}
496
497static ssize_t ipath_diag_read(struct file *fp, char __user *data,
498 size_t count, loff_t *off)
499{
500 struct ipath_devdata *dd = fp->private_data;
501 void __iomem *kreg_base;
502 ssize_t ret;
503
504 kreg_base = dd->ipath_kregbase;
505
506 if (count == 0)
507 ret = 0;
508 else if ((count % 4) || (*off % 4))
509
510 ret = -EINVAL;
511 else if (ipath_diag_inuse < 1 && (*off || count != 8))
512 ret = -EINVAL;
513 else if ((count % 8) || (*off % 8))
514
515 ret = ipath_read_umem32(dd, data, kreg_base + *off, count);
516 else
517 ret = ipath_read_umem64(dd, data, kreg_base + *off, count);
518
519 if (ret >= 0) {
520 *off += count;
521 ret = count;
522 if (ipath_diag_inuse == -2)
523 ipath_diag_inuse++;
524 }
525
526 return ret;
527}
528
529static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
530 size_t count, loff_t *off)
531{
532 struct ipath_devdata *dd = fp->private_data;
533 void __iomem *kreg_base;
534 ssize_t ret;
535
536 kreg_base = dd->ipath_kregbase;
537
538 if (count == 0)
539 ret = 0;
540 else if ((count % 4) || (*off % 4))
541
542 ret = -EINVAL;
543 else if ((ipath_diag_inuse == -1 && (*off || count != 8)) ||
544 ipath_diag_inuse == -2)
545 ret = -EINVAL;
546 else if ((count % 8) || (*off % 8))
547
548 ret = ipath_write_umem32(dd, kreg_base + *off, data, count);
549 else
550 ret = ipath_write_umem64(dd, kreg_base + *off, data, count);
551
552 if (ret >= 0) {
553 *off += count;
554 ret = count;
555 if (ipath_diag_inuse == -1)
556 ipath_diag_inuse = 1;
557 }
558
559 return ret;
560}
561