target/linux/brcm2708/patches-4.1/0117-BCM270x-Switch-to-firmware-driver.patch

   1 From 3349eaf79dd91c2e6f9b7aed0c155668e4f5a856 Mon Sep 17 00:00:00 2001
   2 From: =?UTF-8?q?Noralf=20Tr=C3=B8nnes?= <noralf@tronnes.org>
   3 Date: Fri, 26 Jun 2015 14:37:19 +0200
   4 Subject: [PATCH 117/121] BCM270x: Switch to firmware driver
   5 MIME-Version: 1.0
   6 Content-Type: text/plain; charset=UTF-8
   7 Content-Transfer-Encoding: 8bit
   8
   9 defconfig: enable BCM2835_MBOX, RASPBERRYPI_FIRMWARE and BCM_VCIO.
  10 Add firmware node and change mailbox node in Device Tree.
  11 Add/update platform file for firmware and mailbox.
  12 Strip bcm2708-vcio of everything except the legacy API and hook it
  13 up with the firmware driver.
  14
  15 Signed-off-by: Noralf Trønnes <noralf@tronnes.org>
  16 ---
  17  arch/arm/boot/dts/bcm2708_common.dtsi |   8 +-
  18  arch/arm/configs/bcm2709_defconfig    |   3 +
  19  arch/arm/configs/bcmrpi_defconfig     |   3 +
  20  arch/arm/mach-bcm2708/bcm2708.c       |  13 +-
  21  arch/arm/mach-bcm2709/bcm2709.c       |  13 +-
  22  drivers/mailbox/Kconfig               |   2 +-
  23  drivers/mailbox/bcm2708-vcio.c        | 353 ++--------------------------------
  24  7 files changed, 51 insertions(+), 344 deletions(-)
  25
  26 --- a/arch/arm/boot/dts/bcm2708_common.dtsi
  27 +++ b/arch/arm/boot/dts/bcm2708_common.dtsi
  28 @@ -74,9 +74,10 @@
  29                 };
  30
  31                 mailbox: mailbox@7e00b800 {
  32 -                       compatible = "brcm,bcm2708-vcio";
  33 +                       compatible = "brcm,bcm2835-mbox";
  34                         reg = <0x7e00b880 0x40>;
  35                         interrupts = <0 1>;
  36 +                       #mbox-cells = <0>;
  37                 };
  38
  39                 watchdog: watchdog@7e100000 {
  40 @@ -205,6 +206,11 @@
  41                                      <1 9>;
  42                 };
  43
  44 +               firmware: firmware {
  45 +                       compatible = "raspberrypi,bcm2835-firmware";
  46 +                       mboxes = <&mailbox>;
  47 +               };
  48 +
  49                 leds: leds {
  50                         compatible = "gpio-leds";
  51                 };
  52 --- a/arch/arm/configs/bcm2709_defconfig
  53 +++ b/arch/arm/configs/bcm2709_defconfig
  54 @@ -574,6 +574,7 @@ CONFIG_HW_RANDOM_BCM2708=m
  55  CONFIG_RAW_DRIVER=y
  56  CONFIG_BRCM_CHAR_DRIVERS=y
  57  CONFIG_BCM_VC_CMA=y
  58 +CONFIG_BCM_VCIO=y
  59  CONFIG_BCM_VC_SM=y
  60  CONFIG_I2C=y
  61  CONFIG_I2C_CHARDEV=m
  62 @@ -1074,6 +1075,7 @@ CONFIG_FB_FLEX=m
  63  CONFIG_FB_TFT_FBTFT_DEVICE=m
  64  CONFIG_MAILBOX=y
  65  CONFIG_BCM2708_MBOX=y
  66 +CONFIG_BCM2835_MBOX=y
  67  # CONFIG_IOMMU_SUPPORT is not set
  68  CONFIG_EXTCON=m
  69  CONFIG_EXTCON_ARIZONA=m
  70 @@ -1082,6 +1084,7 @@ CONFIG_IIO_BUFFER=y
  71  CONFIG_IIO_BUFFER_CB=y
  72  CONFIG_IIO_KFIFO_BUF=m
  73  CONFIG_DHT11=m
  74 +CONFIG_RASPBERRYPI_FIRMWARE=y
  75  CONFIG_EXT4_FS=y
  76  CONFIG_EXT4_FS_POSIX_ACL=y
  77  CONFIG_EXT4_FS_SECURITY=y
  78 --- a/arch/arm/configs/bcmrpi_defconfig
  79 +++ b/arch/arm/configs/bcmrpi_defconfig
  80 @@ -567,6 +567,7 @@ CONFIG_HW_RANDOM_BCM2708=m
  81  CONFIG_RAW_DRIVER=y
  82  CONFIG_BRCM_CHAR_DRIVERS=y
  83  CONFIG_BCM_VC_CMA=y
  84 +CONFIG_BCM_VCIO=y
  85  CONFIG_BCM_VC_SM=y
  86  CONFIG_I2C=y
  87  CONFIG_I2C_CHARDEV=m
  88 @@ -1067,6 +1068,7 @@ CONFIG_FB_FLEX=m
  89  CONFIG_FB_TFT_FBTFT_DEVICE=m
  90  CONFIG_MAILBOX=y
  91  CONFIG_BCM2708_MBOX=y
  92 +CONFIG_BCM2835_MBOX=y
  93  # CONFIG_IOMMU_SUPPORT is not set
  94  CONFIG_EXTCON=m
  95  CONFIG_EXTCON_ARIZONA=m
  96 @@ -1075,6 +1077,7 @@ CONFIG_IIO_BUFFER=y
  97  CONFIG_IIO_BUFFER_CB=y
  98  CONFIG_IIO_KFIFO_BUF=m
  99  CONFIG_DHT11=m
 100 +CONFIG_RASPBERRYPI_FIRMWARE=y
 101  CONFIG_EXT4_FS=y
 102  CONFIG_EXT4_FS_POSIX_ACL=y
 103  CONFIG_EXT4_FS_SECURITY=y
 104 --- a/arch/arm/mach-bcm2708/bcm2708.c
 105 +++ b/arch/arm/mach-bcm2708/bcm2708.c
 106 @@ -405,7 +405,7 @@ static struct resource bcm2708_vcio_reso
 107  static u64 vcio_dmamask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON);
 108
 109  static struct platform_device bcm2708_vcio_device = {
 110 -       .name = "bcm2708_vcio",
 111 +       .name = "bcm2835-mbox",
 112         .id = -1,               /* only one VideoCore I/O area */
 113         .resource = bcm2708_vcio_resources,
 114         .num_resources = ARRAY_SIZE(bcm2708_vcio_resources),
 115 @@ -415,6 +415,16 @@ static struct platform_device bcm2708_vc
 116                 },
 117  };
 118
 119 +static u64 rpifw_dmamask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON);
 120 +
 121 +static struct platform_device bcm2708_rpifw_device = {
 122 +       .name = "raspberrypi-firmware",
 123 +       .dev = {
 124 +               .dma_mask = &rpifw_dmamask,
 125 +               .coherent_dma_mask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON),
 126 +       },
 127 +};
 128 +
 129  static struct resource bcm2708_vchiq_resources[] = {
 130         {
 131                 .start = ARMCTRL_0_BELL_BASE,
 132 @@ -871,6 +881,7 @@ void __init bcm2708_init(void)
 133
 134         bcm_register_device_dt(&bcm2708_dmaengine_device);
 135         bcm_register_device_dt(&bcm2708_vcio_device);
 136 +       bcm_register_device_dt(&bcm2708_rpifw_device);
 137         bcm_register_device_dt(&bcm2708_vchiq_device);
 138  #ifdef CONFIG_BCM2708_GPIO
 139         bcm_register_device_dt(&bcm2708_gpio_device);
 140 --- a/arch/arm/mach-bcm2709/bcm2709.c
 141 +++ b/arch/arm/mach-bcm2709/bcm2709.c
 142 @@ -426,7 +426,7 @@ static struct resource bcm2708_vcio_reso
 143  static u64 vcio_dmamask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON);
 144
 145  static struct platform_device bcm2708_vcio_device = {
 146 -       .name = "bcm2708_vcio",
 147 +       .name = "bcm2835-mbox",
 148         .id = -1,               /* only one VideoCore I/O area */
 149         .resource = bcm2708_vcio_resources,
 150         .num_resources = ARRAY_SIZE(bcm2708_vcio_resources),
 151 @@ -436,6 +436,16 @@ static struct platform_device bcm2708_vc
 152                 },
 153  };
 154
 155 +static u64 rpifw_dmamask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON);
 156 +
 157 +static struct platform_device bcm2708_rpifw_device = {
 158 +       .name = "raspberrypi-firmware",
 159 +       .dev = {
 160 +               .dma_mask = &rpifw_dmamask,
 161 +               .coherent_dma_mask = DMA_BIT_MASK(DMA_MASK_BITS_COMMON),
 162 +       },
 163 +};
 164 +
 165  static struct resource bcm2708_vchiq_resources[] = {
 166         {
 167                 .start = ARMCTRL_0_BELL_BASE,
 168 @@ -892,6 +902,7 @@ void __init bcm2709_init(void)
 169
 170         bcm_register_device_dt(&bcm2708_dmaengine_device);
 171         bcm_register_device_dt(&bcm2708_vcio_device);
 172 +       bcm_register_device_dt(&bcm2708_rpifw_device);
 173         bcm_register_device_dt(&bcm2708_vchiq_device);
 174  #ifdef CONFIG_BCM2708_GPIO
 175         bcm_register_device_dt(&bcm2708_gpio_device);
 176 --- a/drivers/mailbox/Kconfig
 177 +++ b/drivers/mailbox/Kconfig
 178 @@ -9,7 +9,7 @@ if MAILBOX
 179
 180  config BCM2708_MBOX
 181         bool "Broadcom BCM2708 Mailbox (vcio)"
 182 -       depends on MACH_BCM2708 || MACH_BCM2709 || ARCH_BCM2835
 183 +       depends on BCM2835_MBOX
 184         help
 185           Broadcom BCM2708 Mailbox (vcio)
 186
 187 --- a/drivers/mailbox/bcm2708-vcio.c
 188 +++ b/drivers/mailbox/bcm2708-vcio.c
 189 @@ -1,6 +1,4 @@
 190  /*
 191 - *  linux/arch/arm/mach-bcm2708/vcio.c
 192 - *
 193   *  Copyright (C) 2010 Broadcom
 194   *
 195   * This program is free software; you can redistribute it and/or modify
 196 @@ -12,195 +10,38 @@
 197   * VideoCore processor
 198   */
 199
 200 -#include <linux/device.h>
 201  #include <linux/dma-mapping.h>
 202 -#include <linux/module.h>
 203 -#include <linux/errno.h>
 204 -#include <linux/fs.h>
 205  #include <linux/init.h>
 206 -#include <linux/interrupt.h>
 207 -#include <linux/io.h>
 208 -#include <linux/ioctl.h>
 209 +#include <linux/module.h>
 210  #include <linux/platform_data/mailbox-bcm2708.h>
 211 -#include <linux/platform_device.h>
 212  #include <linux/uaccess.h>
 213 +#include <soc/bcm2835/raspberrypi-firmware.h>
 214
 215  #define DRIVER_NAME "bcm2708_vcio"
 216 -#define DEVICE_FILE_NAME "vcio"
 217 -
 218 -/* offsets from a mail box base address */
 219 -#define MAIL0_RD       0x00    /* read - and next 4 words */
 220 -#define MAIL0_POL      0x10    /* read without popping the fifo */
 221 -#define MAIL0_SND      0x14    /* sender ID (bottom two bits) */
 222 -#define MAIL0_STA      0x18    /* status */
 223 -#define MAIL0_CNF      0x1C    /* configuration */
 224 -#define MAIL1_WRT      0x20    /* write - and next 4 words */
 225 -#define MAIL1_STA      0x38    /* status */
 226 -
 227 -/* On MACH_BCM270x these come through <linux/interrupt.h> (arm_control.h ) */
 228 -#ifndef ARM_MS_EMPTY
 229 -#define ARM_MS_EMPTY   BIT(30)
 230 -#define ARM_MS_FULL    BIT(31)
 231 -
 232 -#define ARM_MC_IHAVEDATAIRQEN  BIT(0)
 233 -#endif
 234 -
 235 -#define MBOX_MSG(chan, data28)         (((data28) & ~0xf) | ((chan) & 0xf))
 236 -#define MBOX_MSG_LSB(chan, data28)     (((data28) << 4) | ((chan) & 0xf))
 237 -#define MBOX_CHAN(msg)                 ((msg) & 0xf)
 238 -#define MBOX_DATA28(msg)               ((msg) & ~0xf)
 239 -#define MBOX_DATA28_LSB(msg)           (((uint32_t)msg) >> 4)
 240 -
 241 -#define MBOX_MAGIC 0xd0d0c0de
 242 -
 243 -#define MAJOR_NUM 100
 244 -#define IOCTL_MBOX_PROPERTY _IOWR(MAJOR_NUM, 0, char *)
 245 -
 246 -static struct class *vcio_class;
 247 -
 248 -struct vc_mailbox {
 249 -       void __iomem *regs;
 250 -       uint32_t msg[MBOX_CHAN_COUNT];
 251 -       struct semaphore sema[MBOX_CHAN_COUNT];
 252 -       uint32_t magic;
 253 -};
 254 -
 255 -static void mbox_init(struct vc_mailbox *mbox_out)
 256 -{
 257 -       int i;
 258 -
 259 -       for (i = 0; i < MBOX_CHAN_COUNT; i++) {
 260 -               mbox_out->msg[i] = 0;
 261 -               sema_init(&mbox_out->sema[i], 0);
 262 -       }
 263 -
 264 -       /* Enable the interrupt on data reception */
 265 -       writel(ARM_MC_IHAVEDATAIRQEN, mbox_out->regs + MAIL0_CNF);
 266 -
 267 -       mbox_out->magic = MBOX_MAGIC;
 268 -}
 269 -
 270 -static int mbox_write(struct vc_mailbox *mbox, unsigned chan, uint32_t data28)
 271 -{
 272 -       if (mbox->magic != MBOX_MAGIC)
 273 -               return -EINVAL;
 274 -
 275 -       /* wait for the mailbox FIFO to have some space in it */
 276 -       while (0 != (readl(mbox->regs + MAIL1_STA) & ARM_MS_FULL))
 277 -               cpu_relax();
 278 -
 279 -       writel(MBOX_MSG(chan, data28), mbox->regs + MAIL1_WRT);
 280 -
 281 -       return 0;
 282 -}
 283 -
 284 -static int mbox_read(struct vc_mailbox *mbox, unsigned chan, uint32_t *data28)
 285 -{
 286 -       if (mbox->magic != MBOX_MAGIC)
 287 -               return -EINVAL;
 288 -
 289 -       down(&mbox->sema[chan]);
 290 -       *data28 = MBOX_DATA28(mbox->msg[chan]);
 291 -       mbox->msg[chan] = 0;
 292 -
 293 -       return 0;
 294 -}
 295 -
 296 -static irqreturn_t mbox_irq_handler(int irq, void *dev_id)
 297 -{
 298 -       /* wait for the mailbox FIFO to have some data in it */
 299 -       struct vc_mailbox *mbox = (struct vc_mailbox *)dev_id;
 300 -       int status = readl(mbox->regs + MAIL0_STA);
 301 -       int ret = IRQ_NONE;
 302 -
 303 -       while (!(status & ARM_MS_EMPTY)) {
 304 -               uint32_t msg = readl(mbox->regs + MAIL0_RD);
 305 -               int chan = MBOX_CHAN(msg);
 306 -
 307 -               if (chan < MBOX_CHAN_COUNT) {
 308 -                       if (mbox->msg[chan]) {
 309 -                               pr_err(DRIVER_NAME
 310 -                                      ": mbox chan %d overflow - drop %08x\n",
 311 -                                      chan, msg);
 312 -                       } else {
 313 -                               mbox->msg[chan] = (msg | 0xf);
 314 -                               up(&mbox->sema[chan]);
 315 -                       }
 316 -               } else {
 317 -                       pr_err(DRIVER_NAME
 318 -                              ": invalid channel selector (msg %08x)\n", msg);
 319 -               }
 320 -               ret = IRQ_HANDLED;
 321 -               status = readl(mbox->regs + MAIL0_STA);
 322 -       }
 323 -       return ret;
 324 -}
 325 -
 326 -/* Mailbox Methods */
 327 -
 328 -static struct device *mbox_dev;        /* we assume there's only one! */
 329 -
 330 -static int dev_mbox_write(struct device *dev, unsigned chan, uint32_t data28)
 331 -{
 332 -       struct vc_mailbox *mailbox = dev_get_drvdata(dev);
 333 -       int rc;
 334 -
 335 -       device_lock(dev);
 336 -       rc = mbox_write(mailbox, chan, data28);
 337 -       device_unlock(dev);
 338 -
 339 -       return rc;
 340 -}
 341 -
 342 -static int dev_mbox_read(struct device *dev, unsigned chan, uint32_t *data28)
 343 -{
 344 -       struct vc_mailbox *mailbox = dev_get_drvdata(dev);
 345 -       int rc;
 346 -
 347 -       device_lock(dev);
 348 -       rc = mbox_read(mailbox, chan, data28);
 349 -       device_unlock(dev);
 350 -
 351 -       return rc;
 352 -}
 353
 354  extern int bcm_mailbox_write(unsigned chan, uint32_t data28)
 355  {
 356 -       if (!mbox_dev)
 357 +       struct rpi_firmware *fw = rpi_firmware_get(NULL);
 358 +
 359 +       if (!fw)
 360                 return -ENODEV;
 361
 362 -       return dev_mbox_write(mbox_dev, chan, data28);
 363 +       return rpi_firmware_transaction(fw, chan, data28);
 364  }
 365  EXPORT_SYMBOL_GPL(bcm_mailbox_write);
 366
 367  extern int bcm_mailbox_read(unsigned chan, uint32_t *data28)
 368  {
 369 -       if (!mbox_dev)
 370 -               return -ENODEV;
 371 -
 372 -       return dev_mbox_read(mbox_dev, chan, data28);
 373 -}
 374 -EXPORT_SYMBOL_GPL(bcm_mailbox_read);
 375 -
 376 -static int mbox_copy_from_user(void *dst, const void *src, int size)
 377 -{
 378 -       if ((uint32_t)src < TASK_SIZE)
 379 -               return copy_from_user(dst, src, size);
 380 -
 381 -       memcpy(dst, src, size);
 382 +       struct rpi_firmware *fw = rpi_firmware_get(NULL);
 383
 384 -       return 0;
 385 -}
 386 -
 387 -static int mbox_copy_to_user(void *dst, const void *src, int size)
 388 -{
 389 -       if ((uint32_t)dst < TASK_SIZE)
 390 -               return copy_to_user(dst, src, size);
 391 +       if (!fw)
 392 +               return -ENODEV;
 393
 394 -       memcpy(dst, src, size);
 395 +       *data28 = rpi_firmware_transaction_received(fw);
 396
 397         return 0;
 398  }
 399 +EXPORT_SYMBOL_GPL(bcm_mailbox_read);
 400
 401  static DEFINE_MUTEX(mailbox_lock);
 402  extern int bcm_mailbox_property(void *data, int size)
 403 @@ -216,7 +57,7 @@ extern int bcm_mailbox_property(void *da
 404                                       GFP_KERNEL);
 405         if (mem_kern) {
 406                 /* create the message */
 407 -               mbox_copy_from_user(mem_kern, data, size);
 408 +               memcpy(mem_kern, data, size);
 409
 410                 /* send the message */
 411                 wmb();
 412 @@ -226,7 +67,7 @@ extern int bcm_mailbox_property(void *da
 413                 if (s == 0) {
 414                         /* copy the response */
 415                         rmb();
 416 -                       mbox_copy_to_user(data, mem_kern, size);
 417 +                       memcpy(data, mem_kern, size);
 418                 }
 419                 dma_free_coherent(NULL, PAGE_ALIGN(size), mem_kern, mem_bus);
 420         } else {
 421 @@ -240,174 +81,6 @@ extern int bcm_mailbox_property(void *da
 422  }
 423  EXPORT_SYMBOL_GPL(bcm_mailbox_property);
 424
 425 -/* Platform Device for Mailbox */
 426 -
 427 -/* This is called whenever a process attempts to open the device file */
 428 -static int device_open(struct inode *inode, struct file *file)
 429 -{
 430 -       try_module_get(THIS_MODULE);
 431 -
 432 -       return 0;
 433 -}
 434 -
 435 -static int device_release(struct inode *inode, struct file *file)
 436 -{
 437 -       module_put(THIS_MODULE);
 438 -
 439 -       return 0;
 440 -}
 441 -
 442 -/*
 443 - * This function is called whenever a process tries to do an ioctl on our
 444 - * device file. We get two extra parameters (additional to the inode and file
 445 - * structures, which all device functions get): the number of the ioctl called
 446 - * and the parameter given to the ioctl function.
 447 - *
 448 - * If the ioctl is write or read/write (meaning output is returned to the
 449 - * calling process), the ioctl call returns the output of this function.
 450 - *
 451 - */
 452 -static long device_ioctl(struct file *file, unsigned int ioctl_num,
 453 -                        unsigned long ioctl_param)
 454 -{
 455 -       unsigned size;
 456 -
 457 -       switch (ioctl_num) {
 458 -       case IOCTL_MBOX_PROPERTY:
 459 -               /*
 460 -                * Receive a pointer to a message (in user space) and set that
 461 -                * to be the device's message.  Get the parameter given to
 462 -                * ioctl by the process.
 463 -                */
 464 -               mbox_copy_from_user(&size, (void *)ioctl_param, sizeof(size));
 465 -               return bcm_mailbox_property((void *)ioctl_param, size);
 466 -       default:
 467 -               pr_err(DRIVER_NAME "unknown ioctl: %d\n", ioctl_num);
 468 -               return -EINVAL;
 469 -       }
 470 -
 471 -       return 0;
 472 -}
 473 -
 474 -/* Module Declarations */
 475 -
 476 -/*
 477 - * This structure will hold the functions to be called
 478 - * when a process does something to the device we
 479 - * created. Since a pointer to this structure is kept in
 480 - * the devices table, it can't be local to
 481 - * init_module. NULL is for unimplemented functios.
 482 - */
 483 -const struct file_operations fops = {
 484 -       .unlocked_ioctl = device_ioctl,
 485 -       .open = device_open,
 486 -       .release = device_release,      /* a.k.a. close */
 487 -};
 488 -
 489 -static int bcm_vcio_probe(struct platform_device *pdev)
 490 -{
 491 -       struct device *dev = &pdev->dev;
 492 -       struct device *vdev;
 493 -       struct vc_mailbox *mailbox;
 494 -       struct resource *res;
 495 -       int irq, ret;
 496 -
 497 -       mailbox = devm_kzalloc(dev, sizeof(*mailbox), GFP_KERNEL);
 498 -       if (!mailbox)
 499 -               return -ENOMEM;
 500 -
 501 -       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 502 -       mailbox->regs = devm_ioremap_resource(dev, res);
 503 -       if (IS_ERR(mailbox->regs))
 504 -               return PTR_ERR(mailbox->regs);
 505 -
 506 -       irq = platform_get_irq(pdev, 0);
 507 -       ret = devm_request_irq(dev, irq, mbox_irq_handler,
 508 -                              IRQF_IRQPOLL,
 509 -                              dev_name(dev), mailbox);
 510 -       if (ret) {
 511 -               dev_err(dev, "Interrupt request failed %d\n", ret);
 512 -               return ret;
 513 -       }
 514 -
 515 -       ret = register_chrdev(MAJOR_NUM, DEVICE_FILE_NAME, &fops);
 516 -       if (ret < 0) {
 517 -               pr_err("Character device registration failed %d\n", ret);
 518 -               return ret;
 519 -       }
 520 -
 521 -       vcio_class = class_create(THIS_MODULE, DRIVER_NAME);
 522 -       if (IS_ERR(vcio_class)) {
 523 -               ret = PTR_ERR(vcio_class);
 524 -               pr_err("Class creation failed %d\n", ret);
 525 -               goto err_class;
 526 -       }
 527 -
 528 -       vdev = device_create(vcio_class, NULL, MKDEV(MAJOR_NUM, 0), NULL,
 529 -                            "vcio");
 530 -       if (IS_ERR(vdev)) {
 531 -               ret = PTR_ERR(vdev);
 532 -               pr_err("Device creation failed %d\n", ret);
 533 -               goto err_dev;
 534 -       }
 535 -
 536 -       mbox_init(mailbox);
 537 -       platform_set_drvdata(pdev, mailbox);
 538 -       mbox_dev = dev;
 539 -
 540 -       dev_info(dev, "mailbox at %p\n", mailbox->regs);
 541 -
 542 -       return 0;
 543 -
 544 -err_dev:
 545 -       class_destroy(vcio_class);
 546 -err_class:
 547 -       unregister_chrdev(MAJOR_NUM, DEVICE_FILE_NAME);
 548 -
 549 -       return ret;
 550 -}
 551 -
 552 -static int bcm_vcio_remove(struct platform_device *pdev)
 553 -{
 554 -       mbox_dev = NULL;
 555 -       platform_set_drvdata(pdev, NULL);
 556 -       device_destroy(vcio_class, MKDEV(MAJOR_NUM, 0));
 557 -       class_destroy(vcio_class);
 558 -       unregister_chrdev(MAJOR_NUM, DEVICE_FILE_NAME);
 559 -
 560 -       return 0;
 561 -}
 562 -
 563 -static const struct of_device_id bcm_vcio_of_match_table[] = {
 564 -       { .compatible = "brcm,bcm2708-vcio", },
 565 -       {},
 566 -};
 567 -MODULE_DEVICE_TABLE(of, bcm_vcio_of_match_table);
 568 -
 569 -static struct platform_driver bcm_mbox_driver = {
 570 -       .probe = bcm_vcio_probe,
 571 -       .remove = bcm_vcio_remove,
 572 -
 573 -       .driver = {
 574 -                  .name = DRIVER_NAME,
 575 -                  .owner = THIS_MODULE,
 576 -                  .of_match_table = bcm_vcio_of_match_table,
 577 -                  },
 578 -};
 579 -
 580 -static int __init bcm_mbox_init(void)
 581 -{
 582 -       return platform_driver_register(&bcm_mbox_driver);
 583 -}
 584 -
 585 -static void __exit bcm_mbox_exit(void)
 586 -{
 587 -       platform_driver_unregister(&bcm_mbox_driver);
 588 -}
 589 -
 590 -arch_initcall(bcm_mbox_init);  /* Initialize early */
 591 -module_exit(bcm_mbox_exit);
 592 -
 593  MODULE_AUTHOR("Gray Girling");
 594  MODULE_DESCRIPTION("ARM I/O to VideoCore processor");
 595  MODULE_LICENSE("GPL");