| /* SPDX-License-Identifier: GPL-2.0-or-later */ |
| /* |
| * |
| * Linux MegaRAID device driver |
| * |
| * Copyright (c) 2003-2004 LSI Logic Corporation. |
| * |
| * FILE : megaraid_ioctl.h |
| * |
| * Definitions to interface with user level applications |
| */ |
| |
| #ifndef _MEGARAID_IOCTL_H_ |
| #define _MEGARAID_IOCTL_H_ |
| |
| #include <linux/types.h> |
| #include <linux/semaphore.h> |
| #include <linux/timer.h> |
| |
| #include "mbox_defs.h" |
| |
| /* |
| * console messages debug levels |
| */ |
| #define CL_ANN 0 /* print unconditionally, announcements */ |
| #define CL_DLEVEL1 1 /* debug level 1, informative */ |
| #define CL_DLEVEL2 2 /* debug level 2, verbose */ |
| #define CL_DLEVEL3 3 /* debug level 3, very verbose */ |
| |
| /** |
| * con_log() - console log routine |
| * @level : indicates the severity of the message. |
| * @fmt : format string |
| * |
| * con_log displays the error messages on the console based on the current |
| * debug level. Also it attaches the appropriate kernel severity level with |
| * the message. |
| */ |
| #define con_log(level, fmt) if (LSI_DBGLVL >= level) printk fmt; |
| |
| /* |
| * Definitions & Declarations needed to use common management module |
| */ |
| |
| #define MEGAIOC_MAGIC 'm' |
| #define MEGAIOCCMD _IOWR(MEGAIOC_MAGIC, 0, mimd_t) |
| |
| #define MEGAIOC_QNADAP 'm' /* Query # of adapters */ |
| #define MEGAIOC_QDRVRVER 'e' /* Query driver version */ |
| #define MEGAIOC_QADAPINFO 'g' /* Query adapter information */ |
| |
| #define USCSICMD 0x80 |
| #define UIOC_RD 0x00001 |
| #define UIOC_WR 0x00002 |
| |
| #define MBOX_CMD 0x00000 |
| #define GET_DRIVER_VER 0x10000 |
| #define GET_N_ADAP 0x20000 |
| #define GET_ADAP_INFO 0x30000 |
| #define GET_CAP 0x40000 |
| #define GET_STATS 0x50000 |
| #define GET_IOCTL_VERSION 0x01 |
| |
| #define EXT_IOCTL_SIGN_SZ 16 |
| #define EXT_IOCTL_SIGN "$$_EXTD_IOCTL_$$" |
| |
| #define MBOX_LEGACY 0x00 /* ioctl has legacy mbox*/ |
| #define MBOX_HPE 0x01 /* ioctl has hpe mbox */ |
| |
| #define APPTYPE_MIMD 0x00 /* old existing apps */ |
| #define APPTYPE_UIOC 0x01 /* new apps using uioc */ |
| |
| #define IOCTL_ISSUE 0x00000001 /* Issue ioctl */ |
| #define IOCTL_ABORT 0x00000002 /* Abort previous ioctl */ |
| |
| #define DRVRTYPE_MBOX 0x00000001 /* regular mbox driver */ |
| #define DRVRTYPE_HPE 0x00000002 /* new hpe driver */ |
| |
| #define MKADAP(adapno) (MEGAIOC_MAGIC << 8 | (adapno) ) |
| #define GETADAP(mkadap) ((mkadap) ^ MEGAIOC_MAGIC << 8) |
| |
| #define MAX_DMA_POOLS 5 /* 4k, 8k, 16k, 32k, 64k*/ |
| |
| |
| /** |
| * struct uioc_t - the common ioctl packet structure |
| * |
| * @signature : Must be "$$_EXTD_IOCTL_$$" |
| * @mb_type : Type of the mail box (MB_LEGACY or MB_HPE) |
| * @app_type : Type of the issuing application (existing or new) |
| * @opcode : Opcode of the command |
| * @adapno : Adapter number |
| * @cmdbuf : Pointer to buffer - can point to mbox or plain data buffer |
| * @xferlen : xferlen for DCMD and non mailbox commands |
| * @data_dir : Direction of the data transfer |
| * @status : Status from the driver |
| * @reserved : reserved bytes for future expansion |
| * |
| * @user_data : user data transfer address is saved in this |
| * @user_data_len: length of the data buffer sent by user app |
| * @user_pthru : user passthru address is saves in this (null if DCMD) |
| * @pthru32 : kernel address passthru (allocated per kioc) |
| * @pthru32_h : physicall address of @pthru32 |
| * @list : for kioc free pool list maintenance |
| * @done : call back routine for llds to call when kioc is completed |
| * @buf_vaddr : dma pool buffer attached to kioc for data transfer |
| * @buf_paddr : physical address of the dma pool buffer |
| * @pool_index : index of the dma pool that @buf_vaddr is taken from |
| * @free_buf : indicates if buffer needs to be freed after kioc completes |
| * |
| * Note : All LSI drivers understand only this packet. Any other |
| * : format sent by applications would be converted to this. |
| */ |
| typedef struct uioc { |
| |
| /* User Apps: */ |
| |
| uint8_t signature[EXT_IOCTL_SIGN_SZ]; |
| uint16_t mb_type; |
| uint16_t app_type; |
| uint32_t opcode; |
| uint32_t adapno; |
| uint64_t cmdbuf; |
| uint32_t xferlen; |
| uint32_t data_dir; |
| int32_t status; |
| uint8_t reserved[128]; |
| |
| /* Driver Data: */ |
| void __user * user_data; |
| uint32_t user_data_len; |
| |
| /* 64bit alignment */ |
| uint32_t pad_for_64bit_align; |
| |
| mraid_passthru_t __user *user_pthru; |
| |
| mraid_passthru_t *pthru32; |
| dma_addr_t pthru32_h; |
| |
| struct list_head list; |
| void (*done)(struct uioc*); |
| |
| caddr_t buf_vaddr; |
| dma_addr_t buf_paddr; |
| int8_t pool_index; |
| uint8_t free_buf; |
| |
| uint8_t timedout; |
| |
| } __attribute__ ((aligned(1024),packed)) uioc_t; |
| |
| /* For on-stack uioc timers. */ |
| struct uioc_timeout { |
| struct timer_list timer; |
| uioc_t *uioc; |
| }; |
| |
| /** |
| * struct mraid_hba_info - information about the controller |
| * |
| * @pci_vendor_id : PCI vendor id |
| * @pci_device_id : PCI device id |
| * @subsystem_vendor_id : PCI subsystem vendor id |
| * @subsystem_device_id : PCI subsystem device id |
| * @baseport : base port of hba memory |
| * @pci_bus : PCI bus |
| * @pci_dev_fn : PCI device/function values |
| * @irq : interrupt vector for the device |
| * |
| * Extended information of 256 bytes about the controller. Align on the single |
| * byte boundary so that 32-bit applications can be run on 64-bit platform |
| * drivers withoug re-compilation. |
| * NOTE: reduce the number of reserved bytes whenever new field are added, so |
| * that total size of the structure remains 256 bytes. |
| */ |
| typedef struct mraid_hba_info { |
| |
| uint16_t pci_vendor_id; |
| uint16_t pci_device_id; |
| uint16_t subsys_vendor_id; |
| uint16_t subsys_device_id; |
| |
| uint64_t baseport; |
| uint8_t pci_bus; |
| uint8_t pci_dev_fn; |
| uint8_t pci_slot; |
| uint8_t irq; |
| |
| uint32_t unique_id; |
| uint32_t host_no; |
| |
| uint8_t num_ldrv; |
| } __attribute__ ((aligned(256), packed)) mraid_hba_info_t; |
| |
| |
| /** |
| * mcontroller : adapter info structure for old mimd_t apps |
| * |
| * @base : base address |
| * @irq : irq number |
| * @numldrv : number of logical drives |
| * @pcibus : pci bus |
| * @pcidev : pci device |
| * @pcifun : pci function |
| * @pciid : pci id |
| * @pcivendor : vendor id |
| * @pcislot : slot number |
| * @uid : unique id |
| */ |
| typedef struct mcontroller { |
| |
| uint64_t base; |
| uint8_t irq; |
| uint8_t numldrv; |
| uint8_t pcibus; |
| uint16_t pcidev; |
| uint8_t pcifun; |
| uint16_t pciid; |
| uint16_t pcivendor; |
| uint8_t pcislot; |
| uint32_t uid; |
| |
| } __attribute__ ((packed)) mcontroller_t; |
| |
| |
| /** |
| * mm_dmapool_t : Represents one dma pool with just one buffer |
| * |
| * @vaddr : Virtual address |
| * @paddr : DMA physicall address |
| * @bufsize : In KB - 4 = 4k, 8 = 8k etc. |
| * @handle : Handle to the dma pool |
| * @lock : lock to synchronize access to the pool |
| * @in_use : If pool already in use, attach new block |
| */ |
| typedef struct mm_dmapool { |
| caddr_t vaddr; |
| dma_addr_t paddr; |
| uint32_t buf_size; |
| struct dma_pool *handle; |
| spinlock_t lock; |
| uint8_t in_use; |
| } mm_dmapool_t; |
| |
| |
| /** |
| * mraid_mmadp_t: Structure that drivers pass during (un)registration |
| * |
| * @unique_id : Any unique id (usually PCI bus+dev+fn) |
| * @drvr_type : megaraid or hpe (DRVRTYPE_MBOX or DRVRTYPE_HPE) |
| * @drv_data : Driver specific; not touched by the common module |
| * @timeout : timeout for issued kiocs |
| * @max_kioc : Maximum ioctl packets acceptable by the lld |
| * @pdev : pci dev; used for allocating dma'ble memory |
| * @issue_uioc : Driver supplied routine to issue uioc_t commands |
| * : issue_uioc(drvr_data, kioc, ISSUE/ABORT, uioc_done) |
| * @quiescent : flag to indicate if ioctl can be issued to this adp |
| * @list : attach with the global list of adapters |
| * @kioc_list : block of mem for @max_kioc number of kiocs |
| * @kioc_pool : pool of free kiocs |
| * @kioc_pool_lock : protection for free pool |
| * @kioc_semaphore : so as not to exceed @max_kioc parallel ioctls |
| * @mbox_list : block of mem for @max_kioc number of mboxes |
| * @pthru_dma_pool : DMA pool to allocate passthru packets |
| * @dma_pool_list : array of dma pools |
| */ |
| |
| typedef struct mraid_mmadp { |
| |
| /* Filled by driver */ |
| |
| uint32_t unique_id; |
| uint32_t drvr_type; |
| unsigned long drvr_data; |
| uint16_t timeout; |
| uint8_t max_kioc; |
| |
| struct pci_dev *pdev; |
| |
| int(*issue_uioc)(unsigned long, uioc_t *, uint32_t); |
| |
| /* Maintained by common module */ |
| uint32_t quiescent; |
| |
| struct list_head list; |
| uioc_t *kioc_list; |
| struct list_head kioc_pool; |
| spinlock_t kioc_pool_lock; |
| struct semaphore kioc_semaphore; |
| |
| mbox64_t *mbox_list; |
| struct dma_pool *pthru_dma_pool; |
| mm_dmapool_t dma_pool_list[MAX_DMA_POOLS]; |
| |
| } mraid_mmadp_t; |
| |
| int mraid_mm_register_adp(mraid_mmadp_t *); |
| int mraid_mm_unregister_adp(uint32_t); |
| uint32_t mraid_mm_adapter_app_handle(uint32_t); |
| |
| #endif /* _MEGARAID_IOCTL_H_ */ |
