* Parallel SCSI (SPI) transport specific attributes exported to sysfs.
*
* Copyright (c) 2003 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (c) 2004, 2005 James Bottomley <James.Bottomley@SteelEye.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include <asm/scatterlist.h>
#include <asm/io.h>
#include <scsi/scsi.h>
+#include "scsi_priv.h"
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_request.h>
+#include <scsi/scsi_eh.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_spi.h>
-#define SPI_PRINTK(x, l, f, a...) printk(l "scsi(%d:%d:%d:%d): " f, (x)->host->host_no, (x)->channel, (x)->id, (x)->lun , ##a)
-
-static void transport_class_release(struct class_device *class_dev);
+#define SPI_PRINTK(x, l, f, a...) dev_printk(l, &(x)->dev, f , ##a)
#define SPI_NUM_ATTRS 10 /* increase this if you add attributes */
#define SPI_OTHER_ATTRS 1 /* Increase this if you add "always
* on" attributes */
+#define SPI_HOST_ATTRS 1
#define SPI_MAX_ECHO_BUFFER_SIZE 4096
/* Private data accessors (keep these out of the header file) */
-#define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->transport_data)->dv_pending)
-#define spi_dv_sem(x) (((struct spi_transport_attrs *)&(x)->transport_data)->dv_sem)
+#define spi_dv_pending(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_pending)
+#define spi_dv_sem(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_sem)
struct spi_internal {
struct scsi_transport_template t;
/* The array of null terminated pointers to attributes
* needed by scsi_sysfs.c */
struct class_device_attribute *attrs[SPI_NUM_ATTRS + SPI_OTHER_ATTRS + 1];
+ struct class_device_attribute private_host_attrs[SPI_HOST_ATTRS];
+ struct class_device_attribute *host_attrs[SPI_HOST_ATTRS + 1];
};
#define to_spi_internal(tmpl) container_of(tmpl, struct spi_internal, t)
* by 4 */
#define SPI_STATIC_PPR 0x0c
-struct class spi_transport_class = {
- .name = "spi_transport",
- .release = transport_class_release,
+static struct {
+ enum spi_signal_type value;
+ char *name;
+} signal_types[] = {
+ { SPI_SIGNAL_UNKNOWN, "unknown" },
+ { SPI_SIGNAL_SE, "SE" },
+ { SPI_SIGNAL_LVD, "LVD" },
+ { SPI_SIGNAL_HVD, "HVD" },
};
-static __init int spi_transport_init(void)
+static inline const char *spi_signal_to_string(enum spi_signal_type type)
{
- return class_register(&spi_transport_class);
+ int i;
+
+ for (i = 0; i < sizeof(signal_types)/sizeof(signal_types[0]); i++) {
+ if (type == signal_types[i].value)
+ return signal_types[i].name;
+ }
+ return NULL;
}
+static inline enum spi_signal_type spi_signal_to_value(const char *name)
+{
+ int i, len;
-static void __exit spi_transport_exit(void)
+ for (i = 0; i < sizeof(signal_types)/sizeof(signal_types[0]); i++) {
+ len = strlen(signal_types[i].name);
+ if (strncmp(name, signal_types[i].name, len) == 0 &&
+ (name[len] == '\n' || name[len] == '\0'))
+ return signal_types[i].value;
+ }
+ return SPI_SIGNAL_UNKNOWN;
+}
+
+static int spi_host_setup(struct device *dev)
+{
+ struct Scsi_Host *shost = dev_to_shost(dev);
+
+ spi_signalling(shost) = SPI_SIGNAL_UNKNOWN;
+
+ return 0;
+}
+
+static DECLARE_TRANSPORT_CLASS(spi_host_class,
+ "spi_host",
+ spi_host_setup,
+ NULL,
+ NULL);
+
+static int spi_host_match(struct attribute_container *cont,
+ struct device *dev)
{
- class_unregister(&spi_transport_class);
+ struct Scsi_Host *shost;
+ struct spi_internal *i;
+
+ if (!scsi_is_host_device(dev))
+ return 0;
+
+ shost = dev_to_shost(dev);
+ if (!shost->transportt || shost->transportt->host_attrs.class
+ != &spi_host_class.class)
+ return 0;
+
+ i = to_spi_internal(shost->transportt);
+
+ return &i->t.host_attrs == cont;
}
-static int spi_setup_transport_attrs(struct scsi_device *sdev)
+static int spi_device_configure(struct device *dev)
{
- spi_period(sdev) = -1; /* illegal value */
- spi_offset(sdev) = 0; /* async */
- spi_width(sdev) = 0; /* narrow */
- spi_iu(sdev) = 0; /* no IU */
- spi_dt(sdev) = 0; /* ST */
- spi_qas(sdev) = 0;
- spi_wr_flow(sdev) = 0;
- spi_rd_strm(sdev) = 0;
- spi_rti(sdev) = 0;
- spi_pcomp_en(sdev) = 0;
- spi_dv_pending(sdev) = 0;
- init_MUTEX(&spi_dv_sem(sdev));
+ struct scsi_device *sdev = to_scsi_device(dev);
+ struct scsi_target *starget = sdev->sdev_target;
+
+ /* Populate the target capability fields with the values
+ * gleaned from the device inquiry */
+
+ spi_support_sync(starget) = scsi_device_sync(sdev);
+ spi_support_wide(starget) = scsi_device_wide(sdev);
+ spi_support_dt(starget) = scsi_device_dt(sdev);
+ spi_support_dt_only(starget) = scsi_device_dt_only(sdev);
+ spi_support_ius(starget) = scsi_device_ius(sdev);
+ spi_support_qas(starget) = scsi_device_qas(sdev);
return 0;
}
-static void transport_class_release(struct class_device *class_dev)
+static int spi_setup_transport_attrs(struct device *dev)
{
- struct scsi_device *sdev = transport_class_to_sdev(class_dev);
- put_device(&sdev->sdev_gendev);
+ struct scsi_target *starget = to_scsi_target(dev);
+
+ spi_period(starget) = -1; /* illegal value */
+ spi_offset(starget) = 0; /* async */
+ spi_width(starget) = 0; /* narrow */
+ spi_iu(starget) = 0; /* no IU */
+ spi_dt(starget) = 0; /* ST */
+ spi_qas(starget) = 0;
+ spi_wr_flow(starget) = 0;
+ spi_rd_strm(starget) = 0;
+ spi_rti(starget) = 0;
+ spi_pcomp_en(starget) = 0;
+ spi_dv_pending(starget) = 0;
+ spi_initial_dv(starget) = 0;
+ init_MUTEX(&spi_dv_sem(starget));
+
+ return 0;
}
#define spi_transport_show_function(field, format_string) \
static ssize_t \
show_spi_transport_##field(struct class_device *cdev, char *buf) \
{ \
- struct scsi_device *sdev = transport_class_to_sdev(cdev); \
+ struct scsi_target *starget = transport_class_to_starget(cdev); \
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
struct spi_transport_attrs *tp; \
- struct spi_internal *i = to_spi_internal(sdev->host->transportt); \
- tp = (struct spi_transport_attrs *)&sdev->transport_data; \
+ struct spi_internal *i = to_spi_internal(shost->transportt); \
+ tp = (struct spi_transport_attrs *)&starget->starget_data; \
if (i->f->get_##field) \
- i->f->get_##field(sdev); \
+ i->f->get_##field(starget); \
return snprintf(buf, 20, format_string, tp->field); \
}
size_t count) \
{ \
int val; \
- struct scsi_device *sdev = transport_class_to_sdev(cdev); \
- struct spi_internal *i = to_spi_internal(sdev->host->transportt); \
+ struct scsi_target *starget = transport_class_to_starget(cdev); \
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent); \
+ struct spi_internal *i = to_spi_internal(shost->transportt); \
\
val = simple_strtoul(buf, NULL, 0); \
- i->f->set_##field(sdev, val); \
+ i->f->set_##field(starget, val); \
return count; \
}
static ssize_t
store_spi_revalidate(struct class_device *cdev, const char *buf, size_t count)
{
- struct scsi_device *sdev = transport_class_to_sdev(cdev);
+ struct scsi_target *starget = transport_class_to_starget(cdev);
+ /* FIXME: we're relying on an awful lot of device internals
+ * here. We really need a function to get the first available
+ * child */
+ struct device *dev = container_of(starget->dev.children.next, struct device, node);
+ struct scsi_device *sdev = to_scsi_device(dev);
spi_dv_device(sdev);
return count;
}
static ssize_t show_spi_transport_period(struct class_device *cdev, char *buf)
{
- struct scsi_device *sdev = transport_class_to_sdev(cdev);
+ struct scsi_target *starget = transport_class_to_starget(cdev);
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
struct spi_transport_attrs *tp;
const char *str;
- struct spi_internal *i = to_spi_internal(sdev->host->transportt);
+ struct spi_internal *i = to_spi_internal(shost->transportt);
- tp = (struct spi_transport_attrs *)&sdev->transport_data;
+ tp = (struct spi_transport_attrs *)&starget->starget_data;
if (i->f->get_period)
- i->f->get_period(sdev);
+ i->f->get_period(starget);
switch(tp->period) {
store_spi_transport_period(struct class_device *cdev, const char *buf,
size_t count)
{
- struct scsi_device *sdev = transport_class_to_sdev(cdev);
- struct spi_internal *i = to_spi_internal(sdev->host->transportt);
+ struct scsi_target *starget = transport_class_to_starget(cdev);
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+ struct spi_internal *i = to_spi_internal(shost->transportt);
int j, period = -1;
for (j = 0; j < SPI_STATIC_PPR; j++) {
if (period > 0xff)
period = 0xff;
- i->f->set_period(sdev, period);
+ i->f->set_period(starget, period);
return count;
}
show_spi_transport_period,
store_spi_transport_period);
+static ssize_t show_spi_host_signalling(struct class_device *cdev, char *buf)
+{
+ struct Scsi_Host *shost = transport_class_to_shost(cdev);
+ struct spi_internal *i = to_spi_internal(shost->transportt);
+
+ if (i->f->get_signalling)
+ i->f->get_signalling(shost);
+
+ return sprintf(buf, "%s\n", spi_signal_to_string(spi_signalling(shost)));
+}
+static ssize_t store_spi_host_signalling(struct class_device *cdev,
+ const char *buf, size_t count)
+{
+ struct Scsi_Host *shost = transport_class_to_shost(cdev);
+ struct spi_internal *i = to_spi_internal(shost->transportt);
+ enum spi_signal_type type = spi_signal_to_value(buf);
+
+ if (type != SPI_SIGNAL_UNKNOWN)
+ i->f->set_signalling(shost, type);
+
+ return count;
+}
+static CLASS_DEVICE_ATTR(signalling, S_IRUGO | S_IWUSR,
+ show_spi_host_signalling,
+ store_spi_host_signalling);
+
#define DV_SET(x, y) \
if(i->f->set_##x) \
- i->f->set_##x(sdev, y)
+ i->f->set_##x(sdev->sdev_target, y)
#define DV_LOOPS 3
#define DV_TIMEOUT (10*HZ)
#define DV_RETRIES 3 /* should only need at most
* two cc/ua clears */
+enum spi_compare_returns {
+ SPI_COMPARE_SUCCESS,
+ SPI_COMPARE_FAILURE,
+ SPI_COMPARE_SKIP_TEST,
+};
+
/* This is for read/write Domain Validation: If the device supports
* an echo buffer, we do read/write tests to it */
-static int
+static enum spi_compare_returns
spi_dv_device_echo_buffer(struct scsi_request *sreq, u8 *buffer,
u8 *ptr, const int retries)
{
scsi_wait_req(sreq, spi_write_buffer, buffer, len,
DV_TIMEOUT, DV_RETRIES);
if(sreq->sr_result || !scsi_device_online(sdev)) {
+ struct scsi_sense_hdr sshdr;
+
scsi_device_set_state(sdev, SDEV_QUIESCE);
- SPI_PRINTK(sdev, KERN_ERR, "Write Buffer failure %x\n", sreq->sr_result);
- return 0;
+ if (scsi_request_normalize_sense(sreq, &sshdr)
+ && sshdr.sense_key == ILLEGAL_REQUEST
+ /* INVALID FIELD IN CDB */
+ && sshdr.asc == 0x24 && sshdr.ascq == 0x00)
+ /* This would mean that the drive lied
+ * to us about supporting an echo
+ * buffer (unfortunately some Western
+ * Digital drives do precisely this)
+ */
+ return SPI_COMPARE_SKIP_TEST;
+
+
+ SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Write Buffer failure %x\n", sreq->sr_result);
+ return SPI_COMPARE_FAILURE;
}
memset(ptr, 0, len);
scsi_device_set_state(sdev, SDEV_QUIESCE);
if (memcmp(buffer, ptr, len) != 0)
- return 0;
+ return SPI_COMPARE_FAILURE;
}
- return 1;
+ return SPI_COMPARE_SUCCESS;
}
/* This is for the simplest form of Domain Validation: a read test
* on the inquiry data from the device */
-static int
+static enum spi_compare_returns
spi_dv_device_compare_inquiry(struct scsi_request *sreq, u8 *buffer,
u8 *ptr, const int retries)
{
if(sreq->sr_result || !scsi_device_online(sdev)) {
scsi_device_set_state(sdev, SDEV_QUIESCE);
- return 0;
+ return SPI_COMPARE_FAILURE;
}
/* If we don't have the inquiry data already, the
if (memcmp(buffer, ptr, len) != 0)
/* failure */
- return 0;
+ return SPI_COMPARE_FAILURE;
}
- return 1;
+ return SPI_COMPARE_SUCCESS;
}
-static int
+static enum spi_compare_returns
spi_dv_retrain(struct scsi_request *sreq, u8 *buffer, u8 *ptr,
- int (*compare_fn)(struct scsi_request *, u8 *, u8 *, int))
+ enum spi_compare_returns
+ (*compare_fn)(struct scsi_request *, u8 *, u8 *, int))
{
struct spi_internal *i = to_spi_internal(sreq->sr_host->transportt);
struct scsi_device *sdev = sreq->sr_device;
int period = 0, prevperiod = 0;
+ enum spi_compare_returns retval;
for (;;) {
int newperiod;
- if (compare_fn(sreq, buffer, ptr, DV_LOOPS))
- /* Successful DV */
+ retval = compare_fn(sreq, buffer, ptr, DV_LOOPS);
+
+ if (retval == SPI_COMPARE_SUCCESS
+ || retval == SPI_COMPARE_SKIP_TEST)
break;
/* OK, retrain, fallback */
if (i->f->get_period)
- i->f->get_period(sdev);
- newperiod = spi_period(sdev);
+ i->f->get_period(sdev->sdev_target);
+ newperiod = spi_period(sdev->sdev_target);
period = newperiod > period ? newperiod : period;
if (period < 0x0d)
period++;
if (unlikely(period > 0xff || period == prevperiod)) {
/* Total failure; set to async and return */
- SPI_PRINTK(sdev, KERN_ERR, "Domain Validation Failure, dropping back to Asynchronous\n");
+ SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Domain Validation Failure, dropping back to Asynchronous\n");
DV_SET(offset, 0);
- return 0;
+ return SPI_COMPARE_FAILURE;
}
- SPI_PRINTK(sdev, KERN_ERR, "Domain Validation detected failure, dropping back\n");
+ SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Domain Validation detected failure, dropping back\n");
DV_SET(period, period);
prevperiod = period;
}
- return 1;
+ return retval;
}
static int
DV_SET(offset, 0);
DV_SET(width, 0);
- if (!spi_dv_device_compare_inquiry(sreq, buffer, buffer, DV_LOOPS)) {
- SPI_PRINTK(sdev, KERN_ERR, "Domain Validation Initial Inquiry Failed\n");
+ if (spi_dv_device_compare_inquiry(sreq, buffer, buffer, DV_LOOPS)
+ != SPI_COMPARE_SUCCESS) {
+ SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Domain Validation Initial Inquiry Failed\n");
/* FIXME: should probably offline the device here? */
return;
}
/* test width */
if (i->f->set_width && sdev->wdtr) {
- i->f->set_width(sdev, 1);
+ i->f->set_width(sdev->sdev_target, 1);
- if (!spi_dv_device_compare_inquiry(sreq, buffer,
+ if (spi_dv_device_compare_inquiry(sreq, buffer,
buffer + len,
- DV_LOOPS)) {
- SPI_PRINTK(sdev, KERN_ERR, "Wide Transfers Fail\n");
- i->f->set_width(sdev, 0);
+ DV_LOOPS)
+ != SPI_COMPARE_SUCCESS) {
+ SPI_PRINTK(sdev->sdev_target, KERN_ERR, "Wide Transfers Fail\n");
+ i->f->set_width(sdev->sdev_target, 0);
}
}
if(!sdev->ppr && !sdev->sdtr)
return;
+ /* see if the device has an echo buffer. If it does we can
+ * do the SPI pattern write tests */
+
+ len = 0;
+ if (sdev->ppr)
+ len = spi_dv_device_get_echo_buffer(sreq, buffer);
+
+ retry:
+
/* now set up to the maximum */
DV_SET(offset, 255);
DV_SET(period, 1);
- if (!spi_dv_retrain(sreq, buffer, buffer + len,
- spi_dv_device_compare_inquiry))
- return;
- /* OK, now we have our initial speed set by the read only inquiry
- * test, now try an echo buffer test (if the device allows it) */
-
- if ((len = spi_dv_device_get_echo_buffer(sreq, buffer)) == 0) {
- SPI_PRINTK(sdev, KERN_INFO, "Domain Validation skipping write tests\n");
+ if (len == 0) {
+ SPI_PRINTK(sdev->sdev_target, KERN_INFO, "Domain Validation skipping write tests\n");
+ spi_dv_retrain(sreq, buffer, buffer + len,
+ spi_dv_device_compare_inquiry);
return;
}
+
if (len > SPI_MAX_ECHO_BUFFER_SIZE) {
- SPI_PRINTK(sdev, KERN_WARNING, "Echo buffer size %d is too big, trimming to %d\n", len, SPI_MAX_ECHO_BUFFER_SIZE);
+ SPI_PRINTK(sdev->sdev_target, KERN_WARNING, "Echo buffer size %d is too big, trimming to %d\n", len, SPI_MAX_ECHO_BUFFER_SIZE);
len = SPI_MAX_ECHO_BUFFER_SIZE;
}
- spi_dv_retrain(sreq, buffer, buffer + len,
- spi_dv_device_echo_buffer);
+ if (spi_dv_retrain(sreq, buffer, buffer + len,
+ spi_dv_device_echo_buffer)
+ == SPI_COMPARE_SKIP_TEST) {
+ /* OK, the stupid drive can't do a write echo buffer
+ * test after all, fall back to the read tests */
+ len = 0;
+ goto retry;
+ }
}
spi_dv_device(struct scsi_device *sdev)
{
struct scsi_request *sreq = scsi_allocate_request(sdev, GFP_KERNEL);
+ struct scsi_target *starget = sdev->sdev_target;
u8 *buffer;
const int len = SPI_MAX_ECHO_BUFFER_SIZE*2;
memset(buffer, 0, len);
+ /* We need to verify that the actual device will quiesce; the
+ * later target quiesce is just a nice to have */
if (unlikely(scsi_device_quiesce(sdev)))
goto out_free;
- spi_dv_pending(sdev) = 1;
- down(&spi_dv_sem(sdev));
+ scsi_target_quiesce(starget);
- SPI_PRINTK(sdev, KERN_INFO, "Beginning Domain Validation\n");
+ spi_dv_pending(starget) = 1;
+ down(&spi_dv_sem(starget));
+
+ SPI_PRINTK(starget, KERN_INFO, "Beginning Domain Validation\n");
spi_dv_device_internal(sreq, buffer);
- SPI_PRINTK(sdev, KERN_INFO, "Ending Domain Validation\n");
+ SPI_PRINTK(starget, KERN_INFO, "Ending Domain Validation\n");
+
+ up(&spi_dv_sem(starget));
+ spi_dv_pending(starget) = 0;
- up(&spi_dv_sem(sdev));
- spi_dv_pending(sdev) = 0;
+ scsi_target_resume(starget);
- scsi_device_resume(sdev);
+ spi_initial_dv(starget) = 1;
out_free:
kfree(buffer);
kfree(wqw);
spi_dv_device(sdev);
- spi_dv_pending(sdev) = 0;
+ spi_dv_pending(sdev->sdev_target) = 0;
scsi_device_put(sdev);
}
if (unlikely(!wqw))
return;
- if (unlikely(spi_dv_pending(sdev))) {
+ if (unlikely(spi_dv_pending(sdev->sdev_target))) {
kfree(wqw);
return;
}
/* Set pending early (dv_device doesn't check it, only sets it) */
- spi_dv_pending(sdev) = 1;
+ spi_dv_pending(sdev->sdev_target) = 1;
if (unlikely(scsi_device_get(sdev))) {
kfree(wqw);
- spi_dv_pending(sdev) = 0;
+ spi_dv_pending(sdev->sdev_target) = 0;
return;
}
if (i->f->show_##field) \
count++
+#define SETUP_HOST_ATTRIBUTE(field) \
+ i->private_host_attrs[count] = class_device_attr_##field; \
+ if (!i->f->set_##field) { \
+ i->private_host_attrs[count].attr.mode = S_IRUGO; \
+ i->private_host_attrs[count].store = NULL; \
+ } \
+ i->host_attrs[count] = &i->private_host_attrs[count]; \
+ count++
+
+static int spi_device_match(struct attribute_container *cont,
+ struct device *dev)
+{
+ struct scsi_device *sdev;
+ struct Scsi_Host *shost;
+
+ if (!scsi_is_sdev_device(dev))
+ return 0;
+
+ sdev = to_scsi_device(dev);
+ shost = sdev->host;
+ if (!shost->transportt || shost->transportt->host_attrs.class
+ != &spi_host_class.class)
+ return 0;
+ /* Note: this class has no device attributes, so it has
+ * no per-HBA allocation and thus we don't need to distinguish
+ * the attribute containers for the device */
+ return 1;
+}
+
+static int spi_target_match(struct attribute_container *cont,
+ struct device *dev)
+{
+ struct Scsi_Host *shost;
+ struct spi_internal *i;
+
+ if (!scsi_is_target_device(dev))
+ return 0;
+
+ shost = dev_to_shost(dev->parent);
+ if (!shost->transportt || shost->transportt->host_attrs.class
+ != &spi_host_class.class)
+ return 0;
+
+ i = to_spi_internal(shost->transportt);
+
+ return &i->t.target_attrs == cont;
+}
+
+static DECLARE_TRANSPORT_CLASS(spi_transport_class,
+ "spi_transport",
+ spi_setup_transport_attrs,
+ NULL,
+ NULL);
+
+static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
+ spi_device_match,
+ spi_device_configure);
+
struct scsi_transport_template *
spi_attach_transport(struct spi_function_template *ft)
{
memset(i, 0, sizeof(struct spi_internal));
- i->t.attrs = &i->attrs[0];
- i->t.class = &spi_transport_class;
- i->t.setup = &spi_setup_transport_attrs;
- i->t.size = sizeof(struct spi_transport_attrs);
+ i->t.target_attrs.class = &spi_transport_class.class;
+ i->t.target_attrs.attrs = &i->attrs[0];
+ i->t.target_attrs.match = spi_target_match;
+ attribute_container_register(&i->t.target_attrs);
+ i->t.target_size = sizeof(struct spi_transport_attrs);
+ i->t.host_attrs.class = &spi_host_class.class;
+ i->t.host_attrs.attrs = &i->host_attrs[0];
+ i->t.host_attrs.match = spi_host_match;
+ attribute_container_register(&i->t.host_attrs);
+ i->t.host_size = sizeof(struct spi_host_attrs);
i->f = ft;
SETUP_ATTRIBUTE(period);
i->attrs[count] = NULL;
+ count = 0;
+ SETUP_HOST_ATTRIBUTE(signalling);
+
+ BUG_ON(count > SPI_HOST_ATTRS);
+
+ i->host_attrs[count] = NULL;
+
return &i->t;
}
EXPORT_SYMBOL(spi_attach_transport);
{
struct spi_internal *i = to_spi_internal(t);
+ attribute_container_unregister(&i->t.target_attrs);
+ attribute_container_unregister(&i->t.host_attrs);
+
kfree(i);
}
EXPORT_SYMBOL(spi_release_transport);
+static __init int spi_transport_init(void)
+{
+ int error = transport_class_register(&spi_transport_class);
+ if (error)
+ return error;
+ error = anon_transport_class_register(&spi_device_class);
+ return transport_class_register(&spi_host_class);
+}
+
+static void __exit spi_transport_exit(void)
+{
+ transport_class_unregister(&spi_transport_class);
+ anon_transport_class_unregister(&spi_device_class);
+ transport_class_unregister(&spi_host_class);
+}
MODULE_AUTHOR("Martin Hicks");
MODULE_DESCRIPTION("SPI Transport Attributes");
git://git.onelab.eu / linux-2.6.git / blobdiff