arch/mips/tx4938/toshiba_rbtx4938/spi_eeprom.c

   1 /*
   2  * linux/arch/mips/tx4938/toshiba_rbtx4938/spi_eeprom.c
   3  * Copyright (C) 2000-2001 Toshiba Corporation
   4  *
   5  * 2003-2005 (c) MontaVista Software, Inc. This file is licensed under the
   6  * terms of the GNU General Public License version 2. This program is
   7  * licensed "as is" without any warranty of any kind, whether express
   8  * or implied.
   9  *
  10  * Support for TX4938 in 2.6 - Manish Lachwani (mlachwani@mvista.com)
  11  */
  12 #include <linux/init.h>
  13 #include <linux/device.h>
  14 #include <linux/spi/spi.h>
  15 #include <linux/spi/eeprom.h>
  16 #include <asm/tx4938/spi.h>
  17
  18 #define AT250X0_PAGE_SIZE       8
  19
  20 /* register board information for at25 driver */
  21 int __init spi_eeprom_register(int chipid)
  22 {
  23         static struct spi_eeprom eeprom = {
  24                 .name = "at250x0",
  25                 .byte_len = 128,
  26                 .page_size = AT250X0_PAGE_SIZE,
  27                 .flags = EE_ADDR1,
  28         };
  29         struct spi_board_info info = {
  30                 .modalias = "at25",
  31                 .max_speed_hz = 1500000,        /* 1.5Mbps */
  32                 .bus_num = 0,
  33                 .chip_select = chipid,
  34                 .platform_data = &eeprom,
  35                 /* Mode 0: High-Active, Sample-Then-Shift */
  36         };
  37
  38         return spi_register_board_info(&info, 1);
  39 }
  40
  41 /* simple temporary spi driver to provide early access to seeprom. */
  42
  43 static struct read_param {
  44         int chipid;
  45         int address;
  46         unsigned char *buf;
  47         int len;
  48 } *read_param;
  49
  50 static int __init early_seeprom_probe(struct spi_device *spi)
  51 {
  52         int stat = 0;
  53         u8 cmd[2];
  54         int len = read_param->len;
  55         char *buf = read_param->buf;
  56         int address = read_param->address;
  57
  58         dev_info(&spi->dev, "spiclk %u KHz.\n",
  59                  (spi->max_speed_hz + 500) / 1000);
  60         if (read_param->chipid != spi->chip_select)
  61                 return -ENODEV;
  62         while (len > 0) {
  63                 /* spi_write_then_read can only work with small chunk */
  64                 int c = len < AT250X0_PAGE_SIZE ? len : AT250X0_PAGE_SIZE;
  65                 cmd[0] = 0x03;  /* AT25_READ */
  66                 cmd[1] = address;
  67                 stat = spi_write_then_read(spi, cmd, sizeof(cmd), buf, c);
  68                 buf += c;
  69                 len -= c;
  70                 address += c;
  71         }
  72         return stat;
  73 }
  74
  75 static struct spi_driver early_seeprom_driver __initdata = {
  76         .driver = {
  77                 .name   = "at25",
  78                 .owner  = THIS_MODULE,
  79         },
  80         .probe  = early_seeprom_probe,
  81 };
  82
  83 int __init spi_eeprom_read(int chipid, int address,
  84                            unsigned char *buf, int len)
  85 {
  86         int ret;
  87         struct read_param param = {
  88                 .chipid = chipid,
  89                 .address = address,
  90                 .buf = buf,
  91                 .len = len
  92         };
  93
  94         read_param = &param;
  95         ret = spi_register_driver(&early_seeprom_driver);
  96         if (!ret)
  97                 spi_unregister_driver(&early_seeprom_driver);
  98         return ret;
  99 }