package/lqtapi/src/mps/vmmc-core.c

   1 #include <linux/kernel.h>
   2 #include <linux/module.h>
   3 #include <linux/platform_device.h>
   4 #include <linux/slab.h>
   5 #include <linux/interrupt.h>
   6
   7 #include <linux/firmware.h>
   8
   9 #include <linux/delay.h>
  10
  11 #include <ifxmips_gptu.h>
  12
  13 #include <linux/tapi/tapi.h>
  14
  15 #include "vmmc.h"
  16 #include "mps.h"
  17 #include "mps-msg.h"
  18 #include "mps-irq.h"
  19 #include "vmmc-cmds.h"
  20
  21 #include "vmmc-port.h"
  22 #include "vmmc-stream.h"
  23 #include "vmmc-link.h"
  24 #include "vmmc-coder.h"
  25
  26 struct vmmc_capabilities {
  27         uint8_t num_alm;
  28         uint8_t num_pcm;
  29         uint8_t num_signal;
  30         uint8_t num_coder;
  31         uint8_t num_agc;
  32         uint8_t num_eq;
  33         uint8_t num_nlec;
  34         uint8_t num_wlec;
  35         uint8_t num_nwlec;
  36         uint8_t num_wwlec;
  37         uint8_t num_tone_generators;
  38         uint8_t num_dtmf_generators;
  39         uint8_t num_caller_id_senders;
  40         uint8_t num_caller_id_recivers;
  41 };
  42
  43 #define MPS_FIRMWARE_MAGIC 0xcc123456
  44
  45 struct vmmc_firmware_head {
  46         uint32_t crc;
  47         uint32_t crc_start_addr;
  48         uint32_t crc_end_addr;
  49         uint32_t version;
  50         uint32_t encrypted;
  51         uint32_t magic;
  52         uint32_t mem;
  53 } __packed;
  54
  55 #define VMMC_FIFO_UPSTREAM_CMD_BASE_ADDR        0x00
  56 #define VMMC_FIFO_UPSTREAM_CMD_SIZE_ADDR        0x04
  57 #define VMMC_FIFO_DOWNSTREAM_CMD_BASE_ADDR      0x08
  58 #define VMMC_FIFO_DOWNSTREAM_CMD_SIZE_ADDR      0x0c
  59 #define VMMC_FIFO_UPSTREAM_DATA_BASE_ADDR       0x10
  60 #define VMMC_FIFO_UPSTREAM_DATA_SIZE_ADDR       0x14
  61 #define VMMC_FIFO_DOWNSTREAM_DATA_BASE_ADDR     0x18
  62 #define VMMC_FIFO_DOWNSTREAM_DATA_SIZE_ADDR     0x1c
  63 #define VMMC_FIFO_UPSTREAM_CMD_TAIL_ADDR        0x20
  64 #define VMMC_FIFO_UPSTREAM_CMD_HEAD_ADDR        0x24
  65 #define VMMC_FIFO_DOWNSTREAM_CMD_TAIL_ADDR      0x28
  66 #define VMMC_FIFO_DOWNSTREAM_CMD_HEAD_ADDR      0x2c
  67 #define VMMC_FIFO_UPSTREAM_DATA_TAIL_ADDR       0x30
  68 #define VMMC_FIFO_UPSTREAM_DATA_HEAD_ADDR       0x34
  69 #define VMMC_FIFO_DOWNSTREAM_DATA_TAIL_ADDR     0x38
  70 #define VMMC_FIFO_DOWNSTREAM_DATA_HEAD_ADDR     0x3c
  71
  72 #define VMMC_FIFO_EVENT_BASE_ADDR               0x180
  73 #define VMMC_FIFO_EVENT_SIZE_ADDR               0x184
  74 #define VMMC_FIFO_EVENT_TAIL_ADDR               0x188
  75 #define VMMC_FIFO_EVENT_HEAD_ADDR               0x18c
  76
  77
  78 /* Calculates the base of the fifo behind the given fifo */
  79 #define VMMC_NEXT_FIFO_BASE0(_fifo) \
  80         (VMMC_FIFO_ ## _fifo ## _BASE + VMMC_FIFO_ ## _fifo ## _SIZE)
  81 #define VMMC_NEXT_FIFO_BASE1(_fifo) \
  82         (VMMC_FIFO_ ## _fifo ## _BASE + VMMC_FIFO_ ## _fifo ## _SIZE)
  83 #define VMMC_NEXT_FIFO_BASE2(_fifo) \
  84         (VMMC_FIFO_ ## _fifo ## _BASE + VMMC_FIFO_ ## _fifo ## _SIZE)
  85
  86 /* Fifo sizes */
  87 #define VMMC_FIFO_UPSTREAM_CMD_SIZE     64
  88 #define VMMC_FIFO_DOWNSTREAM_CMD_SIZE   64
  89 #define VMMC_FIFO_UPSTREAM_DATA_SIZE    64
  90 #define VMMC_FIFO_DOWNSTREAM_DATA_SIZE  128
  91 #define VMMC_FIFO_EVENT_SIZE            64
  92
  93 /* Fifo addresses */
  94 #define VMMC_FIFO_UPSTREAM_CMD_BASE     0x40
  95 #define VMMC_FIFO_DOWNSTREAM_CMD_BASE   VMMC_NEXT_FIFO_BASE0(UPSTREAM_CMD)
  96 #define VMMC_FIFO_UPSTREAM_DATA_BASE    VMMC_NEXT_FIFO_BASE1(DOWNSTREAM_CMD)
  97 #define VMMC_FIFO_DOWNSTREAM_DATA_BASE  VMMC_NEXT_FIFO_BASE2(UPSTREAM_DATA)
  98 #define VMMC_FIFO_EVENT_BASE            0x190
  99
 100 #define VMMC_DECLARE_FIFO_CONFIG(_name, _fifo) \
 101 static const struct mps_fifo_config _name = { \
 102         .tail_addr = VMMC_FIFO_ ## _fifo ## _TAIL_ADDR, \
 103         .head_addr = VMMC_FIFO_ ## _fifo ## _HEAD_ADDR, \
 104         .base_addr = VMMC_FIFO_ ## _fifo ## _BASE_ADDR, \
 105         .size_addr = VMMC_FIFO_ ## _fifo ## _SIZE_ADDR, \
 106         .base = VMMC_FIFO_ ## _fifo ## _BASE, \
 107         .size = VMMC_FIFO_ ## _fifo ## _SIZE, \
 108 }
 109
 110 VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_upstream_cmd, UPSTREAM_CMD);
 111 VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_downstream_cmd, DOWNSTREAM_CMD);
 112 VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_upstream_data, UPSTREAM_DATA);
 113 VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_downstream_data, DOWNSTREAM_DATA);
 114 VMMC_DECLARE_FIFO_CONFIG(vmmc_fifo_config_event, EVENT);
 115
 116 static void vmmc_setup_fifos(struct vmmc *vmmc)
 117 {
 118     mps_configure_mailbox(vmmc->mps, &vmmc->mbox_cmd,
 119                 &vmmc_fifo_config_upstream_cmd, &vmmc_fifo_config_downstream_cmd);
 120     mps_configure_mailbox(vmmc->mps, &vmmc->mbox_data,
 121                 &vmmc_fifo_config_upstream_data, &vmmc_fifo_config_downstream_data);
 122
 123     mps_configure_fifo(vmmc->mps, &vmmc->fifo_event, &vmmc_fifo_config_event);
 124 }
 125
 126 static uint32_t cram_data[] = {
 127 0x00200000, 0x00008e59, 0x165235cd, 0x17e2f141, 0xe3eef301, 0x0a431281,
 128 0x04fdf20d, 0x7fe363d5, 0xfd4b7333, 0x7ffffd44, 0xfcf80298, 0xfecd00c9,
 129 0xff900042, 0xfff70003, 0x000923b7, 0xe92a354d, 0xc8981f44, 0x9c0f1257,
 130 0x26aacf33, 0x27db9836, 0x10586f5b, 0x9c167d2d, 0x94b679a7, 0x8c227660,
 131 0x83fa7491, 0x7ce0826a, 0x7ff87ff4, 0x296b4e22, 0x76e67fff, 0x008ffc04,
 132 0x02cbfb36, 0x026afeba, 0x009effc3, 0x0013fffd, 0x23b7e92a, 0x354dc898,
 133 0x1f449c0f, 0x125726aa, 0xcf3327db, 0x98361058, 0x74bc93d6, 0x7ebc8f61,
 134 0x7d068986, 0x7b46833b, 0x7a3b7f00, 0x287a47b1, 0x05800367, 0x20ae2715,
 135 0x0fb5da12, 0x1935f53b, 0x01230240, 0xfc717f00, 0x2000d346,
 136 };
 137
 138 static void vmmc_push_data_paket(struct vmmc *vmmc, int type, unsigned int chan,
 139         void __iomem *addr, size_t len)
 140 {
 141         uint32_t data[3];
 142
 143         data[0] = VMMC_VOICE_DATA(type, chan, 8);
 144         data[1] = CPHYSADDR(addr);
 145         data[2] = len;
 146
 147         mps_fifo_in(&vmmc->mbox_data.downstream, data, 3);
 148 }
 149
 150 static struct sk_buff *vmmc_alloc_data_paket(struct vmmc *vmmc)
 151 {
 152         struct sk_buff *skb;
 153
 154         skb = alloc_skb(512, GFP_KERNEL);
 155
 156         skb_queue_tail(&vmmc->recv_queue, skb);
 157
 158         return skb;
 159 }
 160
 161 static void vmmc_provide_paket(struct vmmc *vmmc)
 162 {
 163         struct sk_buff *skb = vmmc_alloc_data_paket(vmmc);
 164         vmmc_push_data_paket(vmmc, CMD_ADDRESS_PACKET, 0, skb->data, skb->len);
 165 }
 166
 167 static void vmmc_recv_paket(struct vmmc *vmmc, unsigned int chan, void __iomem *addr, size_t len)
 168 {
 169         struct sk_buff *skb;
 170         struct sk_buff *tmp;
 171
 172         skb_queue_walk_safe(&vmmc->recv_queue, skb, tmp) {
 173                 if (skb->data == addr)
 174                         break;
 175         }
 176
 177         if (skb == (struct sk_buff *)(&vmmc->recv_queue)) {
 178                 printk("AHHHH\n");
 179                 return;
 180         }
 181
 182         dma_cache_inv((u32)addr, len);
 183         skb_unlink(skb, &vmmc->recv_queue);
 184
 185         if (!vmmc->coder[chan].stream) {
 186                 kfree_skb(skb);
 187                 return;
 188         }
 189
 190         skb_put(skb, len);
 191         tapi_stream_recv(&vmmc->tdev, vmmc->coder[chan].stream, skb);
 192 }
 193
 194 void vmmc_send_paket(struct vmmc *vmmc, unsigned int chan, struct sk_buff *skb)
 195 {
 196         skb_queue_tail(&vmmc->send_queue, skb);
 197
 198         dma_cache_wback((u32)skb->data, skb->len);
 199         vmmc_push_data_paket(vmmc, CMD_RTP_VOICE_DATA_PACKET, chan, skb->data,
 200                 skb->len);
 201 }
 202
 203 static void vmmc_free_paket(struct vmmc *vmmc, void __iomem *addr, size_t len)
 204 {
 205         struct sk_buff *skb;
 206         struct sk_buff *tmp;
 207
 208         skb_queue_walk_safe(&vmmc->send_queue, skb, tmp) {
 209                 if (skb->data == addr)
 210                         break;
 211         }
 212
 213         if (skb == (struct sk_buff *)(&vmmc->send_queue)) {
 214                 printk("AHHHH\n");
 215         } else {
 216                 skb_unlink(skb, &vmmc->send_queue);
 217                 kfree_skb(skb);
 218         }
 219 }
 220
 221
 222 static void vmmc_write_cram_data(struct vmmc *vmmc, unsigned int id,
 223         uint32_t *data, size_t length)
 224 {
 225         size_t transfer_length;
 226         size_t offset = 0;
 227         uint32_t cmd;
 228
 229         length *= 4;
 230         offset = 0x5;
 231
 232         while (length) {
 233                 transfer_length = length > 56 ? 56 : length;
 234                 cmd = VMMC_CMD_ALM_COEF(id, offset, transfer_length);
 235                 vmmc_command_write(vmmc, cmd, data);
 236
 237                 data += transfer_length >> 2;
 238                 offset += transfer_length >> 1;
 239                 length -= transfer_length;
 240         }
 241 }
 242
 243 int vmmc_command_read(struct vmmc *vmmc, uint32_t cmd, uint32_t *result)
 244 {
 245         struct mps_mailbox *mbox = &vmmc->mbox_cmd;
 246
 247         INIT_COMPLETION(vmmc->cmd_completion);
 248
 249         mps_fifo_in(&mbox->downstream, &cmd, 1);
 250
 251         wait_for_completion(&vmmc->cmd_completion);
 252
 253         mps_fifo_out(&mbox->upstream, result, 1);
 254         mps_fifo_out(&mbox->upstream, result, (*result & 0xff) / 4);
 255
 256         return 0;
 257 }
 258
 259 int vmmc_command_write(struct vmmc *vmmc, uint32_t cmd,
 260         const uint32_t *data)
 261 {
 262         struct mps_mailbox *mbox = &vmmc->mbox_cmd;
 263 /*      int i;
 264
 265         printk("cmd: %x\n", cmd);
 266         for (i = 0; i < DIV_ROUND_UP((cmd & 0xff), 4); ++i) {
 267                 printk("data[%d] = %x\n", i, data[i]);
 268         }
 269 */
 270         while (mps_fifo_len(&mbox->downstream) < (cmd & 0xff) + 4)
 271                 mdelay(100);
 272
 273         mps_fifo_in(&mbox->downstream, &cmd, 1);
 274         mps_fifo_in(&mbox->downstream, data, DIV_ROUND_UP((cmd & 0xff), 4));
 275
 276         mdelay(100);
 277
 278         return 0;
 279 }
 280
 281 static int vmmc_modules_sync(struct tapi_device *tapi)
 282 {
 283         struct vmmc *vmmc = tdev_to_vmmc(tapi);
 284         struct vmmc_module *module;
 285
 286         list_for_each_entry(module, &vmmc->modules, head)
 287                 vmmc_module_sync(module);
 288
 289         return 0;
 290 }
 291
 292 static const struct tapi_ops vmmc_tapi_ops = {
 293         .send_dtmf_event = vmmc_port_send_dtmf_event,
 294         .ring = vmmc_port_ring,
 295
 296         .sync = vmmc_modules_sync,
 297
 298         .stream_alloc = vmmc_stream_alloc,
 299         .stream_free = vmmc_stream_free,
 300         .stream_send = vmmc_stream_send,
 301
 302         .link_alloc = vmmc_tapi_link_alloc,
 303         .link_free = vmmc_tapi_link_free,
 304         .link_enable = vmmc_tapi_link_enable,
 305         .link_disable = vmmc_tapi_link_disable,
 306 };
 307
 308 static void setup_alm(struct vmmc *vmmc)
 309 {
 310         int i;
 311
 312         vmmc->tdev.ports = kcalloc(2, sizeof(*vmmc->tdev.ports), GFP_KERNEL);
 313         vmmc->ports = kcalloc(2, sizeof(*vmmc->ports), GFP_KERNEL);
 314
 315         for (i = 0; i < 2; ++i)
 316                 vmmc_port_init(vmmc, &vmmc->ports[i], &vmmc->tdev.ports[i], i);
 317
 318         skb_queue_head_init(&vmmc->send_queue);
 319         skb_queue_head_init(&vmmc->recv_queue);
 320
 321         for (i = 0; i < 10; ++i)
 322                 vmmc_provide_paket(vmmc);
 323
 324         vmmc->tdev.num_ports = 2;
 325         vmmc->tdev.ops = &vmmc_tapi_ops;
 326         tapi_device_register(&vmmc->tdev, "vmmc", vmmc->dev);
 327 }
 328
 329 static void vmmc_init_timer(struct vmmc *vmmc)
 330 {
 331         unsigned int timer;
 332         unsigned int timer_flags;
 333         int ret;
 334         unsigned long loops, count;
 335
 336         timer = TIMER1B;
 337
 338         timer_flags =
 339           TIMER_FLAG_16BIT | TIMER_FLAG_COUNTER | TIMER_FLAG_CYCLIC |
 340           TIMER_FLAG_DOWN | TIMER_FLAG_FALL_EDGE | TIMER_FLAG_SYNC |
 341           TIMER_FLAG_CALLBACK_IN_IRQ;
 342         ret = ifxmips_request_timer (timer, timer_flags, 1, 0, 0);
 343         if (ret < 0) {
 344                 printk("FAILED TO INIT TIMER\n");
 345                 return;
 346         }
 347         ret = ifxmips_start_timer (timer, 0);
 348         if (ret < 0) {
 349                 printk("FAILED TO START TIMER\n");
 350                 return;
 351         }
 352         do
 353         {
 354                 loops++;
 355                 ifxmips_get_count_value(timer, &count);
 356         } while (count);
 357
 358         *((volatile uint32_t *) (KSEG1 + 0x1e100a00 + 0x0014)) = 0x000005c5;
 359 }
 360
 361 static void vmmc_free_timer(struct vmmc *vmmc)
 362 {
 363         ifxmips_free_timer(TIMER1B);
 364 }
 365
 366 static void vmmc_get_capabilities(struct vmmc *vmmc)
 367 {
 368         uint32_t data[10];
 369         uint8_t len;
 370
 371         vmmc_command_read(vmmc,
 372                 MPS_MSG_CMD_EOP_SYSTEM(SYS_CAP_ECMD, sizeof(uint32_t)), data);
 373
 374         len = ((data[0] >> 16) & 0xff) - sizeof(uint32_t);
 375
 376         if (len > sizeof(data))
 377                 len = sizeof(data);
 378
 379         vmmc_command_read(vmmc,
 380                 MPS_MSG_CMD_EOP_SYSTEM(SYS_CAP_ECMD, len), data);
 381
 382         len /= 4;
 383
 384 /*      for (;len > 0; --len) {
 385                 printk("fw cap(%d): %.2x\n", 10-len, data[10-len]);
 386         }
 387 */
 388         setup_alm(vmmc);
 389 }
 390
 391 static void vmmc_get_firmware_version(struct vmmc *vmmc)
 392 {
 393         uint32_t data[1];
 394
 395         vmmc_command_read(vmmc, MPS_CMD_GET_VERSION, data);
 396
 397         printk("firmware version: %x\n", *data);
 398
 399         vmmc_get_capabilities(vmmc);
 400 }
 401
 402 static irqreturn_t vmmc_firmware_loaded_irq(int irq, void *devid)
 403 {
 404         struct vmmc *vmmc = devid;
 405         complete(&vmmc->firmware_loaded_completion);
 406         printk("Firmware loaded irq\n");
 407
 408         return IRQ_HANDLED;
 409 }
 410
 411 static irqreturn_t vmmc_cmd_error_irq(int irq, void *devid)
 412 {
 413 /*      struct vmmc *vmmc = devid;*/
 414
 415         printk("cmd error!!!!\n");
 416
 417         return IRQ_HANDLED;
 418 }
 419
 420 static irqreturn_t vmmc_recv_ov_irq(int irq, void *devid)
 421 {
 422         struct vmmc *vmmc = devid;
 423         uint32_t data[2] = {
 424                 VMMC_CMD_SERR_ACK(0),
 425                 VMMC_CMD_SERR_ACK_DATA1(1)
 426         };
 427         uint32_t voice_data[64];
 428
 429         return IRQ_HANDLED;
 430
 431         mps_fifo_in(&vmmc->mbox_cmd.downstream, data, 2);
 432         mps_fifo_out(&vmmc->mbox_data.upstream, voice_data, 15);
 433
 434         printk("recv overflow: %x\n", voice_data[0]);
 435
 436         return IRQ_HANDLED;
 437 }
 438
 439 static irqreturn_t vmmc_event_fifo_irq(int irq, void *devid)
 440 {
 441         struct vmmc *vmmc = devid;
 442         uint32_t event, event_id;
 443         uint32_t data = 0;
 444         unsigned int chan;
 445
 446         mps_fifo_out(&vmmc->fifo_event, &event, 1);
 447
 448         event_id = event & VMMC_EVENT_ID_MASK;
 449         chan = VMMC_MSG_GET_CHAN(event);
 450
 451         if (event & 0xff)
 452                 mps_fifo_out(&vmmc->fifo_event, &data, 1);
 453
 454         switch (event_id) {
 455         case VMMC_EVENT_HOOK_ID:
 456                 vmmc_alm_hook_event_handler(vmmc, chan, data);
 457                 break;
 458         case VMMC_EVENT_DTMF_ID:
 459                 vmmc_sig_dtmf_event_handler(vmmc, chan, data);
 460                 break;
 461         default:
 462                 printk("Ein unbekanntes Event: %x %x\n", event, data);
 463                 break;
 464         }
 465
 466         return IRQ_HANDLED;
 467 }
 468
 469 static irqreturn_t vmmc_mbox_data_irq_handler(int irq, void *devid)
 470 {
 471         struct vmmc *vmmc = devid;
 472         struct mps_mailbox *mbox = &vmmc->mbox_data;
 473         unsigned int count, type, chan;
 474         uint32_t data[2];
 475         void __iomem *addr;
 476         size_t len;
 477
 478         mps_fifo_out(&mbox->upstream, data, 1);
 479
 480         count = (data[0] & 0xff) / 8;
 481         type = (data[0] >> 24) & 0xff;
 482         chan = (data[0] >> 16) & 0xff;
 483
 484         while (count) {
 485                 mps_fifo_out(&mbox->upstream, data, 2);
 486
 487                 addr = (void __iomem *)CKSEG0ADDR(data[0]);
 488                 len = data[1];
 489
 490                 switch (type) {
 491                 case CMD_ADDRESS_PACKET:
 492                         vmmc_free_paket(vmmc, addr, len);
 493                         break;
 494                 case CMD_RTP_VOICE_DATA_PACKET:
 495                         vmmc_provide_paket(vmmc);
 496                         vmmc_recv_paket(vmmc, chan, addr, len);
 497                         break;
 498                 }
 499                 --count;
 500         }
 501
 502         return IRQ_HANDLED;
 503 }
 504
 505 static irqreturn_t vmmc_mbox_cmd_irq_handler(int irq, void *devid)
 506 {
 507         struct vmmc *vmmc = devid;
 508
 509         complete(&vmmc->cmd_completion);
 510
 511         return IRQ_HANDLED;
 512 }
 513
 514 static void vmmc_load_firmware(const struct firmware *fw, void *context)
 515 {
 516         struct vmmc *vmmc = context;
 517         struct vmmc_firmware_head *fw_head;
 518         size_t tail_size;
 519         enum mps_boot_config config;
 520
 521         if (!fw) {
 522                 printk("failed to load tapi firmware\n");
 523 //              request_firmware_nowait(THIS_MODULE, 1, "danube_firmware.bin", vmmc->dev,
 524 //                      GFP_KERNEL, vmmc, vmmc_load_firmware);
 525                 return;
 526         }
 527
 528         if (fw->size < sizeof(*fw_head))
 529                 return;
 530
 531         fw_head = (struct vmmc_firmware_head *)((uint8_t *)fw->data + fw->size - sizeof(*fw_head));
 532
 533         if (fw_head->magic != MPS_FIRMWARE_MAGIC) {
 534                 config = MPS_BOOT_LEGACY;
 535                 tail_size = sizeof(uint32_t);
 536         } else {
 537                 config = MPS_BOOT_ENCRYPTED;
 538                 tail_size = sizeof(*fw_head) - sizeof(uint32_t);
 539         }
 540
 541         vmmc_setup_fifos(vmmc);
 542         init_completion(&vmmc->firmware_loaded_completion);
 543         mps_load_firmware(vmmc->mps, fw->data, fw->size - tail_size, config);
 544         wait_for_completion_timeout(&vmmc->firmware_loaded_completion, 5*HZ);
 545         vmmc_init_timer(vmmc);
 546         vmmc_write_cram_data(vmmc, 0, cram_data, ARRAY_SIZE(cram_data));
 547         vmmc_write_cram_data(vmmc, 1, cram_data, ARRAY_SIZE(cram_data));
 548         vmmc_get_firmware_version(vmmc);
 549         vmmc_init_coders(vmmc);
 550 }
 551
 552 static int vmmc_request_irqs(struct vmmc *vmmc)
 553 {
 554         int ret;
 555
 556         ret = request_irq(vmmc->irq_fw_loaded, vmmc_firmware_loaded_irq, 0, "vmmc fw loaded", vmmc);
 557         ret = request_irq(vmmc->irq_event_fifo, vmmc_event_fifo_irq, 0, "vmmc event fifo", vmmc);
 558         ret = request_irq(vmmc->irq_cmd_error, vmmc_cmd_error_irq, 0,
 559                 "cmd error irq", vmmc);
 560         ret = request_irq(MPS_IRQ_RCV_OVERFLOW, vmmc_recv_ov_irq, 0,
 561                 "recv_ov irq", vmmc);
 562
 563         ret = request_irq(vmmc->irq_mbox_cmd, vmmc_mbox_cmd_irq_handler, 0,
 564                 "vmmc cmd mailbox irq", vmmc);
 565
 566         ret = request_irq(vmmc->irq_mbox_data, vmmc_mbox_data_irq_handler, 0,
 567                 "vmmc data mailbox irq", vmmc);
 568
 569         return ret;
 570 }
 571
 572 static int __devinit vmmc_probe(struct platform_device *pdev)
 573 {
 574         struct vmmc *vmmc;
 575         int ret = 0;
 576
 577         vmmc = kzalloc(sizeof(*vmmc), GFP_KERNEL);
 578
 579         if (!vmmc)
 580                 return -ENOMEM;
 581
 582         vmmc->dev = &pdev->dev;
 583         vmmc->mps = device_to_mps(pdev->dev.parent);
 584
 585         if (!vmmc->mps) {
 586                 goto err_free;
 587                 ret = -EBUSY;
 588         }
 589
 590         INIT_LIST_HEAD(&vmmc->modules);
 591         init_completion(&vmmc->cmd_completion);
 592
 593         vmmc->irq_fw_loaded = MPS_IRQ_DOWNLOAD_DONE;
 594         vmmc->irq_mbox_cmd = MPS_IRQ_CMD_UPSTREAM;
 595         vmmc->irq_mbox_data = MPS_IRQ_DATA_UPSTREAM;
 596         vmmc->irq_event_fifo = MPS_IRQ_EVENT;
 597         vmmc->irq_cmd_error = MPS_IRQ_CMD_ERROR;
 598
 599         platform_set_drvdata(pdev, vmmc);
 600
 601         vmmc_request_irqs(vmmc);
 602
 603         request_firmware_nowait(THIS_MODULE, 1, "danube_firmware.bin", &pdev->dev,
 604                 GFP_KERNEL, vmmc, vmmc_load_firmware);
 605
 606         return 0;
 607
 608 err_free:
 609         kfree(vmmc);
 610
 611         return ret;
 612 }
 613
 614 static int __devexit vmmc_remove(struct platform_device *pdev)
 615 {
 616         struct vmmc *vmmc = platform_get_drvdata(pdev);
 617         vmmc_free_timer(vmmc);
 618
 619         tapi_device_unregister(&vmmc->tdev);
 620
 621         return 0;
 622 }
 623
 624 static struct platform_driver vmmc_driver = {
 625         .probe = vmmc_probe,
 626         .remove = __devexit_p(vmmc_remove),
 627         .driver = {
 628                 .name = "vmmc",
 629                 .owner = THIS_MODULE
 630         },
 631 };
 632
 633 static int __init vmmc_init(void)
 634 {
 635         return platform_driver_register(&vmmc_driver);
 636 }
 637 module_init(vmmc_init);
 638
 639 static void __exit vmmc_exit(void)
 640 {
 641         platform_driver_unregister(&vmmc_driver);
 642 }
 643 module_exit(vmmc_exit);
 644
 645 MODULE_LICENSE("GPL");
 646 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");