linux/drivers/scsi/stex.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * SuperTrak EX Series Storage Controller driver for Linux
 *
 *	Copyright (C) 2005-2015 Promise Technology Inc.
 *
 *	Written By:
 *		Ed Lin <[email protected]>
 */

#include <linux/init.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/time.h>
#include <linux/pci.h>
#include <linux/blkdev.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/ktime.h>
#include <linux/reboot.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/byteorder.h>
#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_eh.h>

#define DRV_NAME
#define ST_DRIVER_VERSION
#define ST_VER_MAJOR
#define ST_VER_MINOR
#define ST_OEM
#define ST_BUILD_VER

enum {};

enum {};

enum {};

struct st_sgitem {};

struct st_ss_sgitem {};

struct st_sgtable {};

struct st_msg_header {};

struct handshake_frame {};

struct req_msg {};

struct status_msg {};

struct ver_info {};

struct st_frame {};

struct st_drvver {};

struct st_ccb {};

struct st_hba {};

struct st_card_info {};

static int S6flag;
static int stex_halt(struct notifier_block *nb, ulong event, void *buf);
static struct notifier_block stex_notifier =;

static int msi;
module_param(msi, int, 0);
MODULE_PARM_DESC();

static const char console_inq_page[] =;

MODULE_AUTHOR();
MODULE_DESCRIPTION();
MODULE_LICENSE();
MODULE_VERSION();

static struct status_msg *stex_get_status(struct st_hba *hba)
{}

static void stex_invalid_field(struct scsi_cmnd *cmd,
			       void (*done)(struct scsi_cmnd *))
{}

static struct req_msg *stex_alloc_req(struct st_hba *hba)
{}

static struct req_msg *stex_ss_alloc_req(struct st_hba *hba)
{}

static int stex_map_sg(struct st_hba *hba,
	struct req_msg *req, struct st_ccb *ccb)
{}

static int stex_ss_map_sg(struct st_hba *hba,
	struct req_msg *req, struct st_ccb *ccb)
{}

static void stex_controller_info(struct st_hba *hba, struct st_ccb *ccb)
{}

static void
stex_send_cmd(struct st_hba *hba, struct req_msg *req, u16 tag)
{}

static void
stex_ss_send_cmd(struct st_hba *hba, struct req_msg *req, u16 tag)
{}

static void return_abnormal_state(struct st_hba *hba, int status)
{}
static int
stex_slave_config(struct scsi_device *sdev)
{}

static int stex_queuecommand_lck(struct scsi_cmnd *cmd)
{}

static DEF_SCSI_QCMD(stex_queuecommand)

static void stex_scsi_done(struct st_ccb *ccb)
{}

static void stex_copy_data(struct st_ccb *ccb,
	struct status_msg *resp, unsigned int variable)
{}

static void stex_check_cmd(struct st_hba *hba,
	struct st_ccb *ccb, struct status_msg *resp)
{}

static void stex_mu_intr(struct st_hba *hba, u32 doorbell)
{}

static irqreturn_t stex_intr(int irq, void *__hba)
{}

static void stex_ss_mu_intr(struct st_hba *hba)
{}

static irqreturn_t stex_ss_intr(int irq, void *__hba)
{}

static int stex_common_handshake(struct st_hba *hba)
{}

static int stex_ss_handshake(struct st_hba *hba)
{}

static int stex_handshake(struct st_hba *hba)
{}

static int stex_abort(struct scsi_cmnd *cmd)
{}

static void stex_hard_reset(struct st_hba *hba)
{}

static int stex_yos_reset(struct st_hba *hba)
{}

static void stex_ss_reset(struct st_hba *hba)
{}

static void stex_p3_reset(struct st_hba *hba)
{}

static int stex_do_reset(struct st_hba *hba)
{}

static int stex_reset(struct scsi_cmnd *cmd)
{}

static void stex_reset_work(struct work_struct *work)
{}

static int stex_biosparam(struct scsi_device *sdev,
	struct block_device *bdev, sector_t capacity, int geom[])
{}

static const struct scsi_host_template driver_template =;

static struct pci_device_id stex_pci_tbl[] =;

static struct st_card_info stex_card_info[] =;

static int stex_request_irq(struct st_hba *hba)
{}

static void stex_free_irq(struct st_hba *hba)
{}

static int stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{}

static void stex_hba_stop(struct st_hba *hba, int st_sleep_mic)
{}

static void stex_hba_free(struct st_hba *hba)
{}

static void stex_remove(struct pci_dev *pdev)
{}

static void stex_shutdown(struct pci_dev *pdev)
{}

static int stex_choice_sleep_mic(struct st_hba *hba, pm_message_t state)
{}

static int stex_suspend(struct pci_dev *pdev, pm_message_t state)
{}

static int stex_resume(struct pci_dev *pdev)
{}

static int stex_halt(struct notifier_block *nb, unsigned long event, void *buf)
{}
MODULE_DEVICE_TABLE(pci, stex_pci_tbl);

static struct pci_driver stex_pci_driver =;

static int __init stex_init(void)
{}

static void __exit stex_exit(void)
{}

module_init();
module_exit(stex_exit);