hisi_sas_main.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2015 Linaro Ltd.
 * Copyright (c) 2015 Hisilicon Limited.
 */

#include "hisi_sas.h"
#define DRV_NAME …

#define DEV_IS_GONE(dev) …

static int hisi_sas_softreset_ata_disk(struct domain_device *device);
static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
				void *funcdata);
static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
				  struct domain_device *device);
static void hisi_sas_dev_gone(struct domain_device *device);

struct hisi_sas_internal_abort_data { … };

u8 hisi_sas_get_ata_protocol(struct host_to_dev_fis *fis, int direction)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_sata_done(struct sas_task *task,
			    struct hisi_sas_slot *slot)
{ … }
EXPORT_SYMBOL_GPL(…);

/*
 * This function assumes linkrate mask fits in 8 bits, which it
 * does for all HW versions supported.
 */
u8 hisi_sas_get_prog_phy_linkrate_mask(enum sas_linkrate max)
{ … }
EXPORT_SYMBOL_GPL(…);

static struct hisi_hba *dev_to_hisi_hba(struct domain_device *device)
{ … }

struct hisi_sas_port *to_hisi_sas_port(struct asd_sas_port *sas_port)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_stop_phys(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_slot_index_clear(struct hisi_hba *hisi_hba, int slot_idx)
{ … }

static void hisi_sas_slot_index_free(struct hisi_hba *hisi_hba, int slot_idx)
{ … }

static void hisi_sas_slot_index_set(struct hisi_hba *hisi_hba, int slot_idx)
{ … }

static int hisi_sas_slot_index_alloc(struct hisi_hba *hisi_hba,
				     struct request *rq)
{ … }

void hisi_sas_slot_task_free(struct hisi_hba *hisi_hba, struct sas_task *task,
			     struct hisi_sas_slot *slot, bool need_lock)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_task_prep_smp(struct hisi_hba *hisi_hba,
				  struct hisi_sas_slot *slot)
{ … }

static void hisi_sas_task_prep_ssp(struct hisi_hba *hisi_hba,
				  struct hisi_sas_slot *slot)
{ … }

static void hisi_sas_task_prep_ata(struct hisi_hba *hisi_hba,
				  struct hisi_sas_slot *slot)
{ … }

static void hisi_sas_task_prep_abort(struct hisi_hba *hisi_hba,
				     struct hisi_sas_slot *slot)
{ … }

static void hisi_sas_dma_unmap(struct hisi_hba *hisi_hba,
			       struct sas_task *task, int n_elem)
{ … }

static int hisi_sas_dma_map(struct hisi_hba *hisi_hba,
			    struct sas_task *task, int *n_elem)
{ … }

static void hisi_sas_dif_dma_unmap(struct hisi_hba *hisi_hba,
				   struct sas_task *task, int n_elem_dif)
{ … }

static int hisi_sas_dif_dma_map(struct hisi_hba *hisi_hba,
				int *n_elem_dif, struct sas_task *task)
{ … }

static
void hisi_sas_task_deliver(struct hisi_hba *hisi_hba,
			   struct hisi_sas_slot *slot,
			   struct hisi_sas_dq *dq,
			   struct hisi_sas_device *sas_dev)
{ … }

static int hisi_sas_queue_command(struct sas_task *task, gfp_t gfp_flags)
{ … }

static void hisi_sas_bytes_dmaed(struct hisi_hba *hisi_hba, int phy_no,
				 gfp_t gfp_flags)
{ … }

static struct hisi_sas_device *hisi_sas_alloc_dev(struct domain_device *device)
{ … }

static void hisi_sas_sync_poll_cq(struct hisi_sas_cq *cq)
{ … }

static bool hisi_sas_queue_is_poll(struct hisi_sas_cq *cq)
{ … }

static void hisi_sas_sync_cq(struct hisi_sas_cq *cq)
{ … }

void hisi_sas_sync_poll_cqs(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_sync_cqs(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_tmf_aborted(struct sas_task *task)
{ … }

#define HISI_SAS_DISK_RECOVER_CNT …
static int hisi_sas_init_device(struct domain_device *device)
{ … }

int hisi_sas_slave_alloc(struct scsi_device *sdev)
{ … }
EXPORT_SYMBOL_GPL(…);

static int hisi_sas_dev_found(struct domain_device *device)
{ … }

int hisi_sas_device_configure(struct scsi_device *sdev,
		struct queue_limits *lim)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_scan_start(struct Scsi_Host *shost)
{ … }
EXPORT_SYMBOL_GPL(…);

int hisi_sas_scan_finished(struct Scsi_Host *shost, unsigned long time)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_phyup_work_common(struct work_struct *work,
		enum hisi_sas_phy_event event)
{ … }

static void hisi_sas_phyup_work(struct work_struct *work)
{ … }

static void hisi_sas_linkreset_work(struct work_struct *work)
{ … }

static void hisi_sas_phyup_pm_work(struct work_struct *work)
{ … }

static const work_func_t hisi_sas_phye_fns[HISI_PHYES_NUM] = …;

bool hisi_sas_notify_phy_event(struct hisi_sas_phy *phy,
				enum hisi_sas_phy_event event)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_wait_phyup_timedout(struct timer_list *t)
{ … }

#define HISI_SAS_WAIT_PHYUP_RETRIES …

void hisi_sas_phy_oob_ready(struct hisi_hba *hisi_hba, int phy_no)
{ … }

EXPORT_SYMBOL_GPL(…);

static void hisi_sas_phy_init(struct hisi_hba *hisi_hba, int phy_no)
{ … }

/* Wrapper to ensure we track hisi_sas_phy.enable properly */
void hisi_sas_phy_enable(struct hisi_hba *hisi_hba, int phy_no, int enable)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_port_notify_formed(struct asd_sas_phy *sas_phy)
{ … }

static void hisi_sas_do_release_task(struct hisi_hba *hisi_hba, struct sas_task *task,
				     struct hisi_sas_slot *slot, bool need_lock)
{ … }

static void hisi_sas_release_task(struct hisi_hba *hisi_hba,
			struct domain_device *device)
{ … }

void hisi_sas_release_tasks(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_dereg_device(struct hisi_hba *hisi_hba,
				struct domain_device *device)
{ … }

static int
hisi_sas_internal_task_abort_dev(struct hisi_sas_device *sas_dev,
				 bool rst_ha_timeout)
{ … }

static void hisi_sas_dev_gone(struct domain_device *device)
{ … }

static int hisi_sas_phy_set_linkrate(struct hisi_hba *hisi_hba, int phy_no,
			struct sas_phy_linkrates *r)
{ … }

static int hisi_sas_control_phy(struct asd_sas_phy *sas_phy, enum phy_func func,
				void *funcdata)
{ … }

static void hisi_sas_fill_ata_reset_cmd(struct ata_device *dev,
		bool reset, int pmp, u8 *fis)
{ … }

static int hisi_sas_softreset_ata_disk(struct domain_device *device)
{ … }

static void hisi_sas_refresh_port_id(struct hisi_hba *hisi_hba)
{ … }

static void hisi_sas_rescan_topology(struct hisi_hba *hisi_hba, u32 state)
{ … }

static void hisi_sas_reset_init_all_devices(struct hisi_hba *hisi_hba)
{ … }

static void hisi_sas_send_ata_reset_each_phy(struct hisi_hba *hisi_hba,
					     struct asd_sas_port *sas_port,
					     struct domain_device *device)
{ … }

static void hisi_sas_terminate_stp_reject(struct hisi_hba *hisi_hba)
{ … }

void hisi_sas_controller_reset_prepare(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

static void hisi_sas_async_init_wait_phyup(void *data, async_cookie_t cookie)
{ … }

void hisi_sas_controller_reset_done(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

static int hisi_sas_controller_prereset(struct hisi_hba *hisi_hba)
{ … }

static int hisi_sas_controller_reset(struct hisi_hba *hisi_hba)
{ … }

static int hisi_sas_abort_task(struct sas_task *task)
{ … }

static int hisi_sas_abort_task_set(struct domain_device *device, u8 *lun)
{ … }

static int hisi_sas_debug_I_T_nexus_reset(struct domain_device *device)
{ … }

static int hisi_sas_I_T_nexus_reset(struct domain_device *device)
{ … }

static int hisi_sas_lu_reset(struct domain_device *device, u8 *lun)
{ … }

static void hisi_sas_async_I_T_nexus_reset(void *data, async_cookie_t cookie)
{ … }

static int hisi_sas_clear_nexus_ha(struct sas_ha_struct *sas_ha)
{ … }

static int hisi_sas_query_task(struct sas_task *task)
{ … }

static bool hisi_sas_internal_abort_timeout(struct sas_task *task,
					    void *data)
{ … }

static void hisi_sas_port_formed(struct asd_sas_phy *sas_phy)
{ … }

static int hisi_sas_write_gpio(struct sas_ha_struct *sha, u8 reg_type,
			u8 reg_index, u8 reg_count, u8 *write_data)
{ … }

static void hisi_sas_phy_disconnected(struct hisi_sas_phy *phy)
{ … }

void hisi_sas_phy_down(struct hisi_hba *hisi_hba, int phy_no, int rdy,
		       gfp_t gfp_flags)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_phy_bcast(struct hisi_sas_phy *phy)
{ … }
EXPORT_SYMBOL_GPL(…);

int hisi_sas_host_reset(struct Scsi_Host *shost, int reset_type)
{ … }
EXPORT_SYMBOL_GPL(…);

struct scsi_transport_template *hisi_sas_stt;
EXPORT_SYMBOL_GPL(…);

static struct sas_domain_function_template hisi_sas_transport_ops = …;

void hisi_sas_init_mem(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

int hisi_sas_alloc(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_free(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_rst_work_handler(struct work_struct *work)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_sync_rst_work_handler(struct work_struct *work)
{ … }
EXPORT_SYMBOL_GPL(…);

int hisi_sas_get_fw_info(struct hisi_hba *hisi_hba)
{ … }
EXPORT_SYMBOL_GPL(…);

static struct Scsi_Host *hisi_sas_shost_alloc(struct platform_device *pdev,
					      const struct hisi_sas_hw *hw)
{ … }

static int hisi_sas_interrupt_preinit(struct hisi_hba *hisi_hba)
{ … }

int hisi_sas_probe(struct platform_device *pdev,
		   const struct hisi_sas_hw *hw)
{ … }
EXPORT_SYMBOL_GPL(…);

void hisi_sas_remove(struct platform_device *pdev)
{ … }
EXPORT_SYMBOL_GPL(…);

#if IS_ENABLED(CONFIG_SCSI_HISI_SAS_DEBUGFS_DEFAULT_ENABLE)
#define DEBUGFS_ENABLE_DEFAULT …
bool hisi_sas_debugfs_enable = …;
u32 hisi_sas_debugfs_dump_count = …;
#else
#define DEBUGFS_ENABLE_DEFAULT …
bool hisi_sas_debugfs_enable;
u32 hisi_sas_debugfs_dump_count = 1;
#endif

EXPORT_SYMBOL_GPL(…);
module_param_named(debugfs_enable, hisi_sas_debugfs_enable, bool, 0444);
MODULE_PARM_DESC(…) …;

EXPORT_SYMBOL_GPL(…);
module_param_named(debugfs_dump_count, hisi_sas_debugfs_dump_count, uint, 0444);
MODULE_PARM_DESC(…) …;

struct dentry *hisi_sas_debugfs_dir;
EXPORT_SYMBOL_GPL(…);

static __init int hisi_sas_init(void)
{ … }

static __exit void hisi_sas_exit(void)
{ … }

module_init(…) …;
module_exit(hisi_sas_exit);

MODULE_LICENSE(…) …;
MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_ALIAS(…) …;
linux/drivers/scsi/hisi_sas/hisi_sas_main.c
