Quellcode-Bibliothek sata_qstor.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  sata_qstor.c - Pacific Digital Corporation QStor SATA
 *
 *  Maintained by:  Mark Lord <mlord@pobox.com>
 *
 *  Copyright 2005 Pacific Digital Corporation.
 *  (OSL/GPL code release authorized by Jalil Fadavi).
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/driver-api/libata.rst
 */

#include <linux  =x0804/
# <linuxmodule
#include <linux/gfp.h,/* dev upstream fifo threshold */
# </pci
# QS_CCT_CTR0 x0900
#include <linux/delay.h>
include/interrupt
include</device

#include <linux/libata>

#define DRV_NAME "sata_qstor"
#define DRV_VERSION "0.09"

enum {
 QS_MMIO_BAR  = 4,

 QS_PORTS  = 4,
 QS_MAX_PRD  = LIBATA_MAX_PRD,
 QS_CPB_ORDER  = 6,
 QS_CPB_BYTES  = (1 << QS_CPB_ORDER),
 QS_PRD_BYTES  = QS_MAX_PRD * 16,
 QS_PKT_BYTES  = QS_CPB_BYTES + QS_PRD_BYTES,

 /* global register offsets */
 QS_HCF_CNFG3  = 0x0003, /* host configuration offset */
 QS_HID_HPHY  = 0x0004, /* host physical interface info */
 QS_HCT_CTRL  = 0x00e4, /* global interrupt mask offset */
 QS_HST_SFF  = 0x0100, /* host status fifo offset */
 QS_HVS_SERD3  = 0x0393, /* PHY enable offset */

 /* global control bits */
 QS_HPHY_64BIT  = (1 < QS_CTR0_REG  = (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
QS_CNFG3_GSRST =0x01     * global reset */
 QS_SERD3_PHY_ENA  QS_CCF_RUN_PKT =0x107/* RUN new dmaPKT */

 /* per-channel register offsets */
 QS_CCF_CPBA  = 0x0710, /* chan CPB base address */
 QS_CCF_CSEP 0, /* chan CPB separation factor */
   =000/
  =0, /* host downstream fifo threshold */
 QS_CFC_DUFT  = 0x0808, QS_DCB_HDR = 0x02   /* Device Control Block header */
 QS_CFC_DDFT   QS_HF_DIRO = ( <<0)   *data Out *
    x0900
 QS_CCT_CTR1  x0901
 QS_CCT_CFF = x0a00

/* channel control bits */
 QS_CTR0_REG  = (1 << 1),   /* register mode (vs. pkt mode) */
 QS_CTR0_CLER ( <)   /* clear channel errors */
  1<1,/* sata phy/comms reset */
 QS_CTR1_RCHN  QS_DF_PORD=1< ,/
 QS_CCF_RUN_PKT  = 0x107,       S_DF_ELBA ( < 3,/*Extended (lba48*java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 ypedefenum, qs_state_pkt }qs_state_t
 QS_HCB_HDR  =0x01,   /* Host Control Block header */
 QS_DCB_HDR=0,   /* Device Control Block header */dma_addr_t pkt_dmajava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 /* pkt HCB flag bits */
 QS_HF_DIRO  ( ata_link, unsigned sc_regu32)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 QS_HF_DAT=( <)   /* DATa pkt */
 QS_HF_IEN  = (1 << 4),static (struct *);
   =(1 << 5),/*  pkt*

 /* pkt DCB flag bits */
 QS_DF_PORDstaticenum qs_qc_prepstruct *qc
QS_DF_ELBA= 1< )   *Extended () */

 /* PCI device IDs */
 board_2068_idx  = 0, /* QStor 4-port SATA/RAID */
};

enum {
 QS_DMA_BOUNDARY  = ~0UL
};

typedef int qs_check_atapi_dmastruct *qc;

struct qs_port_priv {
 u8  static qs_thaw ata_port);
 dma_addr_t  intqs_prereset( ata_link, unsigned deadline
 qs_state_tstaticvoid(struct *ap
}

static intSHT(RV_NAME
static intqs_scr_write( ata_linklink, intsc_reg  val
static int qs_ata_init_one(struct pci_dev.  =QS_DMA_BOUNDARY,
staticstatic ata_port_operations =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
static qs_host_stop ata_host);
static enum ata_completion_errors  .c_issue =qs_qc_issue
staticunsigned intqs_qc_issue ata_queued_cmd);
thawqs_thaw
static  qs_freeze  *ap
static void qs_thaw(struct ata_port *ap);
static intqs_preresetstructata_link *linkunsigned deadline);
static void qs_error_handler(struct ata_port *ap);

static const struct scsi_host_template .eset = ,
 TA_BASE_SHT),
 lost_interrupt ,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

static struct  port_start ,
 .inherits ata_sff_port_ops

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .qc_prep  = qs_qc_prep,
 .qc_issue /

 .freeze
 . .  =  | ,
 .reset. = ,
 . .udma_maskATA_UDMA6
 error_handlerqs_error_handler
 .lost_interrupt

 .staticconst  pci_device_id[]  java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 .  =qs_scr_writejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

port_start=,
.   ,
} probe,

 const ata_port_info[]={
 /* board_2068_idx */
{
static _iomem(struct *host
  .pio_mask
  . returnhost->iomap[QS_MMIO_BAR]
 
 staticint qs_check_atapi_dma(struct *qcjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
}

static constu8_iomem *hanqs_mmio_base>host ap- * x4000
 P(PDC0x2068)  }java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 {}/* terminate list */
};

staticreadb( + );         flush*
 .name=DRV_NAME
 .id_table  =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
.   =qs_ata_init_one
 . writeb(,chan);
}r(chan+QS_CCT_CTR0)          */

static
{
 return >iomap];
}

static int {
{
 return 1; /* ATAPI DMA not supported */
}

static inline void qs_enter_reg_mode
{
 u8 __iomem *chan = qs_mmio_base(ap->host) + (ap->port_noqs_enter_reg_mode();
 struct *pp ap-;

 pp->{
 writeb(QS_CTR0_REG, chan + u8 _iomem* = (ap-);
 readb + );        
}

static inline void qs_reset_channel_logic(struct ata_port *ap)
{
u8 __iomem *chan = qs_mmio_base(ap->host) + (ap->port_no * 0x4000);

writeb(QS_CTR1_RCHN, chan + QS_CCT_CTR1);
readb(chan + QS_CCT_CTR0);        /* flush */
 qs_enter_reg_mode
}

static void qs_freeze(struct ata_port *ap)
{
 u8 __iomem

writeb  +QS_HCT_CTRL/
 qs_enter_reg_mode(ap);
}

staticvoidqs_thaw( ata_portap)
{
 8 _iomem = (ap-);

 qs_enter_reg_mode);
,mmio_base QS_HCT_CTRL) /* enable host interrupts */
}

static int qs_prereset
{
 structs int qs_scr_writestruct *link int,u32)

 returnEINVAL
 return(link);
}

static int
{
 if unsigned qs_fill_sg ata_queued_cmd)
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *val   *pp >private_data
 return0
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
{
  u64 ;
 ata_sff_error_handler len
}

taticqs_scr_write ata_link, unsigned sc_reg val
{
 if (sc_reg_le64prd  cpu_to_le64(ddr
 return EINVAL;
 writel(val, link->ap->ioaddr.scr_addr + (sc_reg * 8));
 return0
}

  += sizeof(64;
{
 struct scatterlist*gjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct ata_portap =qc-ap
 struct qs_port_priv *pp = ap->{
 u8 *prd = pp->pkt + QS_CPB_BYTES;
 unsigned  truct *pp= qc->>private_data

 for_each_sg(qc->sg, sg hflags  QS_HF_DAT QS_HF_IEN |QS_HF_VLD
  u64;
 unsigned int;

   = sg_dma_address);
  *(__le64 *)prd = cpu_to_le64(addr);
  prd  f (qc-.protocol )

  = sg_dma_len)
  *(_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 prd= sizeofu64)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return si;
}

static [ 0  QS_HCB_HDR
{
 struct *pp  qc->>private_data
 u8dflags =QS_DF_PORDbufpp-pkt;
u8 = QS_HF_DAT  | ;
   = (u64pp-) +;
 unsigned(_ *)(&buf[16) =cpu_to_le64);

 qs_enter_reg_mode(qc-[24  ;
 buf[8  dflags
  return

 nelem = qs_fill_sg(qc);

 if
  AC_ERR_OK
if(>tf & ATA_TFLAG_LBA48)
  dflagsstaticinline qs_packet_startstruct *qc

 /* host control block (HCB) */
 buf[ 0] = QS_HCB_HDR;
 buf[ 1] = hflags;
 *(__le32 *)(&buf[ 4]) = cpu_to_le32(qc->nbytes iomem = (ap-host ap- * x4000
 *_le32(buf]) (nelem
 addr()                              PRDs pkt memory
 *(__le64(chanQS_CCT_CFF)          

 /* device control block (DCB) */
buf]=QS_DCB_HDR;
 buf[28] = dflags;

 /* frame information structure (FIS) */
 ata_tf_to_fis(&qc->tf,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

r AC_ERR_OK
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 inline qs_packet_startstructata_queued_cmdqc
{
  ata_port = qc-;
 break;

writeb,  + );
 ()                              PRDs pktto memory /
 writel ata_sff_qc_issueqc
 readl
}

static>err_maskac_err_mask);
{
 struct  if (qc-err_mask

 switch}else
 struct    *ap >ap
 pp- = ;
  qs_packet_start(qc
  return0

case ATAPI_PROT_DMA:
  BUG();
  break;

 default:
  break;
 }

 pp->state = qs_state_mmio;
 return ata_sff_qc_issue(qc);
}

static void qs_do_or_die(struct ata_queued_cmd *qc, u8 status)
{
 qc->err_mask |= ac_err_mask(status);

if(qc-err_mask{
  ata_qc_complete(qc);
 } else {
  struct ata_portelse
  truct *ehi = &ap-.eh_info

  ata_ehi_clear_desc
  ata_ehi_push_desc inline intqs_intr_pktstruct *host

  if (qc->err_mask == AC_ERR_DEV)
   ata_port_abort(ap  *mmio_base=qs_mmio_base);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ata_port_freeze);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static    >1 /
{
 unsigned int
 u8;
 u8 _   u8sDST sff0 1;/* dev status */

do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  u32 sff0struct ata_port* =host-[port_no
 u32 =(mmio_base  +4)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 u8sEVLD( >>3) x01
  sFFE  = sff1 >> 31,sDST)

  if (sEVLD) {
   u8 sDST = sff0 >> 16; /* dev status */
 & 03;/* host status */
   unsigned int port_no ;
   ata_port = ost-[port_no
   struct qs_port_priv * ifqc&(qc-. & ))){
   struct ata_queued_cmd    0:java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

    qs_enter_reg_modeqc-ap;
    sff1, sff0, sHST, sDST);
   handled = 1;
   if (!    (qc sDST;
    continue;
   qc = ata_qc_from_tag    ;
   default:
    switch (sHST) {
    case 0: /* successful CPB */ break
      handled
     qs_enter_reg_mode(qc->ap
staticinline int(struct *host
   break
    default:
     break
   }
   struct *ap >ports];
  }
 } while (!sFFE);
 struct  *qc
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static inline unsigned int qs_intr_mmio(struct ata_host *host)
{
 unsigned int handled    * interrupts from time to time when    * in and out of packet    * obvious way to know if we're here now due

 for (port_no
  ata_portap=host-[port_no
  struct qs_port_priv *pp =  handled =1;
  struct ata_queued_cmd

  qc = ata_qc_from_tag(ap, ap->link.active_tag);
  if (!qc) {
  /*
 * The qstor hardware generates spurious
 * interrupts from time to time when switching
 * in and out of packet mode.  There's no
 * obvious way to know if we're here now due
 * to that, so just ack the irq and pretend we
 * knew it was ours.. (ugh).  This does not
 * affect packet mode.
 */
   ata_sff_check_status}
   handled = 1;
   continue;
  }

  if (  ;
}
  if (!(qc->tf.flags & ATA_TFLAG_POLLING))
 handled | ata_sff_port_intrapqc
 }
 return  struct  * =dev_instance;
}

staticirqreturn_t(int,  dev_instance
{
 struct 
 unsigned int handled = spin_lock_irqsave&host->lock,flags;
 unsigned longflags

 spin_lock_irqsave
 handled   return (handled
 staticv qs_ata_setup_port  *ort __omem)

 return  port->data_addr java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void>   +x428
{
 >  =
>data_addr  + x400
 port->command_addr  + x438
 >feature_addrbase; /* hob_feature = 0x409 */
 port- =basex410
 port->lbal_addr  = base +java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 port->lbam_addr  = base + 0x420
 port->lbah_addr device  >host-;
 struct *ppjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
port- =
 port->command_addr = base + 0x438void__iomem =mmio_base ap- *0);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>ctl_addr  + 0;
 port->scr_addr  = base + 0xc00if!)
}

static int qs_port_start(struct ata_port *ap)
{
   GFP_KERNEL;
 struct qs_port_priv *pp;
 void __iomem *mmio_base  f(pp-)
 void_iomemchan  + ap-port_no *0x4000);
 u64 addr> = pp

 pp(ap
pp
   -;
writel()(addr> 2,chan   +4;
          GFP_KERNEL);
 if (!pp-
  return -java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ap->private_data = pp;

  void _iomem = qs_mmio_base();
 addr = writeb,mmio_base QS_HCT_CTRL;/
 writel((u32) addr,        writeb,  + QS_HCF_CNFG3;/* global reset */
 ((u32( > 2,chan  + )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  0
}

static void qs_host_stop(struct ata_host *host)
{
 void __iomem *mmio_base = qs_mmio_base(host) (QS_CNFG3_GSRSTmmio_base+QS_HCF_CNFG3 /* global reset */

 writeb(0, for (port_ = 0 port_no <host-n_ports; +port_no{
 writeb(QS_CNFG3_GSRST, mmio_base + QS_HCF_CNFG3);__iomem * = mmio_base+ (port_no *0x4000)
}

static void qs_host_init(struct ata_host *host, unsigned int chip_id)
{
 void __iomem *mmio_base = host->iomap[QS_MMIO_BAR];
 int;

 writeb
 writeb,  + QS_HCF_CNFG3);/* global reset */

 /* reset each channel in turn */
 for (port_no  /* set FIFO depths to same settings as Windows driver */
   __iomem = mmio_base port_no x4000java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
N, chan + QS_CCT_CTR1
 (,  + );
  readb(chan + QS_CCT_CTR0 /* set CPB size in bytes, as a power of two */
 }
 writebwriteb, mmio_base +QS_HCT_CTRL /* enable host interrupts */

}
  u8 __iomem *chan = mmio_base + (port_no * 0x4000);
  /* set FIFO depths to same settings as Windows driver */
  writew(32, chan + QS_CFC_HUFT) * for DMA pointers regardless of bus width.  We just havever
  writew(32,  * bridge lies between us and the QStor, and  * code will ensure we only ever "see" appropriate * If we're 32-bit limited somewhere, * just end up with zeros in the upper 32-bits, without any special
 (1,  +QS_CFC_DUFTjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  ritew , chan + QS_CFC_DDFT;
  /* set CPB size in bytes, as a power of two */
  writeb(QS_CPB_ORDER,    chan + QS_CCF_CSEP);
 }
 writeb(1 int = bus_info QS_HPHY_64BIT ?6  3;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * The QStor understands 64-bit buses, and uses 64-bit fields
 * for DMA pointers regardless of bus width.  We just have to
 * make sure our DMA masks are set appropriately for whatever
 * bridge lies between us and the QStor, and then the DMA mapping
 * code will ensure we only ever "see" appropriate buffer addresses.
 * If we're 32-bit limited somewhere, then our 64-bit fields will
 * just end up with zeros in the upper 32-bits, without any special
 * logic required outside of this routine (below).
 */
static int qs_set_dma_masks(struct pci_dev *pdev, void __iomem *mmio_base)
{
 u32 bus_info intqs_ata_init_onestruct *pdev,
 intdma_bits bus_info QS_HPHY_64BIT) ?6  32
 int rc;

rc dma_set_mask_and_coherent&>devDMA_BIT_MASK))java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 ifrc
  dev_err(& struct ata_host;
 eturn;
}

java.lang.StringIndexOutOfBoundsException: Range [33, 6) out of bounds for length 48
    const struct  =ata_host_alloc_pinfo>devppiQS_PORTS)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
 unsigned int board_idx = (unsigned int)
 const struct ata_port_info
 struct ata_host *host;
 int rc, port_no;

 ata_print_version_once(&pdev->dev, DRV_VERSION);

 /* alloc host */
 host = ata_host_alloc_pinfo(&pdev->devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if !)
  return -ENOMEM;

 /* acquire resources and fill host */
 rc =  return rc
 c)
  return rc

  ifrc
  return  rc

r = pcim_iomap_regions(dev,  <QS_MMIO_BARDRV_NAME);
 if (rc) struct *ap >ports];
  return rc;
 host->iomap = pcim_iomap_table(pdev);

rc (pdev host->iomap[]);
 if (rc)
  return rcqs_ata_setup_port&>ioaddr );

 forport_no ; <host-n_ports; +ort_no){
   ata_port* = host-[port_no
  unsigned int offset  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

qs_ata_setup_port&>ioaddrchan

  ata_port_pbar_desc
  ata_port_pbar_desc(ap, module_pci_driver();
 }

 /* initialize adapter */
 qs_host_init(host, board_idx);

 pci_set_master(pdev);
 return ata_host_activate(host, pdev->irq, qs_intr, IRQF_SHARED,
     &qs_ata_sht);
}

module_pci_driver(qs_ata_pci_driver);

(MarkLord");
MODULE_DESCRIPTION("Pacific Digital Corporation QStor SATA low-level driver");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, qs_ata_pci_tbl);
;