← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to include/scsi/scsi_transport_sas.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/scsi/scsi_transport_sas.h
 
1
#ifndef SCSI_TRANSPORT_SAS_H
 
2
#define SCSI_TRANSPORT_SAS_H
 
3
 
 
4
#include <linux/transport_class.h>
 
5
#include <linux/types.h>
 
6
#include <linux/mutex.h>
 
7
#include <scsi/sas.h>
 
8
 
 
9
struct scsi_transport_template;
 
10
struct sas_rphy;
 
11
struct request;
 
12
 
 
13
enum sas_device_type {
 
14
        SAS_PHY_UNUSED = 0,
 
15
        SAS_END_DEVICE = 1,
 
16
        SAS_EDGE_EXPANDER_DEVICE = 2,
 
17
        SAS_FANOUT_EXPANDER_DEVICE = 3,
 
18
};
 
19
 
 
20
static inline int sas_protocol_ata(enum sas_protocol proto)
 
21
{
 
22
        return ((proto & SAS_PROTOCOL_SATA) ||
 
23
                (proto & SAS_PROTOCOL_STP))? 1 : 0;
 
24
}
 
25
 
 
26
enum sas_linkrate {
 
27
        /* These Values are defined in the SAS standard */
 
28
        SAS_LINK_RATE_UNKNOWN = 0,
 
29
        SAS_PHY_DISABLED = 1,
 
30
        SAS_PHY_RESET_PROBLEM = 2,
 
31
        SAS_SATA_SPINUP_HOLD = 3,
 
32
        SAS_SATA_PORT_SELECTOR = 4,
 
33
        SAS_PHY_RESET_IN_PROGRESS = 5,
 
34
        SAS_LINK_RATE_1_5_GBPS = 8,
 
35
        SAS_LINK_RATE_G1 = SAS_LINK_RATE_1_5_GBPS,
 
36
        SAS_LINK_RATE_3_0_GBPS = 9,
 
37
        SAS_LINK_RATE_G2 = SAS_LINK_RATE_3_0_GBPS,
 
38
        SAS_LINK_RATE_6_0_GBPS = 10,
 
39
        /* These are virtual to the transport class and may never
 
40
         * be signalled normally since the standard defined field
 
41
         * is only 4 bits */
 
42
        SAS_LINK_RATE_FAILED = 0x10,
 
43
        SAS_PHY_VIRTUAL = 0x11,
 
44
};
 
45
 
 
46
struct sas_identify {
 
47
        enum sas_device_type    device_type;
 
48
        enum sas_protocol       initiator_port_protocols;
 
49
        enum sas_protocol       target_port_protocols;
 
50
        u64                     sas_address;
 
51
        u8                      phy_identifier;
 
52
};
 
53
 
 
54
struct sas_phy {
 
55
        struct device           dev;
 
56
        int                     number;
 
57
        int                     enabled;
 
58
 
 
59
        /* phy identification */
 
60
        struct sas_identify     identify;
 
61
 
 
62
        /* phy attributes */
 
63
        enum sas_linkrate       negotiated_linkrate;
 
64
        enum sas_linkrate       minimum_linkrate_hw;
 
65
        enum sas_linkrate       minimum_linkrate;
 
66
        enum sas_linkrate       maximum_linkrate_hw;
 
67
        enum sas_linkrate       maximum_linkrate;
 
68
 
 
69
        /* link error statistics */
 
70
        u32                     invalid_dword_count;
 
71
        u32                     running_disparity_error_count;
 
72
        u32                     loss_of_dword_sync_count;
 
73
        u32                     phy_reset_problem_count;
 
74
 
 
75
        /* for the list of phys belonging to a port */
 
76
        struct list_head        port_siblings;
 
77
 
 
78
        struct work_struct      reset_work;
 
79
};
 
80
 
 
81
#define dev_to_phy(d) \
 
82
        container_of((d), struct sas_phy, dev)
 
83
#define transport_class_to_phy(dev) \
 
84
        dev_to_phy((dev)->parent)
 
85
#define phy_to_shost(phy) \
 
86
        dev_to_shost((phy)->dev.parent)
 
87
 
 
88
struct request_queue;
 
89
struct sas_rphy {
 
90
        struct device           dev;
 
91
        struct sas_identify     identify;
 
92
        struct list_head        list;
 
93
        struct request_queue    *q;
 
94
        u32                     scsi_target_id;
 
95
};
 
96
 
 
97
#define dev_to_rphy(d) \
 
98
        container_of((d), struct sas_rphy, dev)
 
99
#define transport_class_to_rphy(dev) \
 
100
        dev_to_rphy((dev)->parent)
 
101
#define rphy_to_shost(rphy) \
 
102
        dev_to_shost((rphy)->dev.parent)
 
103
#define target_to_rphy(targ) \
 
104
        dev_to_rphy((targ)->dev.parent)
 
105
 
 
106
struct sas_end_device {
 
107
        struct sas_rphy         rphy;
 
108
        /* flags */
 
109
        unsigned                ready_led_meaning:1;
 
110
        unsigned                tlr_supported:1;
 
111
        unsigned                tlr_enabled:1;
 
112
        /* parameters */
 
113
        u16                     I_T_nexus_loss_timeout;
 
114
        u16                     initiator_response_timeout;
 
115
};
 
116
#define rphy_to_end_device(r) \
 
117
        container_of((r), struct sas_end_device, rphy)
 
118
 
 
119
struct sas_expander_device {
 
120
        int    level;
 
121
        int    next_port_id;
 
122
 
 
123
        #define SAS_EXPANDER_VENDOR_ID_LEN      8
 
124
        char   vendor_id[SAS_EXPANDER_VENDOR_ID_LEN+1];
 
125
        #define SAS_EXPANDER_PRODUCT_ID_LEN     16
 
126
        char   product_id[SAS_EXPANDER_PRODUCT_ID_LEN+1];
 
127
        #define SAS_EXPANDER_PRODUCT_REV_LEN    4
 
128
        char   product_rev[SAS_EXPANDER_PRODUCT_REV_LEN+1];
 
129
        #define SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN    8
 
130
        char   component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN+1];
 
131
        u16    component_id;
 
132
        u8     component_revision_id;
 
133
 
 
134
        struct sas_rphy         rphy;
 
135
 
 
136
};
 
137
#define rphy_to_expander_device(r) \
 
138
        container_of((r), struct sas_expander_device, rphy)
 
139
 
 
140
struct sas_port {
 
141
        struct device           dev;
 
142
 
 
143
        int                     port_identifier;
 
144
        int                     num_phys;
 
145
        /* port flags */
 
146
        unsigned int            is_backlink:1;
 
147
 
 
148
        /* the other end of the link */
 
149
        struct sas_rphy         *rphy;
 
150
 
 
151
        struct mutex            phy_list_mutex;
 
152
        struct list_head        phy_list;
 
153
};
 
154
 
 
155
#define dev_to_sas_port(d) \
 
156
        container_of((d), struct sas_port, dev)
 
157
#define transport_class_to_sas_port(dev) \
 
158
        dev_to_sas_port((dev)->parent)
 
159
 
 
160
struct sas_phy_linkrates {
 
161
        enum sas_linkrate maximum_linkrate;
 
162
        enum sas_linkrate minimum_linkrate;
 
163
};
 
164
 
 
165
/* The functions by which the transport class and the driver communicate */
 
166
struct sas_function_template {
 
167
        int (*get_linkerrors)(struct sas_phy *);
 
168
        int (*get_enclosure_identifier)(struct sas_rphy *, u64 *);
 
169
        int (*get_bay_identifier)(struct sas_rphy *);
 
170
        int (*phy_reset)(struct sas_phy *, int);
 
171
        int (*phy_enable)(struct sas_phy *, int);
 
172
        int (*set_phy_speed)(struct sas_phy *, struct sas_phy_linkrates *);
 
173
        int (*smp_handler)(struct Scsi_Host *, struct sas_rphy *, struct request *);
 
174
};
 
175
 
 
176
 
 
177
void sas_remove_children(struct device *);
 
178
extern void sas_remove_host(struct Scsi_Host *);
 
179
 
 
180
extern struct sas_phy *sas_phy_alloc(struct device *, int);
 
181
extern void sas_phy_free(struct sas_phy *);
 
182
extern int sas_phy_add(struct sas_phy *);
 
183
extern void sas_phy_delete(struct sas_phy *);
 
184
extern int scsi_is_sas_phy(const struct device *);
 
185
 
 
186
unsigned int sas_tlr_supported(struct scsi_device *);
 
187
unsigned int sas_is_tlr_enabled(struct scsi_device *);
 
188
void sas_disable_tlr(struct scsi_device *);
 
189
void sas_enable_tlr(struct scsi_device *);
 
190
 
 
191
extern struct sas_rphy *sas_end_device_alloc(struct sas_port *);
 
192
extern struct sas_rphy *sas_expander_alloc(struct sas_port *, enum sas_device_type);
 
193
void sas_rphy_free(struct sas_rphy *);
 
194
extern int sas_rphy_add(struct sas_rphy *);
 
195
extern void sas_rphy_remove(struct sas_rphy *);
 
196
extern void sas_rphy_delete(struct sas_rphy *);
 
197
extern int scsi_is_sas_rphy(const struct device *);
 
198
 
 
199
struct sas_port *sas_port_alloc(struct device *, int);
 
200
struct sas_port *sas_port_alloc_num(struct device *);
 
201
int sas_port_add(struct sas_port *);
 
202
void sas_port_free(struct sas_port *);
 
203
void sas_port_delete(struct sas_port *);
 
204
void sas_port_add_phy(struct sas_port *, struct sas_phy *);
 
205
void sas_port_delete_phy(struct sas_port *, struct sas_phy *);
 
206
void sas_port_mark_backlink(struct sas_port *);
 
207
int scsi_is_sas_port(const struct device *);
 
208
 
 
209
extern struct scsi_transport_template *
 
210
sas_attach_transport(struct sas_function_template *);
 
211
extern void sas_release_transport(struct scsi_transport_template *);
 
212
int sas_read_port_mode_page(struct scsi_device *);
 
213
 
 
214
static inline int
 
215
scsi_is_sas_expander_device(struct device *dev)
 
216
{
 
217
        struct sas_rphy *rphy;
 
218
        if (!scsi_is_sas_rphy(dev))
 
219
                return 0;
 
220
        rphy = dev_to_rphy(dev);
 
221
        return rphy->identify.device_type == SAS_FANOUT_EXPANDER_DEVICE ||
 
222
                rphy->identify.device_type == SAS_EDGE_EXPANDER_DEVICE;
 
223
}
 
224
 
 
225
#define scsi_is_sas_phy_local(phy)      scsi_is_host_device((phy)->dev.parent)
 
226
 
 
227
#endif /* SCSI_TRANSPORT_SAS_H */