drivers/staging/rtl8192u/r8180_93cx6.c

   1 /*
   2    This files contains card eeprom (93c46 or 93c56) programming routines,
   3    memory is addressed by 16 bits words.
   4
   5    This is part of rtl8180 OpenSource driver.
   6    Copyright (C) Andrea Merello 2004  <andrea.merello@gmail.com>
   7    Released under the terms of GPL (General Public Licence)
   8
   9    Parts of this driver are based on the GPL part of the
  10    official realtek driver.
  11
  12    Parts of this driver are based on the rtl8180 driver skeleton
  13    from Patric Schenke & Andres Salomon.
  14
  15    Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver.
  16
  17    We want to thank the Authors of those projects and the Ndiswrapper
  18    project Authors.
  19 */
  20
  21 #include "r8180_93cx6.h"
  22
  23 static void eprom_cs(struct net_device *dev, short bit)
  24 {
  25         u8 cmdreg;
  26         int err;
  27
  28         err = read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
  29         if (err)
  30                 return;
  31         if (bit)
  32                 /* enable EPROM */
  33                 write_nic_byte_E(dev, EPROM_CMD, cmdreg | EPROM_CS_BIT);
  34         else
  35                 /* disable EPROM */
  36                 write_nic_byte_E(dev, EPROM_CMD, cmdreg & ~EPROM_CS_BIT);
  37
  38         force_pci_posting(dev);
  39         udelay(EPROM_DELAY);
  40 }
  41
  42
  43 static void eprom_ck_cycle(struct net_device *dev)
  44 {
  45         u8 cmdreg;
  46         int err;
  47
  48         err = read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
  49         if (err)
  50                 return;
  51         write_nic_byte_E(dev, EPROM_CMD, cmdreg | EPROM_CK_BIT);
  52         force_pci_posting(dev);
  53         udelay(EPROM_DELAY);
  54
  55         read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
  56         write_nic_byte_E(dev, EPROM_CMD, cmdreg & ~EPROM_CK_BIT);
  57         force_pci_posting(dev);
  58         udelay(EPROM_DELAY);
  59 }
  60
  61
  62 static void eprom_w(struct net_device *dev, short bit)
  63 {
  64         u8 cmdreg;
  65         int err;
  66
  67         err = read_nic_byte_E(dev, EPROM_CMD, &cmdreg);
  68         if (err)
  69                 return;
  70         if (bit)
  71                 write_nic_byte_E(dev, EPROM_CMD, cmdreg | EPROM_W_BIT);
  72         else
  73                 write_nic_byte_E(dev, EPROM_CMD, cmdreg & ~EPROM_W_BIT);
  74
  75         force_pci_posting(dev);
  76         udelay(EPROM_DELAY);
  77 }
  78
  79
  80 static short eprom_r(struct net_device *dev)
  81 {
  82         u8 bit;
  83         int err;
  84
  85         err = read_nic_byte_E(dev, EPROM_CMD, &bit);
  86         if (err)
  87                 return err;
  88
  89         udelay(EPROM_DELAY);
  90
  91         if (bit & EPROM_R_BIT)
  92                 return 1;
  93
  94         return 0;
  95 }
  96
  97
  98 static void eprom_send_bits_string(struct net_device *dev, short b[], int len)
  99 {
 100         int i;
 101
 102         for (i = 0; i < len; i++) {
 103                 eprom_w(dev, b[i]);
 104                 eprom_ck_cycle(dev);
 105         }
 106 }
 107
 108
 109 int eprom_read(struct net_device *dev, u32 addr)
 110 {
 111         struct r8192_priv *priv = ieee80211_priv(dev);
 112         short read_cmd[] = {1, 1, 0};
 113         short addr_str[8];
 114         int i;
 115         int addr_len;
 116         u32 ret;
 117         int err;
 118
 119         ret = 0;
 120         /* enable EPROM programming */
 121         write_nic_byte_E(dev, EPROM_CMD,
 122                        (EPROM_CMD_PROGRAM<<EPROM_CMD_OPERATING_MODE_SHIFT));
 123         force_pci_posting(dev);
 124         udelay(EPROM_DELAY);
 125
 126         if (priv->epromtype == EPROM_93c56) {
 127                 addr_str[7] = addr & 1;
 128                 addr_str[6] = addr & (1<<1);
 129                 addr_str[5] = addr & (1<<2);
 130                 addr_str[4] = addr & (1<<3);
 131                 addr_str[3] = addr & (1<<4);
 132                 addr_str[2] = addr & (1<<5);
 133                 addr_str[1] = addr & (1<<6);
 134                 addr_str[0] = addr & (1<<7);
 135                 addr_len = 8;
 136         } else {
 137                 addr_str[5] = addr & 1;
 138                 addr_str[4] = addr & (1<<1);
 139                 addr_str[3] = addr & (1<<2);
 140                 addr_str[2] = addr & (1<<3);
 141                 addr_str[1] = addr & (1<<4);
 142                 addr_str[0] = addr & (1<<5);
 143                 addr_len = 6;
 144         }
 145         eprom_cs(dev, 1);
 146         eprom_ck_cycle(dev);
 147         eprom_send_bits_string(dev, read_cmd, 3);
 148         eprom_send_bits_string(dev, addr_str, addr_len);
 149
 150         /*
 151          * keep chip pin D to low state while reading.
 152          * I'm unsure if it is necessary, but anyway shouldn't hurt
 153          */
 154         eprom_w(dev, 0);
 155
 156         for (i = 0; i < 16; i++) {
 157                 /* eeprom needs a clk cycle between writing opcode&adr
 158                  * and reading data. (eeprom outs a dummy 0)
 159                  */
 160                 eprom_ck_cycle(dev);
 161                 err = eprom_r(dev);
 162                 if (err < 0)
 163                         return err;
 164
 165                 ret |= err<<(15-i);
 166         }
 167
 168         eprom_cs(dev, 0);
 169         eprom_ck_cycle(dev);
 170
 171         /* disable EPROM programming */
 172         write_nic_byte_E(dev, EPROM_CMD,
 173                        (EPROM_CMD_NORMAL<<EPROM_CMD_OPERATING_MODE_SHIFT));
 174         return ret;
 175 }