drivers/ieee1394/highlevel.c

   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 #include <linux/config.h>
  11 #include <linux/slab.h>
  12
  13 #include "ieee1394.h"
  14 #include "ieee1394_types.h"
  15 #include "hosts.h"
  16 #include "ieee1394_core.h"
  17 #include "highlevel.h"
  18
  19
  20 LIST_HEAD(hl_drivers);
  21 rwlock_t hl_drivers_lock = RW_LOCK_UNLOCKED;
  22
  23 LIST_HEAD(addr_space);
  24 rwlock_t addr_space_lock = RW_LOCK_UNLOCKED;
  25
  26 /* addr_space list will have zero and max already included as bounds */
  27 static struct hpsb_address_ops dummy_ops = { NULL, NULL, NULL, NULL };
  28 static struct hpsb_address_serve dummy_zero_addr, dummy_max_addr;
  29
  30 struct hpsb_highlevel *hpsb_register_highlevel(const char *name,
  31                                                struct hpsb_highlevel_ops *ops)
  32 {
  33         struct hpsb_highlevel *hl;
  34
  35         hl = (struct hpsb_highlevel *)kmalloc(sizeof(struct hpsb_highlevel),
  36                                               GFP_KERNEL);
  37         if (hl == NULL) {
  38                 return NULL;
  39         }
  40
  41         INIT_LIST_HEAD(&hl->hl_list);
  42         INIT_LIST_HEAD(&hl->addr_list);
  43         hl->name = name;
  44         hl->op = ops;
  45
  46         write_lock_irq(&hl_drivers_lock);
  47         hl_all_hosts(hl, 1);
  48         list_add_tail(&hl->hl_list, &hl_drivers);
  49         write_unlock_irq(&hl_drivers_lock);
  50
  51         return hl;
  52 }
  53
  54 void hpsb_unregister_highlevel(struct hpsb_highlevel *hl)
  55 {
  56         struct list_head *entry;
  57         struct hpsb_address_serve *as;
  58
  59         if (hl == NULL) {
  60                 return;
  61         }
  62
  63         write_lock_irq(&addr_space_lock);
  64         entry = hl->addr_list.next;
  65
  66         while (entry != &hl->addr_list) {
  67                 as = list_entry(entry, struct hpsb_address_serve, addr_list);
  68                 list_del(&as->as_list);
  69                 entry = entry->next;
  70                 kfree(as);
  71         }
  72         write_unlock_irq(&addr_space_lock);
  73
  74         write_lock_irq(&hl_drivers_lock);
  75         list_del(&hl->hl_list);
  76         hl_all_hosts(hl, 0);
  77         write_unlock_irq(&hl_drivers_lock);
  78
  79         kfree(hl);
  80 }
  81
  82 int hpsb_register_addrspace(struct hpsb_highlevel *hl,
  83                             struct hpsb_address_ops *ops, u64 start, u64 end)
  84 {
  85         struct hpsb_address_serve *as;
  86         struct list_head *entry;
  87         int retval = 0;
  88
  89         if (((start|end) & 3) || (start >= end) || (end > 0x1000000000000ULL)) {
  90                 HPSB_ERR(__FUNCTION__ " called with invalid addresses");
  91                 return 0;
  92         }
  93
  94         as = (struct hpsb_address_serve *)
  95                 kmalloc(sizeof(struct hpsb_address_serve), GFP_KERNEL);
  96         if (as == NULL) {
  97                 return 0;
  98         }
  99
 100         INIT_LIST_HEAD(&as->as_list);
 101         INIT_LIST_HEAD(&as->addr_list);
 102         as->op = ops;
 103         as->start = start;
 104         as->end = end;
 105
 106         write_lock_irq(&addr_space_lock);
 107         entry = addr_space.next;
 108
 109         while (list_entry(entry, struct hpsb_address_serve, as_list)->end
 110                <= start) {
 111                 if (list_entry(entry->next, struct hpsb_address_serve, as_list)
 112                     ->start >= end) {
 113                         list_add(&as->as_list, entry);
 114                         list_add_tail(&as->addr_list, &hl->addr_list);
 115                         retval = 1;
 116                         break;
 117                 }
 118                 entry = entry->next;
 119         }
 120         write_unlock_irq(&addr_space_lock);
 121
 122         if (retval == 0) {
 123                 kfree(as);
 124         }
 125
 126         return retval;
 127 }
 128
 129
 130 void hpsb_listen_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
 131                          unsigned int channel)
 132 {
 133         if (channel > 63) {
 134                 HPSB_ERR(__FUNCTION__ " called with invalid channel");
 135                 return;
 136         }
 137
 138         if (host->iso_listen_count[channel]++ == 0) {
 139                 host->template->devctl(host, ISO_LISTEN_CHANNEL, channel);
 140         }
 141 }
 142
 143 void hpsb_unlisten_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
 144                            unsigned int channel)
 145 {
 146         if (channel > 63) {
 147                 HPSB_ERR(__FUNCTION__ " called with invalid channel");
 148                 return;
 149         }
 150
 151         if (--host->iso_listen_count[channel] == 0) {
 152                 host->template->devctl(host, ISO_UNLISTEN_CHANNEL, channel);
 153         }
 154 }
 155
 156
 157 #define DEFINE_MULTIPLEXER(Function) \
 158 void highlevel_##Function(struct hpsb_host *host) \
 159 { \
 160         struct list_head *entry; \
 161         void (*funcptr)(struct hpsb_host*); \
 162         read_lock(&hl_drivers_lock); \
 163         entry = hl_drivers.next; \
 164         while (entry != &hl_drivers) { \
 165                 funcptr = list_entry(entry, struct hpsb_highlevel, hl_list) \
 166                           ->op->Function; \
 167                 if (funcptr) funcptr(host); \
 168                 entry = entry->next; \
 169         } \
 170         read_unlock(&hl_drivers_lock); \
 171 }
 172
 173 DEFINE_MULTIPLEXER(add_host)
 174 DEFINE_MULTIPLEXER(remove_host)
 175 DEFINE_MULTIPLEXER(host_reset)
 176 #undef DEFINE_MULTIPLEXER
 177
 178 void highlevel_iso_receive(struct hpsb_host *host, quadlet_t *data,
 179                            unsigned int length)
 180 {
 181         struct list_head *entry;
 182         struct hpsb_highlevel *hl;
 183         int channel = (data[0] >> 8) & 0x3f;
 184
 185         read_lock(&hl_drivers_lock);
 186         entry = hl_drivers.next;
 187
 188         while (entry != &hl_drivers) {
 189                 hl = list_entry(entry, struct hpsb_highlevel, hl_list);
 190                 if (hl->op->iso_receive) {
 191                         hl->op->iso_receive(host, channel, data, length);
 192                 }
 193                 entry = entry->next;
 194         }
 195         read_unlock(&hl_drivers_lock);
 196 }
 197
 198 void highlevel_fcp_request(struct hpsb_host *host, int nodeid, int direction,
 199                            u8 *data, unsigned int length)
 200 {
 201         struct list_head *entry;
 202         struct hpsb_highlevel *hl;
 203         int cts = data[0];
 204
 205         read_lock(&hl_drivers_lock);
 206         entry = hl_drivers.next;
 207
 208         while (entry != &hl_drivers) {
 209                 hl = list_entry(entry, struct hpsb_highlevel, hl_list);
 210                 if (hl->op->fcp_request) {
 211                         hl->op->fcp_request(host, nodeid, direction, cts, data,
 212                                             length);
 213                 }
 214                 entry = entry->next;
 215         }
 216         read_unlock(&hl_drivers_lock);
 217 }
 218
 219 int highlevel_read(struct hpsb_host *host, int nodeid, quadlet_t *buffer,
 220                    u64 addr, unsigned int length)
 221 {
 222         struct hpsb_address_serve *as;
 223         struct list_head *entry;
 224         unsigned int partlength;
 225         int rcode = RCODE_ADDRESS_ERROR;
 226
 227         read_lock(&addr_space_lock);
 228
 229         entry = addr_space.next;
 230         as = list_entry(entry, struct hpsb_address_serve, as_list);
 231
 232         while (as->start <= addr) {
 233                 if (as->end > addr) {
 234                         partlength = MIN((unsigned int)(as->end - addr),
 235                                          length);
 236
 237                         if (as->op->read != NULL) {
 238                                 rcode = as->op->read(host, nodeid, buffer, addr,
 239                                                      partlength);
 240                         } else {
 241                                 rcode = RCODE_TYPE_ERROR;
 242                         }
 243
 244                         length -= partlength;
 245                         addr += partlength;
 246
 247                         if ((rcode != RCODE_COMPLETE) || !length) {
 248                                 break;
 249                         }
 250                 }
 251
 252                 entry = entry->next;
 253                 as = list_entry(entry, struct hpsb_address_serve, as_list);
 254         }
 255
 256         read_unlock(&addr_space_lock);
 257
 258         if (length && (rcode == RCODE_COMPLETE)) {
 259                 rcode = RCODE_ADDRESS_ERROR;
 260         }
 261
 262         return rcode;
 263 }
 264
 265 int highlevel_write(struct hpsb_host *host, int nodeid, quadlet_t *data,
 266                     u64 addr, unsigned int length)
 267 {
 268         struct hpsb_address_serve *as;
 269         struct list_head *entry;
 270         unsigned int partlength;
 271         int rcode = RCODE_ADDRESS_ERROR;
 272
 273         read_lock(&addr_space_lock);
 274
 275         entry = addr_space.next;
 276         as = list_entry(entry, struct hpsb_address_serve, as_list);
 277
 278         while (as->start <= addr) {
 279                 if (as->end > addr) {
 280                         partlength = MIN((unsigned int)(as->end - addr),
 281                                          length);
 282
 283                         if (as->op->write != NULL) {
 284                                 rcode = as->op->write(host, nodeid, data, addr,
 285                                                       partlength);
 286                         } else {
 287                                 rcode = RCODE_TYPE_ERROR;
 288                         }
 289
 290                         length -= partlength;
 291                         addr += partlength;
 292
 293                         if ((rcode != RCODE_COMPLETE) || !length) {
 294                                 break;
 295                         }
 296                 }
 297
 298                 entry = entry->next;
 299                 as = list_entry(entry, struct hpsb_address_serve, as_list);
 300         }
 301
 302         read_unlock(&addr_space_lock);
 303
 304         if (length && (rcode == RCODE_COMPLETE)) {
 305                 rcode = RCODE_ADDRESS_ERROR;
 306         }
 307
 308         return rcode;
 309 }
 310
 311
 312 int highlevel_lock(struct hpsb_host *host, int nodeid, quadlet_t *store,
 313                    u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode)
 314 {
 315         struct hpsb_address_serve *as;
 316         struct list_head *entry;
 317         int rcode = RCODE_ADDRESS_ERROR;
 318
 319         read_lock(&addr_space_lock);
 320
 321         entry = addr_space.next;
 322         as = list_entry(entry, struct hpsb_address_serve, as_list);
 323
 324         while (as->start <= addr) {
 325                 if (as->end > addr) {
 326                         if (as->op->lock != NULL) {
 327                                 rcode = as->op->lock(host, nodeid, store, addr,
 328                                                      data, arg, ext_tcode);
 329                         } else {
 330                                 rcode = RCODE_TYPE_ERROR;
 331                         }
 332
 333                         break;
 334                 }
 335
 336                 entry = entry->next;
 337                 as = list_entry(entry, struct hpsb_address_serve, as_list);
 338         }
 339
 340         read_unlock(&addr_space_lock);
 341
 342         return rcode;
 343 }
 344
 345 int highlevel_lock64(struct hpsb_host *host, int nodeid, octlet_t *store,
 346                      u64 addr, octlet_t data, octlet_t arg, int ext_tcode)
 347 {
 348         struct hpsb_address_serve *as;
 349         struct list_head *entry;
 350         int rcode = RCODE_ADDRESS_ERROR;
 351
 352         read_lock(&addr_space_lock);
 353
 354         entry = addr_space.next;
 355         as = list_entry(entry, struct hpsb_address_serve, as_list);
 356
 357         while (as->start <= addr) {
 358                 if (as->end > addr) {
 359                         if (as->op->lock64 != NULL) {
 360                                 rcode = as->op->lock64(host, nodeid, store,
 361                                                        addr, data, arg,
 362                                                        ext_tcode);
 363                         } else {
 364                                 rcode = RCODE_TYPE_ERROR;
 365                         }
 366
 367                         break;
 368                 }
 369
 370                 entry = entry->next;
 371                 as = list_entry(entry, struct hpsb_address_serve, as_list);
 372         }
 373
 374         read_unlock(&addr_space_lock);
 375
 376         return rcode;
 377 }
 378
 379
 380
 381 #ifndef MODULE
 382
 383 void register_builtin_highlevels(void)
 384 {
 385 #ifdef CONFIG_IEEE1394_RAWIO
 386         {
 387                 int init_raw1394(void);
 388                 init_raw1394();
 389         }
 390 #endif
 391 }
 392
 393 #endif /* !MODULE */
 394
 395
 396 void init_hpsb_highlevel(void)
 397 {
 398         INIT_LIST_HEAD(&dummy_zero_addr.as_list);
 399         INIT_LIST_HEAD(&dummy_zero_addr.addr_list);
 400         INIT_LIST_HEAD(&dummy_max_addr.as_list);
 401         INIT_LIST_HEAD(&dummy_max_addr.addr_list);
 402
 403         dummy_zero_addr.op = dummy_max_addr.op = &dummy_ops;
 404
 405         dummy_zero_addr.start = dummy_zero_addr.end = 0;
 406         dummy_max_addr.start = dummy_max_addr.end = ((u64) 1) << 48;
 407
 408         list_add_tail(&dummy_zero_addr.as_list, &addr_space);
 409         list_add_tail(&dummy_max_addr.as_list, &addr_space);
 410
 411 #ifndef MODULE
 412         register_builtin_highlevels();
 413 #endif
 414 }