drivers/net/wireless/p54/p54spi.c

   1 /*
   2  * Copyright (C) 2008 Christian Lamparter <chunkeey@web.de>
   3  * Copyright 2008       Johannes Berg <johannes@sipsolutions.net>
   4  *
   5  * This driver is a port from stlc45xx:
   6  *      Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/firmware.h>
  27 #include <linux/delay.h>
  28 #include <linux/irq.h>
  29 #include <linux/spi/spi.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/gpio.h>
  32 #include <linux/slab.h>
  33
  34 #include "p54spi.h"
  35 #include "p54.h"
  36
  37 #include "lmac.h"
  38
  39 #ifdef CONFIG_P54_SPI_DEFAULT_EEPROM
  40 #include "p54spi_eeprom.h"
  41 #endif /* CONFIG_P54_SPI_DEFAULT_EEPROM */
  42
  43 MODULE_FIRMWARE("3826.arm");
  44 MODULE_ALIAS("stlc45xx");
  45
  46 /*
  47  * gpios should be handled in board files and provided via platform data,
  48  * but because it's currently impossible for p54spi to have a header file
  49  * in include/linux, let's use module paramaters for now
  50  */
  51
  52 static int p54spi_gpio_power = 97;
  53 module_param(p54spi_gpio_power, int, 0444);
  54 MODULE_PARM_DESC(p54spi_gpio_power, "gpio number for power line");
  55
  56 static int p54spi_gpio_irq = 87;
  57 module_param(p54spi_gpio_irq, int, 0444);
  58 MODULE_PARM_DESC(p54spi_gpio_irq, "gpio number for irq line");
  59
  60 static void p54spi_spi_read(struct p54s_priv *priv, u8 address,
  61                               void *buf, size_t len)
  62 {
  63         struct spi_transfer t[2];
  64         struct spi_message m;
  65         __le16 addr;
  66
  67         /* We first push the address */
  68         addr = cpu_to_le16(address << 8 | SPI_ADRS_READ_BIT_15);
  69
  70         spi_message_init(&m);
  71         memset(t, 0, sizeof(t));
  72
  73         t[0].tx_buf = &addr;
  74         t[0].len = sizeof(addr);
  75         spi_message_add_tail(&t[0], &m);
  76
  77         t[1].rx_buf = buf;
  78         t[1].len = len;
  79         spi_message_add_tail(&t[1], &m);
  80
  81         spi_sync(priv->spi, &m);
  82 }
  83
  84
  85 static void p54spi_spi_write(struct p54s_priv *priv, u8 address,
  86                              const void *buf, size_t len)
  87 {
  88         struct spi_transfer t[3];
  89         struct spi_message m;
  90         __le16 addr;
  91
  92         /* We first push the address */
  93         addr = cpu_to_le16(address << 8);
  94
  95         spi_message_init(&m);
  96         memset(t, 0, sizeof(t));
  97
  98         t[0].tx_buf = &addr;
  99         t[0].len = sizeof(addr);
 100         spi_message_add_tail(&t[0], &m);
 101
 102         t[1].tx_buf = buf;
 103         t[1].len = len & ~1;
 104         spi_message_add_tail(&t[1], &m);
 105
 106         if (len % 2) {
 107                 __le16 last_word;
 108                 last_word = cpu_to_le16(((u8 *)buf)[len - 1]);
 109
 110                 t[2].tx_buf = &last_word;
 111                 t[2].len = sizeof(last_word);
 112                 spi_message_add_tail(&t[2], &m);
 113         }
 114
 115         spi_sync(priv->spi, &m);
 116 }
 117
 118 static u32 p54spi_read32(struct p54s_priv *priv, u8 addr)
 119 {
 120         __le32 val;
 121
 122         p54spi_spi_read(priv, addr, &val, sizeof(val));
 123
 124         return le32_to_cpu(val);
 125 }
 126
 127 static inline void p54spi_write16(struct p54s_priv *priv, u8 addr, __le16 val)
 128 {
 129         p54spi_spi_write(priv, addr, &val, sizeof(val));
 130 }
 131
 132 static inline void p54spi_write32(struct p54s_priv *priv, u8 addr, __le32 val)
 133 {
 134         p54spi_spi_write(priv, addr, &val, sizeof(val));
 135 }
 136
 137 static int p54spi_wait_bit(struct p54s_priv *priv, u16 reg, u32 bits)
 138 {
 139         int i;
 140
 141         for (i = 0; i < 2000; i++) {
 142                 u32 buffer = p54spi_read32(priv, reg);
 143                 if ((buffer & bits) == bits)
 144                         return 1;
 145         }
 146         return 0;
 147 }
 148
 149 static int p54spi_spi_write_dma(struct p54s_priv *priv, __le32 base,
 150                                 const void *buf, size_t len)
 151 {
 152         if (!p54spi_wait_bit(priv, SPI_ADRS_DMA_WRITE_CTRL, HOST_ALLOWED)) {
 153                 dev_err(&priv->spi->dev, "spi_write_dma not allowed "
 154                         "to DMA write.\n");
 155                 return -EAGAIN;
 156         }
 157
 158         p54spi_write16(priv, SPI_ADRS_DMA_WRITE_CTRL,
 159                        cpu_to_le16(SPI_DMA_WRITE_CTRL_ENABLE));
 160
 161         p54spi_write16(priv, SPI_ADRS_DMA_WRITE_LEN, cpu_to_le16(len));
 162         p54spi_write32(priv, SPI_ADRS_DMA_WRITE_BASE, base);
 163         p54spi_spi_write(priv, SPI_ADRS_DMA_DATA, buf, len);
 164         return 0;
 165 }
 166
 167 static int p54spi_request_firmware(struct ieee80211_hw *dev)
 168 {
 169         struct p54s_priv *priv = dev->priv;
 170         int ret;
 171
 172         /* FIXME: should driver use it's own struct device? */
 173         ret = request_firmware(&priv->firmware, "3826.arm", &priv->spi->dev);
 174
 175         if (ret < 0) {
 176                 dev_err(&priv->spi->dev, "request_firmware() failed: %d", ret);
 177                 return ret;
 178         }
 179
 180         ret = p54_parse_firmware(dev, priv->firmware);
 181         if (ret) {
 182                 release_firmware(priv->firmware);
 183                 return ret;
 184         }
 185
 186         return 0;
 187 }
 188
 189 static int p54spi_request_eeprom(struct ieee80211_hw *dev)
 190 {
 191         struct p54s_priv *priv = dev->priv;
 192         const struct firmware *eeprom;
 193         int ret;
 194
 195         /*
 196          * allow users to customize their eeprom.
 197          */
 198
 199         ret = request_firmware(&eeprom, "3826.eeprom", &priv->spi->dev);
 200         if (ret < 0) {
 201 #ifdef CONFIG_P54_SPI_DEFAULT_EEPROM
 202                 dev_info(&priv->spi->dev, "loading default eeprom...\n");
 203                 ret = p54_parse_eeprom(dev, (void *) p54spi_eeprom,
 204                                        sizeof(p54spi_eeprom));
 205 #else
 206                 dev_err(&priv->spi->dev, "Failed to request user eeprom\n");
 207 #endif /* CONFIG_P54_SPI_DEFAULT_EEPROM */
 208         } else {
 209                 dev_info(&priv->spi->dev, "loading user eeprom...\n");
 210                 ret = p54_parse_eeprom(dev, (void *) eeprom->data,
 211                                        (int)eeprom->size);
 212                 release_firmware(eeprom);
 213         }
 214         return ret;
 215 }
 216
 217 static int p54spi_upload_firmware(struct ieee80211_hw *dev)
 218 {
 219         struct p54s_priv *priv = dev->priv;
 220         unsigned long fw_len, _fw_len;
 221         unsigned int offset = 0;
 222         int err = 0;
 223         u8 *fw;
 224
 225         fw_len = priv->firmware->size;
 226         fw = kmemdup(priv->firmware->data, fw_len, GFP_KERNEL);
 227         if (!fw)
 228                 return -ENOMEM;
 229
 230         /* stop the device */
 231         p54spi_write16(priv, SPI_ADRS_DEV_CTRL_STAT, cpu_to_le16(
 232                        SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_HOST_RESET |
 233                        SPI_CTRL_STAT_START_HALTED));
 234
 235         msleep(TARGET_BOOT_SLEEP);
 236
 237         p54spi_write16(priv, SPI_ADRS_DEV_CTRL_STAT, cpu_to_le16(
 238                        SPI_CTRL_STAT_HOST_OVERRIDE |
 239                        SPI_CTRL_STAT_START_HALTED));
 240
 241         msleep(TARGET_BOOT_SLEEP);
 242
 243         while (fw_len > 0) {
 244                 _fw_len = min_t(long, fw_len, SPI_MAX_PACKET_SIZE);
 245
 246                 err = p54spi_spi_write_dma(priv, cpu_to_le32(
 247                                            ISL38XX_DEV_FIRMWARE_ADDR + offset),
 248                                            (fw + offset), _fw_len);
 249                 if (err < 0)
 250                         goto out;
 251
 252                 fw_len -= _fw_len;
 253                 offset += _fw_len;
 254         }
 255
 256         BUG_ON(fw_len != 0);
 257
 258         /* enable host interrupts */
 259         p54spi_write32(priv, SPI_ADRS_HOST_INT_EN,
 260                        cpu_to_le32(SPI_HOST_INTS_DEFAULT));
 261
 262         /* boot the device */
 263         p54spi_write16(priv, SPI_ADRS_DEV_CTRL_STAT, cpu_to_le16(
 264                        SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_HOST_RESET |
 265                        SPI_CTRL_STAT_RAM_BOOT));
 266
 267         msleep(TARGET_BOOT_SLEEP);
 268
 269         p54spi_write16(priv, SPI_ADRS_DEV_CTRL_STAT, cpu_to_le16(
 270                        SPI_CTRL_STAT_HOST_OVERRIDE | SPI_CTRL_STAT_RAM_BOOT));
 271         msleep(TARGET_BOOT_SLEEP);
 272
 273 out:
 274         kfree(fw);
 275         return err;
 276 }
 277
 278 static void p54spi_power_off(struct p54s_priv *priv)
 279 {
 280         disable_irq(gpio_to_irq(p54spi_gpio_irq));
 281         gpio_set_value(p54spi_gpio_power, 0);
 282 }
 283
 284 static void p54spi_power_on(struct p54s_priv *priv)
 285 {
 286         gpio_set_value(p54spi_gpio_power, 1);
 287         enable_irq(gpio_to_irq(p54spi_gpio_irq));
 288
 289         /*
 290          * need to wait a while before device can be accessed, the length
 291          * is just a guess
 292          */
 293         msleep(10);
 294 }
 295
 296 static inline void p54spi_int_ack(struct p54s_priv *priv, u32 val)
 297 {
 298         p54spi_write32(priv, SPI_ADRS_HOST_INT_ACK, cpu_to_le32(val));
 299 }
 300
 301 static int p54spi_wakeup(struct p54s_priv *priv)
 302 {
 303         /* wake the chip */
 304         p54spi_write32(priv, SPI_ADRS_ARM_INTERRUPTS,
 305                        cpu_to_le32(SPI_TARGET_INT_WAKEUP));
 306
 307         /* And wait for the READY interrupt */
 308         if (!p54spi_wait_bit(priv, SPI_ADRS_HOST_INTERRUPTS,
 309                              SPI_HOST_INT_READY)) {
 310                 dev_err(&priv->spi->dev, "INT_READY timeout\n");
 311                 return -EBUSY;
 312         }
 313
 314         p54spi_int_ack(priv, SPI_HOST_INT_READY);
 315         return 0;
 316 }
 317
 318 static inline void p54spi_sleep(struct p54s_priv *priv)
 319 {
 320         p54spi_write32(priv, SPI_ADRS_ARM_INTERRUPTS,
 321                        cpu_to_le32(SPI_TARGET_INT_SLEEP));
 322 }
 323
 324 static void p54spi_int_ready(struct p54s_priv *priv)
 325 {
 326         p54spi_write32(priv, SPI_ADRS_HOST_INT_EN, cpu_to_le32(
 327                        SPI_HOST_INT_UPDATE | SPI_HOST_INT_SW_UPDATE));
 328
 329         switch (priv->fw_state) {
 330         case FW_STATE_BOOTING:
 331                 priv->fw_state = FW_STATE_READY;
 332                 complete(&priv->fw_comp);
 333                 break;
 334         case FW_STATE_RESETTING:
 335                 priv->fw_state = FW_STATE_READY;
 336                 /* TODO: reinitialize state */
 337                 break;
 338         default:
 339                 break;
 340         }
 341 }
 342
 343 static int p54spi_rx(struct p54s_priv *priv)
 344 {
 345         struct sk_buff *skb;
 346         u16 len;
 347         u16 rx_head[2];
 348 #define READAHEAD_SZ (sizeof(rx_head)-sizeof(u16))
 349
 350         if (p54spi_wakeup(priv) < 0)
 351                 return -EBUSY;
 352
 353         /* Read data size and first data word in one SPI transaction
 354          * This is workaround for firmware/DMA bug,
 355          * when first data word gets lost under high load.
 356          */
 357         p54spi_spi_read(priv, SPI_ADRS_DMA_DATA, rx_head, sizeof(rx_head));
 358         len = rx_head[0];
 359
 360         if (len == 0) {
 361                 p54spi_sleep(priv);
 362                 dev_err(&priv->spi->dev, "rx request of zero bytes\n");
 363                 return 0;
 364         }
 365
 366         /* Firmware may insert up to 4 padding bytes after the lmac header,
 367          * but it does not amend the size of SPI data transfer.
 368          * Such packets has correct data size in header, thus referencing
 369          * past the end of allocated skb. Reserve extra 4 bytes for this case */
 370         skb = dev_alloc_skb(len + 4);
 371         if (!skb) {
 372                 p54spi_sleep(priv);
 373                 dev_err(&priv->spi->dev, "could not alloc skb");
 374                 return -ENOMEM;
 375         }
 376
 377         if (len <= READAHEAD_SZ) {
 378                 memcpy(skb_put(skb, len), rx_head + 1, len);
 379         } else {
 380                 memcpy(skb_put(skb, READAHEAD_SZ), rx_head + 1, READAHEAD_SZ);
 381                 p54spi_spi_read(priv, SPI_ADRS_DMA_DATA,
 382                                 skb_put(skb, len - READAHEAD_SZ),
 383                                 len - READAHEAD_SZ);
 384         }
 385         p54spi_sleep(priv);
 386         /* Put additional bytes to compensate for the possible
 387          * alignment-caused truncation */
 388         skb_put(skb, 4);
 389
 390         if (p54_rx(priv->hw, skb) == 0)
 391                 dev_kfree_skb(skb);
 392
 393         return 0;
 394 }
 395
 396
 397 static irqreturn_t p54spi_interrupt(int irq, void *config)
 398 {
 399         struct spi_device *spi = config;
 400         struct p54s_priv *priv = dev_get_drvdata(&spi->dev);
 401
 402         ieee80211_queue_work(priv->hw, &priv->work);
 403
 404         return IRQ_HANDLED;
 405 }
 406
 407 static int p54spi_tx_frame(struct p54s_priv *priv, struct sk_buff *skb)
 408 {
 409         struct p54_hdr *hdr = (struct p54_hdr *) skb->data;
 410         int ret = 0;
 411
 412         if (p54spi_wakeup(priv) < 0)
 413                 return -EBUSY;
 414
 415         ret = p54spi_spi_write_dma(priv, hdr->req_id, skb->data, skb->len);
 416         if (ret < 0)
 417                 goto out;
 418
 419         if (!p54spi_wait_bit(priv, SPI_ADRS_HOST_INTERRUPTS,
 420                              SPI_HOST_INT_WR_READY)) {
 421                 dev_err(&priv->spi->dev, "WR_READY timeout\n");
 422                 ret = -EAGAIN;
 423                 goto out;
 424         }
 425
 426         p54spi_int_ack(priv, SPI_HOST_INT_WR_READY);
 427
 428         if (FREE_AFTER_TX(skb))
 429                 p54_free_skb(priv->hw, skb);
 430 out:
 431         p54spi_sleep(priv);
 432         return ret;
 433 }
 434
 435 static int p54spi_wq_tx(struct p54s_priv *priv)
 436 {
 437         struct p54s_tx_info *entry;
 438         struct sk_buff *skb;
 439         struct ieee80211_tx_info *info;
 440         struct p54_tx_info *minfo;
 441         struct p54s_tx_info *dinfo;
 442         unsigned long flags;
 443         int ret = 0;
 444
 445         spin_lock_irqsave(&priv->tx_lock, flags);
 446
 447         while (!list_empty(&priv->tx_pending)) {
 448                 entry = list_entry(priv->tx_pending.next,
 449                                    struct p54s_tx_info, tx_list);
 450
 451                 list_del_init(&entry->tx_list);
 452
 453                 spin_unlock_irqrestore(&priv->tx_lock, flags);
 454
 455                 dinfo = container_of((void *) entry, struct p54s_tx_info,
 456                                      tx_list);
 457                 minfo = container_of((void *) dinfo, struct p54_tx_info,
 458                                      data);
 459                 info = container_of((void *) minfo, struct ieee80211_tx_info,
 460                                     rate_driver_data);
 461                 skb = container_of((void *) info, struct sk_buff, cb);
 462
 463                 ret = p54spi_tx_frame(priv, skb);
 464
 465                 if (ret < 0) {
 466                         p54_free_skb(priv->hw, skb);
 467                         return ret;
 468                 }
 469
 470                 spin_lock_irqsave(&priv->tx_lock, flags);
 471         }
 472         spin_unlock_irqrestore(&priv->tx_lock, flags);
 473         return ret;
 474 }
 475
 476 static void p54spi_op_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
 477 {
 478         struct p54s_priv *priv = dev->priv;
 479         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 480         struct p54_tx_info *mi = (struct p54_tx_info *) info->rate_driver_data;
 481         struct p54s_tx_info *di = (struct p54s_tx_info *) mi->data;
 482         unsigned long flags;
 483
 484         BUILD_BUG_ON(sizeof(*di) > sizeof((mi->data)));
 485
 486         spin_lock_irqsave(&priv->tx_lock, flags);
 487         list_add_tail(&di->tx_list, &priv->tx_pending);
 488         spin_unlock_irqrestore(&priv->tx_lock, flags);
 489
 490         ieee80211_queue_work(priv->hw, &priv->work);
 491 }
 492
 493 static void p54spi_work(struct work_struct *work)
 494 {
 495         struct p54s_priv *priv = container_of(work, struct p54s_priv, work);
 496         u32 ints;
 497         int ret;
 498
 499         mutex_lock(&priv->mutex);
 500
 501         if (priv->fw_state == FW_STATE_OFF)
 502                 goto out;
 503
 504         ints = p54spi_read32(priv, SPI_ADRS_HOST_INTERRUPTS);
 505
 506         if (ints & SPI_HOST_INT_READY) {
 507                 p54spi_int_ready(priv);
 508                 p54spi_int_ack(priv, SPI_HOST_INT_READY);
 509         }
 510
 511         if (priv->fw_state != FW_STATE_READY)
 512                 goto out;
 513
 514         if (ints & SPI_HOST_INT_UPDATE) {
 515                 p54spi_int_ack(priv, SPI_HOST_INT_UPDATE);
 516                 ret = p54spi_rx(priv);
 517                 if (ret < 0)
 518                         goto out;
 519         }
 520         if (ints & SPI_HOST_INT_SW_UPDATE) {
 521                 p54spi_int_ack(priv, SPI_HOST_INT_SW_UPDATE);
 522                 ret = p54spi_rx(priv);
 523                 if (ret < 0)
 524                         goto out;
 525         }
 526
 527         ret = p54spi_wq_tx(priv);
 528 out:
 529         mutex_unlock(&priv->mutex);
 530 }
 531
 532 static int p54spi_op_start(struct ieee80211_hw *dev)
 533 {
 534         struct p54s_priv *priv = dev->priv;
 535         unsigned long timeout;
 536         int ret = 0;
 537
 538         if (mutex_lock_interruptible(&priv->mutex)) {
 539                 ret = -EINTR;
 540                 goto out;
 541         }
 542
 543         priv->fw_state = FW_STATE_BOOTING;
 544
 545         p54spi_power_on(priv);
 546
 547         ret = p54spi_upload_firmware(dev);
 548         if (ret < 0) {
 549                 p54spi_power_off(priv);
 550                 goto out_unlock;
 551         }
 552
 553         mutex_unlock(&priv->mutex);
 554
 555         timeout = msecs_to_jiffies(2000);
 556         timeout = wait_for_completion_interruptible_timeout(&priv->fw_comp,
 557                                                             timeout);
 558         if (!timeout) {
 559                 dev_err(&priv->spi->dev, "firmware boot failed");
 560                 p54spi_power_off(priv);
 561                 ret = -1;
 562                 goto out;
 563         }
 564
 565         if (mutex_lock_interruptible(&priv->mutex)) {
 566                 ret = -EINTR;
 567                 p54spi_power_off(priv);
 568                 goto out;
 569         }
 570
 571         WARN_ON(priv->fw_state != FW_STATE_READY);
 572
 573 out_unlock:
 574         mutex_unlock(&priv->mutex);
 575
 576 out:
 577         return ret;
 578 }
 579
 580 static void p54spi_op_stop(struct ieee80211_hw *dev)
 581 {
 582         struct p54s_priv *priv = dev->priv;
 583         unsigned long flags;
 584
 585         if (mutex_lock_interruptible(&priv->mutex)) {
 586                 /* FIXME: how to handle this error? */
 587                 return;
 588         }
 589
 590         WARN_ON(priv->fw_state != FW_STATE_READY);
 591
 592         cancel_work_sync(&priv->work);
 593
 594         p54spi_power_off(priv);
 595         spin_lock_irqsave(&priv->tx_lock, flags);
 596         INIT_LIST_HEAD(&priv->tx_pending);
 597         spin_unlock_irqrestore(&priv->tx_lock, flags);
 598
 599         priv->fw_state = FW_STATE_OFF;
 600         mutex_unlock(&priv->mutex);
 601 }
 602
 603 static int __devinit p54spi_probe(struct spi_device *spi)
 604 {
 605         struct p54s_priv *priv = NULL;
 606         struct ieee80211_hw *hw;
 607         int ret = -EINVAL;
 608
 609         hw = p54_init_common(sizeof(*priv));
 610         if (!hw) {
 611                 dev_err(&spi->dev, "could not alloc ieee80211_hw");
 612                 return -ENOMEM;
 613         }
 614
 615         priv = hw->priv;
 616         priv->hw = hw;
 617         dev_set_drvdata(&spi->dev, priv);
 618         priv->spi = spi;
 619
 620         spi->bits_per_word = 16;
 621         spi->max_speed_hz = 24000000;
 622
 623         ret = spi_setup(spi);
 624         if (ret < 0) {
 625                 dev_err(&priv->spi->dev, "spi_setup failed");
 626                 goto err_free_common;
 627         }
 628
 629         ret = gpio_request(p54spi_gpio_power, "p54spi power");
 630         if (ret < 0) {
 631                 dev_err(&priv->spi->dev, "power GPIO request failed: %d", ret);
 632                 goto err_free_common;
 633         }
 634
 635         ret = gpio_request(p54spi_gpio_irq, "p54spi irq");
 636         if (ret < 0) {
 637                 dev_err(&priv->spi->dev, "irq GPIO request failed: %d", ret);
 638                 goto err_free_common;
 639         }
 640
 641         gpio_direction_output(p54spi_gpio_power, 0);
 642         gpio_direction_input(p54spi_gpio_irq);
 643
 644         ret = request_irq(gpio_to_irq(p54spi_gpio_irq),
 645                           p54spi_interrupt, IRQF_DISABLED, "p54spi",
 646                           priv->spi);
 647         if (ret < 0) {
 648                 dev_err(&priv->spi->dev, "request_irq() failed");
 649                 goto err_free_common;
 650         }
 651
 652         irq_set_irq_type(gpio_to_irq(p54spi_gpio_irq), IRQ_TYPE_EDGE_RISING);
 653
 654         disable_irq(gpio_to_irq(p54spi_gpio_irq));
 655
 656         INIT_WORK(&priv->work, p54spi_work);
 657         init_completion(&priv->fw_comp);
 658         INIT_LIST_HEAD(&priv->tx_pending);
 659         mutex_init(&priv->mutex);
 660         SET_IEEE80211_DEV(hw, &spi->dev);
 661         priv->common.open = p54spi_op_start;
 662         priv->common.stop = p54spi_op_stop;
 663         priv->common.tx = p54spi_op_tx;
 664
 665         ret = p54spi_request_firmware(hw);
 666         if (ret < 0)
 667                 goto err_free_common;
 668
 669         ret = p54spi_request_eeprom(hw);
 670         if (ret)
 671                 goto err_free_common;
 672
 673         ret = p54_register_common(hw, &priv->spi->dev);
 674         if (ret)
 675                 goto err_free_common;
 676
 677         return 0;
 678
 679 err_free_common:
 680         p54_free_common(priv->hw);
 681         return ret;
 682 }
 683
 684 static int __devexit p54spi_remove(struct spi_device *spi)
 685 {
 686         struct p54s_priv *priv = dev_get_drvdata(&spi->dev);
 687
 688         p54_unregister_common(priv->hw);
 689
 690         free_irq(gpio_to_irq(p54spi_gpio_irq), spi);
 691
 692         gpio_free(p54spi_gpio_power);
 693         gpio_free(p54spi_gpio_irq);
 694         release_firmware(priv->firmware);
 695
 696         mutex_destroy(&priv->mutex);
 697
 698         p54_free_common(priv->hw);
 699
 700         return 0;
 701 }
 702
 703
 704 static struct spi_driver p54spi_driver = {
 705         .driver = {
 706                 .name           = "p54spi",
 707                 .bus            = &spi_bus_type,
 708                 .owner          = THIS_MODULE,
 709         },
 710
 711         .probe          = p54spi_probe,
 712         .remove         = __devexit_p(p54spi_remove),
 713 };
 714
 715 static int __init p54spi_init(void)
 716 {
 717         int ret;
 718
 719         ret = spi_register_driver(&p54spi_driver);
 720         if (ret < 0) {
 721                 printk(KERN_ERR "failed to register SPI driver: %d", ret);
 722                 goto out;
 723         }
 724
 725 out:
 726         return ret;
 727 }
 728
 729 static void __exit p54spi_exit(void)
 730 {
 731         spi_unregister_driver(&p54spi_driver);
 732 }
 733
 734 module_init(p54spi_init);
 735 module_exit(p54spi_exit);
 736
 737 MODULE_LICENSE("GPL");
 738 MODULE_AUTHOR("Christian Lamparter <chunkeey@web.de>");
 739 MODULE_ALIAS("spi:cx3110x");
 740 MODULE_ALIAS("spi:p54spi");