drivers/s390/net/qeth_fs.h

   1 /*
   2  * linux/drivers/s390/net/qeth_fs.h
   3  *
   4  * Linux on zSeries OSA Express and HiperSockets support.
   5  *
   6  * This header file contains definitions related to sysfs and procfs.
   7  *
   8  * Copyright 2000,2003 IBM Corporation
   9  * Author(s): Thomas Spatzier <tspat@de.ibm.com>
  10  *
  11  */
  12 #ifndef __QETH_FS_H__
  13 #define __QETH_FS_H__
  14
  15 #define VERSION_QETH_FS_H "$Revision: 1.10 $"
  16
  17 extern const char *VERSION_QETH_PROC_C;
  18 extern const char *VERSION_QETH_SYS_C;
  19
  20 #ifdef CONFIG_PROC_FS
  21 extern int
  22 qeth_create_procfs_entries(void);
  23
  24 extern void
  25 qeth_remove_procfs_entries(void);
  26 #else
  27 static inline int
  28 qeth_create_procfs_entries(void)
  29 {
  30         return 0;
  31 }
  32
  33 static inline void
  34 qeth_remove_procfs_entries(void)
  35 {
  36 }
  37 #endif /* CONFIG_PROC_FS */
  38
  39 extern int
  40 qeth_create_device_attributes(struct device *dev);
  41
  42 extern void
  43 qeth_remove_device_attributes(struct device *dev);
  44
  45 extern int
  46 qeth_create_device_attributes_osn(struct device *dev);
  47
  48 extern void
  49 qeth_remove_device_attributes_osn(struct device *dev);
  50
  51 extern int
  52 qeth_create_driver_attributes(void);
  53
  54 extern void
  55 qeth_remove_driver_attributes(void);
  56
  57 /*
  58  * utility functions used in qeth_proc.c and qeth_sys.c
  59  */
  60
  61 static inline const char *
  62 qeth_get_checksum_str(struct qeth_card *card)
  63 {
  64         if (card->options.checksum_type == SW_CHECKSUMMING)
  65                 return "sw";
  66         else if (card->options.checksum_type == HW_CHECKSUMMING)
  67                 return "hw";
  68         else
  69                 return "no";
  70 }
  71
  72 static inline const char *
  73 qeth_get_prioq_str(struct qeth_card *card, char *buf)
  74 {
  75         if (card->qdio.do_prio_queueing == QETH_NO_PRIO_QUEUEING)
  76                 sprintf(buf, "always_q_%i", card->qdio.default_out_queue);
  77         else
  78                 strcpy(buf, (card->qdio.do_prio_queueing ==
  79                                         QETH_PRIO_Q_ING_PREC)?
  80                                 "by_prec." : "by_ToS");
  81         return buf;
  82 }
  83
  84 static inline const char *
  85 qeth_get_bufsize_str(struct qeth_card *card)
  86 {
  87         if (card->qdio.in_buf_size == 16384)
  88                 return "16k";
  89         else if (card->qdio.in_buf_size == 24576)
  90                 return "24k";
  91         else if (card->qdio.in_buf_size == 32768)
  92                 return "32k";
  93         else if (card->qdio.in_buf_size == 40960)
  94                 return "40k";
  95         else
  96                 return "64k";
  97 }
  98
  99 static inline const char *
 100 qeth_get_cardname(struct qeth_card *card)
 101 {
 102         if (card->info.guestlan) {
 103                 switch (card->info.type) {
 104                 case QETH_CARD_TYPE_OSAE:
 105                         return " Guest LAN QDIO";
 106                 case QETH_CARD_TYPE_IQD:
 107                         return " Guest LAN Hiper";
 108                 default:
 109                         return " unknown";
 110                 }
 111         } else {
 112                 switch (card->info.type) {
 113                 case QETH_CARD_TYPE_OSAE:
 114                         return " OSD Express";
 115                 case QETH_CARD_TYPE_IQD:
 116                         return " HiperSockets";
 117                 case QETH_CARD_TYPE_OSN:
 118                         return " OSN QDIO";
 119                 default:
 120                         return " unknown";
 121                 }
 122         }
 123         return " n/a";
 124 }
 125
 126 /* max length to be returned: 14 */
 127 static inline const char *
 128 qeth_get_cardname_short(struct qeth_card *card)
 129 {
 130         if (card->info.guestlan){
 131                 switch (card->info.type){
 132                 case QETH_CARD_TYPE_OSAE:
 133                         return "GuestLAN QDIO";
 134                 case QETH_CARD_TYPE_IQD:
 135                         return "GuestLAN Hiper";
 136                 default:
 137                         return "unknown";
 138                 }
 139         } else {
 140                 switch (card->info.type) {
 141                 case QETH_CARD_TYPE_OSAE:
 142                         switch (card->info.link_type) {
 143                         case QETH_LINK_TYPE_FAST_ETH:
 144                                 return "OSD_100";
 145                         case QETH_LINK_TYPE_HSTR:
 146                                 return "HSTR";
 147                         case QETH_LINK_TYPE_GBIT_ETH:
 148                                 return "OSD_1000";
 149                         case QETH_LINK_TYPE_10GBIT_ETH:
 150                                 return "OSD_10GIG";
 151                         case QETH_LINK_TYPE_LANE_ETH100:
 152                                 return "OSD_FE_LANE";
 153                         case QETH_LINK_TYPE_LANE_TR:
 154                                 return "OSD_TR_LANE";
 155                         case QETH_LINK_TYPE_LANE_ETH1000:
 156                                 return "OSD_GbE_LANE";
 157                         case QETH_LINK_TYPE_LANE:
 158                                 return "OSD_ATM_LANE";
 159                         default:
 160                                 return "OSD_Express";
 161                         }
 162                 case QETH_CARD_TYPE_IQD:
 163                         return "HiperSockets";
 164                 case QETH_CARD_TYPE_OSN:
 165                         return "OSN";
 166                 default:
 167                         return "unknown";
 168                 }
 169         }
 170         return "n/a";
 171 }
 172
 173 #endif /* __QETH_FS_H__ */