← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/rtl8192e/r8180_93cx6.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/rtl8192e/r8180_93cx6.c
20
20
 
21
21
#include "r8180_93cx6.h"
22
22
 
23
 
static void eprom_cs(struct net_device *dev, short bit)
 
23
static void eprom_cs(struct r8192_priv *priv, short bit)
24
24
{
25
25
        if (bit)
26
 
                write_nic_byte(dev, EPROM_CMD,
 
26
                write_nic_byte(priv, EPROM_CMD,
27
27
                               (1<<EPROM_CS_SHIFT) |
28
 
                               read_nic_byte(dev, EPROM_CMD)); //enable EPROM
 
28
                               read_nic_byte(priv, EPROM_CMD)); //enable EPROM
29
29
        else
30
 
                write_nic_byte(dev, EPROM_CMD, read_nic_byte(dev, EPROM_CMD)
 
30
                write_nic_byte(priv, EPROM_CMD, read_nic_byte(priv, EPROM_CMD)
31
31
                               &~(1<<EPROM_CS_SHIFT)); //disable EPROM
32
32
 
33
33
        udelay(EPROM_DELAY);
34
34
}
35
35
 
36
36
 
37
 
static void eprom_ck_cycle(struct net_device *dev)
 
37
static void eprom_ck_cycle(struct r8192_priv *priv)
38
38
{
39
 
        write_nic_byte(dev, EPROM_CMD,
40
 
                       (1<<EPROM_CK_SHIFT) | read_nic_byte(dev, EPROM_CMD));
 
39
        write_nic_byte(priv, EPROM_CMD,
 
40
                       (1<<EPROM_CK_SHIFT) | read_nic_byte(priv, EPROM_CMD));
41
41
        udelay(EPROM_DELAY);
42
 
        write_nic_byte(dev, EPROM_CMD,
43
 
                       read_nic_byte(dev, EPROM_CMD) & ~(1<<EPROM_CK_SHIFT));
 
42
        write_nic_byte(priv, EPROM_CMD,
 
43
                       read_nic_byte(priv, EPROM_CMD) & ~(1<<EPROM_CK_SHIFT));
44
44
        udelay(EPROM_DELAY);
45
45
}
46
46
 
47
47
 
48
 
static void eprom_w(struct net_device *dev, short bit)
 
48
static void eprom_w(struct r8192_priv *priv, short bit)
49
49
{
50
50
        if (bit)
51
 
                write_nic_byte(dev, EPROM_CMD, (1<<EPROM_W_SHIFT) |
52
 
                               read_nic_byte(dev, EPROM_CMD));
 
51
                write_nic_byte(priv, EPROM_CMD, (1<<EPROM_W_SHIFT) |
 
52
                               read_nic_byte(priv, EPROM_CMD));
53
53
        else
54
 
                write_nic_byte(dev, EPROM_CMD, read_nic_byte(dev, EPROM_CMD)
 
54
                write_nic_byte(priv, EPROM_CMD, read_nic_byte(priv, EPROM_CMD)
55
55
                               &~(1<<EPROM_W_SHIFT));
56
56
 
57
57
        udelay(EPROM_DELAY);
58
58
}
59
59
 
60
60
 
61
 
static short eprom_r(struct net_device *dev)
 
61
static short eprom_r(struct r8192_priv *priv)
62
62
{
63
63
        short bit;
64
64
 
65
 
        bit = (read_nic_byte(dev, EPROM_CMD) & (1<<EPROM_R_SHIFT));
 
65
        bit = (read_nic_byte(priv, EPROM_CMD) & (1<<EPROM_R_SHIFT));
66
66
        udelay(EPROM_DELAY);
67
67
 
68
68
        if (bit)
71
71
}
72
72
 
73
73
 
74
 
static void eprom_send_bits_string(struct net_device *dev, short b[], int len)
 
74
static void eprom_send_bits_string(struct r8192_priv *priv, short b[], int len)
75
75
{
76
76
        int i;
77
77
 
78
78
        for (i = 0; i < len; i++) {
79
 
                eprom_w(dev, b[i]);
80
 
                eprom_ck_cycle(dev);
 
79
                eprom_w(priv, b[i]);
 
80
                eprom_ck_cycle(priv);
81
81
        }
82
82
}
83
83
 
84
84
 
85
 
u32 eprom_read(struct net_device *dev, u32 addr)
 
85
u32 eprom_read(struct r8192_priv *priv, u32 addr)
86
86
{
87
 
        struct r8192_priv *priv = ieee80211_priv(dev);
88
87
        short read_cmd[] = {1, 1, 0};
89
88
        short addr_str[8];
90
89
        int i;
93
92
 
94
93
        ret = 0;
95
94
        //enable EPROM programming
96
 
        write_nic_byte(dev, EPROM_CMD,
 
95
        write_nic_byte(priv, EPROM_CMD,
97
96
                       (EPROM_CMD_PROGRAM<<EPROM_CMD_OPERATING_MODE_SHIFT));
98
97
        udelay(EPROM_DELAY);
99
98
 
116
115
                addr_str[0] = addr & (1<<5);
117
116
                addr_len = 6;
118
117
        }
119
 
        eprom_cs(dev, 1);
120
 
        eprom_ck_cycle(dev);
121
 
        eprom_send_bits_string(dev, read_cmd, 3);
122
 
        eprom_send_bits_string(dev, addr_str, addr_len);
 
118
        eprom_cs(priv, 1);
 
119
        eprom_ck_cycle(priv);
 
120
        eprom_send_bits_string(priv, read_cmd, 3);
 
121
        eprom_send_bits_string(priv, addr_str, addr_len);
123
122
 
124
123
        //keep chip pin D to low state while reading.
125
124
        //I'm unsure if it is necessary, but anyway shouldn't hurt
126
 
        eprom_w(dev, 0);
 
125
        eprom_w(priv, 0);
127
126
 
128
127
        for (i = 0; i < 16; i++) {
129
128
                //eeprom needs a clk cycle between writing opcode&adr
130
129
                //and reading data. (eeprom outs a dummy 0)
131
 
                eprom_ck_cycle(dev);
132
 
                ret |= (eprom_r(dev)<<(15-i));
 
130
                eprom_ck_cycle(priv);
 
131
                ret |= (eprom_r(priv)<<(15-i));
133
132
        }
134
133
 
135
 
        eprom_cs(dev, 0);
136
 
        eprom_ck_cycle(dev);
 
134
        eprom_cs(priv, 0);
 
135
        eprom_ck_cycle(priv);
137
136
 
138
137
        //disable EPROM programming
139
 
        write_nic_byte(dev, EPROM_CMD,
 
138
        write_nic_byte(priv, EPROM_CMD,
140
139
                       (EPROM_CMD_NORMAL<<EPROM_CMD_OPERATING_MODE_SHIFT));
141
140
        return ret;
142
141
}