drivers/spi/spi_bfin5xx.c

   1 /*
   2  * Blackfin On-Chip SPI Driver
   3  *
   4  * Copyright 2004-2007 Analog Devices Inc.
   5  *
   6  * Enter bugs at http://blackfin.uclinux.org/
   7  *
   8  * Licensed under the GPL-2 or later.
   9  */
  10
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13 #include <linux/delay.h>
  14 #include <linux/device.h>
  15 #include <linux/io.h>
  16 #include <linux/ioport.h>
  17 #include <linux/irq.h>
  18 #include <linux/errno.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/spi/spi.h>
  23 #include <linux/workqueue.h>
  24
  25 #include <asm/dma.h>
  26 #include <asm/portmux.h>
  27 #include <asm/bfin5xx_spi.h>
  28 #include <asm/cacheflush.h>
  29
  30 #define DRV_NAME        "bfin-spi"
  31 #define DRV_AUTHOR      "Bryan Wu, Luke Yang"
  32 #define DRV_DESC        "Blackfin BF5xx on-chip SPI Controller Driver"
  33 #define DRV_VERSION     "1.0"
  34
  35 MODULE_AUTHOR(DRV_AUTHOR);
  36 MODULE_DESCRIPTION(DRV_DESC);
  37 MODULE_LICENSE("GPL");
  38
  39 #define IS_DMA_ALIGNED(x) (((u32)(x)&0x07) == 0)
  40
  41 #define START_STATE     ((void *)0)
  42 #define RUNNING_STATE   ((void *)1)
  43 #define DONE_STATE      ((void *)2)
  44 #define ERROR_STATE     ((void *)-1)
  45 #define QUEUE_RUNNING   0
  46 #define QUEUE_STOPPED   1
  47
  48 struct driver_data {
  49         /* Driver model hookup */
  50         struct platform_device *pdev;
  51
  52         /* SPI framework hookup */
  53         struct spi_master *master;
  54
  55         /* Regs base of SPI controller */
  56         void __iomem *regs_base;
  57
  58         /* Pin request list */
  59         u16 *pin_req;
  60
  61         /* BFIN hookup */
  62         struct bfin5xx_spi_master *master_info;
  63
  64         /* Driver message queue */
  65         struct workqueue_struct *workqueue;
  66         struct work_struct pump_messages;
  67         spinlock_t lock;
  68         struct list_head queue;
  69         int busy;
  70         int run;
  71
  72         /* Message Transfer pump */
  73         struct tasklet_struct pump_transfers;
  74
  75         /* Current message transfer state info */
  76         struct spi_message *cur_msg;
  77         struct spi_transfer *cur_transfer;
  78         struct chip_data *cur_chip;
  79         size_t len_in_bytes;
  80         size_t len;
  81         void *tx;
  82         void *tx_end;
  83         void *rx;
  84         void *rx_end;
  85
  86         /* DMA stuffs */
  87         int dma_channel;
  88         int dma_mapped;
  89         int dma_requested;
  90         dma_addr_t rx_dma;
  91         dma_addr_t tx_dma;
  92
  93         size_t rx_map_len;
  94         size_t tx_map_len;
  95         u8 n_bytes;
  96         int cs_change;
  97         void (*write) (struct driver_data *);
  98         void (*read) (struct driver_data *);
  99         void (*duplex) (struct driver_data *);
 100 };
 101
 102 struct chip_data {
 103         u16 ctl_reg;
 104         u16 baud;
 105         u16 flag;
 106
 107         u8 chip_select_num;
 108         u8 n_bytes;
 109         u8 width;               /* 0 or 1 */
 110         u8 enable_dma;
 111         u8 bits_per_word;       /* 8 or 16 */
 112         u8 cs_change_per_word;
 113         u16 cs_chg_udelay;      /* Some devices require > 255usec delay */
 114         void (*write) (struct driver_data *);
 115         void (*read) (struct driver_data *);
 116         void (*duplex) (struct driver_data *);
 117 };
 118
 119 #define DEFINE_SPI_REG(reg, off) \
 120 static inline u16 read_##reg(struct driver_data *drv_data) \
 121         { return bfin_read16(drv_data->regs_base + off); } \
 122 static inline void write_##reg(struct driver_data *drv_data, u16 v) \
 123         { bfin_write16(drv_data->regs_base + off, v); }
 124
 125 DEFINE_SPI_REG(CTRL, 0x00)
 126 DEFINE_SPI_REG(FLAG, 0x04)
 127 DEFINE_SPI_REG(STAT, 0x08)
 128 DEFINE_SPI_REG(TDBR, 0x0C)
 129 DEFINE_SPI_REG(RDBR, 0x10)
 130 DEFINE_SPI_REG(BAUD, 0x14)
 131 DEFINE_SPI_REG(SHAW, 0x18)
 132
 133 static void bfin_spi_enable(struct driver_data *drv_data)
 134 {
 135         u16 cr;
 136
 137         cr = read_CTRL(drv_data);
 138         write_CTRL(drv_data, (cr | BIT_CTL_ENABLE));
 139 }
 140
 141 static void bfin_spi_disable(struct driver_data *drv_data)
 142 {
 143         u16 cr;
 144
 145         cr = read_CTRL(drv_data);
 146         write_CTRL(drv_data, (cr & (~BIT_CTL_ENABLE)));
 147 }
 148
 149 /* Caculate the SPI_BAUD register value based on input HZ */
 150 static u16 hz_to_spi_baud(u32 speed_hz)
 151 {
 152         u_long sclk = get_sclk();
 153         u16 spi_baud = (sclk / (2 * speed_hz));
 154
 155         if ((sclk % (2 * speed_hz)) > 0)
 156                 spi_baud++;
 157
 158         if (spi_baud < MIN_SPI_BAUD_VAL)
 159                 spi_baud = MIN_SPI_BAUD_VAL;
 160
 161         return spi_baud;
 162 }
 163
 164 static int flush(struct driver_data *drv_data)
 165 {
 166         unsigned long limit = loops_per_jiffy << 1;
 167
 168         /* wait for stop and clear stat */
 169         while (!(read_STAT(drv_data) & BIT_STAT_SPIF) && limit--)
 170                 cpu_relax();
 171
 172         write_STAT(drv_data, BIT_STAT_CLR);
 173
 174         return limit;
 175 }
 176
 177 /* Chip select operation functions for cs_change flag */
 178 static void cs_active(struct driver_data *drv_data, struct chip_data *chip)
 179 {
 180         u16 flag = read_FLAG(drv_data);
 181
 182         flag |= chip->flag;
 183         flag &= ~(chip->flag << 8);
 184
 185         write_FLAG(drv_data, flag);
 186 }
 187
 188 static void cs_deactive(struct driver_data *drv_data, struct chip_data *chip)
 189 {
 190         u16 flag = read_FLAG(drv_data);
 191
 192         flag &= ~chip->flag;
 193         flag |= (chip->flag << 8);
 194
 195         write_FLAG(drv_data, flag);
 196
 197         /* Move delay here for consistency */
 198         if (chip->cs_chg_udelay)
 199                 udelay(chip->cs_chg_udelay);
 200 }
 201
 202 /* stop controller and re-config current chip*/
 203 static void restore_state(struct driver_data *drv_data)
 204 {
 205         struct chip_data *chip = drv_data->cur_chip;
 206
 207         /* Clear status and disable clock */
 208         write_STAT(drv_data, BIT_STAT_CLR);
 209         bfin_spi_disable(drv_data);
 210         dev_dbg(&drv_data->pdev->dev, "restoring spi ctl state\n");
 211
 212         /* Load the registers */
 213         write_CTRL(drv_data, chip->ctl_reg);
 214         write_BAUD(drv_data, chip->baud);
 215
 216         bfin_spi_enable(drv_data);
 217         cs_active(drv_data, chip);
 218 }
 219
 220 /* used to kick off transfer in rx mode */
 221 static unsigned short dummy_read(struct driver_data *drv_data)
 222 {
 223         unsigned short tmp;
 224         tmp = read_RDBR(drv_data);
 225         return tmp;
 226 }
 227
 228 static void null_writer(struct driver_data *drv_data)
 229 {
 230         u8 n_bytes = drv_data->n_bytes;
 231
 232         while (drv_data->tx < drv_data->tx_end) {
 233                 write_TDBR(drv_data, 0);
 234                 while ((read_STAT(drv_data) & BIT_STAT_TXS))
 235                         cpu_relax();
 236                 drv_data->tx += n_bytes;
 237         }
 238 }
 239
 240 static void null_reader(struct driver_data *drv_data)
 241 {
 242         u8 n_bytes = drv_data->n_bytes;
 243         dummy_read(drv_data);
 244
 245         while (drv_data->rx < drv_data->rx_end) {
 246                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 247                         cpu_relax();
 248                 dummy_read(drv_data);
 249                 drv_data->rx += n_bytes;
 250         }
 251 }
 252
 253 static void u8_writer(struct driver_data *drv_data)
 254 {
 255         dev_dbg(&drv_data->pdev->dev,
 256                 "cr8-s is 0x%x\n", read_STAT(drv_data));
 257
 258         while (drv_data->tx < drv_data->tx_end) {
 259                 write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
 260                 while (read_STAT(drv_data) & BIT_STAT_TXS)
 261                         cpu_relax();
 262                 ++drv_data->tx;
 263         }
 264
 265         /* poll for SPI completion before return */
 266         while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 267                 cpu_relax();
 268 }
 269
 270 static void u8_cs_chg_writer(struct driver_data *drv_data)
 271 {
 272         struct chip_data *chip = drv_data->cur_chip;
 273
 274         while (drv_data->tx < drv_data->tx_end) {
 275                 cs_active(drv_data, chip);
 276
 277                 write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
 278                 while (read_STAT(drv_data) & BIT_STAT_TXS)
 279                         cpu_relax();
 280                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 281                         cpu_relax();
 282
 283                 cs_deactive(drv_data, chip);
 284
 285                 ++drv_data->tx;
 286         }
 287 }
 288
 289 static void u8_reader(struct driver_data *drv_data)
 290 {
 291         dev_dbg(&drv_data->pdev->dev,
 292                 "cr-8 is 0x%x\n", read_STAT(drv_data));
 293
 294         /* poll for SPI completion before start */
 295         while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 296                 cpu_relax();
 297
 298         /* clear TDBR buffer before read(else it will be shifted out) */
 299         write_TDBR(drv_data, 0xFFFF);
 300
 301         dummy_read(drv_data);
 302
 303         while (drv_data->rx < drv_data->rx_end - 1) {
 304                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 305                         cpu_relax();
 306                 *(u8 *) (drv_data->rx) = read_RDBR(drv_data);
 307                 ++drv_data->rx;
 308         }
 309
 310         while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 311                 cpu_relax();
 312         *(u8 *) (drv_data->rx) = read_SHAW(drv_data);
 313         ++drv_data->rx;
 314 }
 315
 316 static void u8_cs_chg_reader(struct driver_data *drv_data)
 317 {
 318         struct chip_data *chip = drv_data->cur_chip;
 319
 320         while (drv_data->rx < drv_data->rx_end) {
 321                 cs_active(drv_data, chip);
 322                 read_RDBR(drv_data);    /* kick off */
 323
 324                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 325                         cpu_relax();
 326                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 327                         cpu_relax();
 328
 329                 *(u8 *) (drv_data->rx) = read_SHAW(drv_data);
 330                 cs_deactive(drv_data, chip);
 331
 332                 ++drv_data->rx;
 333         }
 334 }
 335
 336 static void u8_duplex(struct driver_data *drv_data)
 337 {
 338         /* in duplex mode, clk is triggered by writing of TDBR */
 339         while (drv_data->rx < drv_data->rx_end) {
 340                 write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
 341                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 342                         cpu_relax();
 343                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 344                         cpu_relax();
 345                 *(u8 *) (drv_data->rx) = read_RDBR(drv_data);
 346                 ++drv_data->rx;
 347                 ++drv_data->tx;
 348         }
 349 }
 350
 351 static void u8_cs_chg_duplex(struct driver_data *drv_data)
 352 {
 353         struct chip_data *chip = drv_data->cur_chip;
 354
 355         while (drv_data->rx < drv_data->rx_end) {
 356                 cs_active(drv_data, chip);
 357
 358                 write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
 359
 360                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 361                         cpu_relax();
 362                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 363                         cpu_relax();
 364                 *(u8 *) (drv_data->rx) = read_RDBR(drv_data);
 365
 366                 cs_deactive(drv_data, chip);
 367
 368                 ++drv_data->rx;
 369                 ++drv_data->tx;
 370         }
 371 }
 372
 373 static void u16_writer(struct driver_data *drv_data)
 374 {
 375         dev_dbg(&drv_data->pdev->dev,
 376                 "cr16 is 0x%x\n", read_STAT(drv_data));
 377
 378         while (drv_data->tx < drv_data->tx_end) {
 379                 write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
 380                 while ((read_STAT(drv_data) & BIT_STAT_TXS))
 381                         cpu_relax();
 382                 drv_data->tx += 2;
 383         }
 384
 385         /* poll for SPI completion before return */
 386         while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 387                 cpu_relax();
 388 }
 389
 390 static void u16_cs_chg_writer(struct driver_data *drv_data)
 391 {
 392         struct chip_data *chip = drv_data->cur_chip;
 393
 394         while (drv_data->tx < drv_data->tx_end) {
 395                 cs_active(drv_data, chip);
 396
 397                 write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
 398                 while ((read_STAT(drv_data) & BIT_STAT_TXS))
 399                         cpu_relax();
 400                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 401                         cpu_relax();
 402
 403                 cs_deactive(drv_data, chip);
 404
 405                 drv_data->tx += 2;
 406         }
 407 }
 408
 409 static void u16_reader(struct driver_data *drv_data)
 410 {
 411         dev_dbg(&drv_data->pdev->dev,
 412                 "cr-16 is 0x%x\n", read_STAT(drv_data));
 413
 414         /* poll for SPI completion before start */
 415         while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 416                 cpu_relax();
 417
 418         /* clear TDBR buffer before read(else it will be shifted out) */
 419         write_TDBR(drv_data, 0xFFFF);
 420
 421         dummy_read(drv_data);
 422
 423         while (drv_data->rx < (drv_data->rx_end - 2)) {
 424                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 425                         cpu_relax();
 426                 *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
 427                 drv_data->rx += 2;
 428         }
 429
 430         while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 431                 cpu_relax();
 432         *(u16 *) (drv_data->rx) = read_SHAW(drv_data);
 433         drv_data->rx += 2;
 434 }
 435
 436 static void u16_cs_chg_reader(struct driver_data *drv_data)
 437 {
 438         struct chip_data *chip = drv_data->cur_chip;
 439
 440         /* poll for SPI completion before start */
 441         while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 442                 cpu_relax();
 443
 444         /* clear TDBR buffer before read(else it will be shifted out) */
 445         write_TDBR(drv_data, 0xFFFF);
 446
 447         cs_active(drv_data, chip);
 448         dummy_read(drv_data);
 449
 450         while (drv_data->rx < drv_data->rx_end - 2) {
 451                 cs_deactive(drv_data, chip);
 452
 453                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 454                         cpu_relax();
 455                 cs_active(drv_data, chip);
 456                 *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
 457                 drv_data->rx += 2;
 458         }
 459         cs_deactive(drv_data, chip);
 460
 461         while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 462                 cpu_relax();
 463         *(u16 *) (drv_data->rx) = read_SHAW(drv_data);
 464         drv_data->rx += 2;
 465 }
 466
 467 static void u16_duplex(struct driver_data *drv_data)
 468 {
 469         /* in duplex mode, clk is triggered by writing of TDBR */
 470         while (drv_data->tx < drv_data->tx_end) {
 471                 write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
 472                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 473                         cpu_relax();
 474                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 475                         cpu_relax();
 476                 *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
 477                 drv_data->rx += 2;
 478                 drv_data->tx += 2;
 479         }
 480 }
 481
 482 static void u16_cs_chg_duplex(struct driver_data *drv_data)
 483 {
 484         struct chip_data *chip = drv_data->cur_chip;
 485
 486         while (drv_data->tx < drv_data->tx_end) {
 487                 cs_active(drv_data, chip);
 488
 489                 write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
 490                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 491                         cpu_relax();
 492                 while (!(read_STAT(drv_data) & BIT_STAT_RXS))
 493                         cpu_relax();
 494                 *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
 495
 496                 cs_deactive(drv_data, chip);
 497
 498                 drv_data->rx += 2;
 499                 drv_data->tx += 2;
 500         }
 501 }
 502
 503 /* test if ther is more transfer to be done */
 504 static void *next_transfer(struct driver_data *drv_data)
 505 {
 506         struct spi_message *msg = drv_data->cur_msg;
 507         struct spi_transfer *trans = drv_data->cur_transfer;
 508
 509         /* Move to next transfer */
 510         if (trans->transfer_list.next != &msg->transfers) {
 511                 drv_data->cur_transfer =
 512                     list_entry(trans->transfer_list.next,
 513                                struct spi_transfer, transfer_list);
 514                 return RUNNING_STATE;
 515         } else
 516                 return DONE_STATE;
 517 }
 518
 519 /*
 520  * caller already set message->status;
 521  * dma and pio irqs are blocked give finished message back
 522  */
 523 static void giveback(struct driver_data *drv_data)
 524 {
 525         struct chip_data *chip = drv_data->cur_chip;
 526         struct spi_transfer *last_transfer;
 527         unsigned long flags;
 528         struct spi_message *msg;
 529
 530         spin_lock_irqsave(&drv_data->lock, flags);
 531         msg = drv_data->cur_msg;
 532         drv_data->cur_msg = NULL;
 533         drv_data->cur_transfer = NULL;
 534         drv_data->cur_chip = NULL;
 535         queue_work(drv_data->workqueue, &drv_data->pump_messages);
 536         spin_unlock_irqrestore(&drv_data->lock, flags);
 537
 538         last_transfer = list_entry(msg->transfers.prev,
 539                                    struct spi_transfer, transfer_list);
 540
 541         msg->state = NULL;
 542
 543         if (!drv_data->cs_change)
 544                 cs_deactive(drv_data, chip);
 545
 546         /* Not stop spi in autobuffer mode */
 547         if (drv_data->tx_dma != 0xFFFF)
 548                 bfin_spi_disable(drv_data);
 549
 550         if (msg->complete)
 551                 msg->complete(msg->context);
 552 }
 553
 554 static irqreturn_t dma_irq_handler(int irq, void *dev_id)
 555 {
 556         struct driver_data *drv_data = dev_id;
 557         struct chip_data *chip = drv_data->cur_chip;
 558         struct spi_message *msg = drv_data->cur_msg;
 559         unsigned long timeout;
 560         unsigned short dmastat = get_dma_curr_irqstat(drv_data->dma_channel);
 561         u16 spistat = read_STAT(drv_data);
 562
 563         dev_dbg(&drv_data->pdev->dev,
 564                 "in dma_irq_handler dmastat:0x%x spistat:0x%x\n",
 565                 dmastat, spistat);
 566
 567         clear_dma_irqstat(drv_data->dma_channel);
 568
 569         /* Wait for DMA to complete */
 570         while (get_dma_curr_irqstat(drv_data->dma_channel) & DMA_RUN)
 571                 cpu_relax();
 572
 573         /*
 574          * wait for the last transaction shifted out.  HRM states:
 575          * at this point there may still be data in the SPI DMA FIFO waiting
 576          * to be transmitted ... software needs to poll TXS in the SPI_STAT
 577          * register until it goes low for 2 successive reads
 578          */
 579         if (drv_data->tx != NULL) {
 580                 while ((read_STAT(drv_data) & TXS) ||
 581                        (read_STAT(drv_data) & TXS))
 582                         cpu_relax();
 583         }
 584
 585         dev_dbg(&drv_data->pdev->dev,
 586                 "in dma_irq_handler dmastat:0x%x spistat:0x%x\n",
 587                 dmastat, read_STAT(drv_data));
 588
 589         timeout = jiffies + HZ;
 590         while (!(read_STAT(drv_data) & SPIF))
 591                 if (!time_before(jiffies, timeout)) {
 592                         dev_warn(&drv_data->pdev->dev, "timeout waiting for SPIF");
 593                         break;
 594                 } else
 595                         cpu_relax();
 596
 597         if ((dmastat & DMA_ERR) && (spistat & RBSY)) {
 598                 msg->state = ERROR_STATE;
 599                 dev_err(&drv_data->pdev->dev, "dma receive: fifo/buffer overflow\n");
 600         } else {
 601                 msg->actual_length += drv_data->len_in_bytes;
 602
 603                 if (drv_data->cs_change)
 604                         cs_deactive(drv_data, chip);
 605
 606                 /* Move to next transfer */
 607                 msg->state = next_transfer(drv_data);
 608         }
 609
 610         /* Schedule transfer tasklet */
 611         tasklet_schedule(&drv_data->pump_transfers);
 612
 613         /* free the irq handler before next transfer */
 614         dev_dbg(&drv_data->pdev->dev,
 615                 "disable dma channel irq%d\n",
 616                 drv_data->dma_channel);
 617         dma_disable_irq(drv_data->dma_channel);
 618
 619         return IRQ_HANDLED;
 620 }
 621
 622 static void pump_transfers(unsigned long data)
 623 {
 624         struct driver_data *drv_data = (struct driver_data *)data;
 625         struct spi_message *message = NULL;
 626         struct spi_transfer *transfer = NULL;
 627         struct spi_transfer *previous = NULL;
 628         struct chip_data *chip = NULL;
 629         u8 width;
 630         u16 cr, dma_width, dma_config;
 631         u32 tranf_success = 1;
 632         u8 full_duplex = 0;
 633
 634         /* Get current state information */
 635         message = drv_data->cur_msg;
 636         transfer = drv_data->cur_transfer;
 637         chip = drv_data->cur_chip;
 638
 639         /*
 640          * if msg is error or done, report it back using complete() callback
 641          */
 642
 643          /* Handle for abort */
 644         if (message->state == ERROR_STATE) {
 645                 dev_dbg(&drv_data->pdev->dev, "transfer: we've hit an error\n");
 646                 message->status = -EIO;
 647                 giveback(drv_data);
 648                 return;
 649         }
 650
 651         /* Handle end of message */
 652         if (message->state == DONE_STATE) {
 653                 dev_dbg(&drv_data->pdev->dev, "transfer: all done!\n");
 654                 message->status = 0;
 655                 giveback(drv_data);
 656                 return;
 657         }
 658
 659         /* Delay if requested at end of transfer */
 660         if (message->state == RUNNING_STATE) {
 661                 dev_dbg(&drv_data->pdev->dev, "transfer: still running ...\n");
 662                 previous = list_entry(transfer->transfer_list.prev,
 663                                       struct spi_transfer, transfer_list);
 664                 if (previous->delay_usecs)
 665                         udelay(previous->delay_usecs);
 666         }
 667
 668         /* Setup the transfer state based on the type of transfer */
 669         if (flush(drv_data) == 0) {
 670                 dev_err(&drv_data->pdev->dev, "pump_transfers: flush failed\n");
 671                 message->status = -EIO;
 672                 giveback(drv_data);
 673                 return;
 674         }
 675
 676         if (transfer->tx_buf != NULL) {
 677                 drv_data->tx = (void *)transfer->tx_buf;
 678                 drv_data->tx_end = drv_data->tx + transfer->len;
 679                 dev_dbg(&drv_data->pdev->dev, "tx_buf is %p, tx_end is %p\n",
 680                         transfer->tx_buf, drv_data->tx_end);
 681         } else {
 682                 drv_data->tx = NULL;
 683         }
 684
 685         if (transfer->rx_buf != NULL) {
 686                 full_duplex = transfer->tx_buf != NULL;
 687                 drv_data->rx = transfer->rx_buf;
 688                 drv_data->rx_end = drv_data->rx + transfer->len;
 689                 dev_dbg(&drv_data->pdev->dev, "rx_buf is %p, rx_end is %p\n",
 690                         transfer->rx_buf, drv_data->rx_end);
 691         } else {
 692                 drv_data->rx = NULL;
 693         }
 694
 695         drv_data->rx_dma = transfer->rx_dma;
 696         drv_data->tx_dma = transfer->tx_dma;
 697         drv_data->len_in_bytes = transfer->len;
 698         drv_data->cs_change = transfer->cs_change;
 699
 700         /* Bits per word setup */
 701         switch (transfer->bits_per_word) {
 702         case 8:
 703                 drv_data->n_bytes = 1;
 704                 width = CFG_SPI_WORDSIZE8;
 705                 drv_data->read = chip->cs_change_per_word ?
 706                         u8_cs_chg_reader : u8_reader;
 707                 drv_data->write = chip->cs_change_per_word ?
 708                         u8_cs_chg_writer : u8_writer;
 709                 drv_data->duplex = chip->cs_change_per_word ?
 710                         u8_cs_chg_duplex : u8_duplex;
 711                 break;
 712
 713         case 16:
 714                 drv_data->n_bytes = 2;
 715                 width = CFG_SPI_WORDSIZE16;
 716                 drv_data->read = chip->cs_change_per_word ?
 717                         u16_cs_chg_reader : u16_reader;
 718                 drv_data->write = chip->cs_change_per_word ?
 719                         u16_cs_chg_writer : u16_writer;
 720                 drv_data->duplex = chip->cs_change_per_word ?
 721                         u16_cs_chg_duplex : u16_duplex;
 722                 break;
 723
 724         default:
 725                 /* No change, the same as default setting */
 726                 drv_data->n_bytes = chip->n_bytes;
 727                 width = chip->width;
 728                 drv_data->write = drv_data->tx ? chip->write : null_writer;
 729                 drv_data->read = drv_data->rx ? chip->read : null_reader;
 730                 drv_data->duplex = chip->duplex ? chip->duplex : null_writer;
 731                 break;
 732         }
 733         cr = (read_CTRL(drv_data) & (~BIT_CTL_TIMOD));
 734         cr |= (width << 8);
 735         write_CTRL(drv_data, cr);
 736
 737         if (width == CFG_SPI_WORDSIZE16) {
 738                 drv_data->len = (transfer->len) >> 1;
 739         } else {
 740                 drv_data->len = transfer->len;
 741         }
 742         dev_dbg(&drv_data->pdev->dev,
 743                 "transfer: drv_data->write is %p, chip->write is %p, null_wr is %p\n",
 744                 drv_data->write, chip->write, null_writer);
 745
 746         /* speed and width has been set on per message */
 747         message->state = RUNNING_STATE;
 748         dma_config = 0;
 749
 750         /* Speed setup (surely valid because already checked) */
 751         if (transfer->speed_hz)
 752                 write_BAUD(drv_data, hz_to_spi_baud(transfer->speed_hz));
 753         else
 754                 write_BAUD(drv_data, chip->baud);
 755
 756         write_STAT(drv_data, BIT_STAT_CLR);
 757         cr = (read_CTRL(drv_data) & (~BIT_CTL_TIMOD));
 758         if (drv_data->cs_change)
 759                 cs_active(drv_data, chip);
 760
 761         dev_dbg(&drv_data->pdev->dev,
 762                 "now pumping a transfer: width is %d, len is %d\n",
 763                 width, transfer->len);
 764
 765         /*
 766          * Try to map dma buffer and do a dma transfer.  If successful use,
 767          * different way to r/w according to the enable_dma settings and if
 768          * we are not doing a full duplex transfer (since the hardware does
 769          * not support full duplex DMA transfers).
 770          */
 771         if (!full_duplex && drv_data->cur_chip->enable_dma
 772                                 && drv_data->len > 6) {
 773
 774                 unsigned long dma_start_addr, flags;
 775
 776                 disable_dma(drv_data->dma_channel);
 777                 clear_dma_irqstat(drv_data->dma_channel);
 778
 779                 /* config dma channel */
 780                 dev_dbg(&drv_data->pdev->dev, "doing dma transfer\n");
 781                 set_dma_x_count(drv_data->dma_channel, drv_data->len);
 782                 if (width == CFG_SPI_WORDSIZE16) {
 783                         set_dma_x_modify(drv_data->dma_channel, 2);
 784                         dma_width = WDSIZE_16;
 785                 } else {
 786                         set_dma_x_modify(drv_data->dma_channel, 1);
 787                         dma_width = WDSIZE_8;
 788                 }
 789
 790                 /* poll for SPI completion before start */
 791                 while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
 792                         cpu_relax();
 793
 794                 /* dirty hack for autobuffer DMA mode */
 795                 if (drv_data->tx_dma == 0xFFFF) {
 796                         dev_dbg(&drv_data->pdev->dev,
 797                                 "doing autobuffer DMA out.\n");
 798
 799                         /* no irq in autobuffer mode */
 800                         dma_config =
 801                             (DMAFLOW_AUTO | RESTART | dma_width | DI_EN);
 802                         set_dma_config(drv_data->dma_channel, dma_config);
 803                         set_dma_start_addr(drv_data->dma_channel,
 804                                         (unsigned long)drv_data->tx);
 805                         enable_dma(drv_data->dma_channel);
 806
 807                         /* start SPI transfer */
 808                         write_CTRL(drv_data, cr | BIT_CTL_TIMOD_DMA_TX);
 809
 810                         /* just return here, there can only be one transfer
 811                          * in this mode
 812                          */
 813                         message->status = 0;
 814                         giveback(drv_data);
 815                         return;
 816                 }
 817
 818                 /* In dma mode, rx or tx must be NULL in one transfer */
 819                 dma_config = (RESTART | dma_width | DI_EN);
 820                 if (drv_data->rx != NULL) {
 821                         /* set transfer mode, and enable SPI */
 822                         dev_dbg(&drv_data->pdev->dev, "doing DMA in to %p (size %zx)\n",
 823                                 drv_data->rx, drv_data->len_in_bytes);
 824
 825                         /* invalidate caches, if needed */
 826                         if (bfin_addr_dcachable((unsigned long) drv_data->rx))
 827                                 invalidate_dcache_range((unsigned long) drv_data->rx,
 828                                                         (unsigned long) (drv_data->rx +
 829                                                         drv_data->len_in_bytes));
 830
 831                         /* clear tx reg soformer data is not shifted out */
 832                         write_TDBR(drv_data, 0xFFFF);
 833
 834                         dma_config |= WNR;
 835                         dma_start_addr = (unsigned long)drv_data->rx;
 836                         cr |= BIT_CTL_TIMOD_DMA_RX | BIT_CTL_SENDOPT;
 837
 838                 } else if (drv_data->tx != NULL) {
 839                         dev_dbg(&drv_data->pdev->dev, "doing DMA out.\n");
 840
 841                         /* flush caches, if needed */
 842                         if (bfin_addr_dcachable((unsigned long) drv_data->tx))
 843                                 flush_dcache_range((unsigned long) drv_data->tx,
 844                                                 (unsigned long) (drv_data->tx +
 845                                                 drv_data->len_in_bytes));
 846
 847                         dma_start_addr = (unsigned long)drv_data->tx;
 848                         cr |= BIT_CTL_TIMOD_DMA_TX;
 849
 850                 } else
 851                         BUG();
 852
 853                 /* oh man, here there be monsters ... and i dont mean the
 854                  * fluffy cute ones from pixar, i mean the kind that'll eat
 855                  * your data, kick your dog, and love it all.  do *not* try
 856                  * and change these lines unless you (1) heavily test DMA
 857                  * with SPI flashes on a loaded system (e.g. ping floods),
 858                  * (2) know just how broken the DMA engine interaction with
 859                  * the SPI peripheral is, and (3) have someone else to blame
 860                  * when you screw it all up anyways.
 861                  */
 862                 set_dma_start_addr(drv_data->dma_channel, dma_start_addr);
 863                 set_dma_config(drv_data->dma_channel, dma_config);
 864                 local_irq_save(flags);
 865                 SSYNC();
 866                 write_CTRL(drv_data, cr);
 867                 enable_dma(drv_data->dma_channel);
 868                 dma_enable_irq(drv_data->dma_channel);
 869                 local_irq_restore(flags);
 870
 871         } else {
 872                 /* IO mode write then read */
 873                 dev_dbg(&drv_data->pdev->dev, "doing IO transfer\n");
 874
 875                 if (full_duplex) {
 876                         /* full duplex mode */
 877                         BUG_ON((drv_data->tx_end - drv_data->tx) !=
 878                                (drv_data->rx_end - drv_data->rx));
 879                         dev_dbg(&drv_data->pdev->dev,
 880                                 "IO duplex: cr is 0x%x\n", cr);
 881
 882                         /* set SPI transfer mode */
 883                         write_CTRL(drv_data, (cr | CFG_SPI_WRITE));
 884
 885                         drv_data->duplex(drv_data);
 886
 887                         if (drv_data->tx != drv_data->tx_end)
 888                                 tranf_success = 0;
 889                 } else if (drv_data->tx != NULL) {
 890                         /* write only half duplex */
 891                         dev_dbg(&drv_data->pdev->dev,
 892                                 "IO write: cr is 0x%x\n", cr);
 893
 894                         /* set SPI transfer mode */
 895                         write_CTRL(drv_data, (cr | CFG_SPI_WRITE));
 896
 897                         drv_data->write(drv_data);
 898
 899                         if (drv_data->tx != drv_data->tx_end)
 900                                 tranf_success = 0;
 901                 } else if (drv_data->rx != NULL) {
 902                         /* read only half duplex */
 903                         dev_dbg(&drv_data->pdev->dev,
 904                                 "IO read: cr is 0x%x\n", cr);
 905
 906                         /* set SPI transfer mode */
 907                         write_CTRL(drv_data, (cr | CFG_SPI_READ));
 908
 909                         drv_data->read(drv_data);
 910                         if (drv_data->rx != drv_data->rx_end)
 911                                 tranf_success = 0;
 912                 }
 913
 914                 if (!tranf_success) {
 915                         dev_dbg(&drv_data->pdev->dev,
 916                                 "IO write error!\n");
 917                         message->state = ERROR_STATE;
 918                 } else {
 919                         /* Update total byte transfered */
 920                         message->actual_length += drv_data->len_in_bytes;
 921                         /* Move to next transfer of this msg */
 922                         message->state = next_transfer(drv_data);
 923                         if (drv_data->cs_change)
 924                                 cs_deactive(drv_data, chip);
 925                 }
 926                 /* Schedule next transfer tasklet */
 927                 tasklet_schedule(&drv_data->pump_transfers);
 928
 929         }
 930 }
 931
 932 /* pop a msg from queue and kick off real transfer */
 933 static void pump_messages(struct work_struct *work)
 934 {
 935         struct driver_data *drv_data;
 936         unsigned long flags;
 937
 938         drv_data = container_of(work, struct driver_data, pump_messages);
 939
 940         /* Lock queue and check for queue work */
 941         spin_lock_irqsave(&drv_data->lock, flags);
 942         if (list_empty(&drv_data->queue) || drv_data->run == QUEUE_STOPPED) {
 943                 /* pumper kicked off but no work to do */
 944                 drv_data->busy = 0;
 945                 spin_unlock_irqrestore(&drv_data->lock, flags);
 946                 return;
 947         }
 948
 949         /* Make sure we are not already running a message */
 950         if (drv_data->cur_msg) {
 951                 spin_unlock_irqrestore(&drv_data->lock, flags);
 952                 return;
 953         }
 954
 955         /* Extract head of queue */
 956         drv_data->cur_msg = list_entry(drv_data->queue.next,
 957                                        struct spi_message, queue);
 958
 959         /* Setup the SSP using the per chip configuration */
 960         drv_data->cur_chip = spi_get_ctldata(drv_data->cur_msg->spi);
 961         restore_state(drv_data);
 962
 963         list_del_init(&drv_data->cur_msg->queue);
 964
 965         /* Initial message state */
 966         drv_data->cur_msg->state = START_STATE;
 967         drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
 968                                             struct spi_transfer, transfer_list);
 969
 970         dev_dbg(&drv_data->pdev->dev, "got a message to pump, "
 971                 "state is set to: baud %d, flag 0x%x, ctl 0x%x\n",
 972                 drv_data->cur_chip->baud, drv_data->cur_chip->flag,
 973                 drv_data->cur_chip->ctl_reg);
 974
 975         dev_dbg(&drv_data->pdev->dev,
 976                 "the first transfer len is %d\n",
 977                 drv_data->cur_transfer->len);
 978
 979         /* Mark as busy and launch transfers */
 980         tasklet_schedule(&drv_data->pump_transfers);
 981
 982         drv_data->busy = 1;
 983         spin_unlock_irqrestore(&drv_data->lock, flags);
 984 }
 985
 986 /*
 987  * got a msg to transfer, queue it in drv_data->queue.
 988  * And kick off message pumper
 989  */
 990 static int transfer(struct spi_device *spi, struct spi_message *msg)
 991 {
 992         struct driver_data *drv_data = spi_master_get_devdata(spi->master);
 993         unsigned long flags;
 994
 995         spin_lock_irqsave(&drv_data->lock, flags);
 996
 997         if (drv_data->run == QUEUE_STOPPED) {
 998                 spin_unlock_irqrestore(&drv_data->lock, flags);
 999                 return -ESHUTDOWN;
1000         }
1001
1002         msg->actual_length = 0;
1003         msg->status = -EINPROGRESS;
1004         msg->state = START_STATE;
1005
1006         dev_dbg(&spi->dev, "adding an msg in transfer() \n");
1007         list_add_tail(&msg->queue, &drv_data->queue);
1008
1009         if (drv_data->run == QUEUE_RUNNING && !drv_data->busy)
1010                 queue_work(drv_data->workqueue, &drv_data->pump_messages);
1011
1012         spin_unlock_irqrestore(&drv_data->lock, flags);
1013
1014         return 0;
1015 }
1016
1017 #define MAX_SPI_SSEL    7
1018
1019 static u16 ssel[][MAX_SPI_SSEL] = {
1020         {P_SPI0_SSEL1, P_SPI0_SSEL2, P_SPI0_SSEL3,
1021         P_SPI0_SSEL4, P_SPI0_SSEL5,
1022         P_SPI0_SSEL6, P_SPI0_SSEL7},
1023
1024         {P_SPI1_SSEL1, P_SPI1_SSEL2, P_SPI1_SSEL3,
1025         P_SPI1_SSEL4, P_SPI1_SSEL5,
1026         P_SPI1_SSEL6, P_SPI1_SSEL7},
1027
1028         {P_SPI2_SSEL1, P_SPI2_SSEL2, P_SPI2_SSEL3,
1029         P_SPI2_SSEL4, P_SPI2_SSEL5,
1030         P_SPI2_SSEL6, P_SPI2_SSEL7},
1031 };
1032
1033 /* first setup for new devices */
1034 static int setup(struct spi_device *spi)
1035 {
1036         struct bfin5xx_spi_chip *chip_info = NULL;
1037         struct chip_data *chip;
1038         struct driver_data *drv_data = spi_master_get_devdata(spi->master);
1039
1040         /* Abort device setup if requested features are not supported */
1041         if (spi->mode & ~(SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST)) {
1042                 dev_err(&spi->dev, "requested mode not fully supported\n");
1043                 return -EINVAL;
1044         }
1045
1046         /* Zero (the default) here means 8 bits */
1047         if (!spi->bits_per_word)
1048                 spi->bits_per_word = 8;
1049
1050         if (spi->bits_per_word != 8 && spi->bits_per_word != 16)
1051                 return -EINVAL;
1052
1053         /* Only alloc (or use chip_info) on first setup */
1054         chip = spi_get_ctldata(spi);
1055         if (chip == NULL) {
1056                 chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
1057                 if (!chip)
1058                         return -ENOMEM;
1059
1060                 chip->enable_dma = 0;
1061                 chip_info = spi->controller_data;
1062         }
1063
1064         /* chip_info isn't always needed */
1065         if (chip_info) {
1066                 /* Make sure people stop trying to set fields via ctl_reg
1067                  * when they should actually be using common SPI framework.
1068                  * Currently we let through: WOM EMISO PSSE GM SZ TIMOD.
1069                  * Not sure if a user actually needs/uses any of these,
1070                  * but let's assume (for now) they do.
1071                  */
1072                 if (chip_info->ctl_reg & (SPE|MSTR|CPOL|CPHA|LSBF|SIZE)) {
1073                         dev_err(&spi->dev, "do not set bits in ctl_reg "
1074                                 "that the SPI framework manages\n");
1075                         return -EINVAL;
1076                 }
1077
1078                 chip->enable_dma = chip_info->enable_dma != 0
1079                     && drv_data->master_info->enable_dma;
1080                 chip->ctl_reg = chip_info->ctl_reg;
1081                 chip->bits_per_word = chip_info->bits_per_word;
1082                 chip->cs_change_per_word = chip_info->cs_change_per_word;
1083                 chip->cs_chg_udelay = chip_info->cs_chg_udelay;
1084         }
1085
1086         /* translate common spi framework into our register */
1087         if (spi->mode & SPI_CPOL)
1088                 chip->ctl_reg |= CPOL;
1089         if (spi->mode & SPI_CPHA)
1090                 chip->ctl_reg |= CPHA;
1091         if (spi->mode & SPI_LSB_FIRST)
1092                 chip->ctl_reg |= LSBF;
1093         /* we dont support running in slave mode (yet?) */
1094         chip->ctl_reg |= MSTR;
1095
1096         /*
1097          * if any one SPI chip is registered and wants DMA, request the
1098          * DMA channel for it
1099          */
1100         if (chip->enable_dma && !drv_data->dma_requested) {
1101                 /* register dma irq handler */
1102                 if (request_dma(drv_data->dma_channel, "BFIN_SPI_DMA") < 0) {
1103                         dev_dbg(&spi->dev,
1104                                 "Unable to request BlackFin SPI DMA channel\n");
1105                         return -ENODEV;
1106                 }
1107                 if (set_dma_callback(drv_data->dma_channel,
1108                     dma_irq_handler, drv_data) < 0) {
1109                         dev_dbg(&spi->dev, "Unable to set dma callback\n");
1110                         return -EPERM;
1111                 }
1112                 dma_disable_irq(drv_data->dma_channel);
1113                 drv_data->dma_requested = 1;
1114         }
1115
1116         /*
1117          * Notice: for blackfin, the speed_hz is the value of register
1118          * SPI_BAUD, not the real baudrate
1119          */
1120         chip->baud = hz_to_spi_baud(spi->max_speed_hz);
1121         chip->flag = 1 << (spi->chip_select);
1122         chip->chip_select_num = spi->chip_select;
1123
1124         switch (chip->bits_per_word) {
1125         case 8:
1126                 chip->n_bytes = 1;
1127                 chip->width = CFG_SPI_WORDSIZE8;
1128                 chip->read = chip->cs_change_per_word ?
1129                         u8_cs_chg_reader : u8_reader;
1130                 chip->write = chip->cs_change_per_word ?
1131                         u8_cs_chg_writer : u8_writer;
1132                 chip->duplex = chip->cs_change_per_word ?
1133                         u8_cs_chg_duplex : u8_duplex;
1134                 break;
1135
1136         case 16:
1137                 chip->n_bytes = 2;
1138                 chip->width = CFG_SPI_WORDSIZE16;
1139                 chip->read = chip->cs_change_per_word ?
1140                         u16_cs_chg_reader : u16_reader;
1141                 chip->write = chip->cs_change_per_word ?
1142                         u16_cs_chg_writer : u16_writer;
1143                 chip->duplex = chip->cs_change_per_word ?
1144                         u16_cs_chg_duplex : u16_duplex;
1145                 break;
1146
1147         default:
1148                 dev_err(&spi->dev, "%d bits_per_word is not supported\n",
1149                                 chip->bits_per_word);
1150                 kfree(chip);
1151                 return -ENODEV;
1152         }
1153
1154         dev_dbg(&spi->dev, "setup spi chip %s, width is %d, dma is %d\n",
1155                         spi->modalias, chip->width, chip->enable_dma);
1156         dev_dbg(&spi->dev, "ctl_reg is 0x%x, flag_reg is 0x%x\n",
1157                         chip->ctl_reg, chip->flag);
1158
1159         spi_set_ctldata(spi, chip);
1160
1161         dev_dbg(&spi->dev, "chip select number is %d\n", chip->chip_select_num);
1162         if ((chip->chip_select_num > 0)
1163                 && (chip->chip_select_num <= spi->master->num_chipselect))
1164                 peripheral_request(ssel[spi->master->bus_num]
1165                         [chip->chip_select_num-1], spi->modalias);
1166
1167         cs_deactive(drv_data, chip);
1168
1169         return 0;
1170 }
1171
1172 /*
1173  * callback for spi framework.
1174  * clean driver specific data
1175  */
1176 static void cleanup(struct spi_device *spi)
1177 {
1178         struct chip_data *chip = spi_get_ctldata(spi);
1179
1180         if ((chip->chip_select_num > 0)
1181                 && (chip->chip_select_num <= spi->master->num_chipselect))
1182                 peripheral_free(ssel[spi->master->bus_num]
1183                                         [chip->chip_select_num-1]);
1184
1185         kfree(chip);
1186 }
1187
1188 static inline int init_queue(struct driver_data *drv_data)
1189 {
1190         INIT_LIST_HEAD(&drv_data->queue);
1191         spin_lock_init(&drv_data->lock);
1192
1193         drv_data->run = QUEUE_STOPPED;
1194         drv_data->busy = 0;
1195
1196         /* init transfer tasklet */
1197         tasklet_init(&drv_data->pump_transfers,
1198                      pump_transfers, (unsigned long)drv_data);
1199
1200         /* init messages workqueue */
1201         INIT_WORK(&drv_data->pump_messages, pump_messages);
1202         drv_data->workqueue = create_singlethread_workqueue(
1203                                 dev_name(drv_data->master->dev.parent));
1204         if (drv_data->workqueue == NULL)
1205                 return -EBUSY;
1206
1207         return 0;
1208 }
1209
1210 static inline int start_queue(struct driver_data *drv_data)
1211 {
1212         unsigned long flags;
1213
1214         spin_lock_irqsave(&drv_data->lock, flags);
1215
1216         if (drv_data->run == QUEUE_RUNNING || drv_data->busy) {
1217                 spin_unlock_irqrestore(&drv_data->lock, flags);
1218                 return -EBUSY;
1219         }
1220
1221         drv_data->run = QUEUE_RUNNING;
1222         drv_data->cur_msg = NULL;
1223         drv_data->cur_transfer = NULL;
1224         drv_data->cur_chip = NULL;
1225         spin_unlock_irqrestore(&drv_data->lock, flags);
1226
1227         queue_work(drv_data->workqueue, &drv_data->pump_messages);
1228
1229         return 0;
1230 }
1231
1232 static inline int stop_queue(struct driver_data *drv_data)
1233 {
1234         unsigned long flags;
1235         unsigned limit = 500;
1236         int status = 0;
1237
1238         spin_lock_irqsave(&drv_data->lock, flags);
1239
1240         /*
1241          * This is a bit lame, but is optimized for the common execution path.
1242          * A wait_queue on the drv_data->busy could be used, but then the common
1243          * execution path (pump_messages) would be required to call wake_up or
1244          * friends on every SPI message. Do this instead
1245          */
1246         drv_data->run = QUEUE_STOPPED;
1247         while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
1248                 spin_unlock_irqrestore(&drv_data->lock, flags);
1249                 msleep(10);
1250                 spin_lock_irqsave(&drv_data->lock, flags);
1251         }
1252
1253         if (!list_empty(&drv_data->queue) || drv_data->busy)
1254                 status = -EBUSY;
1255
1256         spin_unlock_irqrestore(&drv_data->lock, flags);
1257
1258         return status;
1259 }
1260
1261 static inline int destroy_queue(struct driver_data *drv_data)
1262 {
1263         int status;
1264
1265         status = stop_queue(drv_data);
1266         if (status != 0)
1267                 return status;
1268
1269         destroy_workqueue(drv_data->workqueue);
1270
1271         return 0;
1272 }
1273
1274 static int __init bfin5xx_spi_probe(struct platform_device *pdev)
1275 {
1276         struct device *dev = &pdev->dev;
1277         struct bfin5xx_spi_master *platform_info;
1278         struct spi_master *master;
1279         struct driver_data *drv_data = 0;
1280         struct resource *res;
1281         int status = 0;
1282
1283         platform_info = dev->platform_data;
1284
1285         /* Allocate master with space for drv_data */
1286         master = spi_alloc_master(dev, sizeof(struct driver_data) + 16);
1287         if (!master) {
1288                 dev_err(&pdev->dev, "can not alloc spi_master\n");
1289                 return -ENOMEM;
1290         }
1291
1292         drv_data = spi_master_get_devdata(master);
1293         drv_data->master = master;
1294         drv_data->master_info = platform_info;
1295         drv_data->pdev = pdev;
1296         drv_data->pin_req = platform_info->pin_req;
1297
1298         master->bus_num = pdev->id;
1299         master->num_chipselect = platform_info->num_chipselect;
1300         master->cleanup = cleanup;
1301         master->setup = setup;
1302         master->transfer = transfer;
1303
1304         /* Find and map our resources */
1305         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1306         if (res == NULL) {
1307                 dev_err(dev, "Cannot get IORESOURCE_MEM\n");
1308                 status = -ENOENT;
1309                 goto out_error_get_res;
1310         }
1311
1312         drv_data->regs_base = ioremap(res->start, (res->end - res->start + 1));
1313         if (drv_data->regs_base == NULL) {
1314                 dev_err(dev, "Cannot map IO\n");
1315                 status = -ENXIO;
1316                 goto out_error_ioremap;
1317         }
1318
1319         drv_data->dma_channel = platform_get_irq(pdev, 0);
1320         if (drv_data->dma_channel < 0) {
1321                 dev_err(dev, "No DMA channel specified\n");
1322                 status = -ENOENT;
1323                 goto out_error_no_dma_ch;
1324         }
1325
1326         /* Initial and start queue */
1327         status = init_queue(drv_data);
1328         if (status != 0) {
1329                 dev_err(dev, "problem initializing queue\n");
1330                 goto out_error_queue_alloc;
1331         }
1332
1333         status = start_queue(drv_data);
1334         if (status != 0) {
1335                 dev_err(dev, "problem starting queue\n");
1336                 goto out_error_queue_alloc;
1337         }
1338
1339         status = peripheral_request_list(drv_data->pin_req, DRV_NAME);
1340         if (status != 0) {
1341                 dev_err(&pdev->dev, ": Requesting Peripherals failed\n");
1342                 goto out_error_queue_alloc;
1343         }
1344
1345         /* Register with the SPI framework */
1346         platform_set_drvdata(pdev, drv_data);
1347         status = spi_register_master(master);
1348         if (status != 0) {
1349                 dev_err(dev, "problem registering spi master\n");
1350                 goto out_error_queue_alloc;
1351         }
1352
1353         dev_info(dev, "%s, Version %s, regs_base@%p, dma channel@%d\n",
1354                 DRV_DESC, DRV_VERSION, drv_data->regs_base,
1355                 drv_data->dma_channel);
1356         return status;
1357
1358 out_error_queue_alloc:
1359         destroy_queue(drv_data);
1360 out_error_no_dma_ch:
1361         iounmap((void *) drv_data->regs_base);
1362 out_error_ioremap:
1363 out_error_get_res:
1364         spi_master_put(master);
1365
1366         return status;
1367 }
1368
1369 /* stop hardware and remove the driver */
1370 static int __devexit bfin5xx_spi_remove(struct platform_device *pdev)
1371 {
1372         struct driver_data *drv_data = platform_get_drvdata(pdev);
1373         int status = 0;
1374
1375         if (!drv_data)
1376                 return 0;
1377
1378         /* Remove the queue */
1379         status = destroy_queue(drv_data);
1380         if (status != 0)
1381                 return status;
1382
1383         /* Disable the SSP at the peripheral and SOC level */
1384         bfin_spi_disable(drv_data);
1385
1386         /* Release DMA */
1387         if (drv_data->master_info->enable_dma) {
1388                 if (dma_channel_active(drv_data->dma_channel))
1389                         free_dma(drv_data->dma_channel);
1390         }
1391
1392         /* Disconnect from the SPI framework */
1393         spi_unregister_master(drv_data->master);
1394
1395         peripheral_free_list(drv_data->pin_req);
1396
1397         /* Prevent double remove */
1398         platform_set_drvdata(pdev, NULL);
1399
1400         return 0;
1401 }
1402
1403 #ifdef CONFIG_PM
1404 static int bfin5xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
1405 {
1406         struct driver_data *drv_data = platform_get_drvdata(pdev);
1407         int status = 0;
1408
1409         status = stop_queue(drv_data);
1410         if (status != 0)
1411                 return status;
1412
1413         /* stop hardware */
1414         bfin_spi_disable(drv_data);
1415
1416         return 0;
1417 }
1418
1419 static int bfin5xx_spi_resume(struct platform_device *pdev)
1420 {
1421         struct driver_data *drv_data = platform_get_drvdata(pdev);
1422         int status = 0;
1423
1424         /* Enable the SPI interface */
1425         bfin_spi_enable(drv_data);
1426
1427         /* Start the queue running */
1428         status = start_queue(drv_data);
1429         if (status != 0) {
1430                 dev_err(&pdev->dev, "problem starting queue (%d)\n", status);
1431                 return status;
1432         }
1433
1434         return 0;
1435 }
1436 #else
1437 #define bfin5xx_spi_suspend NULL
1438 #define bfin5xx_spi_resume NULL
1439 #endif                          /* CONFIG_PM */
1440
1441 MODULE_ALIAS("platform:bfin-spi");
1442 static struct platform_driver bfin5xx_spi_driver = {
1443         .driver = {
1444                 .name   = DRV_NAME,
1445                 .owner  = THIS_MODULE,
1446         },
1447         .suspend        = bfin5xx_spi_suspend,
1448         .resume         = bfin5xx_spi_resume,
1449         .remove         = __devexit_p(bfin5xx_spi_remove),
1450 };
1451
1452 static int __init bfin5xx_spi_init(void)
1453 {
1454         return platform_driver_probe(&bfin5xx_spi_driver, bfin5xx_spi_probe);
1455 }
1456 module_init(bfin5xx_spi_init);
1457
1458 static void __exit bfin5xx_spi_exit(void)
1459 {
1460         platform_driver_unregister(&bfin5xx_spi_driver);
1461 }
1462 module_exit(bfin5xx_spi_exit);