1/*
2 * Copyright(c) 2015-2017 Intel Corporation.
3 *
4 * This file is provided under a dual BSD/GPLv2 license.  When using or
5 * redistributing this file, you may do so under either license.
6 *
7 * GPL LICENSE SUMMARY
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 * General Public License for more details.
17 *
18 * BSD LICENSE
19 *
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted provided that the following conditions
22 * are met:
23 *
24 *  - Redistributions of source code must retain the above copyright
25 *    notice, this list of conditions and the following disclaimer.
26 *  - Redistributions in binary form must reproduce the above copyright
27 *    notice, this list of conditions and the following disclaimer in
28 *    the documentation and/or other materials provided with the
29 *    distribution.
30 *  - Neither the name of Intel Corporation nor the names of its
31 *    contributors may be used to endorse or promote products derived
32 *    from this software without specific prior written permission.
33 *
34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
45 *
46 */
47#include <linux/ctype.h>
48
49#include "hfi.h"
50#include "mad.h"
51#include "trace.h"
52
53/*
54 * Start of per-port congestion control structures and support code
55 */
56
57/*
58 * Congestion control table size followed by table entries
59 */
60static ssize_t read_cc_table_bin(struct file *filp, struct kobject *kobj,
61				 struct bin_attribute *bin_attr,
62				 char *buf, loff_t pos, size_t count)
63{
64	int ret;
65	struct hfi1_pportdata *ppd =
66		container_of(kobj, struct hfi1_pportdata, pport_cc_kobj);
67	struct cc_state *cc_state;
68
69	ret = ppd->total_cct_entry * sizeof(struct ib_cc_table_entry_shadow)
70		 + sizeof(__be16);
71
72	if (pos > ret)
73		return -EINVAL;
74
75	if (count > ret - pos)
76		count = ret - pos;
77
78	if (!count)
79		return count;
80
81	rcu_read_lock();
82	cc_state = get_cc_state(ppd);
83	if (!cc_state) {
84		rcu_read_unlock();
85		return -EINVAL;
86	}
87	memcpy(buf, (void *)&cc_state->cct + pos, count);
88	rcu_read_unlock();
89
90	return count;
91}
92
93static void port_release(struct kobject *kobj)
94{
95	/* nothing to do since memory is freed by hfi1_free_devdata() */
96}
97
98static const struct bin_attribute cc_table_bin_attr = {
99	.attr = {.name = "cc_table_bin", .mode = 0444},
100	.read = read_cc_table_bin,
101	.size = PAGE_SIZE,
102};
103
104/*
105 * Congestion settings: port control, control map and an array of 16
106 * entries for the congestion entries - increase, timer, event log
107 * trigger threshold and the minimum injection rate delay.
108 */
109static ssize_t read_cc_setting_bin(struct file *filp, struct kobject *kobj,
110				   struct bin_attribute *bin_attr,
111				   char *buf, loff_t pos, size_t count)
112{
113	int ret;
114	struct hfi1_pportdata *ppd =
115		container_of(kobj, struct hfi1_pportdata, pport_cc_kobj);
116	struct cc_state *cc_state;
117
118	ret = sizeof(struct opa_congestion_setting_attr_shadow);
119
120	if (pos > ret)
121		return -EINVAL;
122	if (count > ret - pos)
123		count = ret - pos;
124
125	if (!count)
126		return count;
127
128	rcu_read_lock();
129	cc_state = get_cc_state(ppd);
130	if (!cc_state) {
131		rcu_read_unlock();
132		return -EINVAL;
133	}
134	memcpy(buf, (void *)&cc_state->cong_setting + pos, count);
135	rcu_read_unlock();
136
137	return count;
138}
139
140static const struct bin_attribute cc_setting_bin_attr = {
141	.attr = {.name = "cc_settings_bin", .mode = 0444},
142	.read = read_cc_setting_bin,
143	.size = PAGE_SIZE,
144};
145
146struct hfi1_port_attr {
147	struct attribute attr;
148	ssize_t	(*show)(struct hfi1_pportdata *, char *);
149	ssize_t	(*store)(struct hfi1_pportdata *, const char *, size_t);
150};
151
152static ssize_t cc_prescan_show(struct hfi1_pportdata *ppd, char *buf)
153{
154	return sprintf(buf, "%s\n", ppd->cc_prescan ? "on" : "off");
155}
156
157static ssize_t cc_prescan_store(struct hfi1_pportdata *ppd, const char *buf,
158				size_t count)
159{
160	if (!memcmp(buf, "on", 2))
161		ppd->cc_prescan = true;
162	else if (!memcmp(buf, "off", 3))
163		ppd->cc_prescan = false;
164
165	return count;
166}
167
168static struct hfi1_port_attr cc_prescan_attr =
169		__ATTR(cc_prescan, 0600, cc_prescan_show, cc_prescan_store);
170
171static ssize_t cc_attr_show(struct kobject *kobj, struct attribute *attr,
172			    char *buf)
173{
174	struct hfi1_port_attr *port_attr =
175		container_of(attr, struct hfi1_port_attr, attr);
176	struct hfi1_pportdata *ppd =
177		container_of(kobj, struct hfi1_pportdata, pport_cc_kobj);
178
179	return port_attr->show(ppd, buf);
180}
181
182static ssize_t cc_attr_store(struct kobject *kobj, struct attribute *attr,
183			     const char *buf, size_t count)
184{
185	struct hfi1_port_attr *port_attr =
186		container_of(attr, struct hfi1_port_attr, attr);
187	struct hfi1_pportdata *ppd =
188		container_of(kobj, struct hfi1_pportdata, pport_cc_kobj);
189
190	return port_attr->store(ppd, buf, count);
191}
192
193static const struct sysfs_ops port_cc_sysfs_ops = {
194	.show = cc_attr_show,
195	.store = cc_attr_store
196};
197
198static struct attribute *port_cc_default_attributes[] = {
199	&cc_prescan_attr.attr,
200	NULL
201};
202
203static struct kobj_type port_cc_ktype = {
204	.release = port_release,
205	.sysfs_ops = &port_cc_sysfs_ops,
206	.default_attrs = port_cc_default_attributes
207};
208
209/* Start sc2vl */
210#define HFI1_SC2VL_ATTR(N)				    \
211	static struct hfi1_sc2vl_attr hfi1_sc2vl_attr_##N = { \
212		.attr = { .name = __stringify(N), .mode = 0444 }, \
213		.sc = N \
214	}
215
216struct hfi1_sc2vl_attr {
217	struct attribute attr;
218	int sc;
219};
220
221HFI1_SC2VL_ATTR(0);
222HFI1_SC2VL_ATTR(1);
223HFI1_SC2VL_ATTR(2);
224HFI1_SC2VL_ATTR(3);
225HFI1_SC2VL_ATTR(4);
226HFI1_SC2VL_ATTR(5);
227HFI1_SC2VL_ATTR(6);
228HFI1_SC2VL_ATTR(7);
229HFI1_SC2VL_ATTR(8);
230HFI1_SC2VL_ATTR(9);
231HFI1_SC2VL_ATTR(10);
232HFI1_SC2VL_ATTR(11);
233HFI1_SC2VL_ATTR(12);
234HFI1_SC2VL_ATTR(13);
235HFI1_SC2VL_ATTR(14);
236HFI1_SC2VL_ATTR(15);
237HFI1_SC2VL_ATTR(16);
238HFI1_SC2VL_ATTR(17);
239HFI1_SC2VL_ATTR(18);
240HFI1_SC2VL_ATTR(19);
241HFI1_SC2VL_ATTR(20);
242HFI1_SC2VL_ATTR(21);
243HFI1_SC2VL_ATTR(22);
244HFI1_SC2VL_ATTR(23);
245HFI1_SC2VL_ATTR(24);
246HFI1_SC2VL_ATTR(25);
247HFI1_SC2VL_ATTR(26);
248HFI1_SC2VL_ATTR(27);
249HFI1_SC2VL_ATTR(28);
250HFI1_SC2VL_ATTR(29);
251HFI1_SC2VL_ATTR(30);
252HFI1_SC2VL_ATTR(31);
253
254static struct attribute *sc2vl_default_attributes[] = {
255	&hfi1_sc2vl_attr_0.attr,
256	&hfi1_sc2vl_attr_1.attr,
257	&hfi1_sc2vl_attr_2.attr,
258	&hfi1_sc2vl_attr_3.attr,
259	&hfi1_sc2vl_attr_4.attr,
260	&hfi1_sc2vl_attr_5.attr,
261	&hfi1_sc2vl_attr_6.attr,
262	&hfi1_sc2vl_attr_7.attr,
263	&hfi1_sc2vl_attr_8.attr,
264	&hfi1_sc2vl_attr_9.attr,
265	&hfi1_sc2vl_attr_10.attr,
266	&hfi1_sc2vl_attr_11.attr,
267	&hfi1_sc2vl_attr_12.attr,
268	&hfi1_sc2vl_attr_13.attr,
269	&hfi1_sc2vl_attr_14.attr,
270	&hfi1_sc2vl_attr_15.attr,
271	&hfi1_sc2vl_attr_16.attr,
272	&hfi1_sc2vl_attr_17.attr,
273	&hfi1_sc2vl_attr_18.attr,
274	&hfi1_sc2vl_attr_19.attr,
275	&hfi1_sc2vl_attr_20.attr,
276	&hfi1_sc2vl_attr_21.attr,
277	&hfi1_sc2vl_attr_22.attr,
278	&hfi1_sc2vl_attr_23.attr,
279	&hfi1_sc2vl_attr_24.attr,
280	&hfi1_sc2vl_attr_25.attr,
281	&hfi1_sc2vl_attr_26.attr,
282	&hfi1_sc2vl_attr_27.attr,
283	&hfi1_sc2vl_attr_28.attr,
284	&hfi1_sc2vl_attr_29.attr,
285	&hfi1_sc2vl_attr_30.attr,
286	&hfi1_sc2vl_attr_31.attr,
287	NULL
288};
289
290static ssize_t sc2vl_attr_show(struct kobject *kobj, struct attribute *attr,
291			       char *buf)
292{
293	struct hfi1_sc2vl_attr *sattr =
294		container_of(attr, struct hfi1_sc2vl_attr, attr);
295	struct hfi1_pportdata *ppd =
296		container_of(kobj, struct hfi1_pportdata, sc2vl_kobj);
297	struct hfi1_devdata *dd = ppd->dd;
298
299	return sprintf(buf, "%u\n", *((u8 *)dd->sc2vl + sattr->sc));
300}
301
302static const struct sysfs_ops hfi1_sc2vl_ops = {
303	.show = sc2vl_attr_show,
304};
305
306static struct kobj_type hfi1_sc2vl_ktype = {
307	.release = port_release,
308	.sysfs_ops = &hfi1_sc2vl_ops,
309	.default_attrs = sc2vl_default_attributes
310};
311
312/* End sc2vl */
313
314/* Start sl2sc */
315#define HFI1_SL2SC_ATTR(N)				    \
316	static struct hfi1_sl2sc_attr hfi1_sl2sc_attr_##N = {	  \
317		.attr = { .name = __stringify(N), .mode = 0444 }, \
318		.sl = N						  \
319	}
320
321struct hfi1_sl2sc_attr {
322	struct attribute attr;
323	int sl;
324};
325
326HFI1_SL2SC_ATTR(0);
327HFI1_SL2SC_ATTR(1);
328HFI1_SL2SC_ATTR(2);
329HFI1_SL2SC_ATTR(3);
330HFI1_SL2SC_ATTR(4);
331HFI1_SL2SC_ATTR(5);
332HFI1_SL2SC_ATTR(6);
333HFI1_SL2SC_ATTR(7);
334HFI1_SL2SC_ATTR(8);
335HFI1_SL2SC_ATTR(9);
336HFI1_SL2SC_ATTR(10);
337HFI1_SL2SC_ATTR(11);
338HFI1_SL2SC_ATTR(12);
339HFI1_SL2SC_ATTR(13);
340HFI1_SL2SC_ATTR(14);
341HFI1_SL2SC_ATTR(15);
342HFI1_SL2SC_ATTR(16);
343HFI1_SL2SC_ATTR(17);
344HFI1_SL2SC_ATTR(18);
345HFI1_SL2SC_ATTR(19);
346HFI1_SL2SC_ATTR(20);
347HFI1_SL2SC_ATTR(21);
348HFI1_SL2SC_ATTR(22);
349HFI1_SL2SC_ATTR(23);
350HFI1_SL2SC_ATTR(24);
351HFI1_SL2SC_ATTR(25);
352HFI1_SL2SC_ATTR(26);
353HFI1_SL2SC_ATTR(27);
354HFI1_SL2SC_ATTR(28);
355HFI1_SL2SC_ATTR(29);
356HFI1_SL2SC_ATTR(30);
357HFI1_SL2SC_ATTR(31);
358
359static struct attribute *sl2sc_default_attributes[] = {
360	&hfi1_sl2sc_attr_0.attr,
361	&hfi1_sl2sc_attr_1.attr,
362	&hfi1_sl2sc_attr_2.attr,
363	&hfi1_sl2sc_attr_3.attr,
364	&hfi1_sl2sc_attr_4.attr,
365	&hfi1_sl2sc_attr_5.attr,
366	&hfi1_sl2sc_attr_6.attr,
367	&hfi1_sl2sc_attr_7.attr,
368	&hfi1_sl2sc_attr_8.attr,
369	&hfi1_sl2sc_attr_9.attr,
370	&hfi1_sl2sc_attr_10.attr,
371	&hfi1_sl2sc_attr_11.attr,
372	&hfi1_sl2sc_attr_12.attr,
373	&hfi1_sl2sc_attr_13.attr,
374	&hfi1_sl2sc_attr_14.attr,
375	&hfi1_sl2sc_attr_15.attr,
376	&hfi1_sl2sc_attr_16.attr,
377	&hfi1_sl2sc_attr_17.attr,
378	&hfi1_sl2sc_attr_18.attr,
379	&hfi1_sl2sc_attr_19.attr,
380	&hfi1_sl2sc_attr_20.attr,
381	&hfi1_sl2sc_attr_21.attr,
382	&hfi1_sl2sc_attr_22.attr,
383	&hfi1_sl2sc_attr_23.attr,
384	&hfi1_sl2sc_attr_24.attr,
385	&hfi1_sl2sc_attr_25.attr,
386	&hfi1_sl2sc_attr_26.attr,
387	&hfi1_sl2sc_attr_27.attr,
388	&hfi1_sl2sc_attr_28.attr,
389	&hfi1_sl2sc_attr_29.attr,
390	&hfi1_sl2sc_attr_30.attr,
391	&hfi1_sl2sc_attr_31.attr,
392	NULL
393};
394
395static ssize_t sl2sc_attr_show(struct kobject *kobj, struct attribute *attr,
396			       char *buf)
397{
398	struct hfi1_sl2sc_attr *sattr =
399		container_of(attr, struct hfi1_sl2sc_attr, attr);
400	struct hfi1_pportdata *ppd =
401		container_of(kobj, struct hfi1_pportdata, sl2sc_kobj);
402	struct hfi1_ibport *ibp = &ppd->ibport_data;
403
404	return sprintf(buf, "%u\n", ibp->sl_to_sc[sattr->sl]);
405}
406
407static const struct sysfs_ops hfi1_sl2sc_ops = {
408	.show = sl2sc_attr_show,
409};
410
411static struct kobj_type hfi1_sl2sc_ktype = {
412	.release = port_release,
413	.sysfs_ops = &hfi1_sl2sc_ops,
414	.default_attrs = sl2sc_default_attributes
415};
416
417/* End sl2sc */
418
419/* Start vl2mtu */
420
421#define HFI1_VL2MTU_ATTR(N) \
422	static struct hfi1_vl2mtu_attr hfi1_vl2mtu_attr_##N = { \
423		.attr = { .name = __stringify(N), .mode = 0444 }, \
424		.vl = N						  \
425	}
426
427struct hfi1_vl2mtu_attr {
428	struct attribute attr;
429	int vl;
430};
431
432HFI1_VL2MTU_ATTR(0);
433HFI1_VL2MTU_ATTR(1);
434HFI1_VL2MTU_ATTR(2);
435HFI1_VL2MTU_ATTR(3);
436HFI1_VL2MTU_ATTR(4);
437HFI1_VL2MTU_ATTR(5);
438HFI1_VL2MTU_ATTR(6);
439HFI1_VL2MTU_ATTR(7);
440HFI1_VL2MTU_ATTR(8);
441HFI1_VL2MTU_ATTR(9);
442HFI1_VL2MTU_ATTR(10);
443HFI1_VL2MTU_ATTR(11);
444HFI1_VL2MTU_ATTR(12);
445HFI1_VL2MTU_ATTR(13);
446HFI1_VL2MTU_ATTR(14);
447HFI1_VL2MTU_ATTR(15);
448
449static struct attribute *vl2mtu_default_attributes[] = {
450	&hfi1_vl2mtu_attr_0.attr,
451	&hfi1_vl2mtu_attr_1.attr,
452	&hfi1_vl2mtu_attr_2.attr,
453	&hfi1_vl2mtu_attr_3.attr,
454	&hfi1_vl2mtu_attr_4.attr,
455	&hfi1_vl2mtu_attr_5.attr,
456	&hfi1_vl2mtu_attr_6.attr,
457	&hfi1_vl2mtu_attr_7.attr,
458	&hfi1_vl2mtu_attr_8.attr,
459	&hfi1_vl2mtu_attr_9.attr,
460	&hfi1_vl2mtu_attr_10.attr,
461	&hfi1_vl2mtu_attr_11.attr,
462	&hfi1_vl2mtu_attr_12.attr,
463	&hfi1_vl2mtu_attr_13.attr,
464	&hfi1_vl2mtu_attr_14.attr,
465	&hfi1_vl2mtu_attr_15.attr,
466	NULL
467};
468
469static ssize_t vl2mtu_attr_show(struct kobject *kobj, struct attribute *attr,
470				char *buf)
471{
472	struct hfi1_vl2mtu_attr *vlattr =
473		container_of(attr, struct hfi1_vl2mtu_attr, attr);
474	struct hfi1_pportdata *ppd =
475		container_of(kobj, struct hfi1_pportdata, vl2mtu_kobj);
476	struct hfi1_devdata *dd = ppd->dd;
477
478	return sprintf(buf, "%u\n", dd->vld[vlattr->vl].mtu);
479}
480
481static const struct sysfs_ops hfi1_vl2mtu_ops = {
482	.show = vl2mtu_attr_show,
483};
484
485static struct kobj_type hfi1_vl2mtu_ktype = {
486	.release = port_release,
487	.sysfs_ops = &hfi1_vl2mtu_ops,
488	.default_attrs = vl2mtu_default_attributes
489};
490
491/* end of per-port file structures and support code */
492
493/*
494 * Start of per-unit (or driver, in some cases, but replicated
495 * per unit) functions (these get a device *)
496 */
497static ssize_t hw_rev_show(struct device *device, struct device_attribute *attr,
498			   char *buf)
499{
500	struct hfi1_ibdev *dev =
501		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
502
503	return sprintf(buf, "%x\n", dd_from_dev(dev)->minrev);
504}
505static DEVICE_ATTR_RO(hw_rev);
506
507static ssize_t board_id_show(struct device *device,
508			     struct device_attribute *attr, char *buf)
509{
510	struct hfi1_ibdev *dev =
511		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
512	struct hfi1_devdata *dd = dd_from_dev(dev);
513	int ret;
514
515	if (!dd->boardname)
516		ret = -EINVAL;
517	else
518		ret = scnprintf(buf, PAGE_SIZE, "%s\n", dd->boardname);
519	return ret;
520}
521static DEVICE_ATTR_RO(board_id);
522
523static ssize_t boardversion_show(struct device *device,
524				 struct device_attribute *attr, char *buf)
525{
526	struct hfi1_ibdev *dev =
527		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
528	struct hfi1_devdata *dd = dd_from_dev(dev);
529
530	/* The string printed here is already newline-terminated. */
531	return scnprintf(buf, PAGE_SIZE, "%s", dd->boardversion);
532}
533static DEVICE_ATTR_RO(boardversion);
534
535static ssize_t nctxts_show(struct device *device,
536			   struct device_attribute *attr, char *buf)
537{
538	struct hfi1_ibdev *dev =
539		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
540	struct hfi1_devdata *dd = dd_from_dev(dev);
541
542	/*
543	 * Return the smaller of send and receive contexts.
544	 * Normally, user level applications would require both a send
545	 * and a receive context, so returning the smaller of the two counts
546	 * give a more accurate picture of total contexts available.
547	 */
548	return scnprintf(buf, PAGE_SIZE, "%u\n",
549			 min(dd->num_user_contexts,
550			     (u32)dd->sc_sizes[SC_USER].count));
551}
552static DEVICE_ATTR_RO(nctxts);
553
554static ssize_t nfreectxts_show(struct device *device,
555			       struct device_attribute *attr, char *buf)
556{
557	struct hfi1_ibdev *dev =
558		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
559	struct hfi1_devdata *dd = dd_from_dev(dev);
560
561	/* Return the number of free user ports (contexts) available. */
562	return scnprintf(buf, PAGE_SIZE, "%u\n", dd->freectxts);
563}
564static DEVICE_ATTR_RO(nfreectxts);
565
566static ssize_t serial_show(struct device *device,
567			   struct device_attribute *attr, char *buf)
568{
569	struct hfi1_ibdev *dev =
570		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
571	struct hfi1_devdata *dd = dd_from_dev(dev);
572
573	return scnprintf(buf, PAGE_SIZE, "%s", dd->serial);
574}
575static DEVICE_ATTR_RO(serial);
576
577static ssize_t chip_reset_store(struct device *device,
578				struct device_attribute *attr, const char *buf,
579				size_t count)
580{
581	struct hfi1_ibdev *dev =
582		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
583	struct hfi1_devdata *dd = dd_from_dev(dev);
584	int ret;
585
586	if (count < 5 || memcmp(buf, "reset", 5) || !dd->diag_client) {
587		ret = -EINVAL;
588		goto bail;
589	}
590
591	ret = hfi1_reset_device(dd->unit);
592bail:
593	return ret < 0 ? ret : count;
594}
595static DEVICE_ATTR_WO(chip_reset);
596
597/*
598 * Convert the reported temperature from an integer (reported in
599 * units of 0.25C) to a floating point number.
600 */
601#define temp2str(temp, buf, size, idx)					\
602	scnprintf((buf) + (idx), (size) - (idx), "%u.%02u ",		\
603			      ((temp) >> 2), ((temp) & 0x3) * 25)
604
605/*
606 * Dump tempsense values, in decimal, to ease shell-scripts.
607 */
608static ssize_t tempsense_show(struct device *device,
609			      struct device_attribute *attr, char *buf)
610{
611	struct hfi1_ibdev *dev =
612		rdma_device_to_drv_device(device, struct hfi1_ibdev, rdi.ibdev);
613	struct hfi1_devdata *dd = dd_from_dev(dev);
614	struct hfi1_temp temp;
615	int ret;
616
617	ret = hfi1_tempsense_rd(dd, &temp);
618	if (!ret) {
619		int idx = 0;
620
621		idx += temp2str(temp.curr, buf, PAGE_SIZE, idx);
622		idx += temp2str(temp.lo_lim, buf, PAGE_SIZE, idx);
623		idx += temp2str(temp.hi_lim, buf, PAGE_SIZE, idx);
624		idx += temp2str(temp.crit_lim, buf, PAGE_SIZE, idx);
625		idx += scnprintf(buf + idx, PAGE_SIZE - idx,
626				"%u %u %u\n", temp.triggers & 0x1,
627				temp.triggers & 0x2, temp.triggers & 0x4);
628		ret = idx;
629	}
630	return ret;
631}
632static DEVICE_ATTR_RO(tempsense);
633
634/*
635 * end of per-unit (or driver, in some cases, but replicated
636 * per unit) functions
637 */
638
639/* start of per-unit file structures and support code */
640static struct attribute *hfi1_attributes[] = {
641	&dev_attr_hw_rev.attr,
642	&dev_attr_board_id.attr,
643	&dev_attr_nctxts.attr,
644	&dev_attr_nfreectxts.attr,
645	&dev_attr_serial.attr,
646	&dev_attr_boardversion.attr,
647	&dev_attr_tempsense.attr,
648	&dev_attr_chip_reset.attr,
649	NULL,
650};
651
652const struct attribute_group ib_hfi1_attr_group = {
653	.attrs = hfi1_attributes,
654};
655
656int hfi1_create_port_files(struct ib_device *ibdev, u8 port_num,
657			   struct kobject *kobj)
658{
659	struct hfi1_pportdata *ppd;
660	struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
661	int ret;
662
663	if (!port_num || port_num > dd->num_pports) {
664		dd_dev_err(dd,
665			   "Skipping infiniband class with invalid port %u\n",
666			   port_num);
667		return -ENODEV;
668	}
669	ppd = &dd->pport[port_num - 1];
670
671	ret = kobject_init_and_add(&ppd->sc2vl_kobj, &hfi1_sc2vl_ktype, kobj,
672				   "sc2vl");
673	if (ret) {
674		dd_dev_err(dd,
675			   "Skipping sc2vl sysfs info, (err %d) port %u\n",
676			   ret, port_num);
677		/*
678		 * Based on the documentation for kobject_init_and_add(), the
679		 * caller should call kobject_put even if this call fails.
680		 */
681		goto bail_sc2vl;
682	}
683	kobject_uevent(&ppd->sc2vl_kobj, KOBJ_ADD);
684
685	ret = kobject_init_and_add(&ppd->sl2sc_kobj, &hfi1_sl2sc_ktype, kobj,
686				   "sl2sc");
687	if (ret) {
688		dd_dev_err(dd,
689			   "Skipping sl2sc sysfs info, (err %d) port %u\n",
690			   ret, port_num);
691		goto bail_sl2sc;
692	}
693	kobject_uevent(&ppd->sl2sc_kobj, KOBJ_ADD);
694
695	ret = kobject_init_and_add(&ppd->vl2mtu_kobj, &hfi1_vl2mtu_ktype, kobj,
696				   "vl2mtu");
697	if (ret) {
698		dd_dev_err(dd,
699			   "Skipping vl2mtu sysfs info, (err %d) port %u\n",
700			   ret, port_num);
701		goto bail_vl2mtu;
702	}
703	kobject_uevent(&ppd->vl2mtu_kobj, KOBJ_ADD);
704
705	ret = kobject_init_and_add(&ppd->pport_cc_kobj, &port_cc_ktype,
706				   kobj, "CCMgtA");
707	if (ret) {
708		dd_dev_err(dd,
709			   "Skipping Congestion Control sysfs info, (err %d) port %u\n",
710			   ret, port_num);
711		goto bail_cc;
712	}
713
714	kobject_uevent(&ppd->pport_cc_kobj, KOBJ_ADD);
715
716	ret = sysfs_create_bin_file(&ppd->pport_cc_kobj, &cc_setting_bin_attr);
717	if (ret) {
718		dd_dev_err(dd,
719			   "Skipping Congestion Control setting sysfs info, (err %d) port %u\n",
720			   ret, port_num);
721		goto bail_cc;
722	}
723
724	ret = sysfs_create_bin_file(&ppd->pport_cc_kobj, &cc_table_bin_attr);
725	if (ret) {
726		dd_dev_err(dd,
727			   "Skipping Congestion Control table sysfs info, (err %d) port %u\n",
728			   ret, port_num);
729		goto bail_cc_entry_bin;
730	}
731
732	dd_dev_info(dd,
733		    "Congestion Control Agent enabled for port %d\n",
734		    port_num);
735
736	return 0;
737
738bail_cc_entry_bin:
739	sysfs_remove_bin_file(&ppd->pport_cc_kobj,
740			      &cc_setting_bin_attr);
741bail_cc:
742	kobject_put(&ppd->pport_cc_kobj);
743bail_vl2mtu:
744	kobject_put(&ppd->vl2mtu_kobj);
745bail_sl2sc:
746	kobject_put(&ppd->sl2sc_kobj);
747bail_sc2vl:
748	kobject_put(&ppd->sc2vl_kobj);
749	return ret;
750}
751
752struct sde_attribute {
753	struct attribute attr;
754	ssize_t (*show)(struct sdma_engine *sde, char *buf);
755	ssize_t (*store)(struct sdma_engine *sde, const char *buf, size_t cnt);
756};
757
758static ssize_t sde_show(struct kobject *kobj, struct attribute *attr, char *buf)
759{
760	struct sde_attribute *sde_attr =
761		container_of(attr, struct sde_attribute, attr);
762	struct sdma_engine *sde =
763		container_of(kobj, struct sdma_engine, kobj);
764
765	if (!sde_attr->show)
766		return -EINVAL;
767
768	return sde_attr->show(sde, buf);
769}
770
771static ssize_t sde_store(struct kobject *kobj, struct attribute *attr,
772			 const char *buf, size_t count)
773{
774	struct sde_attribute *sde_attr =
775		container_of(attr, struct sde_attribute, attr);
776	struct sdma_engine *sde =
777		container_of(kobj, struct sdma_engine, kobj);
778
779	if (!capable(CAP_SYS_ADMIN))
780		return -EPERM;
781
782	if (!sde_attr->store)
783		return -EINVAL;
784
785	return sde_attr->store(sde, buf, count);
786}
787
788static const struct sysfs_ops sde_sysfs_ops = {
789	.show = sde_show,
790	.store = sde_store,
791};
792
793static struct kobj_type sde_ktype = {
794	.sysfs_ops = &sde_sysfs_ops,
795};
796
797#define SDE_ATTR(_name, _mode, _show, _store) \
798	struct sde_attribute sde_attr_##_name = \
799		__ATTR(_name, _mode, _show, _store)
800
801static ssize_t sde_show_cpu_to_sde_map(struct sdma_engine *sde, char *buf)
802{
803	return sdma_get_cpu_to_sde_map(sde, buf);
804}
805
806static ssize_t sde_store_cpu_to_sde_map(struct sdma_engine *sde,
807					const char *buf, size_t count)
808{
809	return sdma_set_cpu_to_sde_map(sde, buf, count);
810}
811
812static ssize_t sde_show_vl(struct sdma_engine *sde, char *buf)
813{
814	int vl;
815
816	vl = sdma_engine_get_vl(sde);
817	if (vl < 0)
818		return vl;
819
820	return snprintf(buf, PAGE_SIZE, "%d\n", vl);
821}
822
823static SDE_ATTR(cpu_list, S_IWUSR | S_IRUGO,
824		sde_show_cpu_to_sde_map,
825		sde_store_cpu_to_sde_map);
826static SDE_ATTR(vl, S_IRUGO, sde_show_vl, NULL);
827
828static struct sde_attribute *sde_attribs[] = {
829	&sde_attr_cpu_list,
830	&sde_attr_vl
831};
832
833/*
834 * Register and create our files in /sys/class/infiniband.
835 */
836int hfi1_verbs_register_sysfs(struct hfi1_devdata *dd)
837{
838	struct ib_device *dev = &dd->verbs_dev.rdi.ibdev;
839	struct device *class_dev = &dev->dev;
840	int i, j, ret;
841
842	for (i = 0; i < dd->num_sdma; i++) {
843		ret = kobject_init_and_add(&dd->per_sdma[i].kobj,
844					   &sde_ktype, &class_dev->kobj,
845					   "sdma%d", i);
846		if (ret)
847			goto bail;
848
849		for (j = 0; j < ARRAY_SIZE(sde_attribs); j++) {
850			ret = sysfs_create_file(&dd->per_sdma[i].kobj,
851						&sde_attribs[j]->attr);
852			if (ret)
853				goto bail;
854		}
855	}
856
857	return 0;
858bail:
859	/*
860	 * The function kobject_put() will call kobject_del() if the kobject
861	 * has been added successfully. The sysfs files created under the
862	 * kobject directory will also be removed during the process.
863	 */
864	for (; i >= 0; i--)
865		kobject_put(&dd->per_sdma[i].kobj);
866
867	return ret;
868}
869
870/*
871 * Unregister and remove our files in /sys/class/infiniband.
872 */
873void hfi1_verbs_unregister_sysfs(struct hfi1_devdata *dd)
874{
875	struct hfi1_pportdata *ppd;
876	int i;
877
878	/* Unwind operations in hfi1_verbs_register_sysfs() */
879	for (i = 0; i < dd->num_sdma; i++)
880		kobject_put(&dd->per_sdma[i].kobj);
881
882	for (i = 0; i < dd->num_pports; i++) {
883		ppd = &dd->pport[i];
884
885		sysfs_remove_bin_file(&ppd->pport_cc_kobj,
886				      &cc_setting_bin_attr);
887		sysfs_remove_bin_file(&ppd->pport_cc_kobj,
888				      &cc_table_bin_attr);
889		kobject_put(&ppd->pport_cc_kobj);
890		kobject_put(&ppd->vl2mtu_kobj);
891		kobject_put(&ppd->sl2sc_kobj);
892		kobject_put(&ppd->sc2vl_kobj);
893	}
894}
895