forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
278 lines
7.2 KiB
278 lines
7.2 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* CXL Flash Device Driver |
|
* |
|
* Written by: Manoj N. Kumar <[email protected]>, IBM Corporation |
|
* Matthew R. Ochs <[email protected]>, IBM Corporation |
|
* |
|
* Copyright (C) 2015 IBM Corporation |
|
*/ |
|
|
|
#include <asm/unaligned.h> |
|
|
|
#include <linux/interrupt.h> |
|
#include <linux/pci.h> |
|
|
|
#include <scsi/scsi_host.h> |
|
#include <uapi/scsi/cxlflash_ioctl.h> |
|
|
|
#include "sislite.h" |
|
#include "common.h" |
|
#include "vlun.h" |
|
#include "superpipe.h" |
|
|
|
/** |
|
* create_local() - allocate and initialize a local LUN information structure |
|
* @sdev: SCSI device associated with LUN. |
|
* @wwid: World Wide Node Name for LUN. |
|
* |
|
* Return: Allocated local llun_info structure on success, NULL on failure |
|
*/ |
|
static struct llun_info *create_local(struct scsi_device *sdev, u8 *wwid) |
|
{ |
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host); |
|
struct device *dev = &cfg->dev->dev; |
|
struct llun_info *lli = NULL; |
|
|
|
lli = kzalloc(sizeof(*lli), GFP_KERNEL); |
|
if (unlikely(!lli)) { |
|
dev_err(dev, "%s: could not allocate lli\n", __func__); |
|
goto out; |
|
} |
|
|
|
lli->sdev = sdev; |
|
lli->host_no = sdev->host->host_no; |
|
lli->in_table = false; |
|
|
|
memcpy(lli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN); |
|
out: |
|
return lli; |
|
} |
|
|
|
/** |
|
* create_global() - allocate and initialize a global LUN information structure |
|
* @sdev: SCSI device associated with LUN. |
|
* @wwid: World Wide Node Name for LUN. |
|
* |
|
* Return: Allocated global glun_info structure on success, NULL on failure |
|
*/ |
|
static struct glun_info *create_global(struct scsi_device *sdev, u8 *wwid) |
|
{ |
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host); |
|
struct device *dev = &cfg->dev->dev; |
|
struct glun_info *gli = NULL; |
|
|
|
gli = kzalloc(sizeof(*gli), GFP_KERNEL); |
|
if (unlikely(!gli)) { |
|
dev_err(dev, "%s: could not allocate gli\n", __func__); |
|
goto out; |
|
} |
|
|
|
mutex_init(&gli->mutex); |
|
memcpy(gli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN); |
|
out: |
|
return gli; |
|
} |
|
|
|
/** |
|
* lookup_local() - find a local LUN information structure by WWID |
|
* @cfg: Internal structure associated with the host. |
|
* @wwid: WWID associated with LUN. |
|
* |
|
* Return: Found local lun_info structure on success, NULL on failure |
|
*/ |
|
static struct llun_info *lookup_local(struct cxlflash_cfg *cfg, u8 *wwid) |
|
{ |
|
struct llun_info *lli, *temp; |
|
|
|
list_for_each_entry_safe(lli, temp, &cfg->lluns, list) |
|
if (!memcmp(lli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN)) |
|
return lli; |
|
|
|
return NULL; |
|
} |
|
|
|
/** |
|
* lookup_global() - find a global LUN information structure by WWID |
|
* @wwid: WWID associated with LUN. |
|
* |
|
* Return: Found global lun_info structure on success, NULL on failure |
|
*/ |
|
static struct glun_info *lookup_global(u8 *wwid) |
|
{ |
|
struct glun_info *gli, *temp; |
|
|
|
list_for_each_entry_safe(gli, temp, &global.gluns, list) |
|
if (!memcmp(gli->wwid, wwid, DK_CXLFLASH_MANAGE_LUN_WWID_LEN)) |
|
return gli; |
|
|
|
return NULL; |
|
} |
|
|
|
/** |
|
* find_and_create_lun() - find or create a local LUN information structure |
|
* @sdev: SCSI device associated with LUN. |
|
* @wwid: WWID associated with LUN. |
|
* |
|
* The LUN is kept both in a local list (per adapter) and in a global list |
|
* (across all adapters). Certain attributes of the LUN are local to the |
|
* adapter (such as index, port selection mask, etc.). |
|
* |
|
* The block allocation map is shared across all adapters (i.e. associated |
|
* wih the global list). Since different attributes are associated with |
|
* the per adapter and global entries, allocate two separate structures for each |
|
* LUN (one local, one global). |
|
* |
|
* Keep a pointer back from the local to the global entry. |
|
* |
|
* This routine assumes the caller holds the global mutex. |
|
* |
|
* Return: Found/Allocated local lun_info structure on success, NULL on failure |
|
*/ |
|
static struct llun_info *find_and_create_lun(struct scsi_device *sdev, u8 *wwid) |
|
{ |
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host); |
|
struct device *dev = &cfg->dev->dev; |
|
struct llun_info *lli = NULL; |
|
struct glun_info *gli = NULL; |
|
|
|
if (unlikely(!wwid)) |
|
goto out; |
|
|
|
lli = lookup_local(cfg, wwid); |
|
if (lli) |
|
goto out; |
|
|
|
lli = create_local(sdev, wwid); |
|
if (unlikely(!lli)) |
|
goto out; |
|
|
|
gli = lookup_global(wwid); |
|
if (gli) { |
|
lli->parent = gli; |
|
list_add(&lli->list, &cfg->lluns); |
|
goto out; |
|
} |
|
|
|
gli = create_global(sdev, wwid); |
|
if (unlikely(!gli)) { |
|
kfree(lli); |
|
lli = NULL; |
|
goto out; |
|
} |
|
|
|
lli->parent = gli; |
|
list_add(&lli->list, &cfg->lluns); |
|
|
|
list_add(&gli->list, &global.gluns); |
|
|
|
out: |
|
dev_dbg(dev, "%s: returning lli=%p, gli=%p\n", __func__, lli, gli); |
|
return lli; |
|
} |
|
|
|
/** |
|
* cxlflash_term_local_luns() - Delete all entries from local LUN list, free. |
|
* @cfg: Internal structure associated with the host. |
|
*/ |
|
void cxlflash_term_local_luns(struct cxlflash_cfg *cfg) |
|
{ |
|
struct llun_info *lli, *temp; |
|
|
|
mutex_lock(&global.mutex); |
|
list_for_each_entry_safe(lli, temp, &cfg->lluns, list) { |
|
list_del(&lli->list); |
|
kfree(lli); |
|
} |
|
mutex_unlock(&global.mutex); |
|
} |
|
|
|
/** |
|
* cxlflash_list_init() - initializes the global LUN list |
|
*/ |
|
void cxlflash_list_init(void) |
|
{ |
|
INIT_LIST_HEAD(&global.gluns); |
|
mutex_init(&global.mutex); |
|
global.err_page = NULL; |
|
} |
|
|
|
/** |
|
* cxlflash_term_global_luns() - frees resources associated with global LUN list |
|
*/ |
|
void cxlflash_term_global_luns(void) |
|
{ |
|
struct glun_info *gli, *temp; |
|
|
|
mutex_lock(&global.mutex); |
|
list_for_each_entry_safe(gli, temp, &global.gluns, list) { |
|
list_del(&gli->list); |
|
cxlflash_ba_terminate(&gli->blka.ba_lun); |
|
kfree(gli); |
|
} |
|
mutex_unlock(&global.mutex); |
|
} |
|
|
|
/** |
|
* cxlflash_manage_lun() - handles LUN management activities |
|
* @sdev: SCSI device associated with LUN. |
|
* @manage: Manage ioctl data structure. |
|
* |
|
* This routine is used to notify the driver about a LUN's WWID and associate |
|
* SCSI devices (sdev) with a global LUN instance. Additionally it serves to |
|
* change a LUN's operating mode: legacy or superpipe. |
|
* |
|
* Return: 0 on success, -errno on failure |
|
*/ |
|
int cxlflash_manage_lun(struct scsi_device *sdev, |
|
struct dk_cxlflash_manage_lun *manage) |
|
{ |
|
struct cxlflash_cfg *cfg = shost_priv(sdev->host); |
|
struct device *dev = &cfg->dev->dev; |
|
struct llun_info *lli = NULL; |
|
int rc = 0; |
|
u64 flags = manage->hdr.flags; |
|
u32 chan = sdev->channel; |
|
|
|
mutex_lock(&global.mutex); |
|
lli = find_and_create_lun(sdev, manage->wwid); |
|
dev_dbg(dev, "%s: WWID=%016llx%016llx, flags=%016llx lli=%p\n", |
|
__func__, get_unaligned_be64(&manage->wwid[0]), |
|
get_unaligned_be64(&manage->wwid[8]), manage->hdr.flags, lli); |
|
if (unlikely(!lli)) { |
|
rc = -ENOMEM; |
|
goto out; |
|
} |
|
|
|
if (flags & DK_CXLFLASH_MANAGE_LUN_ENABLE_SUPERPIPE) { |
|
/* |
|
* Update port selection mask based upon channel, store off LUN |
|
* in unpacked, AFU-friendly format, and hang LUN reference in |
|
* the sdev. |
|
*/ |
|
lli->port_sel |= CHAN2PORTMASK(chan); |
|
lli->lun_id[chan] = lun_to_lunid(sdev->lun); |
|
sdev->hostdata = lli; |
|
} else if (flags & DK_CXLFLASH_MANAGE_LUN_DISABLE_SUPERPIPE) { |
|
if (lli->parent->mode != MODE_NONE) |
|
rc = -EBUSY; |
|
else { |
|
/* |
|
* Clean up local LUN for this port and reset table |
|
* tracking when no more references exist. |
|
*/ |
|
sdev->hostdata = NULL; |
|
lli->port_sel &= ~CHAN2PORTMASK(chan); |
|
if (lli->port_sel == 0U) |
|
lli->in_table = false; |
|
} |
|
} |
|
|
|
dev_dbg(dev, "%s: port_sel=%08x chan=%u lun_id=%016llx\n", |
|
__func__, lli->port_sel, chan, lli->lun_id[chan]); |
|
|
|
out: |
|
mutex_unlock(&global.mutex); |
|
dev_dbg(dev, "%s: returning rc=%d\n", __func__, rc); |
|
return rc; |
|
}
|
|
|