sata_uli.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
  1. /*
  2. * sata_uli.c - ULi Electronics SATA
  3. *
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2, or (at your option)
  8. * any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; see the file COPYING. If not, write to
  17. * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. *
  19. *
  20. * libata documentation is available via 'make {ps|pdf}docs',
  21. * as Documentation/DocBook/libata.*
  22. *
  23. * Hardware documentation available under NDA.
  24. *
  25. */
  26. #include <linux/kernel.h>
  27. #include <linux/module.h>
  28. #include <linux/pci.h>
  29. #include <linux/init.h>
  30. #include <linux/blkdev.h>
  31. #include <linux/delay.h>
  32. #include <linux/interrupt.h>
  33. #include <linux/device.h>
  34. #include <scsi/scsi_host.h>
  35. #include <linux/libata.h>
  36. #define DRV_NAME "sata_uli"
  37. #define DRV_VERSION "1.1"
  38. enum {
  39. uli_5289 = 0,
  40. uli_5287 = 1,
  41. uli_5281 = 2,
  42. uli_max_ports = 4,
  43. /* PCI configuration registers */
  44. ULI5287_BASE = 0x90, /* sata0 phy SCR registers */
  45. ULI5287_OFFS = 0x10, /* offset from sata0->sata1 phy regs */
  46. ULI5281_BASE = 0x60, /* sata0 phy SCR registers */
  47. ULI5281_OFFS = 0x60, /* offset from sata0->sata1 phy regs */
  48. };
  49. struct uli_priv {
  50. unsigned int scr_cfg_addr[uli_max_ports];
  51. };
  52. static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
  53. static u32 uli_scr_read (struct ata_port *ap, unsigned int sc_reg);
  54. static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
  55. static const struct pci_device_id uli_pci_tbl[] = {
  56. { PCI_VDEVICE(AL, 0x5289), uli_5289 },
  57. { PCI_VDEVICE(AL, 0x5287), uli_5287 },
  58. { PCI_VDEVICE(AL, 0x5281), uli_5281 },
  59. { } /* terminate list */
  60. };
  61. static struct pci_driver uli_pci_driver = {
  62. .name = DRV_NAME,
  63. .id_table = uli_pci_tbl,
  64. .probe = uli_init_one,
  65. .remove = ata_pci_remove_one,
  66. };
  67. static struct scsi_host_template uli_sht = {
  68. .module = THIS_MODULE,
  69. .name = DRV_NAME,
  70. .ioctl = ata_scsi_ioctl,
  71. .queuecommand = ata_scsi_queuecmd,
  72. .can_queue = ATA_DEF_QUEUE,
  73. .this_id = ATA_SHT_THIS_ID,
  74. .sg_tablesize = LIBATA_MAX_PRD,
  75. .cmd_per_lun = ATA_SHT_CMD_PER_LUN,
  76. .emulated = ATA_SHT_EMULATED,
  77. .use_clustering = ATA_SHT_USE_CLUSTERING,
  78. .proc_name = DRV_NAME,
  79. .dma_boundary = ATA_DMA_BOUNDARY,
  80. .slave_configure = ata_scsi_slave_config,
  81. .slave_destroy = ata_scsi_slave_destroy,
  82. .bios_param = ata_std_bios_param,
  83. };
  84. static const struct ata_port_operations uli_ops = {
  85. .port_disable = ata_port_disable,
  86. .tf_load = ata_tf_load,
  87. .tf_read = ata_tf_read,
  88. .check_status = ata_check_status,
  89. .exec_command = ata_exec_command,
  90. .dev_select = ata_std_dev_select,
  91. .bmdma_setup = ata_bmdma_setup,
  92. .bmdma_start = ata_bmdma_start,
  93. .bmdma_stop = ata_bmdma_stop,
  94. .bmdma_status = ata_bmdma_status,
  95. .qc_prep = ata_qc_prep,
  96. .qc_issue = ata_qc_issue_prot,
  97. .data_xfer = ata_data_xfer,
  98. .freeze = ata_bmdma_freeze,
  99. .thaw = ata_bmdma_thaw,
  100. .error_handler = ata_bmdma_error_handler,
  101. .post_internal_cmd = ata_bmdma_post_internal_cmd,
  102. .irq_handler = ata_interrupt,
  103. .irq_clear = ata_bmdma_irq_clear,
  104. .irq_on = ata_irq_on,
  105. .irq_ack = ata_irq_ack,
  106. .scr_read = uli_scr_read,
  107. .scr_write = uli_scr_write,
  108. .port_start = ata_port_start,
  109. };
  110. static struct ata_port_info uli_port_info = {
  111. .sht = &uli_sht,
  112. .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
  113. ATA_FLAG_IGN_SIMPLEX,
  114. .pio_mask = 0x1f, /* pio0-4 */
  115. .udma_mask = 0x7f, /* udma0-6 */
  116. .port_ops = &uli_ops,
  117. };
  118. MODULE_AUTHOR("Peer Chen");
  119. MODULE_DESCRIPTION("low-level driver for ULi Electronics SATA controller");
  120. MODULE_LICENSE("GPL");
  121. MODULE_DEVICE_TABLE(pci, uli_pci_tbl);
  122. MODULE_VERSION(DRV_VERSION);
  123. static unsigned int get_scr_cfg_addr(struct ata_port *ap, unsigned int sc_reg)
  124. {
  125. struct uli_priv *hpriv = ap->host->private_data;
  126. return hpriv->scr_cfg_addr[ap->port_no] + (4 * sc_reg);
  127. }
  128. static u32 uli_scr_cfg_read (struct ata_port *ap, unsigned int sc_reg)
  129. {
  130. struct pci_dev *pdev = to_pci_dev(ap->host->dev);
  131. unsigned int cfg_addr = get_scr_cfg_addr(ap, sc_reg);
  132. u32 val;
  133. pci_read_config_dword(pdev, cfg_addr, &val);
  134. return val;
  135. }
  136. static void uli_scr_cfg_write (struct ata_port *ap, unsigned int scr, u32 val)
  137. {
  138. struct pci_dev *pdev = to_pci_dev(ap->host->dev);
  139. unsigned int cfg_addr = get_scr_cfg_addr(ap, scr);
  140. pci_write_config_dword(pdev, cfg_addr, val);
  141. }
  142. static u32 uli_scr_read (struct ata_port *ap, unsigned int sc_reg)
  143. {
  144. if (sc_reg > SCR_CONTROL)
  145. return 0xffffffffU;
  146. return uli_scr_cfg_read(ap, sc_reg);
  147. }
  148. static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val)
  149. {
  150. if (sc_reg > SCR_CONTROL) //SCR_CONTROL=2, SCR_ERROR=1, SCR_STATUS=0
  151. return;
  152. uli_scr_cfg_write(ap, sc_reg, val);
  153. }
  154. static int uli_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
  155. {
  156. static int printed_version;
  157. struct ata_probe_ent *probe_ent;
  158. struct ata_port_info *ppi[2];
  159. int rc;
  160. unsigned int board_idx = (unsigned int) ent->driver_data;
  161. struct uli_priv *hpriv;
  162. void __iomem * const *iomap;
  163. if (!printed_version++)
  164. dev_printk(KERN_INFO, &pdev->dev, "version " DRV_VERSION "\n");
  165. rc = pcim_enable_device(pdev);
  166. if (rc)
  167. return rc;
  168. rc = pci_request_regions(pdev, DRV_NAME);
  169. if (rc) {
  170. pcim_pin_device(pdev);
  171. return rc;
  172. }
  173. rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
  174. if (rc)
  175. return rc;
  176. rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
  177. if (rc)
  178. return rc;
  179. ppi[0] = ppi[1] = &uli_port_info;
  180. probe_ent = ata_pci_init_native_mode(pdev, ppi, ATA_PORT_PRIMARY | ATA_PORT_SECONDARY);
  181. if (!probe_ent)
  182. return -ENOMEM;
  183. hpriv = devm_kzalloc(&pdev->dev, sizeof(*hpriv), GFP_KERNEL);
  184. if (!hpriv)
  185. return -ENOMEM;
  186. probe_ent->private_data = hpriv;
  187. iomap = pcim_iomap_table(pdev);
  188. switch (board_idx) {
  189. case uli_5287:
  190. hpriv->scr_cfg_addr[0] = ULI5287_BASE;
  191. hpriv->scr_cfg_addr[1] = ULI5287_BASE + ULI5287_OFFS;
  192. probe_ent->n_ports = 4;
  193. probe_ent->port[2].cmd_addr = iomap[0] + 8;
  194. probe_ent->port[2].altstatus_addr =
  195. probe_ent->port[2].ctl_addr = (void __iomem *)
  196. ((unsigned long)iomap[1] | ATA_PCI_CTL_OFS) + 4;
  197. probe_ent->port[2].bmdma_addr = iomap[4] + 16;
  198. hpriv->scr_cfg_addr[2] = ULI5287_BASE + ULI5287_OFFS*4;
  199. probe_ent->port[3].cmd_addr = iomap[2] + 8;
  200. probe_ent->port[3].altstatus_addr =
  201. probe_ent->port[3].ctl_addr = (void __iomem *)
  202. ((unsigned long)iomap[3] | ATA_PCI_CTL_OFS) + 4;
  203. probe_ent->port[3].bmdma_addr = iomap[4] + 24;
  204. hpriv->scr_cfg_addr[3] = ULI5287_BASE + ULI5287_OFFS*5;
  205. ata_std_ports(&probe_ent->port[2]);
  206. ata_std_ports(&probe_ent->port[3]);
  207. break;
  208. case uli_5289:
  209. hpriv->scr_cfg_addr[0] = ULI5287_BASE;
  210. hpriv->scr_cfg_addr[1] = ULI5287_BASE + ULI5287_OFFS;
  211. break;
  212. case uli_5281:
  213. hpriv->scr_cfg_addr[0] = ULI5281_BASE;
  214. hpriv->scr_cfg_addr[1] = ULI5281_BASE + ULI5281_OFFS;
  215. break;
  216. default:
  217. BUG();
  218. break;
  219. }
  220. pci_set_master(pdev);
  221. pci_intx(pdev, 1);
  222. if (!ata_device_add(probe_ent))
  223. return -ENODEV;
  224. devm_kfree(&pdev->dev, probe_ent);
  225. return 0;
  226. }
  227. static int __init uli_init(void)
  228. {
  229. return pci_register_driver(&uli_pci_driver);
  230. }
  231. static void __exit uli_exit(void)
  232. {
  233. pci_unregister_driver(&uli_pci_driver);
  234. }
  235. module_init(uli_init);
  236. module_exit(uli_exit);