GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / net / phy / spi_ks8995.c
1 /*
2  * SPI driver for Micrel/Kendin KS8995M and KSZ8864RMN ethernet switches
3  *
4  * Copyright (C) 2008 Gabor Juhos <juhosg at openwrt.org>
5  *
6  * This file was based on: drivers/spi/at25.c
7  *     Copyright (C) 2006 David Brownell
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License version 2 as published
11  * by the Free Software Foundation.
12  */
13
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/delay.h>
20 #include <linux/device.h>
21 #include <linux/gpio/consumer.h>
22 #include <linux/of.h>
23 #include <linux/of_gpio.h>
24
25 #include <linux/spi/spi.h>
26
27 #define DRV_VERSION             "0.1.1"
28 #define DRV_DESC                "Micrel KS8995 Ethernet switch SPI driver"
29
30 /* ------------------------------------------------------------------------ */
31
32 #define KS8995_REG_ID0          0x00    /* Chip ID0 */
33 #define KS8995_REG_ID1          0x01    /* Chip ID1 */
34
35 #define KS8995_REG_GC0          0x02    /* Global Control 0 */
36 #define KS8995_REG_GC1          0x03    /* Global Control 1 */
37 #define KS8995_REG_GC2          0x04    /* Global Control 2 */
38 #define KS8995_REG_GC3          0x05    /* Global Control 3 */
39 #define KS8995_REG_GC4          0x06    /* Global Control 4 */
40 #define KS8995_REG_GC5          0x07    /* Global Control 5 */
41 #define KS8995_REG_GC6          0x08    /* Global Control 6 */
42 #define KS8995_REG_GC7          0x09    /* Global Control 7 */
43 #define KS8995_REG_GC8          0x0a    /* Global Control 8 */
44 #define KS8995_REG_GC9          0x0b    /* Global Control 9 */
45
46 #define KS8995_REG_PC(p, r)     ((0x10 * p) + r)         /* Port Control */
47 #define KS8995_REG_PS(p, r)     ((0x10 * p) + r + 0xe)  /* Port Status */
48
49 #define KS8995_REG_TPC0         0x60    /* TOS Priority Control 0 */
50 #define KS8995_REG_TPC1         0x61    /* TOS Priority Control 1 */
51 #define KS8995_REG_TPC2         0x62    /* TOS Priority Control 2 */
52 #define KS8995_REG_TPC3         0x63    /* TOS Priority Control 3 */
53 #define KS8995_REG_TPC4         0x64    /* TOS Priority Control 4 */
54 #define KS8995_REG_TPC5         0x65    /* TOS Priority Control 5 */
55 #define KS8995_REG_TPC6         0x66    /* TOS Priority Control 6 */
56 #define KS8995_REG_TPC7         0x67    /* TOS Priority Control 7 */
57
58 #define KS8995_REG_MAC0         0x68    /* MAC address 0 */
59 #define KS8995_REG_MAC1         0x69    /* MAC address 1 */
60 #define KS8995_REG_MAC2         0x6a    /* MAC address 2 */
61 #define KS8995_REG_MAC3         0x6b    /* MAC address 3 */
62 #define KS8995_REG_MAC4         0x6c    /* MAC address 4 */
63 #define KS8995_REG_MAC5         0x6d    /* MAC address 5 */
64
65 #define KS8995_REG_IAC0         0x6e    /* Indirect Access Control 0 */
66 #define KS8995_REG_IAC1         0x6f    /* Indirect Access Control 0 */
67 #define KS8995_REG_IAD7         0x70    /* Indirect Access Data 7 */
68 #define KS8995_REG_IAD6         0x71    /* Indirect Access Data 6 */
69 #define KS8995_REG_IAD5         0x72    /* Indirect Access Data 5 */
70 #define KS8995_REG_IAD4         0x73    /* Indirect Access Data 4 */
71 #define KS8995_REG_IAD3         0x74    /* Indirect Access Data 3 */
72 #define KS8995_REG_IAD2         0x75    /* Indirect Access Data 2 */
73 #define KS8995_REG_IAD1         0x76    /* Indirect Access Data 1 */
74 #define KS8995_REG_IAD0         0x77    /* Indirect Access Data 0 */
75
76 #define KSZ8864_REG_ID1         0xfe    /* Chip ID in bit 7 */
77
78 #define KS8995_REGS_SIZE        0x80
79 #define KSZ8864_REGS_SIZE       0x100
80 #define KSZ8795_REGS_SIZE       0x100
81
82 #define ID1_CHIPID_M            0xf
83 #define ID1_CHIPID_S            4
84 #define ID1_REVISION_M          0x7
85 #define ID1_REVISION_S          1
86 #define ID1_START_SW            1       /* start the switch */
87
88 #define FAMILY_KS8995           0x95
89 #define FAMILY_KSZ8795          0x87
90 #define CHIPID_M                0
91 #define KS8995_CHIP_ID          0x00
92 #define KSZ8864_CHIP_ID         0x01
93 #define KSZ8795_CHIP_ID         0x09
94
95 #define KS8995_CMD_WRITE        0x02U
96 #define KS8995_CMD_READ         0x03U
97
98 #define KS8995_RESET_DELAY      10 /* usec */
99
100 enum ks8995_chip_variant {
101         ks8995,
102         ksz8864,
103         ksz8795,
104         max_variant
105 };
106
107 struct ks8995_chip_params {
108         char *name;
109         int family_id;
110         int chip_id;
111         int regs_size;
112         int addr_width;
113         int addr_shift;
114 };
115
116 static const struct ks8995_chip_params ks8995_chip[] = {
117         [ks8995] = {
118                 .name = "KS8995MA",
119                 .family_id = FAMILY_KS8995,
120                 .chip_id = KS8995_CHIP_ID,
121                 .regs_size = KS8995_REGS_SIZE,
122                 .addr_width = 8,
123                 .addr_shift = 0,
124         },
125         [ksz8864] = {
126                 .name = "KSZ8864RMN",
127                 .family_id = FAMILY_KS8995,
128                 .chip_id = KSZ8864_CHIP_ID,
129                 .regs_size = KSZ8864_REGS_SIZE,
130                 .addr_width = 8,
131                 .addr_shift = 0,
132         },
133         [ksz8795] = {
134                 .name = "KSZ8795CLX",
135                 .family_id = FAMILY_KSZ8795,
136                 .chip_id = KSZ8795_CHIP_ID,
137                 .regs_size = KSZ8795_REGS_SIZE,
138                 .addr_width = 12,
139                 .addr_shift = 1,
140         },
141 };
142
143 struct ks8995_pdata {
144         int reset_gpio;
145         enum of_gpio_flags reset_gpio_flags;
146 };
147
148 struct ks8995_switch {
149         struct spi_device       *spi;
150         struct mutex            lock;
151         struct ks8995_pdata     *pdata;
152         struct bin_attribute    regs_attr;
153         const struct ks8995_chip_params *chip;
154         int                     revision_id;
155 };
156
157 static const struct spi_device_id ks8995_id[] = {
158         {"ks8995", ks8995},
159         {"ksz8864", ksz8864},
160         {"ksz8795", ksz8795},
161         { }
162 };
163 MODULE_DEVICE_TABLE(spi, ks8995_id);
164
165 static const struct of_device_id ks8895_spi_of_match[] = {
166         { .compatible = "micrel,ks8995" },
167         { .compatible = "micrel,ksz8864" },
168         { .compatible = "micrel,ksz8795" },
169         { },
170  };
171 MODULE_DEVICE_TABLE(of, ks8895_spi_of_match);
172
173 static inline u8 get_chip_id(u8 val)
174 {
175         return (val >> ID1_CHIPID_S) & ID1_CHIPID_M;
176 }
177
178 static inline u8 get_chip_rev(u8 val)
179 {
180         return (val >> ID1_REVISION_S) & ID1_REVISION_M;
181 }
182
183 /* create_spi_cmd - create a chip specific SPI command header
184  * @ks: pointer to switch instance
185  * @cmd: SPI command for switch
186  * @address: register address for command
187  *
188  * Different chip families use different bit pattern to address the switches
189  * registers:
190  *
191  * KS8995: 8bit command + 8bit address
192  * KSZ8795: 3bit command + 12bit address + 1bit TR (?)
193  */
194 static inline __be16 create_spi_cmd(struct ks8995_switch *ks, int cmd,
195                                     unsigned address)
196 {
197         u16 result = cmd;
198
199         /* make room for address (incl. address shift) */
200         result <<= ks->chip->addr_width + ks->chip->addr_shift;
201         /* add address */
202         result |= address << ks->chip->addr_shift;
203         /* SPI protocol needs big endian */
204         return cpu_to_be16(result);
205 }
206 /* ------------------------------------------------------------------------ */
207 static int ks8995_read(struct ks8995_switch *ks, char *buf,
208                  unsigned offset, size_t count)
209 {
210         __be16 cmd;
211         struct spi_transfer t[2];
212         struct spi_message m;
213         int err;
214
215         cmd = create_spi_cmd(ks, KS8995_CMD_READ, offset);
216         spi_message_init(&m);
217
218         memset(&t, 0, sizeof(t));
219
220         t[0].tx_buf = &cmd;
221         t[0].len = sizeof(cmd);
222         spi_message_add_tail(&t[0], &m);
223
224         t[1].rx_buf = buf;
225         t[1].len = count;
226         spi_message_add_tail(&t[1], &m);
227
228         mutex_lock(&ks->lock);
229         err = spi_sync(ks->spi, &m);
230         mutex_unlock(&ks->lock);
231
232         return err ? err : count;
233 }
234
235 static int ks8995_write(struct ks8995_switch *ks, char *buf,
236                  unsigned offset, size_t count)
237 {
238         __be16 cmd;
239         struct spi_transfer t[2];
240         struct spi_message m;
241         int err;
242
243         cmd = create_spi_cmd(ks, KS8995_CMD_WRITE, offset);
244         spi_message_init(&m);
245
246         memset(&t, 0, sizeof(t));
247
248         t[0].tx_buf = &cmd;
249         t[0].len = sizeof(cmd);
250         spi_message_add_tail(&t[0], &m);
251
252         t[1].tx_buf = buf;
253         t[1].len = count;
254         spi_message_add_tail(&t[1], &m);
255
256         mutex_lock(&ks->lock);
257         err = spi_sync(ks->spi, &m);
258         mutex_unlock(&ks->lock);
259
260         return err ? err : count;
261 }
262
263 static inline int ks8995_read_reg(struct ks8995_switch *ks, u8 addr, u8 *buf)
264 {
265         return ks8995_read(ks, buf, addr, 1) != 1;
266 }
267
268 static inline int ks8995_write_reg(struct ks8995_switch *ks, u8 addr, u8 val)
269 {
270         char buf = val;
271
272         return ks8995_write(ks, &buf, addr, 1) != 1;
273 }
274
275 /* ------------------------------------------------------------------------ */
276
277 static int ks8995_stop(struct ks8995_switch *ks)
278 {
279         return ks8995_write_reg(ks, KS8995_REG_ID1, 0);
280 }
281
282 static int ks8995_start(struct ks8995_switch *ks)
283 {
284         return ks8995_write_reg(ks, KS8995_REG_ID1, 1);
285 }
286
287 static int ks8995_reset(struct ks8995_switch *ks)
288 {
289         int err;
290
291         err = ks8995_stop(ks);
292         if (err)
293                 return err;
294
295         udelay(KS8995_RESET_DELAY);
296
297         return ks8995_start(ks);
298 }
299
300 static ssize_t ks8995_registers_read(struct file *filp, struct kobject *kobj,
301         struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
302 {
303         struct device *dev;
304         struct ks8995_switch *ks8995;
305
306         dev = container_of(kobj, struct device, kobj);
307         ks8995 = dev_get_drvdata(dev);
308
309         return ks8995_read(ks8995, buf, off, count);
310 }
311
312 static ssize_t ks8995_registers_write(struct file *filp, struct kobject *kobj,
313         struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
314 {
315         struct device *dev;
316         struct ks8995_switch *ks8995;
317
318         dev = container_of(kobj, struct device, kobj);
319         ks8995 = dev_get_drvdata(dev);
320
321         return ks8995_write(ks8995, buf, off, count);
322 }
323
324 /* ks8995_get_revision - get chip revision
325  * @ks: pointer to switch instance
326  *
327  * Verify chip family and id and get chip revision.
328  */
329 static int ks8995_get_revision(struct ks8995_switch *ks)
330 {
331         int err;
332         u8 id0, id1, ksz8864_id;
333
334         /* read family id */
335         err = ks8995_read_reg(ks, KS8995_REG_ID0, &id0);
336         if (err) {
337                 err = -EIO;
338                 goto err_out;
339         }
340
341         /* verify family id */
342         if (id0 != ks->chip->family_id) {
343                 dev_err(&ks->spi->dev, "chip family id mismatch: expected 0x%02x but 0x%02x read\n",
344                         ks->chip->family_id, id0);
345                 err = -ENODEV;
346                 goto err_out;
347         }
348
349         switch (ks->chip->family_id) {
350         case FAMILY_KS8995:
351                 /* try reading chip id at CHIP ID1 */
352                 err = ks8995_read_reg(ks, KS8995_REG_ID1, &id1);
353                 if (err) {
354                         err = -EIO;
355                         goto err_out;
356                 }
357
358                 /* verify chip id */
359                 if ((get_chip_id(id1) == CHIPID_M) &&
360                     (get_chip_id(id1) == ks->chip->chip_id)) {
361                         /* KS8995MA */
362                         ks->revision_id = get_chip_rev(id1);
363                 } else if (get_chip_id(id1) != CHIPID_M) {
364                         /* KSZ8864RMN */
365                         err = ks8995_read_reg(ks, KS8995_REG_ID1, &ksz8864_id);
366                         if (err) {
367                                 err = -EIO;
368                                 goto err_out;
369                         }
370
371                         if ((ksz8864_id & 0x80) &&
372                             (ks->chip->chip_id == KSZ8864_CHIP_ID)) {
373                                 ks->revision_id = get_chip_rev(id1);
374                         }
375
376                 } else {
377                         dev_err(&ks->spi->dev, "unsupported chip id for KS8995 family: 0x%02x\n",
378                                 id1);
379                         err = -ENODEV;
380                 }
381                 break;
382         case FAMILY_KSZ8795:
383                 /* try reading chip id at CHIP ID1 */
384                 err = ks8995_read_reg(ks, KS8995_REG_ID1, &id1);
385                 if (err) {
386                         err = -EIO;
387                         goto err_out;
388                 }
389
390                 if (get_chip_id(id1) == ks->chip->chip_id) {
391                         ks->revision_id = get_chip_rev(id1);
392                 } else {
393                         dev_err(&ks->spi->dev, "unsupported chip id for KSZ8795 family: 0x%02x\n",
394                                 id1);
395                         err = -ENODEV;
396                 }
397                 break;
398         default:
399                 dev_err(&ks->spi->dev, "unsupported family id: 0x%02x\n", id0);
400                 err = -ENODEV;
401                 break;
402         }
403 err_out:
404         return err;
405 }
406
407 /* ks8995_parse_dt - setup platform data from devicetree
408  * @ks: pointer to switch instance
409  *
410  * Parses supported DT properties and sets up platform data
411  * accordingly.
412  */
413 static void ks8995_parse_dt(struct ks8995_switch *ks)
414 {
415         struct device_node *np = ks->spi->dev.of_node;
416         struct ks8995_pdata *pdata = ks->pdata;
417
418         if (!np)
419                 return;
420
421         pdata->reset_gpio = of_get_named_gpio_flags(np, "reset-gpios", 0,
422                 &pdata->reset_gpio_flags);
423 }
424
425 static const struct bin_attribute ks8995_registers_attr = {
426         .attr = {
427                 .name   = "registers",
428                 .mode   = 0600,
429         },
430         .size   = KS8995_REGS_SIZE,
431         .read   = ks8995_registers_read,
432         .write  = ks8995_registers_write,
433 };
434
435 /* ------------------------------------------------------------------------ */
436 static int ks8995_probe(struct spi_device *spi)
437 {
438         struct ks8995_switch *ks;
439         int err;
440         int variant = spi_get_device_id(spi)->driver_data;
441
442         if (variant >= max_variant) {
443                 dev_err(&spi->dev, "bad chip variant %d\n", variant);
444                 return -ENODEV;
445         }
446
447         ks = devm_kzalloc(&spi->dev, sizeof(*ks), GFP_KERNEL);
448         if (!ks)
449                 return -ENOMEM;
450
451         mutex_init(&ks->lock);
452         ks->spi = spi;
453         ks->chip = &ks8995_chip[variant];
454
455         if (ks->spi->dev.of_node) {
456                 ks->pdata = devm_kzalloc(&spi->dev, sizeof(*ks->pdata),
457                                          GFP_KERNEL);
458                 if (!ks->pdata)
459                         return -ENOMEM;
460
461                 ks->pdata->reset_gpio = -1;
462
463                 ks8995_parse_dt(ks);
464         }
465
466         if (!ks->pdata)
467                 ks->pdata = spi->dev.platform_data;
468
469         /* de-assert switch reset */
470         if (ks->pdata && gpio_is_valid(ks->pdata->reset_gpio)) {
471                 unsigned long flags;
472
473                 flags = (ks->pdata->reset_gpio_flags == OF_GPIO_ACTIVE_LOW ?
474                          GPIOF_ACTIVE_LOW : 0);
475
476                 err = devm_gpio_request_one(&spi->dev,
477                                             ks->pdata->reset_gpio,
478                                             flags, "switch-reset");
479                 if (err) {
480                         dev_err(&spi->dev,
481                                 "failed to get reset-gpios: %d\n", err);
482                         return -EIO;
483                 }
484
485                 gpiod_set_value(gpio_to_desc(ks->pdata->reset_gpio), 0);
486         }
487
488         spi_set_drvdata(spi, ks);
489
490         spi->mode = SPI_MODE_0;
491         spi->bits_per_word = 8;
492         err = spi_setup(spi);
493         if (err) {
494                 dev_err(&spi->dev, "spi_setup failed, err=%d\n", err);
495                 return err;
496         }
497
498         err = ks8995_get_revision(ks);
499         if (err)
500                 return err;
501
502         memcpy(&ks->regs_attr, &ks8995_registers_attr, sizeof(ks->regs_attr));
503         ks->regs_attr.size = ks->chip->regs_size;
504
505         err = ks8995_reset(ks);
506         if (err)
507                 return err;
508
509         sysfs_attr_init(&ks->regs_attr.attr);
510         err = sysfs_create_bin_file(&spi->dev.kobj, &ks->regs_attr);
511         if (err) {
512                 dev_err(&spi->dev, "unable to create sysfs file, err=%d\n",
513                                     err);
514                 return err;
515         }
516
517         dev_info(&spi->dev, "%s device found, Chip ID:%x, Revision:%x\n",
518                  ks->chip->name, ks->chip->chip_id, ks->revision_id);
519
520         return 0;
521 }
522
523 static int ks8995_remove(struct spi_device *spi)
524 {
525         struct ks8995_switch *ks = spi_get_drvdata(spi);
526
527         sysfs_remove_bin_file(&spi->dev.kobj, &ks->regs_attr);
528
529         /* assert reset */
530         if (ks->pdata && gpio_is_valid(ks->pdata->reset_gpio))
531                 gpiod_set_value(gpio_to_desc(ks->pdata->reset_gpio), 1);
532
533         return 0;
534 }
535
536 /* ------------------------------------------------------------------------ */
537 static struct spi_driver ks8995_driver = {
538         .driver = {
539                 .name       = "spi-ks8995",
540                 .of_match_table = of_match_ptr(ks8895_spi_of_match),
541         },
542         .probe    = ks8995_probe,
543         .remove   = ks8995_remove,
544         .id_table = ks8995_id,
545 };
546
547 module_spi_driver(ks8995_driver);
548
549 MODULE_DESCRIPTION(DRV_DESC);
550 MODULE_VERSION(DRV_VERSION);
551 MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
552 MODULE_LICENSE("GPL v2");