2 * Copyright (c) 2006, 2007 QLogic Corporation. All rights reserved.
3 * Copyright (c) 2006 PathScale, Inc. All rights reserved.
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:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
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.
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
34 #include <linux/ctype.h>
36 #include "ipath_kernel.h"
37 #include "ipath_common.h"
40 * ipath_parse_ushort - parse an unsigned short value in an arbitrary base
41 * @str: the string containing the number
42 * @valp: where to put the result
44 * returns the number of bytes consumed, or negative value on error
46 int ipath_parse_ushort(const char *str
, unsigned short *valp
)
52 if (!isdigit(str
[0])) {
57 val
= simple_strtoul(str
, &end
, 0);
74 static ssize_t
show_version(struct device_driver
*dev
, char *buf
)
76 /* The string printed here is already newline-terminated. */
77 return scnprintf(buf
, PAGE_SIZE
, "%s", ib_ipath_version
);
80 static ssize_t
show_num_units(struct device_driver
*dev
, char *buf
)
82 return scnprintf(buf
, PAGE_SIZE
, "%d\n",
83 ipath_count_units(NULL
, NULL
, NULL
));
86 static ssize_t
show_status(struct device
*dev
,
87 struct device_attribute
*attr
,
90 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
93 if (!dd
->ipath_statusp
) {
98 ret
= scnprintf(buf
, PAGE_SIZE
, "0x%llx\n",
99 (unsigned long long) *(dd
->ipath_statusp
));
105 static const char *ipath_status_str
[] = {
109 "", /* This used to be the old "OIB_SMA" status. */
110 "", /* This used to be the old "SMA" status. */
115 "Fatal_Hardware_Error",
119 static ssize_t
show_status_str(struct device
*dev
,
120 struct device_attribute
*attr
,
123 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
128 if (!dd
->ipath_statusp
) {
133 s
= *(dd
->ipath_statusp
);
135 for (any
= i
= 0; s
&& ipath_status_str
[i
]; i
++) {
137 if (any
&& strlcat(buf
, " ", PAGE_SIZE
) >=
141 if (strlcat(buf
, ipath_status_str
[i
],
142 PAGE_SIZE
) >= PAGE_SIZE
)
149 strlcat(buf
, "\n", PAGE_SIZE
);
157 static ssize_t
show_boardversion(struct device
*dev
,
158 struct device_attribute
*attr
,
161 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
162 /* The string printed here is already newline-terminated. */
163 return scnprintf(buf
, PAGE_SIZE
, "%s", dd
->ipath_boardversion
);
166 static ssize_t
show_lmc(struct device
*dev
,
167 struct device_attribute
*attr
,
170 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
172 return scnprintf(buf
, PAGE_SIZE
, "%u\n", dd
->ipath_lmc
);
175 static ssize_t
store_lmc(struct device
*dev
,
176 struct device_attribute
*attr
,
180 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
184 ret
= ipath_parse_ushort(buf
, &lmc
);
193 ipath_set_lid(dd
, dd
->ipath_lid
, lmc
);
197 ipath_dev_err(dd
, "attempt to set invalid LMC %u\n", lmc
);
202 static ssize_t
show_lid(struct device
*dev
,
203 struct device_attribute
*attr
,
206 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
208 return scnprintf(buf
, PAGE_SIZE
, "0x%x\n", dd
->ipath_lid
);
211 static ssize_t
store_lid(struct device
*dev
,
212 struct device_attribute
*attr
,
216 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
220 ret
= ipath_parse_ushort(buf
, &lid
);
224 if (lid
== 0 || lid
>= IPATH_MULTICAST_LID_BASE
) {
229 ipath_set_lid(dd
, lid
, dd
->ipath_lmc
);
233 ipath_dev_err(dd
, "attempt to set invalid LID 0x%x\n", lid
);
238 static ssize_t
show_mlid(struct device
*dev
,
239 struct device_attribute
*attr
,
242 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
244 return scnprintf(buf
, PAGE_SIZE
, "0x%x\n", dd
->ipath_mlid
);
247 static ssize_t
store_mlid(struct device
*dev
,
248 struct device_attribute
*attr
,
252 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
256 ret
= ipath_parse_ushort(buf
, &mlid
);
257 if (ret
< 0 || mlid
< IPATH_MULTICAST_LID_BASE
)
260 dd
->ipath_mlid
= mlid
;
264 ipath_dev_err(dd
, "attempt to set invalid MLID\n");
269 static ssize_t
show_guid(struct device
*dev
,
270 struct device_attribute
*attr
,
273 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
276 guid
= (u8
*) & (dd
->ipath_guid
);
278 return scnprintf(buf
, PAGE_SIZE
,
279 "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
280 guid
[0], guid
[1], guid
[2], guid
[3],
281 guid
[4], guid
[5], guid
[6], guid
[7]);
284 static ssize_t
store_guid(struct device
*dev
,
285 struct device_attribute
*attr
,
289 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
291 unsigned short guid
[8];
296 if (sscanf(buf
, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx",
297 &guid
[0], &guid
[1], &guid
[2], &guid
[3],
298 &guid
[4], &guid
[5], &guid
[6], &guid
[7]) != 8)
301 ng
= (u8
*) &new_guid
;
303 for (i
= 0; i
< 8; i
++) {
312 dd
->ipath_guid
= new_guid
;
319 ipath_dev_err(dd
, "attempt to set invalid GUID\n");
326 static ssize_t
show_nguid(struct device
*dev
,
327 struct device_attribute
*attr
,
330 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
332 return scnprintf(buf
, PAGE_SIZE
, "%u\n", dd
->ipath_nguid
);
335 static ssize_t
show_nports(struct device
*dev
,
336 struct device_attribute
*attr
,
339 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
341 /* Return the number of user ports available. */
342 return scnprintf(buf
, PAGE_SIZE
, "%u\n", dd
->ipath_cfgports
- 1);
345 static ssize_t
show_serial(struct device
*dev
,
346 struct device_attribute
*attr
,
349 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
351 buf
[sizeof dd
->ipath_serial
] = '\0';
352 memcpy(buf
, dd
->ipath_serial
, sizeof dd
->ipath_serial
);
357 static ssize_t
show_unit(struct device
*dev
,
358 struct device_attribute
*attr
,
361 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
363 return scnprintf(buf
, PAGE_SIZE
, "%u\n", dd
->ipath_unit
);
366 #define DEVICE_COUNTER(name, attr) \
367 static ssize_t show_counter_##name(struct device *dev, \
368 struct device_attribute *attr, \
371 struct ipath_devdata *dd = dev_get_drvdata(dev); \
373 buf, PAGE_SIZE, "%llu\n", (unsigned long long) \
375 dd, offsetof(struct infinipath_counters, \
376 attr) / sizeof(u64))); \
378 static DEVICE_ATTR(name, S_IRUGO, show_counter_##name, NULL);
380 DEVICE_COUNTER(ib_link_downeds
, IBLinkDownedCnt
);
381 DEVICE_COUNTER(ib_link_err_recoveries
, IBLinkErrRecoveryCnt
);
382 DEVICE_COUNTER(ib_status_changes
, IBStatusChangeCnt
);
383 DEVICE_COUNTER(ib_symbol_errs
, IBSymbolErrCnt
);
384 DEVICE_COUNTER(lb_flow_stalls
, LBFlowStallCnt
);
385 DEVICE_COUNTER(lb_ints
, LBIntCnt
);
386 DEVICE_COUNTER(rx_bad_formats
, RxBadFormatCnt
);
387 DEVICE_COUNTER(rx_buf_ovfls
, RxBufOvflCnt
);
388 DEVICE_COUNTER(rx_data_pkts
, RxDataPktCnt
);
389 DEVICE_COUNTER(rx_dropped_pkts
, RxDroppedPktCnt
);
390 DEVICE_COUNTER(rx_dwords
, RxDwordCnt
);
391 DEVICE_COUNTER(rx_ebps
, RxEBPCnt
);
392 DEVICE_COUNTER(rx_flow_ctrl_errs
, RxFlowCtrlErrCnt
);
393 DEVICE_COUNTER(rx_flow_pkts
, RxFlowPktCnt
);
394 DEVICE_COUNTER(rx_icrc_errs
, RxICRCErrCnt
);
395 DEVICE_COUNTER(rx_len_errs
, RxLenErrCnt
);
396 DEVICE_COUNTER(rx_link_problems
, RxLinkProblemCnt
);
397 DEVICE_COUNTER(rx_lpcrc_errs
, RxLPCRCErrCnt
);
398 DEVICE_COUNTER(rx_max_min_len_errs
, RxMaxMinLenErrCnt
);
399 DEVICE_COUNTER(rx_p0_hdr_egr_ovfls
, RxP0HdrEgrOvflCnt
);
400 DEVICE_COUNTER(rx_p1_hdr_egr_ovfls
, RxP1HdrEgrOvflCnt
);
401 DEVICE_COUNTER(rx_p2_hdr_egr_ovfls
, RxP2HdrEgrOvflCnt
);
402 DEVICE_COUNTER(rx_p3_hdr_egr_ovfls
, RxP3HdrEgrOvflCnt
);
403 DEVICE_COUNTER(rx_p4_hdr_egr_ovfls
, RxP4HdrEgrOvflCnt
);
404 DEVICE_COUNTER(rx_p5_hdr_egr_ovfls
, RxP5HdrEgrOvflCnt
);
405 DEVICE_COUNTER(rx_p6_hdr_egr_ovfls
, RxP6HdrEgrOvflCnt
);
406 DEVICE_COUNTER(rx_p7_hdr_egr_ovfls
, RxP7HdrEgrOvflCnt
);
407 DEVICE_COUNTER(rx_p8_hdr_egr_ovfls
, RxP8HdrEgrOvflCnt
);
408 DEVICE_COUNTER(rx_pkey_mismatches
, RxPKeyMismatchCnt
);
409 DEVICE_COUNTER(rx_tid_full_errs
, RxTIDFullErrCnt
);
410 DEVICE_COUNTER(rx_tid_valid_errs
, RxTIDValidErrCnt
);
411 DEVICE_COUNTER(rx_vcrc_errs
, RxVCRCErrCnt
);
412 DEVICE_COUNTER(tx_data_pkts
, TxDataPktCnt
);
413 DEVICE_COUNTER(tx_dropped_pkts
, TxDroppedPktCnt
);
414 DEVICE_COUNTER(tx_dwords
, TxDwordCnt
);
415 DEVICE_COUNTER(tx_flow_pkts
, TxFlowPktCnt
);
416 DEVICE_COUNTER(tx_flow_stalls
, TxFlowStallCnt
);
417 DEVICE_COUNTER(tx_len_errs
, TxLenErrCnt
);
418 DEVICE_COUNTER(tx_max_min_len_errs
, TxMaxMinLenErrCnt
);
419 DEVICE_COUNTER(tx_underruns
, TxUnderrunCnt
);
420 DEVICE_COUNTER(tx_unsup_vl_errs
, TxUnsupVLErrCnt
);
422 static struct attribute
*dev_counter_attributes
[] = {
423 &dev_attr_ib_link_downeds
.attr
,
424 &dev_attr_ib_link_err_recoveries
.attr
,
425 &dev_attr_ib_status_changes
.attr
,
426 &dev_attr_ib_symbol_errs
.attr
,
427 &dev_attr_lb_flow_stalls
.attr
,
428 &dev_attr_lb_ints
.attr
,
429 &dev_attr_rx_bad_formats
.attr
,
430 &dev_attr_rx_buf_ovfls
.attr
,
431 &dev_attr_rx_data_pkts
.attr
,
432 &dev_attr_rx_dropped_pkts
.attr
,
433 &dev_attr_rx_dwords
.attr
,
434 &dev_attr_rx_ebps
.attr
,
435 &dev_attr_rx_flow_ctrl_errs
.attr
,
436 &dev_attr_rx_flow_pkts
.attr
,
437 &dev_attr_rx_icrc_errs
.attr
,
438 &dev_attr_rx_len_errs
.attr
,
439 &dev_attr_rx_link_problems
.attr
,
440 &dev_attr_rx_lpcrc_errs
.attr
,
441 &dev_attr_rx_max_min_len_errs
.attr
,
442 &dev_attr_rx_p0_hdr_egr_ovfls
.attr
,
443 &dev_attr_rx_p1_hdr_egr_ovfls
.attr
,
444 &dev_attr_rx_p2_hdr_egr_ovfls
.attr
,
445 &dev_attr_rx_p3_hdr_egr_ovfls
.attr
,
446 &dev_attr_rx_p4_hdr_egr_ovfls
.attr
,
447 &dev_attr_rx_p5_hdr_egr_ovfls
.attr
,
448 &dev_attr_rx_p6_hdr_egr_ovfls
.attr
,
449 &dev_attr_rx_p7_hdr_egr_ovfls
.attr
,
450 &dev_attr_rx_p8_hdr_egr_ovfls
.attr
,
451 &dev_attr_rx_pkey_mismatches
.attr
,
452 &dev_attr_rx_tid_full_errs
.attr
,
453 &dev_attr_rx_tid_valid_errs
.attr
,
454 &dev_attr_rx_vcrc_errs
.attr
,
455 &dev_attr_tx_data_pkts
.attr
,
456 &dev_attr_tx_dropped_pkts
.attr
,
457 &dev_attr_tx_dwords
.attr
,
458 &dev_attr_tx_flow_pkts
.attr
,
459 &dev_attr_tx_flow_stalls
.attr
,
460 &dev_attr_tx_len_errs
.attr
,
461 &dev_attr_tx_max_min_len_errs
.attr
,
462 &dev_attr_tx_underruns
.attr
,
463 &dev_attr_tx_unsup_vl_errs
.attr
,
467 static struct attribute_group dev_counter_attr_group
= {
469 .attrs
= dev_counter_attributes
472 static ssize_t
store_reset(struct device
*dev
,
473 struct device_attribute
*attr
,
477 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
480 if (count
< 5 || memcmp(buf
, "reset", 5)) {
485 if (dd
->ipath_flags
& IPATH_DISABLED
) {
487 * post-reset init would re-enable interrupts, etc.
488 * so don't allow reset on disabled devices. Not
489 * perfect error, but about the best choice.
491 dev_info(dev
,"Unit %d is disabled, can't reset\n",
495 ret
= ipath_reset_device(dd
->ipath_unit
);
497 return ret
<0 ? ret
: count
;
500 static ssize_t
store_link_state(struct device
*dev
,
501 struct device_attribute
*attr
,
505 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
509 ret
= ipath_parse_ushort(buf
, &state
);
513 r
= ipath_set_linkstate(dd
, state
);
521 ipath_dev_err(dd
, "attempt to set invalid link state\n");
526 static ssize_t
show_mtu(struct device
*dev
,
527 struct device_attribute
*attr
,
530 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
531 return scnprintf(buf
, PAGE_SIZE
, "%u\n", dd
->ipath_ibmtu
);
534 static ssize_t
store_mtu(struct device
*dev
,
535 struct device_attribute
*attr
,
539 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
544 ret
= ipath_parse_ushort(buf
, &mtu
);
548 r
= ipath_set_mtu(dd
, mtu
);
554 ipath_dev_err(dd
, "attempt to set invalid MTU\n");
559 static ssize_t
show_enabled(struct device
*dev
,
560 struct device_attribute
*attr
,
563 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
564 return scnprintf(buf
, PAGE_SIZE
, "%u\n",
565 (dd
->ipath_flags
& IPATH_DISABLED
) ? 0 : 1);
568 static ssize_t
store_enabled(struct device
*dev
,
569 struct device_attribute
*attr
,
573 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
577 ret
= ipath_parse_ushort(buf
, &enable
);
579 ipath_dev_err(dd
, "attempt to use non-numeric on enable\n");
584 if (!(dd
->ipath_flags
& IPATH_DISABLED
))
587 dev_info(dev
, "Enabling unit %d\n", dd
->ipath_unit
);
588 /* same as post-reset */
589 ret
= ipath_init_chip(dd
, 1);
591 ipath_dev_err(dd
, "Failed to enable unit %d\n",
594 dd
->ipath_flags
&= ~IPATH_DISABLED
;
595 *dd
->ipath_statusp
&= ~IPATH_STATUS_ADMIN_DISABLED
;
598 else if (!(dd
->ipath_flags
& IPATH_DISABLED
)) {
599 dev_info(dev
, "Disabling unit %d\n", dd
->ipath_unit
);
600 ipath_shutdown_device(dd
);
601 dd
->ipath_flags
|= IPATH_DISABLED
;
602 *dd
->ipath_statusp
|= IPATH_STATUS_ADMIN_DISABLED
;
609 static ssize_t
store_rx_pol_inv(struct device
*dev
,
610 struct device_attribute
*attr
,
614 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
618 ret
= ipath_parse_ushort(buf
, &val
);
622 r
= ipath_set_rx_pol_inv(dd
, val
);
630 ipath_dev_err(dd
, "attempt to set invalid Rx Polarity invert\n");
635 static ssize_t
store_led_override(struct device
*dev
,
636 struct device_attribute
*attr
,
640 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
644 ret
= ipath_parse_ushort(buf
, &val
);
646 ipath_set_led_override(dd
, val
);
648 ipath_dev_err(dd
, "attempt to set invalid LED override\n");
652 static ssize_t
show_logged_errs(struct device
*dev
,
653 struct device_attribute
*attr
,
656 struct ipath_devdata
*dd
= dev_get_drvdata(dev
);
659 /* force consistency with actual EEPROM */
660 if (ipath_update_eeprom_log(dd
) != 0)
664 for (idx
= 0; idx
< IPATH_EEP_LOG_CNT
; ++idx
) {
665 count
+= scnprintf(buf
+ count
, PAGE_SIZE
- count
, "%d%c",
666 dd
->ipath_eep_st_errs
[idx
],
667 idx
== (IPATH_EEP_LOG_CNT
- 1) ? '\n' : ' ');
673 static DRIVER_ATTR(num_units
, S_IRUGO
, show_num_units
, NULL
);
674 static DRIVER_ATTR(version
, S_IRUGO
, show_version
, NULL
);
676 static struct attribute
*driver_attributes
[] = {
677 &driver_attr_num_units
.attr
,
678 &driver_attr_version
.attr
,
682 static struct attribute_group driver_attr_group
= {
683 .attrs
= driver_attributes
686 struct attribute_group
*ipath_driver_attr_groups
[] = {
691 static DEVICE_ATTR(guid
, S_IWUSR
| S_IRUGO
, show_guid
, store_guid
);
692 static DEVICE_ATTR(lmc
, S_IWUSR
| S_IRUGO
, show_lmc
, store_lmc
);
693 static DEVICE_ATTR(lid
, S_IWUSR
| S_IRUGO
, show_lid
, store_lid
);
694 static DEVICE_ATTR(link_state
, S_IWUSR
, NULL
, store_link_state
);
695 static DEVICE_ATTR(mlid
, S_IWUSR
| S_IRUGO
, show_mlid
, store_mlid
);
696 static DEVICE_ATTR(mtu
, S_IWUSR
| S_IRUGO
, show_mtu
, store_mtu
);
697 static DEVICE_ATTR(enabled
, S_IWUSR
| S_IRUGO
, show_enabled
, store_enabled
);
698 static DEVICE_ATTR(nguid
, S_IRUGO
, show_nguid
, NULL
);
699 static DEVICE_ATTR(nports
, S_IRUGO
, show_nports
, NULL
);
700 static DEVICE_ATTR(reset
, S_IWUSR
, NULL
, store_reset
);
701 static DEVICE_ATTR(serial
, S_IRUGO
, show_serial
, NULL
);
702 static DEVICE_ATTR(status
, S_IRUGO
, show_status
, NULL
);
703 static DEVICE_ATTR(status_str
, S_IRUGO
, show_status_str
, NULL
);
704 static DEVICE_ATTR(boardversion
, S_IRUGO
, show_boardversion
, NULL
);
705 static DEVICE_ATTR(unit
, S_IRUGO
, show_unit
, NULL
);
706 static DEVICE_ATTR(rx_pol_inv
, S_IWUSR
, NULL
, store_rx_pol_inv
);
707 static DEVICE_ATTR(led_override
, S_IWUSR
, NULL
, store_led_override
);
708 static DEVICE_ATTR(logged_errors
, S_IRUGO
, show_logged_errs
, NULL
);
710 static struct attribute
*dev_attributes
[] = {
714 &dev_attr_link_state
.attr
,
717 &dev_attr_nguid
.attr
,
718 &dev_attr_nports
.attr
,
719 &dev_attr_serial
.attr
,
720 &dev_attr_status
.attr
,
721 &dev_attr_status_str
.attr
,
722 &dev_attr_boardversion
.attr
,
724 &dev_attr_enabled
.attr
,
725 &dev_attr_rx_pol_inv
.attr
,
726 &dev_attr_led_override
.attr
,
727 &dev_attr_logged_errors
.attr
,
731 static struct attribute_group dev_attr_group
= {
732 .attrs
= dev_attributes
736 * ipath_expose_reset - create a device reset file
737 * @dev: the device structure
739 * Only expose a file that lets us reset the device after someone
740 * enters diag mode. A device reset is quite likely to crash the
741 * machine entirely, so we don't want to normally make it
744 * Called with ipath_mutex held.
746 int ipath_expose_reset(struct device
*dev
)
752 ret
= device_create_file(dev
, &dev_attr_reset
);
761 int ipath_device_create_group(struct device
*dev
, struct ipath_devdata
*dd
)
765 ret
= sysfs_create_group(&dev
->kobj
, &dev_attr_group
);
769 ret
= sysfs_create_group(&dev
->kobj
, &dev_counter_attr_group
);
773 sysfs_remove_group(&dev
->kobj
, &dev_counter_attr_group
);
775 sysfs_remove_group(&dev
->kobj
, &dev_attr_group
);
780 void ipath_device_remove_group(struct device
*dev
, struct ipath_devdata
*dd
)
782 sysfs_remove_group(&dev
->kobj
, &dev_counter_attr_group
);
783 sysfs_remove_group(&dev
->kobj
, &dev_attr_group
);
785 device_remove_file(dev
, &dev_attr_reset
);