[linux-2.6-block.git] / drivers / ieee1394 / highlevel.c

/*
 * IEEE 1394 for Linux
 *
 * Copyright (C) 1999 Andreas E. Bombe
 *
 * This code is licensed under the GPL.  See the file COPYING in the root
 * directory of the kernel sources for details.
 *
 *
 * Contributions:
 *
 * Christian Toegel <christian.toegel@gmx.at>
 *        unregister address space
 *
 * Manfred Weihs <weihs@ict.tuwien.ac.at>
 *        unregister address space
 *
 */

#include <linux/config.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/bitops.h>

#include "ieee1394.h"
#include "ieee1394_types.h"
#include "hosts.h"
#include "ieee1394_core.h"
#include "highlevel.h"
#include "nodemgr.h"


struct hl_host_info {
	struct list_head list;
	struct hpsb_host *host;
	size_t size;
	unsigned long key;
	void *data;
};


static LIST_HEAD(hl_drivers);
static DECLARE_RWSEM(hl_drivers_sem);

static LIST_HEAD(hl_irqs);
static DEFINE_RWLOCK(hl_irqs_lock);

static DEFINE_RWLOCK(addr_space_lock);

/* addr_space list will have zero and max already included as bounds */
static struct hpsb_address_ops dummy_ops = { NULL, NULL, NULL, NULL };
static struct hpsb_address_serve dummy_zero_addr, dummy_max_addr;


static struct hl_host_info *hl_get_hostinfo(struct hpsb_highlevel *hl,
					      struct hpsb_host *host)
{
	struct hl_host_info *hi = NULL;

	if (!hl || !host)
		return NULL;

	read_lock(&hl->host_info_lock);
	list_for_each_entry(hi, &hl->host_info_list, list) {
		if (hi->host == host) {
			read_unlock(&hl->host_info_lock);
			return hi;
		}
	}
	read_unlock(&hl->host_info_lock);

	return NULL;
}


/* Returns a per host/driver data structure that was previously stored by
 * hpsb_create_hostinfo. */
void *hpsb_get_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host)
{
	struct hl_host_info *hi = hl_get_hostinfo(hl, host);

	if (hi)
		return hi->data;

	return NULL;
}


/* If size is zero, then the return here is only valid for error checking */
void *hpsb_create_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host,
			   size_t data_size)
{
	struct hl_host_info *hi;
	void *data;
	unsigned long flags;

	hi = hl_get_hostinfo(hl, host);
	if (hi) {
		HPSB_ERR("%s called hpsb_create_hostinfo when hostinfo already exists",
			 hl->name);
		return NULL;
	}

	hi = kzalloc(sizeof(*hi) + data_size, GFP_ATOMIC);
	if (!hi)
		return NULL;

	if (data_size) {
		data = hi->data = hi + 1;
		hi->size = data_size;
	} else
		data = hi;

	hi->host = host;

	write_lock_irqsave(&hl->host_info_lock, flags);
	list_add_tail(&hi->list, &hl->host_info_list);
	write_unlock_irqrestore(&hl->host_info_lock, flags);

	return data;
}


int hpsb_set_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host,
		      void *data)
{
	struct hl_host_info *hi;

	hi = hl_get_hostinfo(hl, host);
	if (hi) {
		if (!hi->size && !hi->data) {
			hi->data = data;
			return 0;
		} else
			HPSB_ERR("%s called hpsb_set_hostinfo when hostinfo already has data",
				 hl->name);
	} else
		HPSB_ERR("%s called hpsb_set_hostinfo when no hostinfo exists",
			 hl->name);

	return -EINVAL;
}


void hpsb_destroy_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host)
{
	struct hl_host_info *hi;

	hi = hl_get_hostinfo(hl, host);
	if (hi) {
		unsigned long flags;
		write_lock_irqsave(&hl->host_info_lock, flags);
		list_del(&hi->list);
		write_unlock_irqrestore(&hl->host_info_lock, flags);
		kfree(hi);
	}

	return;
}


void hpsb_set_hostinfo_key(struct hpsb_highlevel *hl, struct hpsb_host *host, unsigned long key)
{
	struct hl_host_info *hi;

	hi = hl_get_hostinfo(hl, host);
	if (hi)
		hi->key = key;

	return;
}


void *hpsb_get_hostinfo_bykey(struct hpsb_highlevel *hl, unsigned long key)
{
	struct hl_host_info *hi;
	void *data = NULL;

	if (!hl)
		return NULL;

	read_lock(&hl->host_info_lock);
	list_for_each_entry(hi, &hl->host_info_list, list) {
		if (hi->key == key) {
			data = hi->data;
			break;
		}
	}
	read_unlock(&hl->host_info_lock);

	return data;
}


static int highlevel_for_each_host_reg(struct hpsb_host *host, void *__data)
{
	struct hpsb_highlevel *hl = __data;

	hl->add_host(host);

        if (host->update_config_rom) {
		if (hpsb_update_config_rom_image(host) < 0) {
			HPSB_ERR("Failed to generate Configuration ROM image for host "
				 "%s-%d", hl->name, host->id);
		}
	}

	return 0;
}

void hpsb_register_highlevel(struct hpsb_highlevel *hl)
{
	unsigned long flags;

        INIT_LIST_HEAD(&hl->addr_list);
	INIT_LIST_HEAD(&hl->host_info_list);

	rwlock_init(&hl->host_info_lock);

	down_write(&hl_drivers_sem);
        list_add_tail(&hl->hl_list, &hl_drivers);
	up_write(&hl_drivers_sem);

	write_lock_irqsave(&hl_irqs_lock, flags);
	list_add_tail(&hl->irq_list, &hl_irqs);
	write_unlock_irqrestore(&hl_irqs_lock, flags);

	if (hl->add_host)
		nodemgr_for_each_host(hl, highlevel_for_each_host_reg);

        return;
}

static void __delete_addr(struct hpsb_address_serve *as)
{
	list_del(&as->host_list);
	list_del(&as->hl_list);
	kfree(as);
}

static void __unregister_host(struct hpsb_highlevel *hl, struct hpsb_host *host, int update_cr)
{
	unsigned long flags;
	struct list_head *lh, *next;
	struct hpsb_address_serve *as;

	/* First, let the highlevel driver unreg */
	if (hl->remove_host)
		hl->remove_host(host);

	/* Remove any addresses that are matched for this highlevel driver
	 * and this particular host. */
	write_lock_irqsave(&addr_space_lock, flags);
	list_for_each_safe (lh, next, &hl->addr_list) {
		as = list_entry(lh, struct hpsb_address_serve, hl_list);

		if (as->host == host)
			__delete_addr(as);
	}
	write_unlock_irqrestore(&addr_space_lock, flags);

	/* Now update the config-rom to reflect anything removed by the
	 * highlevel driver. */
	if (update_cr && host->update_config_rom) {
		if (hpsb_update_config_rom_image(host) < 0) {
			HPSB_ERR("Failed to generate Configuration ROM image for host "
				 "%s-%d", hl->name, host->id);
		}
	}

	/* And finally, remove all the host info associated between these
	 * two. */
	hpsb_destroy_hostinfo(hl, host);
}

static int highlevel_for_each_host_unreg(struct hpsb_host *host, void *__data)
{
	struct hpsb_highlevel *hl = __data;

	__unregister_host(hl, host, 1);

	return 0;
}

void hpsb_unregister_highlevel(struct hpsb_highlevel *hl)
{
	unsigned long flags;

	write_lock_irqsave(&hl_irqs_lock, flags);
	list_del(&hl->irq_list);
	write_unlock_irqrestore(&hl_irqs_lock, flags);

	down_write(&hl_drivers_sem);
        list_del(&hl->hl_list);
	up_write(&hl_drivers_sem);

	nodemgr_for_each_host(hl, highlevel_for_each_host_unreg);
}

u64 hpsb_allocate_and_register_addrspace(struct hpsb_highlevel *hl,
					 struct hpsb_host *host,
					 struct hpsb_address_ops *ops,
					 u64 size, u64 alignment,
					 u64 start, u64 end)
{
	struct hpsb_address_serve *as, *a1, *a2;
	struct list_head *entry;
	u64 retval = CSR1212_INVALID_ADDR_SPACE;
	unsigned long flags;
	u64 align_mask = ~(alignment - 1);

	if ((alignment & 3) || (alignment > 0x800000000000ULL) ||
	    (hweight64(alignment) != 1)) {
		HPSB_ERR("%s called with invalid alignment: 0x%048llx",
			 __FUNCTION__, (unsigned long long)alignment);
		return retval;
	}

	/* default range,
	 * avoids controller's posted write area (see OHCI 1.1 clause 1.5) */
	if (start == CSR1212_INVALID_ADDR_SPACE &&
	    end   == CSR1212_INVALID_ADDR_SPACE) {
		start = host->middle_addr_space;
		end   = CSR1212_ALL_SPACE_END;
	}

	if (((start|end) & ~align_mask) || (start >= end) || (end > 0x1000000000000ULL)) {
		HPSB_ERR("%s called with invalid addresses (start = %012Lx    end = %012Lx)",
			 __FUNCTION__, (unsigned long long)start, (unsigned long long)end);
		return retval;
	}

	as = kmalloc(sizeof(*as), GFP_KERNEL);
	if (!as)
		return retval;

	INIT_LIST_HEAD(&as->host_list);
	INIT_LIST_HEAD(&as->hl_list);
	as->op = ops;
	as->host = host;

	write_lock_irqsave(&addr_space_lock, flags);

	list_for_each(entry, &host->addr_space) {
		u64 a1sa, a1ea;
		u64 a2sa, a2ea;

		a1 = list_entry(entry, struct hpsb_address_serve, host_list);
		a2 = list_entry(entry->next, struct hpsb_address_serve, host_list);

		a1sa = a1->start & align_mask;
		a1ea = (a1->end + alignment -1) & align_mask;
		a2sa = a2->start & align_mask;
		a2ea = (a2->end + alignment -1) & align_mask;

		if ((a2sa - a1ea >= size) && (a2sa - start >= size) && (a2sa > start)) {
			as->start = max(start, a1ea);
			as->end = as->start + size;
			list_add(&as->host_list, entry);
			list_add_tail(&as->hl_list, &hl->addr_list);
			retval = as->start;
			break;
		}
	}

	write_unlock_irqrestore(&addr_space_lock, flags);

	if (retval == CSR1212_INVALID_ADDR_SPACE) {
		kfree(as);
	}

	return retval;
}

int hpsb_register_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
                            struct hpsb_address_ops *ops, u64 start, u64 end)
{
        struct hpsb_address_serve *as;
	struct list_head *lh;
        int retval = 0;
        unsigned long flags;

        if (((start|end) & 3) || (start >= end) || (end > 0x1000000000000ULL)) {
                HPSB_ERR("%s called with invalid addresses", __FUNCTION__);
                return 0;
        }

	as = kmalloc(sizeof(*as), GFP_ATOMIC);
	if (!as)
		return 0;

        INIT_LIST_HEAD(&as->host_list);
        INIT_LIST_HEAD(&as->hl_list);
        as->op = ops;
        as->start = start;
        as->end = end;
	as->host = host;

	write_lock_irqsave(&addr_space_lock, flags);

	list_for_each(lh, &host->addr_space) {
		struct hpsb_address_serve *as_this =
			list_entry(lh, struct hpsb_address_serve, host_list);
		struct hpsb_address_serve *as_next =
			list_entry(lh->next, struct hpsb_address_serve, host_list);

		if (as_this->end > as->start)
			break;

		if (as_next->start >= as->end) {
			list_add(&as->host_list, lh);
			list_add_tail(&as->hl_list, &hl->addr_list);
			retval = 1;
			break;
		}
	}
	write_unlock_irqrestore(&addr_space_lock, flags);

	if (retval == 0)
		kfree(as);

        return retval;
}

int hpsb_unregister_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
                              u64 start)
{
        int retval = 0;
        struct hpsb_address_serve *as;
        struct list_head *lh, *next;
        unsigned long flags;

        write_lock_irqsave(&addr_space_lock, flags);

	list_for_each_safe (lh, next, &hl->addr_list) {
                as = list_entry(lh, struct hpsb_address_serve, hl_list);
                if (as->start == start && as->host == host) {
			__delete_addr(as);
                        retval = 1;
                        break;
                }
        }

        write_unlock_irqrestore(&addr_space_lock, flags);

        return retval;
}

int hpsb_listen_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
                         unsigned int channel)
{
        if (channel > 63) {
                HPSB_ERR("%s called with invalid channel", __FUNCTION__);
                return -EINVAL;
        }

        if (host->iso_listen_count[channel]++ == 0) {
                return host->driver->devctl(host, ISO_LISTEN_CHANNEL, channel);
        }

	return 0;
}

void hpsb_unlisten_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
                           unsigned int channel)
{
        if (channel > 63) {
                HPSB_ERR("%s called with invalid channel", __FUNCTION__);
                return;
        }

        if (--host->iso_listen_count[channel] == 0) {
                host->driver->devctl(host, ISO_UNLISTEN_CHANNEL, channel);
        }
}

static void init_hpsb_highlevel(struct hpsb_host *host)
{
	INIT_LIST_HEAD(&dummy_zero_addr.host_list);
	INIT_LIST_HEAD(&dummy_zero_addr.hl_list);
	INIT_LIST_HEAD(&dummy_max_addr.host_list);
	INIT_LIST_HEAD(&dummy_max_addr.hl_list);

	dummy_zero_addr.op = dummy_max_addr.op = &dummy_ops;

	dummy_zero_addr.start = dummy_zero_addr.end = 0;
	dummy_max_addr.start = dummy_max_addr.end = ((u64) 1) << 48;

	list_add_tail(&dummy_zero_addr.host_list, &host->addr_space);
	list_add_tail(&dummy_max_addr.host_list, &host->addr_space);
}

void highlevel_add_host(struct hpsb_host *host)
{
        struct hpsb_highlevel *hl;

	init_hpsb_highlevel(host);

	down_read(&hl_drivers_sem);
        list_for_each_entry(hl, &hl_drivers, hl_list) {
		if (hl->add_host)
			hl->add_host(host);
        }
	up_read(&hl_drivers_sem);
	if (host->update_config_rom) {
		if (hpsb_update_config_rom_image(host) < 0)
			HPSB_ERR("Failed to generate Configuration ROM image for "
				 "host %s-%d", hl->name, host->id);
	}
}

void highlevel_remove_host(struct hpsb_host *host)
{
        struct hpsb_highlevel *hl;

	down_read(&hl_drivers_sem);
	list_for_each_entry(hl, &hl_drivers, hl_list)
		__unregister_host(hl, host, 0);
	up_read(&hl_drivers_sem);
}

void highlevel_host_reset(struct hpsb_host *host)
{
	unsigned long flags;
        struct hpsb_highlevel *hl;

	read_lock_irqsave(&hl_irqs_lock, flags);
	list_for_each_entry(hl, &hl_irqs, irq_list) {
                if (hl->host_reset)
                        hl->host_reset(host);
        }
	read_unlock_irqrestore(&hl_irqs_lock, flags);
}

void highlevel_iso_receive(struct hpsb_host *host, void *data, size_t length)
{
	unsigned long flags;
        struct hpsb_highlevel *hl;
        int channel = (((quadlet_t *)data)[0] >> 8) & 0x3f;

        read_lock_irqsave(&hl_irqs_lock, flags);
	list_for_each_entry(hl, &hl_irqs, irq_list) {
                if (hl->iso_receive)
                        hl->iso_receive(host, channel, data, length);
        }
        read_unlock_irqrestore(&hl_irqs_lock, flags);
}

void highlevel_fcp_request(struct hpsb_host *host, int nodeid, int direction,
			   void *data, size_t length)
{
	unsigned long flags;
        struct hpsb_highlevel *hl;
        int cts = ((quadlet_t *)data)[0] >> 4;

        read_lock_irqsave(&hl_irqs_lock, flags);
	list_for_each_entry(hl, &hl_irqs, irq_list) {
                if (hl->fcp_request)
                        hl->fcp_request(host, nodeid, direction, cts, data,
					length);
        }
        read_unlock_irqrestore(&hl_irqs_lock, flags);
}

int highlevel_read(struct hpsb_host *host, int nodeid, void *data,
                   u64 addr, unsigned int length, u16 flags)
{
        struct hpsb_address_serve *as;
        unsigned int partlength;
        int rcode = RCODE_ADDRESS_ERROR;

        read_lock(&addr_space_lock);

	list_for_each_entry(as, &host->addr_space, host_list) {
		if (as->start > addr)
			break;

                if (as->end > addr) {
                        partlength = min(as->end - addr, (u64) length);

                        if (as->op->read) {
                                rcode = as->op->read(host, nodeid, data,
						     addr, partlength, flags);
                        } else {
                                rcode = RCODE_TYPE_ERROR;
                        }

			data += partlength;
                        length -= partlength;
                        addr += partlength;

                        if ((rcode != RCODE_COMPLETE) || !length) {
                                break;
                        }
                }
        }

        read_unlock(&addr_space_lock);

        if (length && (rcode == RCODE_COMPLETE)) {
                rcode = RCODE_ADDRESS_ERROR;
        }

        return rcode;
}

int highlevel_write(struct hpsb_host *host, int nodeid, int destid,
		    void *data, u64 addr, unsigned int length, u16 flags)
{
        struct hpsb_address_serve *as;
        unsigned int partlength;
        int rcode = RCODE_ADDRESS_ERROR;

        read_lock(&addr_space_lock);

	list_for_each_entry(as, &host->addr_space, host_list) {
		if (as->start > addr)
			break;

                if (as->end > addr) {
                        partlength = min(as->end - addr, (u64) length);

                        if (as->op->write) {
                                rcode = as->op->write(host, nodeid, destid,
						      data, addr, partlength, flags);
                        } else {
                                rcode = RCODE_TYPE_ERROR;
                        }

			data += partlength;
                        length -= partlength;
                        addr += partlength;

                        if ((rcode != RCODE_COMPLETE) || !length) {
                                break;
                        }
                }
        }

        read_unlock(&addr_space_lock);

        if (length && (rcode == RCODE_COMPLETE)) {
                rcode = RCODE_ADDRESS_ERROR;
        }

        return rcode;
}


int highlevel_lock(struct hpsb_host *host, int nodeid, quadlet_t *store,
                   u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags)
{
        struct hpsb_address_serve *as;
        int rcode = RCODE_ADDRESS_ERROR;

        read_lock(&addr_space_lock);

	list_for_each_entry(as, &host->addr_space, host_list) {
		if (as->start > addr)
			break;

                if (as->end > addr) {
                        if (as->op->lock) {
                                rcode = as->op->lock(host, nodeid, store, addr,
                                                     data, arg, ext_tcode, flags);
                        } else {
                                rcode = RCODE_TYPE_ERROR;
                        }

                        break;
                }
        }

        read_unlock(&addr_space_lock);

        return rcode;
}

int highlevel_lock64(struct hpsb_host *host, int nodeid, octlet_t *store,
                     u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags)
{
        struct hpsb_address_serve *as;
        int rcode = RCODE_ADDRESS_ERROR;

        read_lock(&addr_space_lock);

	list_for_each_entry(as, &host->addr_space, host_list) {
		if (as->start > addr)
			break;

                if (as->end > addr) {
                        if (as->op->lock64) {
                                rcode = as->op->lock64(host, nodeid, store,
                                                       addr, data, arg,
                                                       ext_tcode, flags);
                        } else {
                                rcode = RCODE_TYPE_ERROR;
                        }

                        break;
                }
        }

        read_unlock(&addr_space_lock);

        return rcode;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* IEEE 1394 for Linux
	3	*
	4	* Copyright (C) 1999 Andreas E. Bombe
	5	*
	6	* This code is licensed under the GPL. See the file COPYING in the root
	7	* directory of the kernel sources for details.
	8	*
	9	*
	10	* Contributions:
	11	*
	12	* Christian Toegel <christian.toegel@gmx.at>
	13	* unregister address space
	14	*
	15	* Manfred Weihs <weihs@ict.tuwien.ac.at>
	16	* unregister address space
	17	*
	18	*/
	19
	20	#include <linux/config.h>
	21	#include <linux/slab.h>
	22	#include <linux/list.h>
	23	#include <linux/bitops.h>
	24
	25	#include "ieee1394.h"
	26	#include "ieee1394_types.h"
	27	#include "hosts.h"
	28	#include "ieee1394_core.h"
	29	#include "highlevel.h"
	30	#include "nodemgr.h"
	31
	32
	33	struct hl_host_info {
	34	struct list_head list;
	35	struct hpsb_host *host;
	36	size_t size;
	37	unsigned long key;
	38	void *data;
	39	};
	40
	41
	42	static LIST_HEAD(hl_drivers);
	43	static DECLARE_RWSEM(hl_drivers_sem);
	44
	45	static LIST_HEAD(hl_irqs);
	46	static DEFINE_RWLOCK(hl_irqs_lock);
	47
	48	static DEFINE_RWLOCK(addr_space_lock);
	49
	50	/* addr_space list will have zero and max already included as bounds */
	51	static struct hpsb_address_ops dummy_ops = { NULL, NULL, NULL, NULL };
	52	static struct hpsb_address_serve dummy_zero_addr, dummy_max_addr;
	53
	54
	55	static struct hl_host_info hl_get_hostinfo(struct hpsb_highlevel hl,
	56	struct hpsb_host *host)
	57	{
	58	struct hl_host_info *hi = NULL;
	59
	60	if (!hl \|\| !host)
	61	return NULL;
	62
	63	read_lock(&hl->host_info_lock);
	64	list_for_each_entry(hi, &hl->host_info_list, list) {
65	if (hi->host == host) {
66	read_unlock(&hl->host_info_lock);
67	return hi;
68	}
69	}
70	read_unlock(&hl->host_info_lock);
71
72	return NULL;
73	}
74
75
76	/* Returns a per host/driver data structure that was previously stored by
77	* hpsb_create_hostinfo. */
78	void hpsb_get_hostinfo(struct hpsb_highlevel hl, struct hpsb_host *host)
79	{
80	struct hl_host_info *hi = hl_get_hostinfo(hl, host);
81
82	if (hi)
83	return hi->data;
84
85	return NULL;
86	}
87
88
89	/* If size is zero, then the return here is only valid for error checking */
90	void hpsb_create_hostinfo(struct hpsb_highlevel hl, struct hpsb_host *host,
91	size_t data_size)
92	{
93	struct hl_host_info *hi;
94	void *data;
95	unsigned long flags;
96
97	hi = hl_get_hostinfo(hl, host);
98	if (hi) {
99	HPSB_ERR("%s called hpsb_create_hostinfo when hostinfo already exists",
100	hl->name);
101	return NULL;
102	}
103
8551158a	104	hi = kzalloc(sizeof(*hi) + data_size, GFP_ATOMIC);
1da177e4 LT	105	if (!hi)
	106	return NULL;
	107
1da177e4 LT	108	if (data_size) {
	109	data = hi->data = hi + 1;
	110	hi->size = data_size;
	111	} else
	112	data = hi;
	113
	114	hi->host = host;
	115
	116	write_lock_irqsave(&hl->host_info_lock, flags);
	117	list_add_tail(&hi->list, &hl->host_info_list);
	118	write_unlock_irqrestore(&hl->host_info_lock, flags);
	119
	120	return data;
	121	}
	122
	123
	124	int hpsb_set_hostinfo(struct hpsb_highlevel hl, struct hpsb_host host,
	125	void *data)
	126	{
	127	struct hl_host_info *hi;
	128
	129	hi = hl_get_hostinfo(hl, host);
	130	if (hi) {
	131	if (!hi->size && !hi->data) {
	132	hi->data = data;
	133	return 0;
	134	} else
	135	HPSB_ERR("%s called hpsb_set_hostinfo when hostinfo already has data",
	136	hl->name);
	137	} else
	138	HPSB_ERR("%s called hpsb_set_hostinfo when no hostinfo exists",
	139	hl->name);
	140
	141	return -EINVAL;
	142	}
	143
	144
	145	void hpsb_destroy_hostinfo(struct hpsb_highlevel hl, struct hpsb_host host)
	146	{
	147	struct hl_host_info *hi;
	148
	149	hi = hl_get_hostinfo(hl, host);
	150	if (hi) {
	151	unsigned long flags;
	152	write_lock_irqsave(&hl->host_info_lock, flags);
	153	list_del(&hi->list);
	154	write_unlock_irqrestore(&hl->host_info_lock, flags);
	155	kfree(hi);
	156	}
	157
	158	return;
	159	}
	160
	161
	162	void hpsb_set_hostinfo_key(struct hpsb_highlevel hl, struct hpsb_host host, unsigned long key)
	163	{
	164	struct hl_host_info *hi;
	165
	166	hi = hl_get_hostinfo(hl, host);
	167	if (hi)
	168	hi->key = key;
	169
	170	return;
	171	}
172
173
174	void hpsb_get_hostinfo_bykey(struct hpsb_highlevel hl, unsigned long key)
175	{
176	struct hl_host_info *hi;
177	void *data = NULL;
178
179	if (!hl)
180	return NULL;
181
182	read_lock(&hl->host_info_lock);
183	list_for_each_entry(hi, &hl->host_info_list, list) {
184	if (hi->key == key) {
185	data = hi->data;
186	break;
187	}
188	}
189	read_unlock(&hl->host_info_lock);
190
191	return data;
192	}
193
194
195	static int highlevel_for_each_host_reg(struct hpsb_host host, void __data)
196	{
197	struct hpsb_highlevel *hl = __data;
198
199	hl->add_host(host);
200
201	if (host->update_config_rom) {
202	if (hpsb_update_config_rom_image(host) < 0) {
203	HPSB_ERR("Failed to generate Configuration ROM image for host "
204	"%s-%d", hl->name, host->id);
205	}
206	}
207
208	return 0;
209	}
210
211	void hpsb_register_highlevel(struct hpsb_highlevel *hl)
212	{
44515193 BC	213	unsigned long flags;
44515193 BC	214
1da177e4 LT	215	INIT_LIST_HEAD(&hl->addr_list);
	216	INIT_LIST_HEAD(&hl->host_info_list);
	217
	218	rwlock_init(&hl->host_info_lock);
	219
	220	down_write(&hl_drivers_sem);
	221	list_add_tail(&hl->hl_list, &hl_drivers);
	222	up_write(&hl_drivers_sem);
	223
44515193	224	write_lock_irqsave(&hl_irqs_lock, flags);
1da177e4	225	list_add_tail(&hl->irq_list, &hl_irqs);
44515193	226	write_unlock_irqrestore(&hl_irqs_lock, flags);
1da177e4 LT	227
	228	if (hl->add_host)
	229	nodemgr_for_each_host(hl, highlevel_for_each_host_reg);
	230
	231	return;
	232	}
	233
	234	static void __delete_addr(struct hpsb_address_serve *as)
	235	{
	236	list_del(&as->host_list);
	237	list_del(&as->hl_list);
	238	kfree(as);
	239	}
	240
	241	static void __unregister_host(struct hpsb_highlevel hl, struct hpsb_host host, int update_cr)
	242	{
	243	unsigned long flags;
	244	struct list_head lh, next;
	245	struct hpsb_address_serve *as;
	246
	247	/* First, let the highlevel driver unreg */
	248	if (hl->remove_host)
	249	hl->remove_host(host);
	250
	251	/* Remove any addresses that are matched for this highlevel driver
	252	* and this particular host. */
	253	write_lock_irqsave(&addr_space_lock, flags);
	254	list_for_each_safe (lh, next, &hl->addr_list) {
	255	as = list_entry(lh, struct hpsb_address_serve, hl_list);
	256
	257	if (as->host == host)
	258	__delete_addr(as);
	259	}
	260	write_unlock_irqrestore(&addr_space_lock, flags);
	261
	262	/* Now update the config-rom to reflect anything removed by the
	263	* highlevel driver. */
	264	if (update_cr && host->update_config_rom) {
	265	if (hpsb_update_config_rom_image(host) < 0) {
	266	HPSB_ERR("Failed to generate Configuration ROM image for host "
	267	"%s-%d", hl->name, host->id);
	268	}
	269	}
	270
	271	/* And finally, remove all the host info associated between these
	272	* two. */
	273	hpsb_destroy_hostinfo(hl, host);
	274	}
	275
	276	static int highlevel_for_each_host_unreg(struct hpsb_host host, void __data)
	277	{
	278	struct hpsb_highlevel *hl = __data;
	279
	280	__unregister_host(hl, host, 1);
	281
	282	return 0;
	283	}
	284
	285	void hpsb_unregister_highlevel(struct hpsb_highlevel *hl)
	286	{
44515193 BC	287	unsigned long flags;
	288
	289	write_lock_irqsave(&hl_irqs_lock, flags);
1da177e4	290	list_del(&hl->irq_list);
44515193	291	write_unlock_irqrestore(&hl_irqs_lock, flags);
1da177e4 LT	292
	293	down_write(&hl_drivers_sem);
	294	list_del(&hl->hl_list);
	295	up_write(&hl_drivers_sem);
	296
	297	nodemgr_for_each_host(hl, highlevel_for_each_host_unreg);
	298	}
	299
	300	u64 hpsb_allocate_and_register_addrspace(struct hpsb_highlevel *hl,
	301	struct hpsb_host *host,
	302	struct hpsb_address_ops *ops,
	303	u64 size, u64 alignment,
	304	u64 start, u64 end)
	305	{
	306	struct hpsb_address_serve as, a1, *a2;
	307	struct list_head *entry;
6737231e	308	u64 retval = CSR1212_INVALID_ADDR_SPACE;
1da177e4 LT	309	unsigned long flags;
	310	u64 align_mask = ~(alignment - 1);
	311
	312	if ((alignment & 3) \|\| (alignment > 0x800000000000ULL) \|\|
37d54111	313	(hweight64(alignment) != 1)) {
1da177e4 LT	314	HPSB_ERR("%s called with invalid alignment: 0x%048llx",
	315	__FUNCTION__, (unsigned long long)alignment);
	316	return retval;
	317	}
	318
8aef63ff BC	319	/* default range,
8aef63ff BC	320	* avoids controller's posted write area (see OHCI 1.1 clause 1.5) */
6737231e BC	321	if (start == CSR1212_INVALID_ADDR_SPACE &&
6737231e BC	322	end == CSR1212_INVALID_ADDR_SPACE) {
8aef63ff	323	start = host->middle_addr_space;
6737231e	324	end = CSR1212_ALL_SPACE_END;
1da177e4 LT	325	}
	326
	327	if (((start\|end) & ~align_mask) \|\| (start >= end) \|\| (end > 0x1000000000000ULL)) {
	328	HPSB_ERR("%s called with invalid addresses (start = %012Lx end = %012Lx)",
	329	__FUNCTION__, (unsigned long long)start, (unsigned long long)end);
	330	return retval;
	331	}
	332
8551158a SR	333	as = kmalloc(sizeof(*as), GFP_KERNEL);
8551158a SR	334	if (!as)
1da177e4	335	return retval;
1da177e4 LT	336
	337	INIT_LIST_HEAD(&as->host_list);
	338	INIT_LIST_HEAD(&as->hl_list);
	339	as->op = ops;
	340	as->host = host;
	341
	342	write_lock_irqsave(&addr_space_lock, flags);
	343
	344	list_for_each(entry, &host->addr_space) {
	345	u64 a1sa, a1ea;
	346	u64 a2sa, a2ea;
	347
	348	a1 = list_entry(entry, struct hpsb_address_serve, host_list);
	349	a2 = list_entry(entry->next, struct hpsb_address_serve, host_list);
	350
	351	a1sa = a1->start & align_mask;
	352	a1ea = (a1->end + alignment -1) & align_mask;
	353	a2sa = a2->start & align_mask;
	354	a2ea = (a2->end + alignment -1) & align_mask;
	355
	356	if ((a2sa - a1ea >= size) && (a2sa - start >= size) && (a2sa > start)) {
	357	as->start = max(start, a1ea);
	358	as->end = as->start + size;
	359	list_add(&as->host_list, entry);
	360	list_add_tail(&as->hl_list, &hl->addr_list);
	361	retval = as->start;
	362	break;
	363	}
	364	}
	365
	366	write_unlock_irqrestore(&addr_space_lock, flags);
	367
6737231e	368	if (retval == CSR1212_INVALID_ADDR_SPACE) {
1da177e4 LT	369	kfree(as);
	370	}
	371
	372	return retval;
	373	}
	374
	375	int hpsb_register_addrspace(struct hpsb_highlevel hl, struct hpsb_host host,
	376	struct hpsb_address_ops *ops, u64 start, u64 end)
	377	{
	378	struct hpsb_address_serve *as;
	379	struct list_head *lh;
	380	int retval = 0;
	381	unsigned long flags;
	382
	383	if (((start\|end) & 3) \|\| (start >= end) \|\| (end > 0x1000000000000ULL)) {
	384	HPSB_ERR("%s called with invalid addresses", __FUNCTION__);
	385	return 0;
	386	}
	387
8551158a SR	388	as = kmalloc(sizeof(*as), GFP_ATOMIC);
	389	if (!as)
	390	return 0;
1da177e4 LT	391
	392	INIT_LIST_HEAD(&as->host_list);
	393	INIT_LIST_HEAD(&as->hl_list);
	394	as->op = ops;
	395	as->start = start;
	396	as->end = end;
	397	as->host = host;
	398
	399	write_lock_irqsave(&addr_space_lock, flags);
	400
	401	list_for_each(lh, &host->addr_space) {
	402	struct hpsb_address_serve *as_this =
	403	list_entry(lh, struct hpsb_address_serve, host_list);
	404	struct hpsb_address_serve *as_next =
	405	list_entry(lh->next, struct hpsb_address_serve, host_list);
	406
	407	if (as_this->end > as->start)
	408	break;
	409
	410	if (as_next->start >= as->end) {
	411	list_add(&as->host_list, lh);
	412	list_add_tail(&as->hl_list, &hl->addr_list);
	413	retval = 1;
	414	break;
	415	}
	416	}
	417	write_unlock_irqrestore(&addr_space_lock, flags);
	418
	419	if (retval == 0)
	420	kfree(as);
	421
	422	return retval;
	423	}
	424
	425	int hpsb_unregister_addrspace(struct hpsb_highlevel hl, struct hpsb_host host,
	426	u64 start)
	427	{
	428	int retval = 0;
	429	struct hpsb_address_serve *as;
	430	struct list_head lh, next;
	431	unsigned long flags;
	432
	433	write_lock_irqsave(&addr_space_lock, flags);
	434
	435	list_for_each_safe (lh, next, &hl->addr_list) {
	436	as = list_entry(lh, struct hpsb_address_serve, hl_list);
	437	if (as->start == start && as->host == host) {
	438	__delete_addr(as);
	439	retval = 1;
	440	break;
	441	}
	442	}
	443
	444	write_unlock_irqrestore(&addr_space_lock, flags);
	445
	446	return retval;
	447	}
	448
	449	int hpsb_listen_channel(struct hpsb_highlevel hl, struct hpsb_host host,
	450	unsigned int channel)
	451	{
	452	if (channel > 63) {
	453	HPSB_ERR("%s called with invalid channel", __FUNCTION__);
	454	return -EINVAL;
455	}
456
457	if (host->iso_listen_count[channel]++ == 0) {
458	return host->driver->devctl(host, ISO_LISTEN_CHANNEL, channel);
459	}
460
461	return 0;
462	}
463
464	void hpsb_unlisten_channel(struct hpsb_highlevel hl, struct hpsb_host host,
465	unsigned int channel)
466	{
467	if (channel > 63) {
468	HPSB_ERR("%s called with invalid channel", __FUNCTION__);
469	return;
470	}
471
472	if (--host->iso_listen_count[channel] == 0) {
473	host->driver->devctl(host, ISO_UNLISTEN_CHANNEL, channel);
474	}
475	}
476
477	static void init_hpsb_highlevel(struct hpsb_host *host)
478	{
479	INIT_LIST_HEAD(&dummy_zero_addr.host_list);
480	INIT_LIST_HEAD(&dummy_zero_addr.hl_list);
481	INIT_LIST_HEAD(&dummy_max_addr.host_list);
482	INIT_LIST_HEAD(&dummy_max_addr.hl_list);
483
484	dummy_zero_addr.op = dummy_max_addr.op = &dummy_ops;
485
486	dummy_zero_addr.start = dummy_zero_addr.end = 0;
487	dummy_max_addr.start = dummy_max_addr.end = ((u64) 1) << 48;
488
489	list_add_tail(&dummy_zero_addr.host_list, &host->addr_space);
490	list_add_tail(&dummy_max_addr.host_list, &host->addr_space);
491	}
492
493	void highlevel_add_host(struct hpsb_host *host)
494	{
495	struct hpsb_highlevel *hl;
496
497	init_hpsb_highlevel(host);
498
499	down_read(&hl_drivers_sem);
500	list_for_each_entry(hl, &hl_drivers, hl_list) {
501	if (hl->add_host)
502	hl->add_host(host);
503	}
504	up_read(&hl_drivers_sem);
505	if (host->update_config_rom) {
506	if (hpsb_update_config_rom_image(host) < 0)
507	HPSB_ERR("Failed to generate Configuration ROM image for "
508	"host %s-%d", hl->name, host->id);
509	}
510	}
511
512	void highlevel_remove_host(struct hpsb_host *host)
513	{
514	struct hpsb_highlevel *hl;
515
516	down_read(&hl_drivers_sem);
517	list_for_each_entry(hl, &hl_drivers, hl_list)
518	__unregister_host(hl, host, 0);
519	up_read(&hl_drivers_sem);
520	}
521
522	void highlevel_host_reset(struct hpsb_host *host)
523	{
44515193	524	unsigned long flags;
1da177e4 LT	525	struct hpsb_highlevel *hl;
1da177e4 LT	526
44515193	527	read_lock_irqsave(&hl_irqs_lock, flags);
1da177e4 LT	528	list_for_each_entry(hl, &hl_irqs, irq_list) {
	529	if (hl->host_reset)
	530	hl->host_reset(host);
	531	}
44515193	532	read_unlock_irqrestore(&hl_irqs_lock, flags);
1da177e4 LT	533	}
	534
	535	void highlevel_iso_receive(struct hpsb_host host, void data, size_t length)
	536	{
44515193	537	unsigned long flags;
1da177e4 LT	538	struct hpsb_highlevel *hl;
	539	int channel = (((quadlet_t *)data)[0] >> 8) & 0x3f;
	540
44515193	541	read_lock_irqsave(&hl_irqs_lock, flags);
1da177e4 LT	542	list_for_each_entry(hl, &hl_irqs, irq_list) {
	543	if (hl->iso_receive)
	544	hl->iso_receive(host, channel, data, length);
	545	}
44515193	546	read_unlock_irqrestore(&hl_irqs_lock, flags);
1da177e4 LT	547	}
	548
	549	void highlevel_fcp_request(struct hpsb_host *host, int nodeid, int direction,
	550	void *data, size_t length)
	551	{
44515193	552	unsigned long flags;
1da177e4 LT	553	struct hpsb_highlevel *hl;
	554	int cts = ((quadlet_t *)data)[0] >> 4;
	555
44515193	556	read_lock_irqsave(&hl_irqs_lock, flags);
1da177e4 LT	557	list_for_each_entry(hl, &hl_irqs, irq_list) {
	558	if (hl->fcp_request)
	559	hl->fcp_request(host, nodeid, direction, cts, data,
	560	length);
	561	}
44515193	562	read_unlock_irqrestore(&hl_irqs_lock, flags);
1da177e4 LT	563	}
	564
	565	int highlevel_read(struct hpsb_host host, int nodeid, void data,
	566	u64 addr, unsigned int length, u16 flags)
	567	{
	568	struct hpsb_address_serve *as;
	569	unsigned int partlength;
	570	int rcode = RCODE_ADDRESS_ERROR;
	571
	572	read_lock(&addr_space_lock);
	573
	574	list_for_each_entry(as, &host->addr_space, host_list) {
	575	if (as->start > addr)
	576	break;
	577
	578	if (as->end > addr) {
	579	partlength = min(as->end - addr, (u64) length);
	580
	581	if (as->op->read) {
	582	rcode = as->op->read(host, nodeid, data,
	583	addr, partlength, flags);
	584	} else {
	585	rcode = RCODE_TYPE_ERROR;
	586	}
	587
	588	data += partlength;
	589	length -= partlength;
	590	addr += partlength;
	591
	592	if ((rcode != RCODE_COMPLETE) \|\| !length) {
	593	break;
	594	}
	595	}
	596	}
	597
	598	read_unlock(&addr_space_lock);
	599
	600	if (length && (rcode == RCODE_COMPLETE)) {
	601	rcode = RCODE_ADDRESS_ERROR;
	602	}
	603
	604	return rcode;
	605	}
	606
	607	int highlevel_write(struct hpsb_host *host, int nodeid, int destid,
	608	void *data, u64 addr, unsigned int length, u16 flags)
	609	{
	610	struct hpsb_address_serve *as;
	611	unsigned int partlength;
	612	int rcode = RCODE_ADDRESS_ERROR;
	613
	614	read_lock(&addr_space_lock);
	615
	616	list_for_each_entry(as, &host->addr_space, host_list) {
	617	if (as->start > addr)
	618	break;
	619
	620	if (as->end > addr) {
	621	partlength = min(as->end - addr, (u64) length);
	622
	623	if (as->op->write) {
	624	rcode = as->op->write(host, nodeid, destid,
	625	data, addr, partlength, flags);
	626	} else {
627	rcode = RCODE_TYPE_ERROR;
628	}
629
630	data += partlength;
631	length -= partlength;
632	addr += partlength;
633
634	if ((rcode != RCODE_COMPLETE) \|\| !length) {
635	break;
636	}
637	}
638	}
639
640	read_unlock(&addr_space_lock);
641
642	if (length && (rcode == RCODE_COMPLETE)) {
643	rcode = RCODE_ADDRESS_ERROR;
644	}
645
646	return rcode;
647	}
648
649
650	int highlevel_lock(struct hpsb_host host, int nodeid, quadlet_t store,
651	u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags)
652	{
653	struct hpsb_address_serve *as;
654	int rcode = RCODE_ADDRESS_ERROR;
655
656	read_lock(&addr_space_lock);
657
658	list_for_each_entry(as, &host->addr_space, host_list) {
659	if (as->start > addr)
660	break;
661
662	if (as->end > addr) {
663	if (as->op->lock) {
664	rcode = as->op->lock(host, nodeid, store, addr,
665	data, arg, ext_tcode, flags);
666	} else {
667	rcode = RCODE_TYPE_ERROR;
668	}
669
670	break;
671	}
672	}
673
674	read_unlock(&addr_space_lock);
675
676	return rcode;
677	}
678
679	int highlevel_lock64(struct hpsb_host host, int nodeid, octlet_t store,
680	u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags)
681	{
682	struct hpsb_address_serve *as;
683	int rcode = RCODE_ADDRESS_ERROR;
684
685	read_lock(&addr_space_lock);
686
687	list_for_each_entry(as, &host->addr_space, host_list) {
688	if (as->start > addr)
689	break;
690
691	if (as->end > addr) {
692	if (as->op->lock64) {
693	rcode = as->op->lock64(host, nodeid, store,
694	addr, data, arg,
695	ext_tcode, flags);
696	} else {
697	rcode = RCODE_TYPE_ERROR;
698	}
699
700	break;
701	}
702	}
703
704	read_unlock(&addr_space_lock);
705
706	return rcode;
707	}