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 rwlock_t hl_irqs_lock
= RW_LOCK_UNLOCKED
;
48 static rwlock_t addr_space_lock
= RW_LOCK_UNLOCKED
;
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
= kmalloc(sizeof(*hi
) + data_size
, GFP_ATOMIC
);
108 memset(hi
, 0, sizeof(*hi
) + data_size
);
111 data
= hi
->data
= hi
+ 1;
112 hi
->size
= data_size
;
118 write_lock_irqsave(&hl
->host_info_lock
, flags
);
119 list_add_tail(&hi
->list
, &hl
->host_info_list
);
120 write_unlock_irqrestore(&hl
->host_info_lock
, flags
);
126 int hpsb_set_hostinfo(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
129 struct hl_host_info
*hi
;
131 hi
= hl_get_hostinfo(hl
, host
);
133 if (!hi
->size
&& !hi
->data
) {
137 HPSB_ERR("%s called hpsb_set_hostinfo when hostinfo already has data",
140 HPSB_ERR("%s called hpsb_set_hostinfo when no hostinfo exists",
147 void hpsb_destroy_hostinfo(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
)
149 struct hl_host_info
*hi
;
151 hi
= hl_get_hostinfo(hl
, host
);
154 write_lock_irqsave(&hl
->host_info_lock
, flags
);
156 write_unlock_irqrestore(&hl
->host_info_lock
, flags
);
164 void hpsb_set_hostinfo_key(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
, unsigned long key
)
166 struct hl_host_info
*hi
;
168 hi
= hl_get_hostinfo(hl
, host
);
176 unsigned long hpsb_get_hostinfo_key(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
)
178 struct hl_host_info
*hi
;
180 hi
= hl_get_hostinfo(hl
, host
);
188 void *hpsb_get_hostinfo_bykey(struct hpsb_highlevel
*hl
, unsigned long key
)
190 struct hl_host_info
*hi
;
196 read_lock(&hl
->host_info_lock
);
197 list_for_each_entry(hi
, &hl
->host_info_list
, list
) {
198 if (hi
->key
== key
) {
203 read_unlock(&hl
->host_info_lock
);
209 struct hpsb_host
*hpsb_get_host_bykey(struct hpsb_highlevel
*hl
, unsigned long key
)
211 struct hl_host_info
*hi
;
212 struct hpsb_host
*host
= NULL
;
217 read_lock(&hl
->host_info_lock
);
218 list_for_each_entry(hi
, &hl
->host_info_list
, list
) {
219 if (hi
->key
== key
) {
224 read_unlock(&hl
->host_info_lock
);
229 static int highlevel_for_each_host_reg(struct hpsb_host
*host
, void *__data
)
231 struct hpsb_highlevel
*hl
= __data
;
235 if (host
->update_config_rom
) {
236 if (hpsb_update_config_rom_image(host
) < 0) {
237 HPSB_ERR("Failed to generate Configuration ROM image for host "
238 "%s-%d", hl
->name
, host
->id
);
245 void hpsb_register_highlevel(struct hpsb_highlevel
*hl
)
247 INIT_LIST_HEAD(&hl
->addr_list
);
248 INIT_LIST_HEAD(&hl
->host_info_list
);
250 rwlock_init(&hl
->host_info_lock
);
252 down_write(&hl_drivers_sem
);
253 list_add_tail(&hl
->hl_list
, &hl_drivers
);
254 up_write(&hl_drivers_sem
);
256 write_lock(&hl_irqs_lock
);
257 list_add_tail(&hl
->irq_list
, &hl_irqs
);
258 write_unlock(&hl_irqs_lock
);
261 nodemgr_for_each_host(hl
, highlevel_for_each_host_reg
);
266 static void __delete_addr(struct hpsb_address_serve
*as
)
268 list_del(&as
->host_list
);
269 list_del(&as
->hl_list
);
273 static void __unregister_host(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
, int update_cr
)
276 struct list_head
*lh
, *next
;
277 struct hpsb_address_serve
*as
;
279 /* First, let the highlevel driver unreg */
281 hl
->remove_host(host
);
283 /* Remove any addresses that are matched for this highlevel driver
284 * and this particular host. */
285 write_lock_irqsave(&addr_space_lock
, flags
);
286 list_for_each_safe (lh
, next
, &hl
->addr_list
) {
287 as
= list_entry(lh
, struct hpsb_address_serve
, hl_list
);
289 if (as
->host
== host
)
292 write_unlock_irqrestore(&addr_space_lock
, flags
);
294 /* Now update the config-rom to reflect anything removed by the
295 * highlevel driver. */
296 if (update_cr
&& host
->update_config_rom
) {
297 if (hpsb_update_config_rom_image(host
) < 0) {
298 HPSB_ERR("Failed to generate Configuration ROM image for host "
299 "%s-%d", hl
->name
, host
->id
);
303 /* And finally, remove all the host info associated between these
305 hpsb_destroy_hostinfo(hl
, host
);
308 static int highlevel_for_each_host_unreg(struct hpsb_host
*host
, void *__data
)
310 struct hpsb_highlevel
*hl
= __data
;
312 __unregister_host(hl
, host
, 1);
317 void hpsb_unregister_highlevel(struct hpsb_highlevel
*hl
)
319 write_lock(&hl_irqs_lock
);
320 list_del(&hl
->irq_list
);
321 write_unlock(&hl_irqs_lock
);
323 down_write(&hl_drivers_sem
);
324 list_del(&hl
->hl_list
);
325 up_write(&hl_drivers_sem
);
327 nodemgr_for_each_host(hl
, highlevel_for_each_host_unreg
);
330 u64
hpsb_allocate_and_register_addrspace(struct hpsb_highlevel
*hl
,
331 struct hpsb_host
*host
,
332 struct hpsb_address_ops
*ops
,
333 u64 size
, u64 alignment
,
336 struct hpsb_address_serve
*as
, *a1
, *a2
;
337 struct list_head
*entry
;
340 u64 align_mask
= ~(alignment
- 1);
342 if ((alignment
& 3) || (alignment
> 0x800000000000ULL
) ||
343 ((hweight32(alignment
>> 32) +
344 hweight32(alignment
& 0xffffffff) != 1))) {
345 HPSB_ERR("%s called with invalid alignment: 0x%048llx",
346 __FUNCTION__
, (unsigned long long)alignment
);
350 if (start
== ~0ULL && end
== ~0ULL) {
351 start
= CSR1212_ALL_SPACE_BASE
+ 0xffff00000000ULL
; /* ohci1394.c limit */
352 end
= CSR1212_ALL_SPACE_END
;
355 if (((start
|end
) & ~align_mask
) || (start
>= end
) || (end
> 0x1000000000000ULL
)) {
356 HPSB_ERR("%s called with invalid addresses (start = %012Lx end = %012Lx)",
357 __FUNCTION__
, (unsigned long long)start
, (unsigned long long)end
);
361 as
= (struct hpsb_address_serve
*)
362 kmalloc(sizeof(struct hpsb_address_serve
), GFP_KERNEL
);
367 INIT_LIST_HEAD(&as
->host_list
);
368 INIT_LIST_HEAD(&as
->hl_list
);
372 write_lock_irqsave(&addr_space_lock
, flags
);
374 list_for_each(entry
, &host
->addr_space
) {
378 a1
= list_entry(entry
, struct hpsb_address_serve
, host_list
);
379 a2
= list_entry(entry
->next
, struct hpsb_address_serve
, host_list
);
381 a1sa
= a1
->start
& align_mask
;
382 a1ea
= (a1
->end
+ alignment
-1) & align_mask
;
383 a2sa
= a2
->start
& align_mask
;
384 a2ea
= (a2
->end
+ alignment
-1) & align_mask
;
386 if ((a2sa
- a1ea
>= size
) && (a2sa
- start
>= size
) && (a2sa
> start
)) {
387 as
->start
= max(start
, a1ea
);
388 as
->end
= as
->start
+ size
;
389 list_add(&as
->host_list
, entry
);
390 list_add_tail(&as
->hl_list
, &hl
->addr_list
);
396 write_unlock_irqrestore(&addr_space_lock
, flags
);
398 if (retval
== ~0ULL) {
405 int hpsb_register_addrspace(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
406 struct hpsb_address_ops
*ops
, u64 start
, u64 end
)
408 struct hpsb_address_serve
*as
;
409 struct list_head
*lh
;
413 if (((start
|end
) & 3) || (start
>= end
) || (end
> 0x1000000000000ULL
)) {
414 HPSB_ERR("%s called with invalid addresses", __FUNCTION__
);
418 as
= (struct hpsb_address_serve
*)
419 kmalloc(sizeof(struct hpsb_address_serve
), GFP_KERNEL
);
424 INIT_LIST_HEAD(&as
->host_list
);
425 INIT_LIST_HEAD(&as
->hl_list
);
431 write_lock_irqsave(&addr_space_lock
, flags
);
433 list_for_each(lh
, &host
->addr_space
) {
434 struct hpsb_address_serve
*as_this
=
435 list_entry(lh
, struct hpsb_address_serve
, host_list
);
436 struct hpsb_address_serve
*as_next
=
437 list_entry(lh
->next
, struct hpsb_address_serve
, host_list
);
439 if (as_this
->end
> as
->start
)
442 if (as_next
->start
>= as
->end
) {
443 list_add(&as
->host_list
, lh
);
444 list_add_tail(&as
->hl_list
, &hl
->addr_list
);
449 write_unlock_irqrestore(&addr_space_lock
, flags
);
457 int hpsb_unregister_addrspace(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
461 struct hpsb_address_serve
*as
;
462 struct list_head
*lh
, *next
;
465 write_lock_irqsave(&addr_space_lock
, flags
);
467 list_for_each_safe (lh
, next
, &hl
->addr_list
) {
468 as
= list_entry(lh
, struct hpsb_address_serve
, hl_list
);
469 if (as
->start
== start
&& as
->host
== host
) {
476 write_unlock_irqrestore(&addr_space_lock
, flags
);
481 int hpsb_listen_channel(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
482 unsigned int channel
)
485 HPSB_ERR("%s called with invalid channel", __FUNCTION__
);
489 if (host
->iso_listen_count
[channel
]++ == 0) {
490 return host
->driver
->devctl(host
, ISO_LISTEN_CHANNEL
, channel
);
496 void hpsb_unlisten_channel(struct hpsb_highlevel
*hl
, struct hpsb_host
*host
,
497 unsigned int channel
)
500 HPSB_ERR("%s called with invalid channel", __FUNCTION__
);
504 if (--host
->iso_listen_count
[channel
] == 0) {
505 host
->driver
->devctl(host
, ISO_UNLISTEN_CHANNEL
, channel
);
509 static void init_hpsb_highlevel(struct hpsb_host
*host
)
511 INIT_LIST_HEAD(&dummy_zero_addr
.host_list
);
512 INIT_LIST_HEAD(&dummy_zero_addr
.hl_list
);
513 INIT_LIST_HEAD(&dummy_max_addr
.host_list
);
514 INIT_LIST_HEAD(&dummy_max_addr
.hl_list
);
516 dummy_zero_addr
.op
= dummy_max_addr
.op
= &dummy_ops
;
518 dummy_zero_addr
.start
= dummy_zero_addr
.end
= 0;
519 dummy_max_addr
.start
= dummy_max_addr
.end
= ((u64
) 1) << 48;
521 list_add_tail(&dummy_zero_addr
.host_list
, &host
->addr_space
);
522 list_add_tail(&dummy_max_addr
.host_list
, &host
->addr_space
);
525 void highlevel_add_host(struct hpsb_host
*host
)
527 struct hpsb_highlevel
*hl
;
529 init_hpsb_highlevel(host
);
531 down_read(&hl_drivers_sem
);
532 list_for_each_entry(hl
, &hl_drivers
, hl_list
) {
536 up_read(&hl_drivers_sem
);
537 if (host
->update_config_rom
) {
538 if (hpsb_update_config_rom_image(host
) < 0)
539 HPSB_ERR("Failed to generate Configuration ROM image for "
540 "host %s-%d", hl
->name
, host
->id
);
544 void highlevel_remove_host(struct hpsb_host
*host
)
546 struct hpsb_highlevel
*hl
;
548 down_read(&hl_drivers_sem
);
549 list_for_each_entry(hl
, &hl_drivers
, hl_list
)
550 __unregister_host(hl
, host
, 0);
551 up_read(&hl_drivers_sem
);
554 void highlevel_host_reset(struct hpsb_host
*host
)
556 struct hpsb_highlevel
*hl
;
558 read_lock(&hl_irqs_lock
);
559 list_for_each_entry(hl
, &hl_irqs
, irq_list
) {
561 hl
->host_reset(host
);
563 read_unlock(&hl_irqs_lock
);
566 void highlevel_iso_receive(struct hpsb_host
*host
, void *data
, size_t length
)
568 struct hpsb_highlevel
*hl
;
569 int channel
= (((quadlet_t
*)data
)[0] >> 8) & 0x3f;
571 read_lock(&hl_irqs_lock
);
572 list_for_each_entry(hl
, &hl_irqs
, irq_list
) {
574 hl
->iso_receive(host
, channel
, data
, length
);
576 read_unlock(&hl_irqs_lock
);
579 void highlevel_fcp_request(struct hpsb_host
*host
, int nodeid
, int direction
,
580 void *data
, size_t length
)
582 struct hpsb_highlevel
*hl
;
583 int cts
= ((quadlet_t
*)data
)[0] >> 4;
585 read_lock(&hl_irqs_lock
);
586 list_for_each_entry(hl
, &hl_irqs
, irq_list
) {
588 hl
->fcp_request(host
, nodeid
, direction
, cts
, data
,
591 read_unlock(&hl_irqs_lock
);
594 int highlevel_read(struct hpsb_host
*host
, int nodeid
, void *data
,
595 u64 addr
, unsigned int length
, u16 flags
)
597 struct hpsb_address_serve
*as
;
598 unsigned int partlength
;
599 int rcode
= RCODE_ADDRESS_ERROR
;
601 read_lock(&addr_space_lock
);
603 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
604 if (as
->start
> addr
)
607 if (as
->end
> addr
) {
608 partlength
= min(as
->end
- addr
, (u64
) length
);
611 rcode
= as
->op
->read(host
, nodeid
, data
,
612 addr
, partlength
, flags
);
614 rcode
= RCODE_TYPE_ERROR
;
618 length
-= partlength
;
621 if ((rcode
!= RCODE_COMPLETE
) || !length
) {
627 read_unlock(&addr_space_lock
);
629 if (length
&& (rcode
== RCODE_COMPLETE
)) {
630 rcode
= RCODE_ADDRESS_ERROR
;
636 int highlevel_write(struct hpsb_host
*host
, int nodeid
, int destid
,
637 void *data
, u64 addr
, unsigned int length
, u16 flags
)
639 struct hpsb_address_serve
*as
;
640 unsigned int partlength
;
641 int rcode
= RCODE_ADDRESS_ERROR
;
643 read_lock(&addr_space_lock
);
645 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
646 if (as
->start
> addr
)
649 if (as
->end
> addr
) {
650 partlength
= min(as
->end
- addr
, (u64
) length
);
653 rcode
= as
->op
->write(host
, nodeid
, destid
,
654 data
, addr
, partlength
, flags
);
656 rcode
= RCODE_TYPE_ERROR
;
660 length
-= partlength
;
663 if ((rcode
!= RCODE_COMPLETE
) || !length
) {
669 read_unlock(&addr_space_lock
);
671 if (length
&& (rcode
== RCODE_COMPLETE
)) {
672 rcode
= RCODE_ADDRESS_ERROR
;
679 int highlevel_lock(struct hpsb_host
*host
, int nodeid
, quadlet_t
*store
,
680 u64 addr
, quadlet_t data
, quadlet_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
) {
693 rcode
= as
->op
->lock(host
, nodeid
, store
, addr
,
694 data
, arg
, ext_tcode
, flags
);
696 rcode
= RCODE_TYPE_ERROR
;
703 read_unlock(&addr_space_lock
);
708 int highlevel_lock64(struct hpsb_host
*host
, int nodeid
, octlet_t
*store
,
709 u64 addr
, octlet_t data
, octlet_t arg
, int ext_tcode
, u16 flags
)
711 struct hpsb_address_serve
*as
;
712 int rcode
= RCODE_ADDRESS_ERROR
;
714 read_lock(&addr_space_lock
);
716 list_for_each_entry(as
, &host
->addr_space
, host_list
) {
717 if (as
->start
> addr
)
720 if (as
->end
> addr
) {
721 if (as
->op
->lock64
) {
722 rcode
= as
->op
->lock64(host
, nodeid
, store
,
726 rcode
= RCODE_TYPE_ERROR
;
733 read_unlock(&addr_space_lock
);