arch/arm/mach-pxa/lubbock.c

   1 /*
   2  *  linux/arch/arm/mach-pxa/lubbock.c
   3  *
   4  *  Support for the Intel DBPXA250 Development Platform.
   5  *
   6  *  Author:     Nicolas Pitre
   7  *  Created:    Jun 15, 2001
   8  *  Copyright:  MontaVista Software Inc.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2 as
  12  *  published by the Free Software Foundation.
  13  */
  14 #include <linux/clkdev.h>
  15 #include <linux/gpio.h>
  16 #include <linux/gpio/gpio-reg.h>
  17 #include <linux/gpio/machine.h>
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/init.h>
  21 #include <linux/io.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/syscore_ops.h>
  24 #include <linux/major.h>
  25 #include <linux/fb.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/mtd/mtd.h>
  28 #include <linux/mtd/partitions.h>
  29 #include <linux/smc91x.h>
  30 #include <linux/slab.h>
  31 #include <linux/leds.h>
  32
  33 #include <linux/spi/spi.h>
  34 #include <linux/spi/ads7846.h>
  35 #include <linux/spi/pxa2xx_spi.h>
  36
  37 #include <asm/setup.h>
  38 #include <asm/memory.h>
  39 #include <asm/mach-types.h>
  40 #include <mach/hardware.h>
  41 #include <asm/irq.h>
  42 #include <asm/sizes.h>
  43
  44 #include <asm/mach/arch.h>
  45 #include <asm/mach/map.h>
  46 #include <asm/mach/irq.h>
  47 #include <asm/mach/flash.h>
  48
  49 #include <asm/hardware/sa1111.h>
  50
  51 #include "pxa25x.h"
  52 #include <mach/audio.h>
  53 #include <mach/lubbock.h>
  54 #include "udc.h"
  55 #include <linux/platform_data/irda-pxaficp.h>
  56 #include <linux/platform_data/video-pxafb.h>
  57 #include <linux/platform_data/mmc-pxamci.h>
  58 #include "pm.h"
  59 #include <mach/smemc.h>
  60
  61 #include "generic.h"
  62 #include "devices.h"
  63
  64 static unsigned long lubbock_pin_config[] __initdata = {
  65         GPIO15_nCS_1,   /* CS1 - Flash */
  66         GPIO78_nCS_2,   /* CS2 - Baseboard FGPA */
  67         GPIO79_nCS_3,   /* CS3 - SMC ethernet */
  68         GPIO80_nCS_4,   /* CS4 - SA1111 */
  69
  70         /* SSP data pins */
  71         GPIO23_SSP1_SCLK,
  72         GPIO25_SSP1_TXD,
  73         GPIO26_SSP1_RXD,
  74
  75         /* AC97 */
  76         GPIO28_AC97_BITCLK,
  77         GPIO29_AC97_SDATA_IN_0,
  78         GPIO30_AC97_SDATA_OUT,
  79         GPIO31_AC97_SYNC,
  80
  81         /* LCD - 16bpp DSTN */
  82         GPIOxx_LCD_DSTN_16BPP,
  83
  84         /* BTUART */
  85         GPIO42_BTUART_RXD,
  86         GPIO43_BTUART_TXD,
  87         GPIO44_BTUART_CTS,
  88         GPIO45_BTUART_RTS,
  89
  90         /* PC Card */
  91         GPIO48_nPOE,
  92         GPIO49_nPWE,
  93         GPIO50_nPIOR,
  94         GPIO51_nPIOW,
  95         GPIO52_nPCE_1,
  96         GPIO53_nPCE_2,
  97         GPIO54_nPSKTSEL,
  98         GPIO55_nPREG,
  99         GPIO56_nPWAIT,
 100         GPIO57_nIOIS16,
 101
 102         /* MMC */
 103         GPIO6_MMC_CLK,
 104         GPIO8_MMC_CS0,
 105
 106         /* SA1111 chip */
 107         GPIO11_3_6MHz,
 108
 109         /* wakeup */
 110         GPIO1_GPIO | WAKEUP_ON_EDGE_RISE,
 111 };
 112
 113 #define LUB_HEXLED              __LUB_REG(LUBBOCK_FPGA_PHYS + 0x010)
 114
 115 void lubbock_set_hexled(uint32_t value)
 116 {
 117         LUB_HEXLED = value;
 118 }
 119
 120 static struct gpio_chip *lubbock_misc_wr_gc;
 121
 122 void lubbock_set_misc_wr(unsigned int mask, unsigned int set)
 123 {
 124         unsigned long m = mask, v = set;
 125         lubbock_misc_wr_gc->set_multiple(lubbock_misc_wr_gc, &m, &v);
 126 }
 127 EXPORT_SYMBOL(lubbock_set_misc_wr);
 128
 129 static int lubbock_udc_is_connected(void)
 130 {
 131         return (LUB_MISC_RD & (1 << 9)) == 0;
 132 }
 133
 134 static struct pxa2xx_udc_mach_info udc_info __initdata = {
 135         .udc_is_connected       = lubbock_udc_is_connected,
 136         // no D+ pullup; lubbock can't connect/disconnect in software
 137 };
 138
 139 /* GPIOs for SA1111 PCMCIA */
 140 static struct gpiod_lookup_table sa1111_pcmcia_gpio_table = {
 141         .dev_id = "1800",
 142         .table = {
 143                 { "sa1111", 0, "a0vpp", GPIO_ACTIVE_HIGH },
 144                 { "sa1111", 1, "a1vpp", GPIO_ACTIVE_HIGH },
 145                 { "sa1111", 2, "a0vcc", GPIO_ACTIVE_HIGH },
 146                 { "sa1111", 3, "a1vcc", GPIO_ACTIVE_HIGH },
 147                 { "lubbock", 14, "b0vcc", GPIO_ACTIVE_HIGH },
 148                 { "lubbock", 15, "b1vcc", GPIO_ACTIVE_HIGH },
 149                 { },
 150         },
 151 };
 152
 153 static void lubbock_init_pcmcia(void)
 154 {
 155         struct clk *clk;
 156
 157         gpiod_add_lookup_table(&sa1111_pcmcia_gpio_table);
 158
 159         /* Add an alias for the SA1111 PCMCIA clock */
 160         clk = clk_get_sys("pxa2xx-pcmcia", NULL);
 161         if (!IS_ERR(clk)) {
 162                 clkdev_create(clk, NULL, "1800");
 163                 clk_put(clk);
 164         }
 165 }
 166
 167 static struct resource sa1111_resources[] = {
 168         [0] = {
 169                 .start  = 0x10000000,
 170                 .end    = 0x10001fff,
 171                 .flags  = IORESOURCE_MEM,
 172         },
 173         [1] = {
 174                 .start  = LUBBOCK_SA1111_IRQ,
 175                 .end    = LUBBOCK_SA1111_IRQ,
 176                 .flags  = IORESOURCE_IRQ,
 177         },
 178 };
 179
 180 static struct sa1111_platform_data sa1111_info = {
 181         .irq_base       = LUBBOCK_SA1111_IRQ_BASE,
 182         .disable_devs   = SA1111_DEVID_SAC,
 183 };
 184
 185 static struct platform_device sa1111_device = {
 186         .name           = "sa1111",
 187         .id             = -1,
 188         .num_resources  = ARRAY_SIZE(sa1111_resources),
 189         .resource       = sa1111_resources,
 190         .dev            = {
 191                 .platform_data  = &sa1111_info,
 192         },
 193 };
 194
 195 /* ADS7846 is connected through SSP ... and if your board has J5 populated,
 196  * you can select it to replace the ucb1400 by switching the touchscreen cable
 197  * (to J5) and poking board registers (as done below).  Else it's only useful
 198  * for the temperature sensors.
 199  */
 200 static struct pxa2xx_spi_controller pxa_ssp_master_info = {
 201         .num_chipselect = 1,
 202 };
 203
 204 static int lubbock_ads7846_pendown_state(void)
 205 {
 206         /* TS_BUSY is bit 8 in LUB_MISC_RD, but pendown is irq-only */
 207         return 0;
 208 }
 209
 210 static struct ads7846_platform_data ads_info = {
 211         .model                  = 7846,
 212         .vref_delay_usecs       = 100,          /* internal, no cap */
 213         .get_pendown_state      = lubbock_ads7846_pendown_state,
 214         // .x_plate_ohms                = 500,  /* GUESS! */
 215         // .y_plate_ohms                = 500,  /* GUESS! */
 216 };
 217
 218 static void ads7846_cs(u32 command)
 219 {
 220         static const unsigned   TS_nCS = 1 << 11;
 221         lubbock_set_misc_wr(TS_nCS, (command == PXA2XX_CS_ASSERT) ? 0 : TS_nCS);
 222 }
 223
 224 static struct pxa2xx_spi_chip ads_hw = {
 225         .tx_threshold           = 1,
 226         .rx_threshold           = 2,
 227         .cs_control             = ads7846_cs,
 228 };
 229
 230 static struct spi_board_info spi_board_info[] __initdata = { {
 231         .modalias       = "ads7846",
 232         .platform_data  = &ads_info,
 233         .controller_data = &ads_hw,
 234         .irq            = LUBBOCK_BB_IRQ,
 235         .max_speed_hz   = 120000 /* max sample rate at 3V */
 236                                 * 26 /* command + data + overhead */,
 237         .bus_num        = 1,
 238         .chip_select    = 0,
 239 },
 240 };
 241
 242 static struct resource smc91x_resources[] = {
 243         [0] = {
 244                 .name   = "smc91x-regs",
 245                 .start  = 0x0c000c00,
 246                 .end    = 0x0c0fffff,
 247                 .flags  = IORESOURCE_MEM,
 248         },
 249         [1] = {
 250                 .start  = LUBBOCK_ETH_IRQ,
 251                 .end    = LUBBOCK_ETH_IRQ,
 252                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
 253         },
 254         [2] = {
 255                 .name   = "smc91x-attrib",
 256                 .start  = 0x0e000000,
 257                 .end    = 0x0e0fffff,
 258                 .flags  = IORESOURCE_MEM,
 259         },
 260 };
 261
 262 static struct smc91x_platdata lubbock_smc91x_info = {
 263         .flags  = SMC91X_USE_16BIT | SMC91X_NOWAIT | SMC91X_IO_SHIFT_2,
 264 };
 265
 266 static struct platform_device smc91x_device = {
 267         .name           = "smc91x",
 268         .id             = -1,
 269         .num_resources  = ARRAY_SIZE(smc91x_resources),
 270         .resource       = smc91x_resources,
 271         .dev            = {
 272                 .platform_data = &lubbock_smc91x_info,
 273         },
 274 };
 275
 276 static struct resource flash_resources[] = {
 277         [0] = {
 278                 .start  = 0x00000000,
 279                 .end    = SZ_64M - 1,
 280                 .flags  = IORESOURCE_MEM,
 281         },
 282         [1] = {
 283                 .start  = 0x04000000,
 284                 .end    = 0x04000000 + SZ_64M - 1,
 285                 .flags  = IORESOURCE_MEM,
 286         },
 287 };
 288
 289 static struct mtd_partition lubbock_partitions[] = {
 290         {
 291                 .name =         "Bootloader",
 292                 .size =         0x00040000,
 293                 .offset =       0,
 294                 .mask_flags =   MTD_WRITEABLE  /* force read-only */
 295         },{
 296                 .name =         "Kernel",
 297                 .size =         0x00100000,
 298                 .offset =       0x00040000,
 299         },{
 300                 .name =         "Filesystem",
 301                 .size =         MTDPART_SIZ_FULL,
 302                 .offset =       0x00140000
 303         }
 304 };
 305
 306 static struct flash_platform_data lubbock_flash_data[2] = {
 307         {
 308                 .map_name       = "cfi_probe",
 309                 .parts          = lubbock_partitions,
 310                 .nr_parts       = ARRAY_SIZE(lubbock_partitions),
 311         }, {
 312                 .map_name       = "cfi_probe",
 313                 .parts          = NULL,
 314                 .nr_parts       = 0,
 315         }
 316 };
 317
 318 static struct platform_device lubbock_flash_device[2] = {
 319         {
 320                 .name           = "pxa2xx-flash",
 321                 .id             = 0,
 322                 .dev = {
 323                         .platform_data = &lubbock_flash_data[0],
 324                 },
 325                 .resource = &flash_resources[0],
 326                 .num_resources = 1,
 327         },
 328         {
 329                 .name           = "pxa2xx-flash",
 330                 .id             = 1,
 331                 .dev = {
 332                         .platform_data = &lubbock_flash_data[1],
 333                 },
 334                 .resource = &flash_resources[1],
 335                 .num_resources = 1,
 336         },
 337 };
 338
 339 static struct resource lubbock_cplds_resources[] = {
 340         [0] = {
 341                 .start  = LUBBOCK_FPGA_PHYS + 0xc0,
 342                 .end    = LUBBOCK_FPGA_PHYS + 0xe0 - 1,
 343                 .flags  = IORESOURCE_MEM,
 344         },
 345         [1] = {
 346                 .start  = PXA_GPIO_TO_IRQ(0),
 347                 .end    = PXA_GPIO_TO_IRQ(0),
 348                 .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE,
 349         },
 350         [2] = {
 351                 .start  = LUBBOCK_IRQ(0),
 352                 .end    = LUBBOCK_IRQ(6),
 353                 .flags  = IORESOURCE_IRQ,
 354         },
 355 };
 356
 357 static struct platform_device lubbock_cplds_device = {
 358         .name           = "pxa_cplds_irqs",
 359         .id             = -1,
 360         .resource       = &lubbock_cplds_resources[0],
 361         .num_resources  = 3,
 362 };
 363
 364
 365 static struct platform_device *devices[] __initdata = {
 366         &sa1111_device,
 367         &smc91x_device,
 368         &lubbock_flash_device[0],
 369         &lubbock_flash_device[1],
 370         &lubbock_cplds_device,
 371 };
 372
 373 static struct pxafb_mode_info sharp_lm8v31_mode = {
 374         .pixclock       = 270000,
 375         .xres           = 640,
 376         .yres           = 480,
 377         .bpp            = 16,
 378         .hsync_len      = 1,
 379         .left_margin    = 3,
 380         .right_margin   = 3,
 381         .vsync_len      = 1,
 382         .upper_margin   = 0,
 383         .lower_margin   = 0,
 384         .sync           = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
 385         .cmap_greyscale = 0,
 386 };
 387
 388 static struct pxafb_mach_info sharp_lm8v31 = {
 389         .modes          = &sharp_lm8v31_mode,
 390         .num_modes      = 1,
 391         .cmap_inverse   = 0,
 392         .cmap_static    = 0,
 393         .lcd_conn       = LCD_COLOR_DSTN_16BPP | LCD_PCLK_EDGE_FALL |
 394                           LCD_AC_BIAS_FREQ(255),
 395 };
 396
 397 #define MMC_POLL_RATE           msecs_to_jiffies(1000)
 398
 399 static irq_handler_t mmc_detect_int;
 400 static void *mmc_detect_int_data;
 401 static struct timer_list mmc_timer;
 402
 403 static void lubbock_mmc_poll(struct timer_list *unused)
 404 {
 405         unsigned long flags;
 406
 407         /* clear any previous irq state, then ... */
 408         local_irq_save(flags);
 409         LUB_IRQ_SET_CLR &= ~(1 << 0);
 410         local_irq_restore(flags);
 411
 412         /* poll until mmc/sd card is removed */
 413         if (LUB_IRQ_SET_CLR & (1 << 0))
 414                 mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE);
 415         else {
 416                 (void) mmc_detect_int(LUBBOCK_SD_IRQ, mmc_detect_int_data);
 417                 enable_irq(LUBBOCK_SD_IRQ);
 418         }
 419 }
 420
 421 static irqreturn_t lubbock_detect_int(int irq, void *data)
 422 {
 423         /* IRQ is level triggered; disable, and poll for removal */
 424         disable_irq(irq);
 425         mod_timer(&mmc_timer, jiffies + MMC_POLL_RATE);
 426
 427         return mmc_detect_int(irq, data);
 428 }
 429
 430 static int lubbock_mci_init(struct device *dev,
 431                 irq_handler_t detect_int,
 432                 void *data)
 433 {
 434         /* detect card insert/eject */
 435         mmc_detect_int = detect_int;
 436         mmc_detect_int_data = data;
 437         timer_setup(&mmc_timer, lubbock_mmc_poll, 0);
 438         return request_irq(LUBBOCK_SD_IRQ, lubbock_detect_int,
 439                            0, "lubbock-sd-detect", data);
 440 }
 441
 442 static int lubbock_mci_get_ro(struct device *dev)
 443 {
 444         return (LUB_MISC_RD & (1 << 2)) != 0;
 445 }
 446
 447 static void lubbock_mci_exit(struct device *dev, void *data)
 448 {
 449         free_irq(LUBBOCK_SD_IRQ, data);
 450         del_timer_sync(&mmc_timer);
 451 }
 452
 453 static struct pxamci_platform_data lubbock_mci_platform_data = {
 454         .ocr_mask               = MMC_VDD_32_33|MMC_VDD_33_34,
 455         .detect_delay_ms        = 10,
 456         .init                   = lubbock_mci_init,
 457         .get_ro                 = lubbock_mci_get_ro,
 458         .exit                   = lubbock_mci_exit,
 459 };
 460
 461 static void lubbock_irda_transceiver_mode(struct device *dev, int mode)
 462 {
 463         unsigned long flags;
 464
 465         local_irq_save(flags);
 466         if (mode & IR_SIRMODE) {
 467                 lubbock_set_misc_wr(BIT(4), 0);
 468         } else if (mode & IR_FIRMODE) {
 469                 lubbock_set_misc_wr(BIT(4), BIT(4));
 470         }
 471         pxa2xx_transceiver_mode(dev, mode);
 472         local_irq_restore(flags);
 473 }
 474
 475 static struct pxaficp_platform_data lubbock_ficp_platform_data = {
 476         .gpio_pwdown            = -1,
 477         .transceiver_cap        = IR_SIRMODE | IR_FIRMODE,
 478         .transceiver_mode       = lubbock_irda_transceiver_mode,
 479 };
 480
 481 static void __init lubbock_init(void)
 482 {
 483         int flashboot = (LUB_CONF_SWITCHES & 1);
 484
 485         pxa2xx_mfp_config(ARRAY_AND_SIZE(lubbock_pin_config));
 486
 487         lubbock_misc_wr_gc = gpio_reg_init(NULL, (void *)&LUB_MISC_WR,
 488                                            -1, 16, "lubbock", 0, LUB_MISC_WR,
 489                                            NULL, NULL, NULL);
 490         if (IS_ERR(lubbock_misc_wr_gc)) {
 491                 pr_err("Lubbock: unable to register lubbock GPIOs: %ld\n",
 492                        PTR_ERR(lubbock_misc_wr_gc));
 493                 lubbock_misc_wr_gc = NULL;
 494         }
 495
 496         pxa_set_ffuart_info(NULL);
 497         pxa_set_btuart_info(NULL);
 498         pxa_set_stuart_info(NULL);
 499
 500         lubbock_init_pcmcia();
 501
 502         clk_add_alias("SA1111_CLK", NULL, "GPIO11_CLK", NULL);
 503         pxa_set_udc_info(&udc_info);
 504         pxa_set_fb_info(NULL, &sharp_lm8v31);
 505         pxa_set_mci_info(&lubbock_mci_platform_data);
 506         pxa_set_ficp_info(&lubbock_ficp_platform_data);
 507         pxa_set_ac97_info(NULL);
 508
 509         lubbock_flash_data[0].width = lubbock_flash_data[1].width =
 510                 (__raw_readl(BOOT_DEF) & 1) ? 2 : 4;
 511         /* Compensate for the nROMBT switch which swaps the flash banks */
 512         printk(KERN_NOTICE "Lubbock configured to boot from %s (bank %d)\n",
 513                flashboot?"Flash":"ROM", flashboot);
 514
 515         lubbock_flash_data[flashboot^1].name = "application-flash";
 516         lubbock_flash_data[flashboot].name = "boot-rom";
 517         (void) platform_add_devices(devices, ARRAY_SIZE(devices));
 518
 519         pxa2xx_set_spi_info(1, &pxa_ssp_master_info);
 520         spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info));
 521 }
 522
 523 static struct map_desc lubbock_io_desc[] __initdata = {
 524         {       /* CPLD */
 525                 .virtual        =  LUBBOCK_FPGA_VIRT,
 526                 .pfn            = __phys_to_pfn(LUBBOCK_FPGA_PHYS),
 527                 .length         = 0x00100000,
 528                 .type           = MT_DEVICE
 529         }
 530 };
 531
 532 static void __init lubbock_map_io(void)
 533 {
 534         pxa25x_map_io();
 535         iotable_init(lubbock_io_desc, ARRAY_SIZE(lubbock_io_desc));
 536
 537         PCFR |= PCFR_OPDE;
 538 }
 539
 540 /*
 541  * Driver for the 8 discrete LEDs available for general use:
 542  * Note: bits [15-8] are used to enable/blank the 8 7 segment hex displays
 543  * so be sure to not monkey with them here.
 544  */
 545
 546 #if defined(CONFIG_NEW_LEDS) && defined(CONFIG_LEDS_CLASS)
 547 struct lubbock_led {
 548         struct led_classdev     cdev;
 549         u8                      mask;
 550 };
 551
 552 /*
 553  * The triggers lines up below will only be used if the
 554  * LED triggers are compiled in.
 555  */
 556 static const struct {
 557         const char *name;
 558         const char *trigger;
 559 } lubbock_leds[] = {
 560         { "lubbock:D28", "default-on", },
 561         { "lubbock:D27", "cpu0", },
 562         { "lubbock:D26", "heartbeat" },
 563         { "lubbock:D25", },
 564         { "lubbock:D24", },
 565         { "lubbock:D23", },
 566         { "lubbock:D22", },
 567         { "lubbock:D21", },
 568 };
 569
 570 static void lubbock_led_set(struct led_classdev *cdev,
 571                               enum led_brightness b)
 572 {
 573         struct lubbock_led *led = container_of(cdev,
 574                                          struct lubbock_led, cdev);
 575         u32 reg = LUB_DISC_BLNK_LED;
 576
 577         if (b != LED_OFF)
 578                 reg |= led->mask;
 579         else
 580                 reg &= ~led->mask;
 581
 582         LUB_DISC_BLNK_LED = reg;
 583 }
 584
 585 static enum led_brightness lubbock_led_get(struct led_classdev *cdev)
 586 {
 587         struct lubbock_led *led = container_of(cdev,
 588                                          struct lubbock_led, cdev);
 589         u32 reg = LUB_DISC_BLNK_LED;
 590
 591         return (reg & led->mask) ? LED_FULL : LED_OFF;
 592 }
 593
 594 static int __init lubbock_leds_init(void)
 595 {
 596         int i;
 597
 598         if (!machine_is_lubbock())
 599                 return -ENODEV;
 600
 601         /* All ON */
 602         LUB_DISC_BLNK_LED |= 0xff;
 603         for (i = 0; i < ARRAY_SIZE(lubbock_leds); i++) {
 604                 struct lubbock_led *led;
 605
 606                 led = kzalloc(sizeof(*led), GFP_KERNEL);
 607                 if (!led)
 608                         break;
 609
 610                 led->cdev.name = lubbock_leds[i].name;
 611                 led->cdev.brightness_set = lubbock_led_set;
 612                 led->cdev.brightness_get = lubbock_led_get;
 613                 led->cdev.default_trigger = lubbock_leds[i].trigger;
 614                 led->mask = BIT(i);
 615
 616                 if (led_classdev_register(NULL, &led->cdev) < 0) {
 617                         kfree(led);
 618                         break;
 619                 }
 620         }
 621
 622         return 0;
 623 }
 624
 625 /*
 626  * Since we may have triggers on any subsystem, defer registration
 627  * until after subsystem_init.
 628  */
 629 fs_initcall(lubbock_leds_init);
 630 #endif
 631
 632 MACHINE_START(LUBBOCK, "Intel DBPXA250 Development Platform (aka Lubbock)")
 633         /* Maintainer: MontaVista Software Inc. */
 634         .map_io         = lubbock_map_io,
 635         .nr_irqs        = LUBBOCK_NR_IRQS,
 636         .init_irq       = pxa25x_init_irq,
 637         .handle_irq     = pxa25x_handle_irq,
 638         .init_time      = pxa_timer_init,
 639         .init_machine   = lubbock_init,
 640         .restart        = pxa_restart,
 641 MACHINE_END