|
|
@@ -24,21 +24,63 @@
|
|
|
#include <linux/list.h>
|
|
|
#include <linux/idr.h>
|
|
|
|
|
|
+#include <uapi/linux/fsi.h>
|
|
|
+
|
|
|
#define FSI_ENGID_SCOM 0x5
|
|
|
|
|
|
/* SCOM engine register set */
|
|
|
#define SCOM_DATA0_REG 0x00
|
|
|
#define SCOM_DATA1_REG 0x04
|
|
|
#define SCOM_CMD_REG 0x08
|
|
|
+#define SCOM_FSI2PIB_RESET_REG 0x18
|
|
|
+#define SCOM_STATUS_REG 0x1C /* Read */
|
|
|
+#define SCOM_PIB_RESET_REG 0x1C /* Write */
|
|
|
|
|
|
+/* Command register */
|
|
|
#define SCOM_WRITE_CMD 0x80000000
|
|
|
+#define SCOM_READ_CMD 0x00000000
|
|
|
+
|
|
|
+/* Status register bits */
|
|
|
+#define SCOM_STATUS_ERR_SUMMARY 0x80000000
|
|
|
+#define SCOM_STATUS_PROTECTION 0x01000000
|
|
|
+#define SCOM_STATUS_PARITY 0x04000000
|
|
|
+#define SCOM_STATUS_PIB_ABORT 0x00100000
|
|
|
+#define SCOM_STATUS_PIB_RESP_MASK 0x00007000
|
|
|
+#define SCOM_STATUS_PIB_RESP_SHIFT 12
|
|
|
+
|
|
|
+#define SCOM_STATUS_ANY_ERR (SCOM_STATUS_ERR_SUMMARY | \
|
|
|
+ SCOM_STATUS_PROTECTION | \
|
|
|
+ SCOM_STATUS_PARITY | \
|
|
|
+ SCOM_STATUS_PIB_ABORT | \
|
|
|
+ SCOM_STATUS_PIB_RESP_MASK)
|
|
|
+/* SCOM address encodings */
|
|
|
+#define XSCOM_ADDR_IND_FLAG BIT_ULL(63)
|
|
|
+#define XSCOM_ADDR_INF_FORM1 BIT_ULL(60)
|
|
|
+
|
|
|
+/* SCOM indirect stuff */
|
|
|
+#define XSCOM_ADDR_DIRECT_PART 0x7fffffffull
|
|
|
+#define XSCOM_ADDR_INDIRECT_PART 0x000fffff00000000ull
|
|
|
+#define XSCOM_DATA_IND_READ BIT_ULL(63)
|
|
|
+#define XSCOM_DATA_IND_COMPLETE BIT_ULL(31)
|
|
|
+#define XSCOM_DATA_IND_ERR_MASK 0x70000000ull
|
|
|
+#define XSCOM_DATA_IND_ERR_SHIFT 28
|
|
|
+#define XSCOM_DATA_IND_DATA 0x0000ffffull
|
|
|
+#define XSCOM_DATA_IND_FORM1_DATA 0x000fffffffffffffull
|
|
|
+#define XSCOM_ADDR_FORM1_LOW 0x000ffffffffull
|
|
|
+#define XSCOM_ADDR_FORM1_HI 0xfff00000000ull
|
|
|
+#define XSCOM_ADDR_FORM1_HI_SHIFT 20
|
|
|
+
|
|
|
+/* Retries */
|
|
|
+#define SCOM_MAX_RETRIES 100 /* Retries on busy */
|
|
|
+#define SCOM_MAX_IND_RETRIES 10 /* Retries indirect not ready */
|
|
|
|
|
|
struct scom_device {
|
|
|
struct list_head link;
|
|
|
struct fsi_device *fsi_dev;
|
|
|
struct miscdevice mdev;
|
|
|
+ struct mutex lock;
|
|
|
char name[32];
|
|
|
- int idx;
|
|
|
+ int idx;
|
|
|
};
|
|
|
|
|
|
#define to_scom_dev(x) container_of((x), struct scom_device, mdev)
|
|
|
@@ -47,11 +89,11 @@ static struct list_head scom_devices;
|
|
|
|
|
|
static DEFINE_IDA(scom_ida);
|
|
|
|
|
|
-static int put_scom(struct scom_device *scom_dev, uint64_t value,
|
|
|
- uint32_t addr)
|
|
|
+static int __put_scom(struct scom_device *scom_dev, uint64_t value,
|
|
|
+ uint32_t addr, uint32_t *status)
|
|
|
{
|
|
|
+ __be32 data, raw_status;
|
|
|
int rc;
|
|
|
- uint32_t data;
|
|
|
|
|
|
data = cpu_to_be32((value >> 32) & 0xffffffff);
|
|
|
rc = fsi_device_write(scom_dev->fsi_dev, SCOM_DATA0_REG, &data,
|
|
|
@@ -66,53 +108,285 @@ static int put_scom(struct scom_device *scom_dev, uint64_t value,
|
|
|
return rc;
|
|
|
|
|
|
data = cpu_to_be32(SCOM_WRITE_CMD | addr);
|
|
|
- return fsi_device_write(scom_dev->fsi_dev, SCOM_CMD_REG, &data,
|
|
|
+ rc = fsi_device_write(scom_dev->fsi_dev, SCOM_CMD_REG, &data,
|
|
|
sizeof(uint32_t));
|
|
|
+ if (rc)
|
|
|
+ return rc;
|
|
|
+ rc = fsi_device_read(scom_dev->fsi_dev, SCOM_STATUS_REG, &raw_status,
|
|
|
+ sizeof(uint32_t));
|
|
|
+ if (rc)
|
|
|
+ return rc;
|
|
|
+ *status = be32_to_cpu(raw_status);
|
|
|
+
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-static int get_scom(struct scom_device *scom_dev, uint64_t *value,
|
|
|
- uint32_t addr)
|
|
|
+static int __get_scom(struct scom_device *scom_dev, uint64_t *value,
|
|
|
+ uint32_t addr, uint32_t *status)
|
|
|
{
|
|
|
- uint32_t result, data;
|
|
|
+ __be32 data, raw_status;
|
|
|
int rc;
|
|
|
|
|
|
+
|
|
|
*value = 0ULL;
|
|
|
- data = cpu_to_be32(addr);
|
|
|
+ data = cpu_to_be32(SCOM_READ_CMD | addr);
|
|
|
rc = fsi_device_write(scom_dev->fsi_dev, SCOM_CMD_REG, &data,
|
|
|
sizeof(uint32_t));
|
|
|
if (rc)
|
|
|
return rc;
|
|
|
+ rc = fsi_device_read(scom_dev->fsi_dev, SCOM_STATUS_REG, &raw_status,
|
|
|
+ sizeof(uint32_t));
|
|
|
+ if (rc)
|
|
|
+ return rc;
|
|
|
|
|
|
- rc = fsi_device_read(scom_dev->fsi_dev, SCOM_DATA0_REG, &result,
|
|
|
+ /*
|
|
|
+ * Read the data registers even on error, so we don't have
|
|
|
+ * to interpret the status register here.
|
|
|
+ */
|
|
|
+ rc = fsi_device_read(scom_dev->fsi_dev, SCOM_DATA0_REG, &data,
|
|
|
sizeof(uint32_t));
|
|
|
if (rc)
|
|
|
return rc;
|
|
|
-
|
|
|
- *value |= (uint64_t)cpu_to_be32(result) << 32;
|
|
|
- rc = fsi_device_read(scom_dev->fsi_dev, SCOM_DATA1_REG, &result,
|
|
|
+ *value |= (uint64_t)be32_to_cpu(data) << 32;
|
|
|
+ rc = fsi_device_read(scom_dev->fsi_dev, SCOM_DATA1_REG, &data,
|
|
|
sizeof(uint32_t));
|
|
|
if (rc)
|
|
|
return rc;
|
|
|
+ *value |= be32_to_cpu(data);
|
|
|
+ *status = be32_to_cpu(raw_status);
|
|
|
+
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+
|
|
|
+static int put_indirect_scom_form0(struct scom_device *scom, uint64_t value,
|
|
|
+ uint64_t addr, uint32_t *status)
|
|
|
+{
|
|
|
+ uint64_t ind_data, ind_addr;
|
|
|
+ int rc, retries, err = 0;
|
|
|
+
|
|
|
+ if (value & ~XSCOM_DATA_IND_DATA)
|
|
|
+ return -EINVAL;
|
|
|
+
|
|
|
+ ind_addr = addr & XSCOM_ADDR_DIRECT_PART;
|
|
|
+ ind_data = (addr & XSCOM_ADDR_INDIRECT_PART) | value;
|
|
|
+ rc = __put_scom(scom, ind_data, ind_addr, status);
|
|
|
+ if (rc || (*status & SCOM_STATUS_ANY_ERR))
|
|
|
+ return rc;
|
|
|
+
|
|
|
+ for (retries = 0; retries < SCOM_MAX_IND_RETRIES; retries++) {
|
|
|
+ rc = __get_scom(scom, &ind_data, addr, status);
|
|
|
+ if (rc || (*status & SCOM_STATUS_ANY_ERR))
|
|
|
+ return rc;
|
|
|
+
|
|
|
+ err = (ind_data & XSCOM_DATA_IND_ERR_MASK) >> XSCOM_DATA_IND_ERR_SHIFT;
|
|
|
+ *status = err << SCOM_STATUS_PIB_RESP_SHIFT;
|
|
|
+ if ((ind_data & XSCOM_DATA_IND_COMPLETE) || (err != SCOM_PIB_BLOCKED))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ msleep(1);
|
|
|
+ }
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+
|
|
|
+static int put_indirect_scom_form1(struct scom_device *scom, uint64_t value,
|
|
|
+ uint64_t addr, uint32_t *status)
|
|
|
+{
|
|
|
+ uint64_t ind_data, ind_addr;
|
|
|
+
|
|
|
+ if (value & ~XSCOM_DATA_IND_FORM1_DATA)
|
|
|
+ return -EINVAL;
|
|
|
+
|
|
|
+ ind_addr = addr & XSCOM_ADDR_FORM1_LOW;
|
|
|
+ ind_data = value | (addr & XSCOM_ADDR_FORM1_HI) << XSCOM_ADDR_FORM1_HI_SHIFT;
|
|
|
+ return __put_scom(scom, ind_data, ind_addr, status);
|
|
|
+}
|
|
|
+
|
|
|
+static int get_indirect_scom_form0(struct scom_device *scom, uint64_t *value,
|
|
|
+ uint64_t addr, uint32_t *status)
|
|
|
+{
|
|
|
+ uint64_t ind_data, ind_addr;
|
|
|
+ int rc, retries, err = 0;
|
|
|
+
|
|
|
+ ind_addr = addr & XSCOM_ADDR_DIRECT_PART;
|
|
|
+ ind_data = (addr & XSCOM_ADDR_INDIRECT_PART) | XSCOM_DATA_IND_READ;
|
|
|
+ rc = __put_scom(scom, ind_data, ind_addr, status);
|
|
|
+ if (rc || (*status & SCOM_STATUS_ANY_ERR))
|
|
|
+ return rc;
|
|
|
+
|
|
|
+ for (retries = 0; retries < SCOM_MAX_IND_RETRIES; retries++) {
|
|
|
+ rc = __get_scom(scom, &ind_data, addr, status);
|
|
|
+ if (rc || (*status & SCOM_STATUS_ANY_ERR))
|
|
|
+ return rc;
|
|
|
+
|
|
|
+ err = (ind_data & XSCOM_DATA_IND_ERR_MASK) >> XSCOM_DATA_IND_ERR_SHIFT;
|
|
|
+ *status = err << SCOM_STATUS_PIB_RESP_SHIFT;
|
|
|
+ *value = ind_data & XSCOM_DATA_IND_DATA;
|
|
|
+
|
|
|
+ if ((ind_data & XSCOM_DATA_IND_COMPLETE) || (err != SCOM_PIB_BLOCKED))
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ msleep(1);
|
|
|
+ }
|
|
|
+ return rc;
|
|
|
+}
|
|
|
|
|
|
- *value |= cpu_to_be32(result);
|
|
|
+static int raw_put_scom(struct scom_device *scom, uint64_t value,
|
|
|
+ uint64_t addr, uint32_t *status)
|
|
|
+{
|
|
|
+ if (addr & XSCOM_ADDR_IND_FLAG) {
|
|
|
+ if (addr & XSCOM_ADDR_INF_FORM1)
|
|
|
+ return put_indirect_scom_form1(scom, value, addr, status);
|
|
|
+ else
|
|
|
+ return put_indirect_scom_form0(scom, value, addr, status);
|
|
|
+ } else
|
|
|
+ return __put_scom(scom, value, addr, status);
|
|
|
+}
|
|
|
+
|
|
|
+static int raw_get_scom(struct scom_device *scom, uint64_t *value,
|
|
|
+ uint64_t addr, uint32_t *status)
|
|
|
+{
|
|
|
+ if (addr & XSCOM_ADDR_IND_FLAG) {
|
|
|
+ if (addr & XSCOM_ADDR_INF_FORM1)
|
|
|
+ return -ENXIO;
|
|
|
+ return get_indirect_scom_form0(scom, value, addr, status);
|
|
|
+ } else
|
|
|
+ return __get_scom(scom, value, addr, status);
|
|
|
+}
|
|
|
|
|
|
+static int handle_fsi2pib_status(struct scom_device *scom, uint32_t status)
|
|
|
+{
|
|
|
+ uint32_t dummy = -1;
|
|
|
+
|
|
|
+ if (status & SCOM_STATUS_PROTECTION)
|
|
|
+ return -EPERM;
|
|
|
+ if (status & SCOM_STATUS_PARITY) {
|
|
|
+ fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG, &dummy,
|
|
|
+ sizeof(uint32_t));
|
|
|
+ return -EIO;
|
|
|
+ }
|
|
|
+ /* Return -EBUSY on PIB abort to force a retry */
|
|
|
+ if (status & SCOM_STATUS_PIB_ABORT)
|
|
|
+ return -EBUSY;
|
|
|
+ if (status & SCOM_STATUS_ERR_SUMMARY) {
|
|
|
+ fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG, &dummy,
|
|
|
+ sizeof(uint32_t));
|
|
|
+ return -EIO;
|
|
|
+ }
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
+static int handle_pib_status(struct scom_device *scom, uint8_t status)
|
|
|
+{
|
|
|
+ uint32_t dummy = -1;
|
|
|
+
|
|
|
+ if (status == SCOM_PIB_SUCCESS)
|
|
|
+ return 0;
|
|
|
+ if (status == SCOM_PIB_BLOCKED)
|
|
|
+ return -EBUSY;
|
|
|
+
|
|
|
+ /* Reset the bridge */
|
|
|
+ fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG, &dummy,
|
|
|
+ sizeof(uint32_t));
|
|
|
+
|
|
|
+ switch(status) {
|
|
|
+ case SCOM_PIB_OFFLINE:
|
|
|
+ return -ENODEV;
|
|
|
+ case SCOM_PIB_BAD_ADDR:
|
|
|
+ return -ENXIO;
|
|
|
+ case SCOM_PIB_TIMEOUT:
|
|
|
+ return -ETIMEDOUT;
|
|
|
+ case SCOM_PIB_PARTIAL:
|
|
|
+ case SCOM_PIB_CLK_ERR:
|
|
|
+ case SCOM_PIB_PARITY_ERR:
|
|
|
+ default:
|
|
|
+ return -EIO;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int put_scom(struct scom_device *scom, uint64_t value,
|
|
|
+ uint64_t addr)
|
|
|
+{
|
|
|
+ uint32_t status, dummy = -1;
|
|
|
+ int rc, retries;
|
|
|
+
|
|
|
+ for (retries = 0; retries < SCOM_MAX_RETRIES; retries++) {
|
|
|
+ rc = raw_put_scom(scom, value, addr, &status);
|
|
|
+ if (rc) {
|
|
|
+ /* Try resetting the bridge if FSI fails */
|
|
|
+ if (rc != -ENODEV && retries == 0) {
|
|
|
+ fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG,
|
|
|
+ &dummy, sizeof(uint32_t));
|
|
|
+ rc = -EBUSY;
|
|
|
+ } else
|
|
|
+ return rc;
|
|
|
+ } else
|
|
|
+ rc = handle_fsi2pib_status(scom, status);
|
|
|
+ if (rc && rc != -EBUSY)
|
|
|
+ break;
|
|
|
+ if (rc == 0) {
|
|
|
+ rc = handle_pib_status(scom,
|
|
|
+ (status & SCOM_STATUS_PIB_RESP_MASK)
|
|
|
+ >> SCOM_STATUS_PIB_RESP_SHIFT);
|
|
|
+ if (rc && rc != -EBUSY)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (rc == 0)
|
|
|
+ break;
|
|
|
+ msleep(1);
|
|
|
+ }
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+
|
|
|
+static int get_scom(struct scom_device *scom, uint64_t *value,
|
|
|
+ uint64_t addr)
|
|
|
+{
|
|
|
+ uint32_t status, dummy = -1;
|
|
|
+ int rc, retries;
|
|
|
+
|
|
|
+ for (retries = 0; retries < SCOM_MAX_RETRIES; retries++) {
|
|
|
+ rc = raw_get_scom(scom, value, addr, &status);
|
|
|
+ if (rc) {
|
|
|
+ /* Try resetting the bridge if FSI fails */
|
|
|
+ if (rc != -ENODEV && retries == 0) {
|
|
|
+ fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG,
|
|
|
+ &dummy, sizeof(uint32_t));
|
|
|
+ rc = -EBUSY;
|
|
|
+ } else
|
|
|
+ return rc;
|
|
|
+ } else
|
|
|
+ rc = handle_fsi2pib_status(scom, status);
|
|
|
+ if (rc && rc != -EBUSY)
|
|
|
+ break;
|
|
|
+ if (rc == 0) {
|
|
|
+ rc = handle_pib_status(scom,
|
|
|
+ (status & SCOM_STATUS_PIB_RESP_MASK)
|
|
|
+ >> SCOM_STATUS_PIB_RESP_SHIFT);
|
|
|
+ if (rc && rc != -EBUSY)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (rc == 0)
|
|
|
+ break;
|
|
|
+ msleep(1);
|
|
|
+ }
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+
|
|
|
static ssize_t scom_read(struct file *filep, char __user *buf, size_t len,
|
|
|
- loff_t *offset)
|
|
|
+ loff_t *offset)
|
|
|
{
|
|
|
- int rc;
|
|
|
struct miscdevice *mdev =
|
|
|
(struct miscdevice *)filep->private_data;
|
|
|
struct scom_device *scom = to_scom_dev(mdev);
|
|
|
struct device *dev = &scom->fsi_dev->dev;
|
|
|
uint64_t val;
|
|
|
+ int rc;
|
|
|
|
|
|
if (len != sizeof(uint64_t))
|
|
|
return -EINVAL;
|
|
|
|
|
|
+ mutex_lock(&scom->lock);
|
|
|
rc = get_scom(scom, &val, *offset);
|
|
|
+ mutex_unlock(&scom->lock);
|
|
|
if (rc) {
|
|
|
dev_dbg(dev, "get_scom fail:%d\n", rc);
|
|
|
return rc;
|
|
|
@@ -126,7 +400,7 @@ static ssize_t scom_read(struct file *filep, char __user *buf, size_t len,
|
|
|
}
|
|
|
|
|
|
static ssize_t scom_write(struct file *filep, const char __user *buf,
|
|
|
- size_t len, loff_t *offset)
|
|
|
+ size_t len, loff_t *offset)
|
|
|
{
|
|
|
int rc;
|
|
|
struct miscdevice *mdev = filep->private_data;
|
|
|
@@ -143,7 +417,9 @@ static ssize_t scom_write(struct file *filep, const char __user *buf,
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
+ mutex_lock(&scom->lock);
|
|
|
rc = put_scom(scom, val, *offset);
|
|
|
+ mutex_unlock(&scom->lock);
|
|
|
if (rc) {
|
|
|
dev_dbg(dev, "put_scom failed with:%d\n", rc);
|
|
|
return rc;
|
|
|
@@ -167,11 +443,125 @@ static loff_t scom_llseek(struct file *file, loff_t offset, int whence)
|
|
|
return offset;
|
|
|
}
|
|
|
|
|
|
+static void raw_convert_status(struct scom_access *acc, uint32_t status)
|
|
|
+{
|
|
|
+ acc->pib_status = (status & SCOM_STATUS_PIB_RESP_MASK) >>
|
|
|
+ SCOM_STATUS_PIB_RESP_SHIFT;
|
|
|
+ acc->intf_errors = 0;
|
|
|
+
|
|
|
+ if (status & SCOM_STATUS_PROTECTION)
|
|
|
+ acc->intf_errors |= SCOM_INTF_ERR_PROTECTION;
|
|
|
+ else if (status & SCOM_STATUS_PARITY)
|
|
|
+ acc->intf_errors |= SCOM_INTF_ERR_PARITY;
|
|
|
+ else if (status & SCOM_STATUS_PIB_ABORT)
|
|
|
+ acc->intf_errors |= SCOM_INTF_ERR_ABORT;
|
|
|
+ else if (status & SCOM_STATUS_ERR_SUMMARY)
|
|
|
+ acc->intf_errors |= SCOM_INTF_ERR_UNKNOWN;
|
|
|
+}
|
|
|
+
|
|
|
+static int scom_raw_read(struct scom_device *scom, void __user *argp)
|
|
|
+{
|
|
|
+ struct scom_access acc;
|
|
|
+ uint32_t status;
|
|
|
+ int rc;
|
|
|
+
|
|
|
+ if (copy_from_user(&acc, argp, sizeof(struct scom_access)))
|
|
|
+ return -EFAULT;
|
|
|
+
|
|
|
+ rc = raw_get_scom(scom, &acc.data, acc.addr, &status);
|
|
|
+ if (rc)
|
|
|
+ return rc;
|
|
|
+ raw_convert_status(&acc, status);
|
|
|
+ if (copy_to_user(argp, &acc, sizeof(struct scom_access)))
|
|
|
+ return -EFAULT;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int scom_raw_write(struct scom_device *scom, void __user *argp)
|
|
|
+{
|
|
|
+ u64 prev_data, mask, data;
|
|
|
+ struct scom_access acc;
|
|
|
+ uint32_t status;
|
|
|
+ int rc;
|
|
|
+
|
|
|
+ if (copy_from_user(&acc, argp, sizeof(struct scom_access)))
|
|
|
+ return -EFAULT;
|
|
|
+
|
|
|
+ if (acc.mask) {
|
|
|
+ rc = raw_get_scom(scom, &prev_data, acc.addr, &status);
|
|
|
+ if (rc)
|
|
|
+ return rc;
|
|
|
+ if (status & SCOM_STATUS_ANY_ERR)
|
|
|
+ goto fail;
|
|
|
+ mask = acc.mask;
|
|
|
+ } else {
|
|
|
+ prev_data = mask = -1ull;
|
|
|
+ }
|
|
|
+ data = (prev_data & ~mask) | (acc.data & mask);
|
|
|
+ rc = raw_put_scom(scom, data, acc.addr, &status);
|
|
|
+ if (rc)
|
|
|
+ return rc;
|
|
|
+ fail:
|
|
|
+ raw_convert_status(&acc, status);
|
|
|
+ if (copy_to_user(argp, &acc, sizeof(struct scom_access)))
|
|
|
+ return -EFAULT;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int scom_reset(struct scom_device *scom, void __user *argp)
|
|
|
+{
|
|
|
+ uint32_t flags, dummy = -1;
|
|
|
+ int rc = 0;
|
|
|
+
|
|
|
+ if (get_user(flags, (__u32 __user *)argp))
|
|
|
+ return -EFAULT;
|
|
|
+ if (flags & SCOM_RESET_PIB)
|
|
|
+ rc = fsi_device_write(scom->fsi_dev, SCOM_PIB_RESET_REG, &dummy,
|
|
|
+ sizeof(uint32_t));
|
|
|
+ if (!rc && (flags & (SCOM_RESET_PIB | SCOM_RESET_INTF)))
|
|
|
+ rc = fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG, &dummy,
|
|
|
+ sizeof(uint32_t));
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+
|
|
|
+static int scom_check(struct scom_device *scom, void __user *argp)
|
|
|
+{
|
|
|
+ /* Still need to find out how to get "protected" */
|
|
|
+ return put_user(SCOM_CHECK_SUPPORTED, (__u32 __user *)argp);
|
|
|
+}
|
|
|
+
|
|
|
+static long scom_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
|
|
+{
|
|
|
+ struct miscdevice *mdev = file->private_data;
|
|
|
+ struct scom_device *scom = to_scom_dev(mdev);
|
|
|
+ void __user *argp = (void __user *)arg;
|
|
|
+ int rc = -ENOTTY;
|
|
|
+
|
|
|
+ mutex_lock(&scom->lock);
|
|
|
+ switch(cmd) {
|
|
|
+ case FSI_SCOM_CHECK:
|
|
|
+ rc = scom_check(scom, argp);
|
|
|
+ break;
|
|
|
+ case FSI_SCOM_READ:
|
|
|
+ rc = scom_raw_read(scom, argp);
|
|
|
+ break;
|
|
|
+ case FSI_SCOM_WRITE:
|
|
|
+ rc = scom_raw_write(scom, argp);
|
|
|
+ break;
|
|
|
+ case FSI_SCOM_RESET:
|
|
|
+ rc = scom_reset(scom, argp);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ mutex_unlock(&scom->lock);
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+
|
|
|
static const struct file_operations scom_fops = {
|
|
|
- .owner = THIS_MODULE,
|
|
|
- .llseek = scom_llseek,
|
|
|
- .read = scom_read,
|
|
|
- .write = scom_write,
|
|
|
+ .owner = THIS_MODULE,
|
|
|
+ .llseek = scom_llseek,
|
|
|
+ .read = scom_read,
|
|
|
+ .write = scom_write,
|
|
|
+ .unlocked_ioctl = scom_ioctl,
|
|
|
};
|
|
|
|
|
|
static int scom_probe(struct device *dev)
|
|
|
@@ -183,6 +573,7 @@ static int scom_probe(struct device *dev)
|
|
|
if (!scom)
|
|
|
return -ENOMEM;
|
|
|
|
|
|
+ mutex_init(&scom->lock);
|
|
|
scom->idx = ida_simple_get(&scom_ida, 1, INT_MAX, GFP_KERNEL);
|
|
|
snprintf(scom->name, sizeof(scom->name), "scom%d", scom->idx);
|
|
|
scom->fsi_dev = fsi_dev;
|
Greg Kroah-Hartman