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 #ifdef CONFIG_PROC_FS
  16 extern int
  17 qeth_create_procfs_entries(void);
  18
  19 extern void
  20 qeth_remove_procfs_entries(void);
  21 #else
  22 static inline int
  23 qeth_create_procfs_entries(void)
  24 {
  25         return 0;
  26 }
  27
  28 static inline void
  29 qeth_remove_procfs_entries(void)
  30 {
  31 }
  32 #endif /* CONFIG_PROC_FS */
  33
  34 extern int
  35 qeth_create_device_attributes(struct device *dev);
  36
  37 extern void
  38 qeth_remove_device_attributes(struct device *dev);
  39
  40 extern int
  41 qeth_create_driver_attributes(void);
  42
  43 extern void
  44 qeth_remove_driver_attributes(void);
  45
  46 /*
  47  * utility functions used in qeth_proc.c and qeth_sys.c
  48  */
  49
  50 static inline const char *
  51 qeth_get_checksum_str(struct qeth_card *card)
  52 {
  53         if (card->options.checksum_type == SW_CHECKSUMMING)
  54                 return "sw";
  55         else if (card->options.checksum_type == HW_CHECKSUMMING)
  56                 return "hw";
  57         else
  58                 return "no";
  59 }
  60
  61 static inline const char *
  62 qeth_get_prioq_str(struct qeth_card *card, char *buf)
  63 {
  64         if (card->qdio.do_prio_queueing == QETH_NO_PRIO_QUEUEING)
  65                 sprintf(buf, "always_q_%i", card->qdio.default_out_queue);
  66         else
  67                 strcpy(buf, (card->qdio.do_prio_queueing ==
  68                                         QETH_PRIO_Q_ING_PREC)?
  69                                 "by_prec." : "by_ToS");
  70         return buf;
  71 }
  72
  73 static inline const char *
  74 qeth_get_bufsize_str(struct qeth_card *card)
  75 {
  76         if (card->qdio.in_buf_size == 16384)
  77                 return "16k";
  78         else if (card->qdio.in_buf_size == 24576)
  79                 return "24k";
  80         else if (card->qdio.in_buf_size == 32768)
  81                 return "32k";
  82         else if (card->qdio.in_buf_size == 40960)
  83                 return "40k";
  84         else
  85                 return "64k";
  86 }
  87
  88 static inline const char *
  89 qeth_get_cardname(struct qeth_card *card)
  90 {
  91         if (card->info.guestlan) {
  92                 switch (card->info.type) {
  93                 case QETH_CARD_TYPE_OSAE:
  94                         return " Guest LAN QDIO";
  95                 case QETH_CARD_TYPE_IQD:
  96                         return " Guest LAN Hiper";
  97                 default:
  98                         return " unknown";
  99                 }
 100         } else {
 101                 switch (card->info.type) {
 102                 case QETH_CARD_TYPE_OSAE:
 103                         return " OSD Express";
 104                 case QETH_CARD_TYPE_IQD:
 105                         return " HiperSockets";
 106                 default:
 107                         return " unknown";
 108                 }
 109         }
 110         return " n/a";
 111 }
 112
 113 /* max length to be returned: 14 */
 114 static inline const char *
 115 qeth_get_cardname_short(struct qeth_card *card)
 116 {
 117         if (card->info.guestlan){
 118                 switch (card->info.type){
 119                 case QETH_CARD_TYPE_OSAE:
 120                         return "GuestLAN QDIO";
 121                 case QETH_CARD_TYPE_IQD:
 122                         return "GuestLAN Hiper";
 123                 default:
 124                         return "unknown";
 125                 }
 126         } else {
 127                 switch (card->info.type) {
 128                 case QETH_CARD_TYPE_OSAE:
 129                         switch (card->info.link_type) {
 130                         case QETH_LINK_TYPE_FAST_ETH:
 131                                 return "OSD_100";
 132                         case QETH_LINK_TYPE_HSTR:
 133                                 return "HSTR";
 134                         case QETH_LINK_TYPE_GBIT_ETH:
 135                                 return "OSD_1000";
 136                         case QETH_LINK_TYPE_LANE_ETH100:
 137                                 return "OSD_FE_LANE";
 138                         case QETH_LINK_TYPE_LANE_TR:
 139                                 return "OSD_TR_LANE";
 140                         case QETH_LINK_TYPE_LANE_ETH1000:
 141                                 return "OSD_GbE_LANE";
 142                         case QETH_LINK_TYPE_LANE:
 143                                 return "OSD_ATM_LANE";
 144                         default:
 145                                 return "OSD_Express";
 146                         }
 147                 case QETH_CARD_TYPE_IQD:
 148                         return "HiperSockets";
 149                 default:
 150                         return "unknown";
 151                 }
 152         }
 153         return "n/a";
 154 }
 155
 156 #endif /* __QETH_FS_H__ */