1 /*
2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
4 *
5 * GPL LICENSE SUMMARY
6 *
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
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 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
23 *
24 * BSD LICENSE
25 *
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
28 *
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
31 * are met:
32 *
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
38 * distribution.
39 * * Neither the name of Intel Corporation nor the names of its
40 * contributors may be used to endorse or promote products derived
41 * from this software without specific prior written permission.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 */
55 #ifndef _SCI_HOST_H_
56 #define _SCI_HOST_H_
57
58 #include "remote_device.h"
59 #include "phy.h"
60 #include "isci.h"
61 #include "remote_node_table.h"
62 #include "registers.h"
63 #include "unsolicited_frame_control.h"
64 #include "probe_roms.h"
65
66 struct isci_request;
67 struct scu_task_context;
68
69
70 /**
71 * struct sci_power_control -
72 *
73 * This structure defines the fields for managing power control for direct
74 * attached disk devices.
75 */
76 struct sci_power_control {
77 /**
78 * This field is set when the power control timer is running and cleared when
79 * it is not.
80 */
81 bool timer_started;
82
83 /**
84 * Timer to control when the directed attached disks can consume power.
85 */
86 struct sci_timer timer;
87
88 /**
89 * This field is used to keep track of how many phys are put into the
90 * requesters field.
91 */
92 u8 phys_waiting;
93
94 /**
95 * This field is used to keep track of how many phys have been granted to consume power
96 */
97 u8 phys_granted_power;
98
99 /**
100 * This field is an array of phys that we are waiting on. The phys are direct
101 * mapped into requesters via struct sci_phy.phy_index
102 */
103 struct isci_phy *requesters[SCI_MAX_PHYS];
104
105 };
106
107 struct sci_port_configuration_agent;
108 typedef void (*port_config_fn)(struct isci_host *,
109 struct sci_port_configuration_agent *,
110 struct isci_port *, struct isci_phy *);
111
112 struct sci_port_configuration_agent {
113 u16 phy_configured_mask;
114 u16 phy_ready_mask;
115 struct {
116 u8 min_index;
117 u8 max_index;
118 } phy_valid_port_range[SCI_MAX_PHYS];
119 bool timer_pending;
120 port_config_fn link_up_handler;
121 port_config_fn link_down_handler;
122 struct sci_timer timer;
123 };
124
125 /**
126 * isci_host - primary host/controller object
127 * @timer: timeout start/stop operations
128 * @device_table: rni (hw remote node index) to remote device lookup table
129 * @available_remote_nodes: rni allocator
130 * @power_control: manage device spin up
131 * @io_request_sequence: generation number for tci's (task contexts)
132 * @task_context_table: hw task context table
133 * @remote_node_context_table: hw remote node context table
134 * @completion_queue: hw-producer driver-consumer communication ring
135 * @completion_queue_get: tracks the driver 'head' of the ring to notify hw
136 * @logical_port_entries: min({driver|silicon}-supported-port-count)
137 * @remote_node_entries: min({driver|silicon}-supported-node-count)
138 * @task_context_entries: min({driver|silicon}-supported-task-count)
139 * @phy_timer: phy startup timer
140 * @invalid_phy_mask: if an invalid_link_up notification is reported a bit for
141 * the phy index is set so further notifications are not
142 * made. Once the phy reports link up and is made part of a
143 * port then this bit is cleared.
144
145 */
146 struct isci_host {
147 struct sci_base_state_machine sm;
148 /* XXX can we time this externally */
149 struct sci_timer timer;
150 /* XXX drop reference module params directly */
151 struct sci_user_parameters user_parameters;
152 /* XXX no need to be a union */
153 struct sci_oem_params oem_parameters;
154 struct sci_port_configuration_agent port_agent;
155 struct isci_remote_device *device_table[SCI_MAX_REMOTE_DEVICES];
156 struct sci_remote_node_table available_remote_nodes;
157 struct sci_power_control power_control;
158 u8 io_request_sequence[SCI_MAX_IO_REQUESTS];
159 struct scu_task_context *task_context_table;
160 dma_addr_t task_context_dma;
161 union scu_remote_node_context *remote_node_context_table;
162 u32 *completion_queue;
163 u32 completion_queue_get;
164 u32 logical_port_entries;
165 u32 remote_node_entries;
166 u32 task_context_entries;
167 struct sci_unsolicited_frame_control uf_control;
168
169 /* phy startup */
170 struct sci_timer phy_timer;
171 /* XXX kill */
172 bool phy_startup_timer_pending;
173 u32 next_phy_to_start;
174 /* XXX convert to unsigned long and use bitops */
175 u8 invalid_phy_mask;
176
177 /* TODO attempt dynamic interrupt coalescing scheme */
178 u16 interrupt_coalesce_number;
179 u32 interrupt_coalesce_timeout;
180 struct smu_registers __iomem *smu_registers;
181 struct scu_registers __iomem *scu_registers;
182
183 u16 tci_head;
184 u16 tci_tail;
185 u16 tci_pool[SCI_MAX_IO_REQUESTS];
186
187 int id; /* unique within a given pci device */
188 struct isci_phy phys[SCI_MAX_PHYS];
189 struct isci_port ports[SCI_MAX_PORTS + 1]; /* includes dummy port */
190 struct asd_sas_port sas_ports[SCI_MAX_PORTS];
191 struct sas_ha_struct sas_ha;
192
193 spinlock_t state_lock;
194 struct pci_dev *pdev;
195 enum isci_status status;
196 #define IHOST_START_PENDING 0
197 #define IHOST_STOP_PENDING 1
198 unsigned long flags;
199 wait_queue_head_t eventq;
200 struct Scsi_Host *shost;
201 struct tasklet_struct completion_tasklet;
202 struct list_head requests_to_complete;
203 struct list_head requests_to_errorback;
204 spinlock_t scic_lock;
205 struct isci_request *reqs[SCI_MAX_IO_REQUESTS];
206 struct isci_remote_device devices[SCI_MAX_REMOTE_DEVICES];
207 };
208
209 /**
210 * enum sci_controller_states - This enumeration depicts all the states
211 * for the common controller state machine.
212 */
213 enum sci_controller_states {
214 /**
215 * Simply the initial state for the base controller state machine.
216 */
217 SCIC_INITIAL = 0,
218
219 /**
220 * This state indicates that the controller is reset. The memory for
221 * the controller is in it's initial state, but the controller requires
222 * initialization.
223 * This state is entered from the INITIAL state.
224 * This state is entered from the RESETTING state.
225 */
226 SCIC_RESET,
227
228 /**
229 * This state is typically an action state that indicates the controller
230 * is in the process of initialization. In this state no new IO operations
231 * are permitted.
232 * This state is entered from the RESET state.
233 */
234 SCIC_INITIALIZING,
235
236 /**
237 * This state indicates that the controller has been successfully
238 * initialized. In this state no new IO operations are permitted.
239 * This state is entered from the INITIALIZING state.
240 */
241 SCIC_INITIALIZED,
242
243 /**
244 * This state indicates the the controller is in the process of becoming
245 * ready (i.e. starting). In this state no new IO operations are permitted.
246 * This state is entered from the INITIALIZED state.
247 */
248 SCIC_STARTING,
249
250 /**
251 * This state indicates the controller is now ready. Thus, the user
252 * is able to perform IO operations on the controller.
253 * This state is entered from the STARTING state.
254 */
255 SCIC_READY,
256
257 /**
258 * This state is typically an action state that indicates the controller
259 * is in the process of resetting. Thus, the user is unable to perform
260 * IO operations on the controller. A reset is considered destructive in
261 * most cases.
262 * This state is entered from the READY state.
263 * This state is entered from the FAILED state.
264 * This state is entered from the STOPPED state.
265 */
266 SCIC_RESETTING,
267
268 /**
269 * This state indicates that the controller is in the process of stopping.
270 * In this state no new IO operations are permitted, but existing IO
271 * operations are allowed to complete.
272 * This state is entered from the READY state.
273 */
274 SCIC_STOPPING,
275
276 /**
277 * This state indicates that the controller has successfully been stopped.
278 * In this state no new IO operations are permitted.
279 * This state is entered from the STOPPING state.
280 */
281 SCIC_STOPPED,
282
283 /**
284 * This state indicates that the controller could not successfully be
285 * initialized. In this state no new IO operations are permitted.
286 * This state is entered from the INITIALIZING state.
287 * This state is entered from the STARTING state.
288 * This state is entered from the STOPPING state.
289 * This state is entered from the RESETTING state.
290 */
291 SCIC_FAILED,
292 };
293
294 /**
295 * struct isci_pci_info - This class represents the pci function containing the
296 * controllers. Depending on PCI SKU, there could be up to 2 controllers in
297 * the PCI function.
298 */
299 #define SCI_MAX_MSIX_INT (SCI_NUM_MSI_X_INT*SCI_MAX_CONTROLLERS)
300
301 struct isci_pci_info {
302 struct msix_entry msix_entries[SCI_MAX_MSIX_INT];
303 struct isci_host *hosts[SCI_MAX_CONTROLLERS];
304 struct isci_orom *orom;
305 };
306
to_pci_info(struct pci_dev * pdev)307 static inline struct isci_pci_info *to_pci_info(struct pci_dev *pdev)
308 {
309 return pci_get_drvdata(pdev);
310 }
311
312 #define for_each_isci_host(id, ihost, pdev) \
313 for (id = 0; id < SCI_MAX_CONTROLLERS && \
314 (ihost = to_pci_info(pdev)->hosts[id]); id++)
315
isci_host_get_state(struct isci_host * isci_host)316 static inline enum isci_status isci_host_get_state(struct isci_host *isci_host)
317 {
318 return isci_host->status;
319 }
320
isci_host_change_state(struct isci_host * isci_host,enum isci_status status)321 static inline void isci_host_change_state(struct isci_host *isci_host,
322 enum isci_status status)
323 {
324 unsigned long flags;
325
326 dev_dbg(&isci_host->pdev->dev,
327 "%s: isci_host = %p, state = 0x%x",
328 __func__,
329 isci_host,
330 status);
331 spin_lock_irqsave(&isci_host->state_lock, flags);
332 isci_host->status = status;
333 spin_unlock_irqrestore(&isci_host->state_lock, flags);
334
335 }
336
wait_for_start(struct isci_host * ihost)337 static inline void wait_for_start(struct isci_host *ihost)
338 {
339 wait_event(ihost->eventq, !test_bit(IHOST_START_PENDING, &ihost->flags));
340 }
341
wait_for_stop(struct isci_host * ihost)342 static inline void wait_for_stop(struct isci_host *ihost)
343 {
344 wait_event(ihost->eventq, !test_bit(IHOST_STOP_PENDING, &ihost->flags));
345 }
346
wait_for_device_start(struct isci_host * ihost,struct isci_remote_device * idev)347 static inline void wait_for_device_start(struct isci_host *ihost, struct isci_remote_device *idev)
348 {
349 wait_event(ihost->eventq, !test_bit(IDEV_START_PENDING, &idev->flags));
350 }
351
wait_for_device_stop(struct isci_host * ihost,struct isci_remote_device * idev)352 static inline void wait_for_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
353 {
354 wait_event(ihost->eventq, !test_bit(IDEV_STOP_PENDING, &idev->flags));
355 }
356
dev_to_ihost(struct domain_device * dev)357 static inline struct isci_host *dev_to_ihost(struct domain_device *dev)
358 {
359 return dev->port->ha->lldd_ha;
360 }
361
362 /* we always use protocol engine group zero */
363 #define ISCI_PEG 0
364
365 /* see sci_controller_io_tag_allocate|free for how seq and tci are built */
366 #define ISCI_TAG(seq, tci) (((u16) (seq)) << 12 | tci)
367
368 /* these are returned by the hardware, so sanitize them */
369 #define ISCI_TAG_SEQ(tag) (((tag) >> 12) & (SCI_MAX_SEQ-1))
370 #define ISCI_TAG_TCI(tag) ((tag) & (SCI_MAX_IO_REQUESTS-1))
371
372 /* interrupt coalescing baseline: 9 == 3 to 5us interrupt delay per command */
373 #define ISCI_COALESCE_BASE 9
374
375 /* expander attached sata devices require 3 rnc slots */
sci_remote_device_node_count(struct isci_remote_device * idev)376 static inline int sci_remote_device_node_count(struct isci_remote_device *idev)
377 {
378 struct domain_device *dev = idev->domain_dev;
379
380 if ((dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) &&
381 !idev->is_direct_attached)
382 return SCU_STP_REMOTE_NODE_COUNT;
383 return SCU_SSP_REMOTE_NODE_COUNT;
384 }
385
386 /**
387 * sci_controller_clear_invalid_phy() -
388 *
389 * This macro will clear the bit in the invalid phy mask for this controller
390 * object. This is used to control messages reported for invalid link up
391 * notifications.
392 */
393 #define sci_controller_clear_invalid_phy(controller, phy) \
394 ((controller)->invalid_phy_mask &= ~(1 << (phy)->phy_index))
395
scirdev_to_dev(struct isci_remote_device * idev)396 static inline struct device *scirdev_to_dev(struct isci_remote_device *idev)
397 {
398 if (!idev || !idev->isci_port || !idev->isci_port->isci_host)
399 return NULL;
400
401 return &idev->isci_port->isci_host->pdev->dev;
402 }
403
is_a2(struct pci_dev * pdev)404 static inline bool is_a2(struct pci_dev *pdev)
405 {
406 if (pdev->revision < 4)
407 return true;
408 return false;
409 }
410
is_b0(struct pci_dev * pdev)411 static inline bool is_b0(struct pci_dev *pdev)
412 {
413 if (pdev->revision == 4)
414 return true;
415 return false;
416 }
417
is_c0(struct pci_dev * pdev)418 static inline bool is_c0(struct pci_dev *pdev)
419 {
420 if (pdev->revision == 5)
421 return true;
422 return false;
423 }
424
is_c1(struct pci_dev * pdev)425 static inline bool is_c1(struct pci_dev *pdev)
426 {
427 if (pdev->revision >= 6)
428 return true;
429 return false;
430 }
431
432 enum cable_selections {
433 short_cable = 0,
434 long_cable = 1,
435 medium_cable = 2,
436 undefined_cable = 3
437 };
438
439 #define CABLE_OVERRIDE_DISABLED (0x10000)
440
is_cable_select_overridden(void)441 static inline int is_cable_select_overridden(void)
442 {
443 return cable_selection_override < CABLE_OVERRIDE_DISABLED;
444 }
445
446 enum cable_selections decode_cable_selection(struct isci_host *ihost, int phy);
447 void validate_cable_selections(struct isci_host *ihost);
448 char *lookup_cable_names(enum cable_selections);
449
450 /* set hw control for 'activity', even though active enclosures seem to drive
451 * the activity led on their own. Skip setting FSENG control on 'status' due
452 * to unexpected operation and 'error' due to not being a supported automatic
453 * FSENG output
454 */
455 #define SGPIO_HW_CONTROL 0x00000443
456
isci_gpio_count(struct isci_host * ihost)457 static inline int isci_gpio_count(struct isci_host *ihost)
458 {
459 return ARRAY_SIZE(ihost->scu_registers->peg0.sgpio.output_data_select);
460 }
461
462 void sci_controller_post_request(struct isci_host *ihost,
463 u32 request);
464 void sci_controller_release_frame(struct isci_host *ihost,
465 u32 frame_index);
466 void sci_controller_copy_sata_response(void *response_buffer,
467 void *frame_header,
468 void *frame_buffer);
469 enum sci_status sci_controller_allocate_remote_node_context(struct isci_host *ihost,
470 struct isci_remote_device *idev,
471 u16 *node_id);
472 void sci_controller_free_remote_node_context(
473 struct isci_host *ihost,
474 struct isci_remote_device *idev,
475 u16 node_id);
476
477 struct isci_request *sci_request_by_tag(struct isci_host *ihost,
478 u16 io_tag);
479
480 void sci_controller_power_control_queue_insert(
481 struct isci_host *ihost,
482 struct isci_phy *iphy);
483
484 void sci_controller_power_control_queue_remove(
485 struct isci_host *ihost,
486 struct isci_phy *iphy);
487
488 void sci_controller_link_up(
489 struct isci_host *ihost,
490 struct isci_port *iport,
491 struct isci_phy *iphy);
492
493 void sci_controller_link_down(
494 struct isci_host *ihost,
495 struct isci_port *iport,
496 struct isci_phy *iphy);
497
498 void sci_controller_remote_device_stopped(
499 struct isci_host *ihost,
500 struct isci_remote_device *idev);
501
502 void sci_controller_copy_task_context(
503 struct isci_host *ihost,
504 struct isci_request *ireq);
505
506 void sci_controller_register_setup(struct isci_host *ihost);
507
508 enum sci_status sci_controller_continue_io(struct isci_request *ireq);
509 int isci_host_scan_finished(struct Scsi_Host *, unsigned long);
510 void isci_host_scan_start(struct Scsi_Host *);
511 u16 isci_alloc_tag(struct isci_host *ihost);
512 enum sci_status isci_free_tag(struct isci_host *ihost, u16 io_tag);
513 void isci_tci_free(struct isci_host *ihost, u16 tci);
514
515 int isci_host_init(struct isci_host *);
516
517 void isci_host_init_controller_names(
518 struct isci_host *isci_host,
519 unsigned int controller_idx);
520
521 void isci_host_deinit(
522 struct isci_host *);
523
524 void isci_host_port_link_up(
525 struct isci_host *,
526 struct isci_port *,
527 struct isci_phy *);
528 int isci_host_dev_found(struct domain_device *);
529
530 void isci_host_remote_device_start_complete(
531 struct isci_host *,
532 struct isci_remote_device *,
533 enum sci_status);
534
535 void sci_controller_disable_interrupts(
536 struct isci_host *ihost);
537
538 enum sci_status sci_controller_start_io(
539 struct isci_host *ihost,
540 struct isci_remote_device *idev,
541 struct isci_request *ireq);
542
543 enum sci_task_status sci_controller_start_task(
544 struct isci_host *ihost,
545 struct isci_remote_device *idev,
546 struct isci_request *ireq);
547
548 enum sci_status sci_controller_terminate_request(
549 struct isci_host *ihost,
550 struct isci_remote_device *idev,
551 struct isci_request *ireq);
552
553 enum sci_status sci_controller_complete_io(
554 struct isci_host *ihost,
555 struct isci_remote_device *idev,
556 struct isci_request *ireq);
557
558 void sci_port_configuration_agent_construct(
559 struct sci_port_configuration_agent *port_agent);
560
561 enum sci_status sci_port_configuration_agent_initialize(
562 struct isci_host *ihost,
563 struct sci_port_configuration_agent *port_agent);
564
565 int isci_gpio_write(struct sas_ha_struct *, u8 reg_type, u8 reg_index,
566 u8 reg_count, u8 *write_data);
567 #endif
568