4 * Copyright (C) 1999 Andreas E. Bombe
6 * This code is licensed under the GPL. See the file COPYING in the root
7 * directory of the kernel sources for details.
12 * Christian Toegel <christian.toegel@gmx.at>
13 * unregister address space
15 * Manfred Weihs <weihs@ict.tuwien.ac.at>
16 * unregister address space
20 #include <linux/config.h>
21 #include <linux/slab.h>
22 #include <linux/list.h>
23 #include <linux/bitops.h>
26 #include "ieee1394_types.h"
28 #include "ieee1394_core.h"
29 #include "highlevel.h"
34 struct list_head list;
35 struct hpsb_host *host;
42 static LIST_HEAD(hl_drivers);
43 static DECLARE_RWSEM(hl_drivers_sem);
45 static LIST_HEAD(hl_irqs);
46 static DEFINE_RWLOCK(hl_irqs_lock);
48 static DEFINE_RWLOCK(addr_space_lock);
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;
55 static struct hl_host_info *hl_get_hostinfo(struct hpsb_highlevel *hl,
56 struct hpsb_host *host)
58 struct hl_host_info *hi = NULL;
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);
70 read_unlock(&hl->host_info_lock);
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)
80 struct hl_host_info *hi = hl_get_hostinfo(hl, host);
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,
93 struct hl_host_info *hi;
97 hi = hl_get_hostinfo(hl, host);
99 HPSB_ERR("%s called hpsb_create_hostinfo when hostinfo already exists",
104 hi = kzalloc(sizeof(*hi) + data_size, GFP_ATOMIC);
109 data = hi->data = hi + 1;
110 hi->size = data_size;
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);
124 int hpsb_set_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host,
127 struct hl_host_info *hi;
129 hi = hl_get_hostinfo(hl, host);
131 if (!hi->size && !hi->data) {
135 HPSB_ERR("%s called hpsb_set_hostinfo when hostinfo already has data",
138 HPSB_ERR("%s called hpsb_set_hostinfo when no hostinfo exists",
145 void hpsb_destroy_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host)
147 struct hl_host_info *hi;
149 hi = hl_get_hostinfo(hl, host);
152 write_lock_irqsave(&hl->host_info_lock, flags);
154 write_unlock_irqrestore(&hl->host_info_lock, flags);
162 void hpsb_set_hostinfo_key(struct hpsb_highlevel *hl, struct hpsb_host *host, unsigned long key)
164 struct hl_host_info *hi;
166 hi = hl_get_hostinfo(hl, host);
174 void *hpsb_get_hostinfo_bykey(struct hpsb_highlevel *hl, unsigned long key)
176 struct hl_host_info *hi;
182 read_lock(&hl->host_info_lock);
183 list_for_each_entry(hi, &hl->host_info_list, list) {
184 if (hi->key == key) {
189 read_unlock(&hl->host_info_lock);
195 static int highlevel_for_each_host_reg(struct hpsb_host *host, void *__data)
197 struct hpsb_highlevel *hl = __data;
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);
211 void hpsb_register_highlevel(struct hpsb_highlevel *hl)
215 INIT_LIST_HEAD(&hl->addr_list);
216 INIT_LIST_HEAD(&hl->host_info_list);
218 rwlock_init(&hl->host_info_lock);
220 down_write(&hl_drivers_sem);
221 list_add_tail(&hl->hl_list, &hl_drivers);
222 up_write(&hl_drivers_sem);
224 write_lock_irqsave(&hl_irqs_lock, flags);
225 list_add_tail(&hl->irq_list, &hl_irqs);
226 write_unlock_irqrestore(&hl_irqs_lock, flags);
229 nodemgr_for_each_host(hl, highlevel_for_each_host_reg);
234 static void __delete_addr(struct hpsb_address_serve *as)
236 list_del(&as->host_list);
237 list_del(&as->hl_list);
241 static void __unregister_host(struct hpsb_highlevel *hl, struct hpsb_host *host, int update_cr)
244 struct list_head *lh, *next;
245 struct hpsb_address_serve *as;
247 /* First, let the highlevel driver unreg */
249 hl->remove_host(host);
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);
257 if (as->host == host)
260 write_unlock_irqrestore(&addr_space_lock, flags);
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);
271 /* And finally, remove all the host info associated between these
273 hpsb_destroy_hostinfo(hl, host);
276 static int highlevel_for_each_host_unreg(struct hpsb_host *host, void *__data)
278 struct hpsb_highlevel *hl = __data;
280 __unregister_host(hl, host, 1);
285 void hpsb_unregister_highlevel(struct hpsb_highlevel *hl)
289 write_lock_irqsave(&hl_irqs_lock, flags);
290 list_del(&hl->irq_list);
291 write_unlock_irqrestore(&hl_irqs_lock, flags);
293 down_write(&hl_drivers_sem);
294 list_del(&hl->hl_list);
295 up_write(&hl_drivers_sem);
297 nodemgr_for_each_host(hl, highlevel_for_each_host_unreg);
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,
306 struct hpsb_address_serve *as, *a1, *a2;
307 struct list_head *entry;
308 u64 retval = CSR1212_INVALID_ADDR_SPACE;
310 u64 align_mask = ~(alignment - 1);
312 if ((alignment & 3) || (alignment > 0x800000000000ULL) ||
313 (hweight64(alignment) != 1)) {
314 HPSB_ERR("%s called with invalid alignment: 0x%048llx",
315 __FUNCTION__, (unsigned long long)alignment);
320 * avoids controller's posted write area (see OHCI 1.1 clause 1.5) */
321 if (start == CSR1212_INVALID_ADDR_SPACE &&
322 end == CSR1212_INVALID_ADDR_SPACE) {
323 start = host->middle_addr_space;
324 end = CSR1212_ALL_SPACE_END;
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);
333 as = kmalloc(sizeof(*as), GFP_KERNEL);
337 INIT_LIST_HEAD(&as->host_list);
338 INIT_LIST_HEAD(&as->hl_list);
342 write_lock_irqsave(&addr_space_lock, flags);
344 list_for_each(entry, &host->addr_space) {
348 a1 = list_entry(entry, struct hpsb_address_serve, host_list);
349 a2 = list_entry(entry->next, struct hpsb_address_serve, host_list);
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;
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);
366 write_unlock_irqrestore(&addr_space_lock, flags);
368 if (retval == CSR1212_INVALID_ADDR_SPACE) {
375 int hpsb_register_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
376 struct hpsb_address_ops *ops, u64 start, u64 end)
378 struct hpsb_address_serve *as;
379 struct list_head *lh;
383 if (((start|end) & 3) || (start >= end) || (end > 0x1000000000000ULL)) {
384 HPSB_ERR("%s called with invalid addresses", __FUNCTION__);
388 as = kmalloc(sizeof(*as), GFP_ATOMIC);
392 INIT_LIST_HEAD(&as->host_list);
393 INIT_LIST_HEAD(&as->hl_list);
399 write_lock_irqsave(&addr_space_lock, flags);
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);
407 if (as_this->end > as->start)
410 if (as_next->start >= as->end) {
411 list_add(&as->host_list, lh);
412 list_add_tail(&as->hl_list, &hl->addr_list);
417 write_unlock_irqrestore(&addr_space_lock, flags);
425 int hpsb_unregister_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
429 struct hpsb_address_serve *as;
430 struct list_head *lh, *next;
433 write_lock_irqsave(&addr_space_lock, flags);
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) {
444 write_unlock_irqrestore(&addr_space_lock, flags);
449 int hpsb_listen_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
450 unsigned int channel)
453 HPSB_ERR("%s called with invalid channel", __FUNCTION__);
457 if (host->iso_listen_count[channel]++ == 0) {
458 return host->driver->devctl(host, ISO_LISTEN_CHANNEL, channel);
464 void hpsb_unlisten_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
465 unsigned int channel)
468 HPSB_ERR("%s called with invalid channel", __FUNCTION__);
472 if (--host->iso_listen_count[channel] == 0) {
473 host->driver->devctl(host, ISO_UNLISTEN_CHANNEL, channel);
477 static void init_hpsb_highlevel(struct hpsb_host *host)
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);
484 dummy_zero_addr.op = dummy_max_addr.op = &dummy_ops;
486 dummy_zero_addr.start = dummy_zero_addr.end = 0;
487 dummy_max_addr.start = dummy_max_addr.end = ((u64) 1) << 48;
489 list_add_tail(&dummy_zero_addr.host_list, &host->addr_space);
490 list_add_tail(&dummy_max_addr.host_list, &host->addr_space);
493 void highlevel_add_host(struct hpsb_host *host)
495 struct hpsb_highlevel *hl;
497 init_hpsb_highlevel(host);
499 down_read(&hl_drivers_sem);
500 list_for_each_entry(hl, &hl_drivers, hl_list) {
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);
512 void highlevel_remove_host(struct hpsb_host *host)
514 struct hpsb_highlevel *hl;
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);
522 void highlevel_host_reset(struct hpsb_host *host)
525 struct hpsb_highlevel *hl;
527 read_lock_irqsave(&hl_irqs_lock, flags);
528 list_for_each_entry(hl, &hl_irqs, irq_list) {
530 hl->host_reset(host);
532 read_unlock_irqrestore(&hl_irqs_lock, flags);
535 void highlevel_iso_receive(struct hpsb_host *host, void *data, size_t length)
538 struct hpsb_highlevel *hl;
539 int channel = (((quadlet_t *)data)[0] >> 8) & 0x3f;
541 read_lock_irqsave(&hl_irqs_lock, flags);
542 list_for_each_entry(hl, &hl_irqs, irq_list) {
544 hl->iso_receive(host, channel, data, length);
546 read_unlock_irqrestore(&hl_irqs_lock, flags);
549 void highlevel_fcp_request(struct hpsb_host *host, int nodeid, int direction,
550 void *data, size_t length)
553 struct hpsb_highlevel *hl;
554 int cts = ((quadlet_t *)data)[0] >> 4;
556 read_lock_irqsave(&hl_irqs_lock, flags);
557 list_for_each_entry(hl, &hl_irqs, irq_list) {
559 hl->fcp_request(host, nodeid, direction, cts, data,
562 read_unlock_irqrestore(&hl_irqs_lock, flags);
565 int highlevel_read(struct hpsb_host *host, int nodeid, void *data,
566 u64 addr, unsigned int length, u16 flags)
568 struct hpsb_address_serve *as;
569 unsigned int partlength;
570 int rcode = RCODE_ADDRESS_ERROR;
572 read_lock(&addr_space_lock);
574 list_for_each_entry(as, &host->addr_space, host_list) {
575 if (as->start > addr)
578 if (as->end > addr) {
579 partlength = min(as->end - addr, (u64) length);
582 rcode = as->op->read(host, nodeid, data,
583 addr, partlength, flags);
585 rcode = RCODE_TYPE_ERROR;
589 length -= partlength;
592 if ((rcode != RCODE_COMPLETE) || !length) {
598 read_unlock(&addr_space_lock);
600 if (length && (rcode == RCODE_COMPLETE)) {
601 rcode = RCODE_ADDRESS_ERROR;
607 int highlevel_write(struct hpsb_host *host, int nodeid, int destid,
608 void *data, u64 addr, unsigned int length, u16 flags)
610 struct hpsb_address_serve *as;
611 unsigned int partlength;
612 int rcode = RCODE_ADDRESS_ERROR;
614 read_lock(&addr_space_lock);
616 list_for_each_entry(as, &host->addr_space, host_list) {
617 if (as->start > addr)
620 if (as->end > addr) {
621 partlength = min(as->end - addr, (u64) length);
624 rcode = as->op->write(host, nodeid, destid,
625 data, addr, partlength, flags);
627 rcode = RCODE_TYPE_ERROR;
631 length -= partlength;
634 if ((rcode != RCODE_COMPLETE) || !length) {
640 read_unlock(&addr_space_lock);
642 if (length && (rcode == RCODE_COMPLETE)) {
643 rcode = RCODE_ADDRESS_ERROR;
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)
653 struct hpsb_address_serve *as;
654 int rcode = RCODE_ADDRESS_ERROR;
656 read_lock(&addr_space_lock);
658 list_for_each_entry(as, &host->addr_space, host_list) {
659 if (as->start > addr)
662 if (as->end > addr) {
664 rcode = as->op->lock(host, nodeid, store, addr,
665 data, arg, ext_tcode, flags);
667 rcode = RCODE_TYPE_ERROR;
674 read_unlock(&addr_space_lock);
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)
682 struct hpsb_address_serve *as;
683 int rcode = RCODE_ADDRESS_ERROR;
685 read_lock(&addr_space_lock);
687 list_for_each_entry(as, &host->addr_space, host_list) {
688 if (as->start > addr)
691 if (as->end > addr) {
692 if (as->op->lock64) {
693 rcode = as->op->lock64(host, nodeid, store,
697 rcode = RCODE_TYPE_ERROR;
704 read_unlock(&addr_space_lock);